├── .gitignore
├── LICENSE
├── README.md
├── build.sh
├── cmd
    ├── fileresult.go
    ├── filesubmit.go
    ├── result.go
    ├── root.go
    ├── submit.go
    └── version.go
├── main.go
├── observatory
    ├── methods.go
    ├── observatory.go
    └── structs.go
└── utils
    ├── parse_hosts_file.go
    ├── validation.go
    └── version.go


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
 2 | *.o
 3 | *.a
 4 | *.so
 5 | 
 6 | # Folders
 7 | _obj
 8 | _test
 9 | 
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 | 
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 | 
20 | _testmain.go
21 | 
22 | *.exe
23 | *.test
24 | *.prof
25 | 
26 | /build/
27 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Leon Jacobs
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # go-observe
 2 | 🌌 Go-Observe: A command line Mozilla Observatory client written in Go
 3 | 
 4 | ![Screenshot](https://i.imgur.com/PMhaFdu.png)
 5 | 
 6 | ## usage:
 7 | 
 8 | ```
 9 | ~ » go-observe
10 |                       __
11 |   ___ ____  _______  / /  ___ ___ _____  _____
12 |  / _  / _ \/___/ _ \/ _ \(_-</ -_) __/ |/ / -_)
13 |  \_, /\___/    \___/_.__/___/\__/_/  |___/\__/
14 | /___/ @leonjza
15 | 
16 | Usage:
17 |   go-observe [command]
18 | 
19 | Available Commands:
20 |   fileresult  Get scan results for URLs / Hostnames in a file
21 |   filesubmit  Submit URLs / Hostnames from a file to the Observatory for analysis
22 |   result      Retrieve results for a URL / Hostname from the Observatory
23 |   submit      Submit a URL / Hostname to the Observatory for analysis
24 |   version     Show the version of go-observe
25 | 
26 | Use "go-observe [command] --help" for more information about a command.
27 | ```
28 | 
29 | ## install
30 | There are many options to get `go-observe`.
31 | 
32 | Download the release binaries [here](https://github.com/leonjza/go-observe/releases)
33 | 
34 | *or*
35 | 
36 | Download with `go get` if you have `$GOPATH` setup: `go get github.com/leonjza/go-observe`
37 | 
38 | *or*
39 | 
40 | Build from source!
41 | ```
42 | $ git clone https://github.com/leonjza/go-observe.git
43 | $ cd go-observe
44 | $ go build -o go-observe *.go 
45 | $ ./go-observe
46 | ```
47 | 


--------------------------------------------------------------------------------
/build.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env sh
 2 | 
 3 | # get the version
 4 | if [ -z "$1" ]
 5 | then
 6 |     echo "Provide the version!"
 7 |     exit
 8 | fi
 9 | 
10 | VERSION=$1
11 | 
12 | # build references:
13 | # https://golang.org/doc/install/source#environment
14 | 
15 | # Linux builds
16 | FILENAME="go-observe-$VERSION-linux-386"
17 | echo "Compiling 386 Linux to $FILENAME"
18 | GOOS=linux GOARCH=386 go build  -o build/$FILENAME
19 | 
20 | FILENAME="go-observe-$VERSION-linux-amd64"
21 | echo "Compiling amd64 Linux to $FILENAME"
22 | GOOS=linux GOARCH=amd64 go build  -o build/$FILENAME
23 | 
24 | FILENAME="go-observe-$VERSION-linux-arm"
25 | echo "Compiling arm Linux to $FILENAME"
26 | GOOS=linux GOARCH=arm go build  -o build/$FILENAME
27 | 
28 | FILENAME="go-observe-$VERSION-linux-arm64"
29 | echo "Compiling arm64 Linux to $FILENAME"
30 | GOOS=linux GOARCH=arm go build  -o build/$FILENAME
31 | 
32 | # Windows build
33 | FILENAME="go-observe-$VERSION-windows-386.exe"
34 | echo "Compiling 386 Windows to $FILENAME"
35 | GOOS=windows GOARCH=386 go build  -o build/$FILENAME
36 | 
37 | FILENAME="go-observe-$VERSION-windows-amd64.exe"
38 | echo "Compiling amd64 Windows to $FILENAME"
39 | GOOS=windows GOARCH=amd64 go build  -o build/$FILENAME
40 | 
41 | # macOS build
42 | FILENAME="go-observe-$VERSION-darwin-386"
43 | echo "Compiling 386 macOS to $FILENAME"
44 | GOOS=darwin GOARCH=386 go build  -o build/$FILENAME
45 | 
46 | FILENAME="go-observe-$VERSION-darwin-amd64"
47 | echo "Compiling amd64 macOS to $FILENAME"
48 | GOOS=darwin GOARCH=amd64 go build  -o build/$FILENAME
49 | 


--------------------------------------------------------------------------------
/cmd/fileresult.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 
 6 | 	"github.com/leonjza/go-observe/observatory"
 7 | 	"github.com/leonjza/go-observe/utils"
 8 | 	"github.com/spf13/cobra"
 9 | )
10 | 
11 | // fileresultCmd represents the fileresult command
12 | var fileresultCmd = &cobra.Command{
13 | 	Use:   "fileresult",
14 | 	Short: "Get scan results for URLs / Hostnames in a file",
15 | 	Long: `Gets scan results from the Observatory for URLs / Hostnames in
16 | a file. A file should have newline seperated entries to be read in.
17 | 
18 | Examples:
19 | 	go-observe fileresult hostnames`,
20 | 
21 | 	Run: func(cmd *cobra.Command, args []string) {
22 | 
23 | 		if len(args) <= 0 {
24 | 			fmt.Println("Must provide a filename for results")
25 | 			return
26 | 		}
27 | 
28 | 		hosts, err := utils.ParseHostsFile(args[0])
29 | 		if err != nil {
30 | 			fmt.Printf("Failed to parse hosts from file with error: %s\n", err)
31 | 			return
32 | 		}
33 | 
34 | 		for _, host := range hosts {
35 | 
36 | 			result, err := observatory.GetObservatoryResults(host)
37 | 			if err != nil {
38 | 				fmt.Printf("Failed to get results for %s with error: %s\n", host, err)
39 | 				continue
40 | 			}
41 | 
42 | 			fmt.Printf("[%s] Scan State: 		%s\n", host, result.State)
43 | 			fmt.Printf("[%s] Scan Start Time: 	%s\n", host, result.StartTime)
44 | 
45 | 			if result.State == "FINISHED" {
46 | 				fmt.Printf("[%s] Grade:			%s\n", host, result.Grade)
47 | 				fmt.Printf("[%s] Score:			%d\n", host, result.Score)
48 | 				fmt.Printf("[%s] Failed/Passed/Total: 	%d/%d/%d\n", host,
49 | 					result.TestsFailed, result.TestsPassed, result.TestsQuantity)
50 | 				fmt.Printf("[%s] Scan ID:		%d\n", host, result.ScanID)
51 | 			}
52 | 		}
53 | 	},
54 | }
55 | 
56 | func init() {
57 | 	RootCmd.AddCommand(fileresultCmd)
58 | }
59 | 


--------------------------------------------------------------------------------
/cmd/filesubmit.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 
 6 | 	"github.com/leonjza/go-observe/observatory"
 7 | 	"github.com/leonjza/go-observe/utils"
 8 | 	"github.com/spf13/cobra"
 9 | )
