initial

Author: nl5887

LICENSE

@@ -0,0 +1,14 @@
+Copyright 2018 Remco Verhoef
+
+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.
+

README.md

@@ -0,0 +1,42 @@
+# gogreynoise [![](https://godoc.org/github.com/dutchcoders/gogreynoise?status.svg)](http://godoc.org/github.com/dutchcoders/gogreynoise) [![Go Report Card](https://goreportcard.com/badge/dutchcoders/gogreynoise)](https://goreportcard.com/report/dutchcoders/gogreynoise) 
+
+Golang client for Greynoise.io. The client currently only implements /context, but it is easy to extend other features.
+
+## Usage
+
+```
+package greynoise
+
+import (
+        "fmt"
+        "net"
+
+        greynoise "github.com/dutchcoders/gogreynoise"
+)
+
+func ExampleExamples_output() {
+        client, err := greynoise.New(
+                greynoise.WithKey("{key}"),
+        )
+        if err != nil {
+                panic(err.Error)
+        }
+
+        ip := net.ParseIP("8.8.8.8")
+        result, err := client.Context(ip)
+        if err != nil {
+                panic(err.Error)
+        }
+
+        fmt.Printf("Actor: %s\n", result.Actor)
+}
+```
+
+## Contributors
+
+* [Remco Verhoef](https://twitter.com/remco_verhoef)
+
+## Copyright and license
+
+Code released under [Apache License 2.0](LICENSE).
+

client.go

@@ -0,0 +1,61 @@
+package greynoise
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+)
+
+type Client struct {
+	Key string
+
+	*http.Client
+	baseURL *url.URL
+}
+
+// Context will return more information about a given IP address. Returns time ranges, IP metadata (network owner,
+// ASN,reverse DNS pointer, country), associated actors, activity tags, and raw port scan and web
+// request information.
+func (c *Client) Context(ip net.IP) (*ContextResult, error) {
+	request, err := c.NewRequest("GET", fmt.Sprintf("/v2/noise/context/%s", ip.String()), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	output := ContextResult{}
+	if err := c.Do(request, &output); err != nil {
+		return nil, err
+	}
+
+	return &output, nil
+}
+
+type optionFn func(*Client)
+
+// WithKey contains the Greynoise API key
+func WithKey(key string) optionFn {
+	return func(c *Client) {
+		c.Key = key
+	}
+}
+
+// New returns a Greynoise API client
+func New(options ...optionFn) (*Client, error) {
+	baseURL, err := url.Parse("https://enterprise.api.greynoise.io/v2/noise/")
+	if err != nil {
+		panic(err)
+	}
+
+	c := &Client{
+		baseURL: baseURL,
+		Client:  http.DefaultClient,
+	}
+
+	for _, optionFn := range options {
+		optionFn(c)
+
+	}
+
+	return c, nil
+}

driver.go

@@ -0,0 +1,81 @@
+package greynoise
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+)
+
+// NewRequest prepares http.Request to call the Greynoise API
+func (c *Client) NewRequest(method, urlStr string, body interface{}) (*http.Request, error) {
+	rel, err := url.Parse(urlStr)
+	if err != nil {
+		return nil, err
+	}
+
+	u := c.baseURL.ResolveReference(rel)
+
+	var buf io.ReadWriter
+	if body != nil {
+		buf = new(bytes.Buffer)
+		err := json.NewEncoder(buf).Encode(body)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	req, err := http.NewRequest(method, u.String(), buf)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Add("Content-Type", "text/json; charset=UTF-8")
+	req.Header.Add("Accept", "text/json")
+	req.Header.Add("Key", c.Key)
+	req.Header.Add("User-Agent", "gogreynoise")
+
+	return req, nil
+}
+
+// Do will execute the http.Request and decode the result
+func (wd *Client) Do(req *http.Request, v interface{}) error {
+	if dump, err := httputil.DumpRequestOut(req, true); err == nil {
+		os.Stdout.Write(dump)
+	}
+
+	resp, err := wd.Client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	r := resp.Body
+	defer r.Close()
+
+	if true {
+	} else if dump, err := httputil.DumpResponse(resp, true); err == nil {
+		os.Stdout.Write(dump)
+
+		resp.Body = ioutil.NopCloser(bytes.NewBuffer(dump))
+	}
+
+	r2 := r
+
+	if resp.StatusCode != http.StatusOK {
+		result := ErrorResult{}
+		json.NewDecoder(r2).Decode(&result)
+		return fmt.Errorf(result.Error)
+	}
+
+	err = json.NewDecoder(r2).Decode(&v)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

error.go

@@ -0,0 +1,12 @@
+package greynoise
+
+import "fmt"
+
+type Error struct {
+	ErrorCode   int    `json:"error_code"`
+	ErrorString string `json:"error"`
+}
+
+func (de *Error) Error() string {
+	return fmt.Sprintf("%s (%d)", de.ErrorString, de.ErrorCode)
+}

greynoise_test.go

@@ -0,0 +1,25 @@
+package greynoise
+
+import (
+	"fmt"
+	"net"
+
+	greynoise "github.com/dutchcoders/gogreynoise"
+)
+
+func ExampleExamples_output() {
+	client, err := greynoise.New(
+		greynoise.WithKey("{key}"),
+	)
+	if err != nil {
+		panic(err.Error)
+	}
+
+	ip := net.ParseIP("8.8.8.8")
+	result, err := client.Context(ip)
+	if err != nil {
+		panic(err.Error)
+	}
+
+	fmt.Printf("Actor: %s\n", result.Actor)
+}

merge.go

@@ -0,0 +1,97 @@
+package greynoise
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func Merge(dest interface{}, src interface{}) error {
+	vSrc := reflect.ValueOf(src)
+
+	vDst := reflect.ValueOf(dest)
+	if vDst.Kind() == reflect.Ptr {
+		vDst = vDst.Elem()
+	}
+	return merge(vDst, vSrc)
+}
+
+func merge(dest reflect.Value, src reflect.Value) error {
+	switch src.Kind() {
+	case reflect.Func:
+		if !dest.CanSet() {
+			return nil
+		}
+		src = src.Call([]reflect.Value{})[0]
+		if src.Kind() == reflect.Ptr {
+			src = src.Elem()
+		}
+		if err := merge(dest, src); err != nil {
+			return err
+		}
+	case reflect.Struct:
+		// try to set the struct
+		if src.Type() == dest.Type() {
+			if !dest.CanSet() {
+				return nil
+			}
+
+			dest.Set(src)
+			return nil
+		}
+
+		for i := 0; i < src.NumMethod(); i++ {
+			tMethod := src.Type().Method(i)
+
+			df := dest.FieldByName(tMethod.Name)
+			if df.Kind() == 0 {
+				continue
+			}
+
+			if err := merge(df, src.Method(i)); err != nil {
+				return err
+			}
+		}
+
+		for i := 0; i < src.NumField(); i++ {
+			tField := src.Type().Field(i)
+
+			df := dest.FieldByName(tField.Name)
+			if df.Kind() == 0 {
+				continue
+			}
+
+			if err := merge(df, src.Field(i)); err != nil {
+				return err
+			}
+		}
+
+	case reflect.Map:
+		x := reflect.MakeMap(dest.Type())
+		for _, k := range src.MapKeys() {
+			x.SetMapIndex(k, src.MapIndex(k))
+		}
+		dest.Set(x)
+	case reflect.Slice:
+		x := reflect.MakeSlice(dest.Type(), src.Len(), src.Len())
+		for j := 0; j < src.Len(); j++ {
+			merge(x.Index(j), src.Index(j))
+		}
+		dest.Set(x)
+	case reflect.Chan:
+	case reflect.Ptr:
+		if !src.IsNil() && dest.CanSet() {
+			fmt.Println(src.Type().Name())
+			fmt.Println(dest.Type().Name())
+			x := reflect.New(dest.Type().Elem())
+			merge(x.Elem(), src.Elem())
+			dest.Set(x)
+		}
+	default:
+		if !dest.CanSet() {
+			return nil
+		}
+		dest.Set(src)
+	}
+
+	return nil
+}

messages.go

@@ -0,0 +1,35 @@
+package greynoise
+
+// ContextResult is the result of the /context api
+type ContextResult struct {
+	Actor     string `json:"actor"`
+	FirstSeen string `json:"first_seen"`
+	IP        string `json:"ip"`
+	LastSeen  string `json:"last_seen"`
+	Metadata  struct {
+		ASN          string `json:"asn"`
+		Category     string `json:"category"`
+		City         string `json:"city"`
+		Country      string `json:"country"`
+		CountryCode  string `json:"country_code"`
+		Organization string `json:"organization"`
+		Os           string `json:"os"`
+		Rdns         string `json:"rdns"`
+		Tor          bool   `json:"tor"`
+	} `json:"metadata"`
+	RawData struct {
+		Scan []struct {
+			Port     int64  `json:"port"`
+			Protocol string `json:"protocol"`
+		} `json:"scan"`
+		Web struct {
+		} `json:"web"`
+	} `json:"raw_data"`
+	Seen bool     `json:"seen"`
+	Tags []string `json:"tags"`
+}
+
+// ErrorResult is the result when an error occurs
+type ErrorResult struct {
+	Error string `json:"error"`
+}