Initial commit

Author: picatz

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Kent 'picat' Gruber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,17 @@
+# Subzero
+❄️  Work-in-progress development of the _cool_ new SubFinder core API `V2`
+
+# Why?
+`V1` of SubFinder's core API is actually not that bad. However, I decided I would try and re-work the design to attempt to improve it. The main motivating factor being to simplify the boilerplate to add new subdomain enumeration sources and utilize the `interface` type in golang.
+
+# How can I help?
+Make an issue or pull request to this repository to improve it!
+
+* Try running the tests.
+* Fix the tests.
+* Write some tests.
+* Ask questions about parts that confuse you.
+* Add documentation.
+* Provide solutions for better word choices in documentation.
+* Spellchecking is awesome.
+* Be creative!

enumeration_options.go

@@ -0,0 +1,16 @@
+package subzero
+
+// EnumerationOptions provides all the data needed for subdomain
+// enumeration. This includes all the sources which will be
+// queried to find them.
+type EnumerationOptions struct {
+	Sources []Source
+}
+
+// HasSources checks if the EnumerationOptions have any source defined.
+func (opts *EnumerationOptions) HasSources() bool {
+	if len(opts.Sources) == 0 {
+		return false
+	}
+	return true
+}

enumeration_options_test.go

@@ -0,0 +1,28 @@
+package subzero
+
+import "testing"
+import "fmt"
+
+func TestEnumerationOptions(t *testing.T) {
+	opts := EnumerationOptions{}
+	if len(opts.Sources) != 0 {
+		t.Error("new enumeration options doesn't have empty sources list")
+	}
+}
+
+func TestEnumerationOptionsHasSources(t *testing.T) {
+	opts := EnumerationOptions{}
+	if opts.HasSources() {
+		t.Error("new enumeration options doesn't have empty sources list")
+	}
+}
+
+func ExampleEnumerationOptions() {
+	opts := EnumerationOptions{}
+	if opts.HasSources() {
+		fmt.Println("sources found in options")
+	} else {
+		fmt.Println("sources not found in options")
+	}
+	// Output: sources not found in options
+}

result.go

@@ -0,0 +1,38 @@
+package subzero
+
+// Result contains the information from any given
+// source. It's the Source author's job to set the
+// type when returning a result. Upon success, a
+// Source source should provide a string as the found
+// subdomain. Upon Failure, the source should provide an error.
+type Result struct {
+	Type    string
+	Success string
+	Failure error
+}
+
+// IsSuccess checks if the Result has any failure before
+// determining if the result succeeded.
+func (r *Result) IsSuccess() bool {
+	if r.Failure != nil {
+		return false
+	}
+	return true
+}
+
+// IsSuccess checks if the Result has any failure before
+// determining if the result failed.
+func (r *Result) IsFailure() bool {
+	if r.Failure != nil {
+		return true
+	}
+	return false
+}
+
+// HasType checks if the Result has a type value set.
+func (r *Result) HasType() bool {
+	if r.Type != "" {
+		return true
+	}
+	return false
+}

result_test.go

@@ -0,0 +1,105 @@
+package subzero
+
+import "testing"
+import "fmt"
+import "errors"
+import "reflect"
+
+func TestResult(t *testing.T) {
+	var units = []struct {
+		exp Result
+		got string
+	}{
+		{Result{Type: "example", Success: "info.bing.com"}, "info.bing.com"},
+		{Result{Type: "example", Failure: errors.New("failed")}, "failed"},
+	}
+	for _, u := range units {
+		if u.exp.Failure != nil {
+			if !reflect.DeepEqual(u.exp.Failure.Error(), u.got) {
+				t.Fatalf("expected '%v', got '%v'", u.exp, u.got)
+			}
+		} else {
+			if !reflect.DeepEqual(u.exp.Success, u.got) {
+				t.Fatalf("expected '%v', got '%v'", u.exp, u.got)
+			}
+		}
+	}
+}
+
+func TestResultIsSuccess(t *testing.T) {
+	var units = []struct {
+		exp Result
+		got bool
+	}{
+		{Result{Type: "example", Success: "info.bing.com"}, true},
+		{Result{Type: "example", Failure: errors.New("failed")}, false},
+	}
+	for _, u := range units {
+		if u.exp.IsSuccess() != u.got {
+			t.Fatalf("expected '%v', got '%v'", u.exp, u.got)
+		}
+	}
+}
+
+func TestResultIsFailure(t *testing.T) {
+	var units = []struct {
+		exp Result
+		got bool
+	}{
+		{Result{Type: "example", Success: "info.bing.com"}, false},
+		{Result{Type: "example", Failure: errors.New("failed")}, true},
+	}
+	for _, u := range units {
+		if u.exp.IsFailure() != u.got {
+			t.Fatalf("expected '%v', got '%v'", u.exp, u.got)
+		}
+	}
+}
+
+func TestResultHasType(t *testing.T) {
+	var units = []struct {
+		exp Result
+		got bool
+	}{
+		{Result{Type: "example", Success: "info.bing.com"}, true},
+		{Result{Type: "example", Failure: errors.New("failed")}, true},
+		{Result{}, false},
+	}
+	for _, u := range units {
+		if u.exp.HasType() != u.got {
+			t.Fatalf("expected '%v', got '%v'", u.exp, u.got)
+		}
+	}
+}
+
+func ExampleResult() {
+	result := Result{Type: "example", Success: "info.bing.com"}
+	if result.Failure != nil {
+		fmt.Println(result.Type, ":", result.Failure)
+	} else {
+		fmt.Println(result.Type, ":", result.Success)
+	}
+	// Output: example : info.bing.com
+}
+
+func ExampleResultIsSuccess() {
+	result := Result{Success: "wiggle.github.com"}
+	if result.IsSuccess() {
+		fmt.Println(result.Success)
+	}
+	// Output: wiggle.github.com
+}
+
+func ExampleResultIsFailure() {
+	result := Result{Failure: errors.New("failed to party")}
+	if result.IsFailure() {
+		fmt.Println(result.Failure.Error())
+	}
+	// Output: failed to party
+}
+
+func ExampleResultHasType() {
+	result := Result{Type: "example"}
+	fmt.Println(result.HasType())
+	// Output: true
+}

source.go

@@ -0,0 +1,7 @@
+package subzero
+
+// Source defines the minimum interface any
+// subdomain enumeration module should follow.
+type Source interface {
+	ProcessDomain(string) <-chan *Result
+}