10 | 
11 | // flag variables are taken from `submit.go` ;)
12 | 
13 | // filesubmitCmd represents the filesubmit command
14 | var filesubmitCmd = &cobra.Command{
15 | 	Use:   "filesubmit",
16 | 	Short: "Submit URLs / Hostnames from a file to the Observatory for analysis",
17 | 	Long: `Submits URLs / Hostnames from a file to the Observatory for analysis. A
18 | file should have newline seperated entries to be read in.
19 | 
20 | Examples:
21 | 	go-observe filesubmit hostnames
22 | 	go-observe filesubmit hostnames --rescan
23 | 	go-observe filesubmit hostnames --rescan --no-hide`,
24 | 
25 | 	Run: func(cmd *cobra.Command, args []string) {
26 | 
27 | 		if len(args) <= 0 {
28 | 			fmt.Println("Must provide a filename to submit")
29 | 			return
30 | 		}
31 | 
32 | 		// the slice of hosts we are going to submit
33 | 		hosts, err := utils.ParseHostsFile(args[0])
34 | 		if err != nil {
35 | 			fmt.Printf("Failed to parse the file %s with error: %s\n", args[0], err)
36 | 			return
37 | 		}
38 | 
39 | 		fmt.Printf("Submitting %d hosts parsed from file to the Observatory\n", len(hosts))
40 | 
41 | 		for _, host := range hosts {
42 | 
43 | 			result, err := observatory.SubmitObservatoryAnalysis(host, noHidden, forceRescan)
44 | 			if err != nil {
45 | 				fmt.Printf("Failed to submit host %s with error: %s\n", host, err)
46 | 				continue
47 | 			}
48 | 
49 | 			fmt.Printf("Submitted %s. Observatory status: %s\n", host, result.State)
50 | 		}
51 | 	},
52 | }
53 | 
54 | func init() {
55 | 	RootCmd.AddCommand(filesubmitCmd)
56 | 
57 | 	filesubmitCmd.Flags().BoolVarP(&forceRescan, "rescan", "r", false, "Force a rescan from the Observatory")
58 | 	filesubmitCmd.Flags().BoolVarP(&noHidden, "no-hide", "n", false, "Remove the flag that hides scan results from the Observatory")
59 | }
60 | 


--------------------------------------------------------------------------------
/cmd/result.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 
 6 | 	"github.com/leonjza/go-observe/observatory"
 7 | 	"github.com/leonjza/go-observe/utils"
 8 | 	"github.com/spf13/cobra"
 9 | )
10 | 
11 | // variables for flags
12 | var details bool
13 | 
14 | // resultCmd represents the result command
15 | var resultCmd = &cobra.Command{
16 | 	Use:   "result [url / hostname]",
17 | 	Short: "Retrieve results for a URL / Hostname from the Observatory",
18 | 	Long: `Retreives scan results for a URL from the Observatory.
19 | 
20 | When the --detail flag is provided, a list of the findings details will also
21 | be retreived.`,
22 | 	Run: func(cmd *cobra.Command, args []string) {
23 | 
24 | 		if len(args) <= 0 {
25 | 			fmt.Println("Must provide a URL / Hostname to submit")
26 | 			return
27 | 		}
28 | 
29 | 		// validate the url/host
30 | 		target, err := utils.ValidateAndGetURLHost(args[0])
31 | 		if err != nil {
32 | 			fmt.Printf("Failed to parse url/host with error: %s\n", err)
33 | 			return
34 | 		}
35 | 
36 | 		result, err := observatory.GetObservatoryResults(target)
37 | 		if err != nil {
38 | 			fmt.Printf("Failed to get results with error: %s\n", err)
39 | 			return
40 | 		}
41 | 
42 | 		// echo the results
43 | 		fmt.Println("")
44 | 		fmt.Printf("Scan State: 		%s\n", result.State)
45 | 		fmt.Printf("Scan Start Time: 	%s\n", result.StartTime)
46 | 
47 | 		if result.State == "FINISHED" {
48 | 			fmt.Printf("Grade:			%s\n", result.Grade)
49 | 			fmt.Printf("Score:			%d\n", result.Score)
50 | 			fmt.Printf("Failed/Passed/Total: 	%d/%d/%d\n", result.TestsFailed, result.TestsPassed, result.TestsQuantity)
51 | 			fmt.Printf("Scan ID:		%d\n", result.ScanID)
52 | 		}
53 | 
54 | 		// if we need the details, get that too!
55 | 		if details && result.State == "FINISHED" {
56 | 
57 | 			details, err := observatory.GetObservatoryDetails(result.ScanID)
58 | 			if err != nil {
59 | 				fmt.Printf("An error occured when trying to get the details: %s\n", err)
60 | 				return
61 | 			}
62 | 
63 | 			fmt.Println("")
64 | 			for _, v := range details {
65 | 
66 | 				fmt.Printf("Pass: %t	Score: %d	Description: %s\n", v.Pass, v.ScoreModifier, v.ScoreDescription)
67 | 			}
68 | 		}
69 | 	},
70 | }
71 | 
72 | func init() {
73 | 	RootCmd.AddCommand(resultCmd)
74 | 
75 | 	resultCmd.Flags().BoolVarP(&details, "detail", "d", false, "Get issue details too")
76 | }
77 | 


--------------------------------------------------------------------------------
/cmd/root.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"os"
 6 | 
 7 | 	"github.com/spf13/cobra"
 8 | )
 9 | 
10 | var cfgFile string
11 | 
12 | // RootCmd represents the base command when called without any subcommands
13 | var RootCmd = &cobra.Command{
14 | 	Use:   "go-observe",
15 | 	Short: "A command line Mozilla Observatory client",
16 | 	Long: `
17 |                       __
18 |   ___ ____  _______  / /  ___ ___ _____  _____
19 |  / _  / _ \/___/ _ \/ _ \(_-</ -_) __/ |/ / -_)
20 |  \_, /\___/    \___/_.__/___/\__/_/  |___/\__/
21 | /___/ @leonjza`,
22 | }
23 | 
24 | // Execute adds all child commands to the root command sets flags appropriately.
25 | // This is called by main.main(). It only needs to happen once to the rootCmd.
26 | func Execute() {
27 | 	if err := RootCmd.Execute(); err != nil {
28 | 		fmt.Println(err)
29 | 		os.Exit(-1)
30 | 	}
31 | }
32 | 


--------------------------------------------------------------------------------
/cmd/submit.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 
 6 | 	"github.com/leonjza/go-observe/observatory"
 7 | 	"github.com/leonjza/go-observe/utils"
 8 | 	"github.com/spf13/cobra"
 9 | )
10 | 
11 | // variables for flags
12 | var (
13 | 	noHidden    bool
14 | 	forceRescan bool
15 | )
16 | 
17 | // submitCmd represents the submit command
18 | var submitCmd = &cobra.Command{
19 | 	Use:   "submit [url / hostname to submit]",
20 | 	Short: "Submit a URL / Hostname to the Observatory for analysis",
21 | 	Long: `Submits a URL or a Hostname to the Observatory for analysis.
22 | 
23 | If a URL / Hostname has previously been submitted to the Observatory,
24 | then the API will respond with a "FINISHED". A rescan can be forced with
25 | the --rescan flag.
26 | 
27 | Examples:
28 | 	go-observe submit https://duckduckgo.com
29 | 	go-observe submit duckduckgo.com --rescan
30 | 	go-observe submit duckduckgo.com --rescan -n`,
31 | 
32 | 	Run: func(cmd *cobra.Command, args []string) {
33 | 
34 | 		if len(args) <= 0 {
35 | 			fmt.Println("Must provide a URL / Hostname to submit")
36 | 			return
37 | 		}
38 | 
39 | 		// validate the url/host
40 | 		target, err := utils.ValidateAndGetURLHost(args[0])
41 | 		if err != nil {
42 | 			fmt.Printf("Failed to parse url/host with error: %s\n", err)
43 | 			return
44 | 		}
45 | 
46 | 		// Submit the analysis
47 | 		response, err := observatory.SubmitObservatoryAnalysis(target, noHidden, forceRescan)
48 | 		if err != nil {
49 | 			fmt.Printf("Failed to send host for analysis for error: %s\n", err)
50 | 			return
51 | 		}
52 | 
53 | 		// check the response
54 | 		if response.State == "FINISHED" {
55 | 			fmt.Printf("Scan has already been finished on %s.\n", response.EndTime)
56 | 			fmt.Printf("Use `go-observe results %s` to get scan results.\n", target)
57 | 		} else {
58 | 			fmt.Printf("Scan has been submitted and now has status: %s\n", response.State)
59 | 		}
60 | 	},
61 | }
62 | 
63 | func init() {
64 | 	RootCmd.AddCommand(submitCmd)
65 | 
66 | 	submitCmd.Flags().BoolVarP(&forceRescan, "rescan", "r", false, "Force a rescan from the Observatory")
67 | 	submitCmd.Flags().BoolVarP(&noHidden, "no-hide", "n", false, "Remove the flag that hides scan results from the Observatory")
68 | }
69 | 


--------------------------------------------------------------------------------
/cmd/version.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 
 6 | 	"github.com/leonjza/go-observe/utils"
 7 | 	"github.com/spf13/cobra"
 8 | )
 9 | 
10 | // versionCmd represents the version command
11 | var versionCmd = &cobra.Command{
12 | 	Use:   "version",
13 | 	Short: "Show the version of go-observe",
14 | 	Run: func(cmd *cobra.Command, args []string) {
15 | 
16 | 		fmt.Printf("%s\n", utils.Version)
17 | 	},
18 | }
19 | 
20 | func init() {
21 | 	RootCmd.AddCommand(versionCmd)
22 | }
23 | 


--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | package main
2 | 
3 | import "github.com/leonjza/go-observe/cmd"
4 | 
5 | func main() {
6 | 
7 | 	cmd.Execute()
8 | }
9 | 


--------------------------------------------------------------------------------
/observatory/methods.go:
--------------------------------------------------------------------------------
 1 | package observatory
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 	"fmt"
 6 | 	"strconv"
 7 | )
 8 | 
 9 | // SubmitObservatoryAnalysis submits a URL for analysis
10 | func SubmitObservatoryAnalysis(observatoryHost string, nohide bool, rescan bool) (ScanObject, error) {
11 | 
12 | 	fmt.Printf("Submitting analysis for %s\n", observatoryHost)
13 | 
14 | 	queryString := make(map[string]string)
15 | 	queryString["host"] = observatoryHost
16 | 
17 | 	// by default, hide results from the observatory
18 | 	requestBody := make(map[string]string)
19 | 	requestBody["hidden"] = "true"
20 | 
21 | 	if nohide {
22 | 		fmt.Println("Removing 'hidden' flag for this scan on the observatory")
23 | 		delete(requestBody, "hidden")
24 | 	}
25 | 
26 | 	if rescan {
27 | 		fmt.Println("Forcing a rescan on the observatory")
28 | 		requestBody["rescan"] = "true"
29 | 	}
30 | 
31 | 	results := ScanObject{}
32 | 	err := callObservatory("post", "analyze", &results, queryString, requestBody)
33 | 	if err != nil {
34 | 		return results, err
35 | 	}
36 | 
37 | 	// If there was an error, return that too
38 | 	if results.Error != "" {
39 | 		return results, errors.New(results.Error)
40 | 	}
41 | 
42 | 	return results, nil
43 | }
44 | 
45 | // GetObservatoryResults gets the results of a hostname
46 | func GetObservatoryResults(observatoryHost string) (ScanObject, error) {
47 | 
48 | 	fmt.Printf("Getting results for: %s\n", observatoryHost)
49 | 
50 | 	m := make(map[string]string)
51 | 	m["host"] = observatoryHost
52 | 
53 | 	result := ScanObject{}
54 | 	err := callObservatory("get", "analyze", &result, m, make(map[string]string))
55 | 	if err != nil {
56 | 		return result, err
57 | 	}
58 | 
59 | 	// If there was an error, return that too
60 | 	if result.Error != "" {
61 | 		return result, errors.New(result.Error)
62 | 	}
63 | 
64 | 	return result, nil
65 | }
66 | 
67 | // GetObservatoryDetails gets the details of a hostname
68 | func GetObservatoryDetails(scanID int) (map[string]ScanDetail, error) {
69 | 
70 | 	fmt.Printf("Getting scan details for scan: %d\n", scanID)
71 | 
72 | 	m := make(map[string]string)
73 | 	m["scan"] = strconv.Itoa(scanID)
74 | 
75 | 	result := map[string]ScanDetail{}
76 | 	err := callObservatory("get", "getScanResults", &result, m, make(map[string]string))
77 | 	if err != nil {
78 | 		return result, err
79 | 	}
80 | 
81 | 	return result, nil
82 | }
83 | 


--------------------------------------------------------------------------------
/observatory/observatory.go:
--------------------------------------------------------------------------------
 1 | package observatory
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"fmt"
 6 | 	"net/http"
 7 | 	"net/url"
 8 | 	"strings"
 9 | 	"time"
10 | )
11 | 
12 | func callObservatory(method string, endpoint string, target interface{}, queryString map[string]string,
13 | 	requestBody map[string]string) error {
14 | 
15 | 	observatoryBase := "https://http-observatory.security.mozilla.org/api/v1/"
16 | 
17 | 	// prepare the final url we will call
18 | 	u, err := url.Parse(observatoryBase + endpoint)
19 | 	if err != nil {
20 | 		return err
21 | 	}
22 | 
23 | 	// prepare to add the query string parameters
24 | 	params := url.Values{}
25 | 	for k, v := range queryString {
26 | 		params.Add(k, v)
27 | 	}
28 | 
29 | 	// slap the query string on to u
30 | 	u.RawQuery = params.Encode()
31 | 	fmt.Printf("[%s] %s\n", method, u.String())
32 | 
33 | 	// prepare to add the body values
34 | 	bodyData := url.Values{}
35 | 	for k, v := range requestBody {
36 | 		bodyData.Add(k, v)
37 | 	}
38 | 
39 | 	// build the request
40 | 	req, err := http.NewRequest(method, u.String(), strings.NewReader(bodyData.Encode()))
41 | 	if err != nil {
42 | 		return err
43 | 	}
44 | 
45 | 	// If we are using the post method, set the content type
46 | 	// as form-encoded so that the body could be understood on the
47 | 	// other end.
48 | 	if method == "post" {
49 | 		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
50 | 	}
51 | 
52 | 	// make the request
53 | 	client := http.Client{Timeout: 10 * time.Second}
54 | 	resp, err := client.Do(req)
55 | 	if err != nil {
56 | 		return err
57 | 	}
58 | 
59 | 	defer resp.Body.Close()
60 | 
61 | 	// marshal the response into the struct type at target
62 | 	json.NewDecoder(resp.Body).Decode(&target)
63 | 
64 | 	return nil
65 | }
66 | 


--------------------------------------------------------------------------------
/observatory/structs.go:
--------------------------------------------------------------------------------
 1 | package observatory
 2 | 
 3 | // ScanObject is a representation of a scans summary
 4 | type ScanObject struct {
 5 | 	// If an error occured, the Error key will be set. This is how
 6 | 	// we will know if shit went south.
 7 | 	Error string `json:"error"`
 8 | 
 9 | 	// Values from:
10 | 	//	https://github.com/mozilla/http-observatory/blob/master/httpobs/docs/api.md#scan
11 | 	EndTime             string            `json:"end_time"`
12 | 	Grade               string            `json:"grade"`
13 | 	Hidden              bool              `json:"hidden"`
14 | 	LikelihoodIndicator string            `json:"likelihood_indicator"`
15 | 	ResponseHeaders     map[string]string `json:"response_headers"`
16 | 	ScanID              int               `json:"scan_id"`
17 | 	Score               int               `json:"score"`
18 | 	StartTime           string            `json:"start_time"`
19 | 	State               string            `json:"state"`
20 | 	TestsFailed         int               `json:"tests_failed"`
21 | 	TestsPassed         int               `json:"tests_passed"`
22 | 	TestsQuantity       int               `json:"tests_quantity"`
23 | }
24 | 
25 | // ScanDetail is the representation of a scans details
26 | type ScanDetail struct {
27 | 	// Values from:
28 | 	//  https://github.com/mozilla/http-observatory/blob/master/httpobs/docs/api.md#tests
29 | 	Expectation      string `json:"expectation"`
30 | 	Name             string `json:"name"`
31 | 	Pass             bool   `json:"pass"`
32 | 	Result           string `json:"result"`
33 | 	ScoreDescription string `json:"score_description"`
34 | 	ScoreModifier    int    `json:"score_modifier"`
35 | }
36 | 


--------------------------------------------------------------------------------
/utils/parse_hosts_file.go:
--------------------------------------------------------------------------------
 1 | package utils
 2 | 
 3 | import (
 4 | 	"bufio"
 5 | 	"fmt"
 6 | 	"os"
 7 | )
 8 | 
 9 | // ParseHostsFile parses a file and attempts to extract
10 | // valid hosts from it
11 | func ParseHostsFile(fileName string) ([]string, error) {
12 | 
13 | 	hosts := []string{}
14 | 
15 | 	// try to read entries from a file and submit the results
16 | 	if file, err := os.Open(fileName); err == nil {
17 | 
18 | 		// close the file when we are done
19 | 		defer file.Close()
20 | 
21 | 		// read the file line by line
22 | 		scanner := bufio.NewScanner(file)
23 | 		for scanner.Scan() {
24 | 			candidate := scanner.Text()
25 | 
26 | 			host, err := ValidateAndGetURLHost(candidate)
27 | 			if err != nil {
28 | 				fmt.Printf("Skipping entry %s because of error %s\n", candidate, err)
29 | 				continue
30 | 			}
31 | 
32 | 			hosts = append(hosts, host)
33 | 		}
34 | 
35 | 	} else {
36 | 		return hosts, err
37 | 	}
38 | 
39 | 	return hosts, nil
40 | }
41 | 


--------------------------------------------------------------------------------
/utils/validation.go:
--------------------------------------------------------------------------------
 1 | package utils
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/url"
 6 | 	"strings"
 7 | )
 8 | 
 9 | // ValidateAndGetURLHost checks a string and attempts to extract
10 | // a hostname from it.
11 | func ValidateAndGetURLHost(urlSample string) (string, error) {
12 | 
13 | 	// cheat a little by checking if we have :// in the string.
14 | 	// if we dont, its probably a hostname already
15 | 	if !strings.Contains(urlSample, "://") {
16 | 
17 | 		s := strings.TrimSpace(urlSample)
18 | 		return s, nil
19 | 	}
20 | 
21 | 	// otherwise, if there is a ://, try and extract the hostname
22 | 	parsed, err := url.ParseRequestURI(urlSample)
23 | 
24 | 	if err != nil {
25 | 		fmt.Printf("Unable to parse URL '%s' to get the host\n", urlSample)
26 | 		return "", err
27 | 	}
28 | 
29 | 	// return parsed.Scheme + "://" + parsed.Host
30 | 	return parsed.Host, nil
31 | }
32 | 


--------------------------------------------------------------------------------
/utils/version.go:
--------------------------------------------------------------------------------
1 | package utils
2 | 
3 | // Version is the version we haz, duhr
4 | const Version = "0.4"
5 | 


--------------------------------------------------------------------------------