├── .envrc
├── .gitignore
├── CallbackServer
    ├── command
    │   └── command.go
    ├── config.json
    ├── controllers
    │   └── api
    │   │   ├── CatalogFileEvent.go
    │   │   ├── GetUpdate.go
    │   │   ├── Heartbeat.go
    │   │   ├── ProcessEvent.go
    │   │   ├── RegisterAgent.go
    │   │   ├── UploadFile.go
    │   │   ├── helpers.go
    │   │   └── routes.go
    ├── server.go
    └── system
    │   ├── configuration.go
    │   ├── controller.go
    │   ├── core.go
    │   └── middleware.go
├── Godeps
├── LICENSE
├── README.md
├── WebServer
    ├── config.json
    ├── controllers
    │   ├── api
    │   │   ├── files.go
    │   │   ├── main.go
    │   │   ├── processes.go
    │   │   ├── profile.go
    │   │   └── systems.go
    │   ├── doc.go
    │   └── web
    │   │   ├── downloadInstaller.go
    │   │   ├── index.go
    │   │   ├── logout.go
    │   │   ├── main.go
    │   │   ├── register.go
    │   │   ├── signin.go
    │   │   ├── static.go
    │   │   └── utils.go
    ├── helpers
    │   ├── auth.go
    │   ├── configureInstaller.go
    │   ├── session.go
    │   └── template.go
    ├── public
    │   ├── css
    │   │   ├── bootstrap.css.map
    │   │   ├── bootstrap.min.css
    │   │   ├── dataTables.bootstrap.css
    │   │   ├── font-awesome.min.css
    │   │   ├── griddle.css
    │   │   ├── lato.css
    │   │   └── style.css
    │   ├── fonts
    │   │   ├── FontAwesome.otf
    │   │   ├── fontawesome-webfont.eot
    │   │   ├── fontawesome-webfont.svg
    │   │   ├── fontawesome-webfont.ttf
    │   │   ├── fontawesome-webfont.woff
    │   │   ├── glyphicons-halflings-regular.eot
    │   │   ├── glyphicons-halflings-regular.svg
    │   │   ├── glyphicons-halflings-regular.ttf
    │   │   ├── glyphicons-halflings-regular.woff
    │   │   ├── lato-bold.woff
    │   │   ├── lato-bolditalic.woff
    │   │   ├── lato-italic.woff
    │   │   ├── lato-light.woff
    │   │   ├── lato-lightitalic.woff
    │   │   └── lato-regular.woff
    │   ├── images
    │   │   ├── favicon.ico
    │   │   ├── loading.gif
    │   │   ├── logo.png
    │   │   ├── sort_asc.png
    │   │   ├── sort_both.png
    │   │   └── sort_desc.png
    │   ├── js
    │   │   ├── bootstrap.min.js
    │   │   ├── dataTables.bootstrap.js
    │   │   ├── html5shiv.js
    │   │   ├── jquery-1.11.0.js
    │   │   ├── jquery.dataTables.min.js
    │   │   ├── parsley.min.js
    │   │   ├── respond.min.js
    │   │   └── srepp.js
    │   └── robots.txt
    ├── server.go
    ├── system
    │   ├── configuration.go
    │   ├── controller.go
    │   ├── core.go
    │   └── middleware.go
    └── views
    │   ├── auth
    │       ├── forgot_password.html
    │       ├── forgot_password_post.html
    │       ├── register.html
    │       └── signin.html
    │   ├── footer.html
    │   ├── header.html
    │   ├── help.html
    │   ├── index.html
    │   ├── main.html
    │   ├── privacy.html
    │   └── terms_and_conditions.html
├── docs
    ├── frontend.txt
    ├── go.txt
    └── sysadmin
    │   ├── aws.txt
    │   ├── ec2.txt
    │   ├── no_aws.txt
    │   └── rabbitmq.txt
├── frontend
    ├── gulpfile.js
    ├── package.json
    ├── src
    │   └── js
    │   │   ├── components
    │   │       ├── GriddleWithCallback.jsx
    │   │       ├── Modal.jsx
    │   │       ├── app-help.jsx
    │   │       ├── app-privacy_policy.jsx
    │   │       ├── app-template.jsx
    │   │       ├── app-terms_and_conditions.jsx
    │   │       ├── app.jsx
    │   │       ├── csrf.jsx
    │   │       ├── dashboard
    │   │       │   ├── app-dashboard.jsx
    │   │       │   └── dashboard-item.jsx
    │   │       ├── executables
    │   │       │   ├── app-executables.jsx
    │   │       │   └── app-executables_table.jsx
    │   │       ├── file
    │   │       │   └── app-file.jsx
    │   │       ├── flash.jsx
    │   │       ├── footer
    │   │       │   └── app-footer.jsx
    │   │       ├── form_input.jsx
    │   │       ├── header
    │   │       │   └── app-header.jsx
    │   │       ├── password_change
    │   │       │   └── app-password_change.jsx
    │   │       ├── password_reset
    │   │       │   └── app-password_reset.jsx
    │   │       ├── process_events
    │   │       │   ├── app-process_events.jsx
    │   │       │   └── app-process_events_table.jsx
    │   │       ├── profile
    │   │       │   └── app-profile.jsx
    │   │       ├── react-datepicker
    │   │       │   ├── calendar.js
    │   │       │   ├── date_input.js
    │   │       │   ├── datepicker.js
    │   │       │   ├── day.js
    │   │       │   ├── popover.js
    │   │       │   └── util
    │   │       │   │   └── date.js
    │   │       ├── react-typeahead
    │   │       │   ├── keyevent.js
    │   │       │   ├── react-typeahead.js
    │   │       │   ├── tokenizer
    │   │       │   │   ├── index.js
    │   │       │   │   └── token.js
    │   │       │   └── typeahead
    │   │       │   │   ├── index.js
    │   │       │   │   ├── option.js
    │   │       │   │   └── selector.js
    │   │       └── systems
    │   │       │   ├── app-systeminfo.jsx
    │   │       │   ├── app-systems.jsx
    │   │       │   └── app-systems_table.jsx
    │   │   └── main.js
    └── update_libs.sh
├── lib
    ├── TaskQueue
    │   └── taskqueue.go
    ├── models
    │   ├── create_tables.sql
    │   ├── mappings.go
    │   ├── models.go
    │   └── users.go
    └── utils
    │   ├── conversions.go
    │   ├── crypto.go
    │   ├── db.go
    │   ├── email.go
    │   └── files.go
├── utilities
    ├── commander
    │   ├── commander.go
    │   └── config.json
    ├── hashpasswd
    │   └── hashpasswd.go
    └── uploadfile
    │   └── uploadfile.go
└── worker
    └── fileanalyzer
        ├── config.json
        ├── fileTaskWorker.py
        ├── model.py
        ├── oid.py
        ├── pefile
            ├── CHANGES_up_to_1.2.6
            ├── COPYING
            ├── MANIFEST
            ├── README
            ├── __init__.py
            ├── ordlookup
            │   ├── __init__.py
            │   ├── oleaut32.py
            │   └── ws2_32.py
            ├── pefile.py
            ├── peutils.py
            └── setup.py
        └── verifysigs
            ├── CHANGES
            ├── COPYING
            ├── README
            ├── __init__.py
            ├── asn1
                ├── __init__.py
                ├── catalog.py
                ├── dn.py
                ├── oids.py
                ├── pkcs7.py
                ├── spc.py
                ├── time_test.py
                ├── x509.py
                └── x509_time.py
            ├── auth_data.py
            ├── auth_data_test.py
            ├── fingerprint.py
            ├── fingerprinter_test.py
            ├── generate_test_data.py
            ├── pecoff_blob.py
            └── print_pe_certs.py


/.envrc:
--------------------------------------------------------------------------------
1 | export  GVP_DIR="$(pwd)/.godeps"
2 | export GOBIN="$GVP_DIR/bin"
3 | export GOPATH="$GVP_DIR:`echo $PWD | sed 's/src.*//'`"
4 | export PATH="$GOBIN:$PATH"
5 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .godeps
 2 | /configureMSI
 3 | 
 4 | /WebServer/server
 5 | /WebServer/downloads
 6 | /WebServer/public/index.html
 7 | /WebServer/public/js/main.js
 8 | /WebServer_old
 9 | 
10 | /CallbackServer/server
11 | /CallbackServer/uploaded
12 | /CallbackServer/updates
13 | /frontend/node_modules
14 | 
15 | *.pyc
16 | /utilities/createTask/createTask
17 | /bin
18 | /utilities/commander/commander
19 | /.idea
20 | 


--------------------------------------------------------------------------------
/CallbackServer/command/command.go:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////
  2 | //
  3 | // Summit Route End Point Protection
  4 | //
  5 | // This source code is licensed under the BSD-style license found in the
  6 | // LICENSE file in the root directory of this source tree.
  7 | //
  8 | /////////////////////////////////////////////////////////////////////////////
  9 | 
 10 | 
 11 | package command
 12 | 
 13 | import (
 14 | 	"encoding/json"
 15 | 
 16 | 	"github.com/coopernurse/gorp"
 17 | 
 18 | 	"qdserver/lib/models"
 19 | 	"qdserver/lib/utils"
 20 | )
 21 | 
 22 | // ResponseToAgent struct
 23 | type ResponseToAgent struct {
 24 | 	Command   string
 25 | 	Arguments interface{}
 26 | }
 27 | 
 28 | // SetSystemUUID command
 29 | func SetSystemUUID(systemUUID string) ResponseToAgent {
 30 | 	response := ResponseToAgent{
 31 | 		Command: "SetSystemUUID",
 32 | 		Arguments: struct {
 33 | 			SystemUUID string
 34 | 		}{
 35 | 			systemUUID,
 36 | 		}}
 37 | 	return response
 38 | }
 39 | 
 40 | // GetFileByHash command
 41 | func GetFileByHash(sha256 string) ResponseToAgent {
 42 | 	response := ResponseToAgent{
 43 | 		Command: "GetFileByHash",
 44 | 		Arguments: struct {
 45 | 			Sha256 string
 46 | 		}{
 47 | 			sha256,
 48 | 		}}
 49 | 	return response
 50 | }
 51 | 
 52 | // GetCatalogFileByHash command
 53 | func GetCatalogFileByHash(sha256 string) ResponseToAgent {
 54 | 	response := ResponseToAgent{
 55 | 		Command: "GetCatalogFileByHash",
 56 | 		Arguments: struct {
 57 | 			Sha256 string
 58 | 		}{
 59 | 			sha256,
 60 | 		}}
 61 | 	return response
 62 | }
 63 | 
 64 | // Update command
 65 | func Update(newVersion string) ResponseToAgent {
 66 | 	response := ResponseToAgent{
 67 | 		Command: "Update",
 68 | 		Arguments: struct {
 69 | 			NewVersion string
 70 | 		}{
 71 | 			newVersion,
 72 | 		}}
 73 | 	return response
 74 | }
 75 | 
 76 | // Stall command is used when something has gone wrong on the server, so we delay the client so I have time to hopefully fix it
 77 | func Stall() ResponseToAgent {
 78 | 	response := ResponseToAgent{
 79 | 		Command:   "Stall",
 80 | 		Arguments: nil}
 81 | 	return response
 82 | }
 83 | 
 84 | // Nop command
 85 | func Nop() ResponseToAgent {
 86 | 	response := ResponseToAgent{
 87 | 		Command:   "NOP",
 88 | 		Arguments: nil}
 89 | 	return response
 90 | }
 91 | 
 92 | // Success command tells the agent it was successful for times when process events are sent
 93 | func Success() ResponseToAgent {
 94 | 	response := ResponseToAgent{
 95 | 		Command:   "Success",
 96 | 		Arguments: nil}
 97 | 	return response
 98 | }
 99 | 
100 | // AddTask stores a task to be sent to a system next time it calls in
101 | func AddTask(db *gorp.DbMap, systemID int64, agentCommand ResponseToAgent) (err error) {
102 | 	// Convert command to json
103 | 	jsonCommand, err := json.Marshal(agentCommand)
104 | 	if err != nil {
105 | 		return err
106 | 	}
107 | 
108 | 	task := &models.Task{
109 | 		SystemID:     systemID,
110 | 		CreationDate: utils.DBTimeNow(),
111 | 		Command:      string(jsonCommand),
112 | 	}
113 | 
114 | 	// Save it
115 | 	if err = db.Insert(task); err != nil {
116 | 		return err
117 | 	}
118 | 
119 | 	return nil
120 | }
121 | 


--------------------------------------------------------------------------------
/CallbackServer/config.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"listening_port": "8080",
 3 | 	"upload_path": "./uploaded/",
 4 | 	"amqp_server": "amqp://guest:guest@localhost:5672/",
 5 | 	"database": {
 6 | 		"connection_string": "user=postgres password=password dbname=srepp sslmode=disable"
 7 | 	},
 8 | 	"aws": {
 9 | 		"exe_upload": {
10 | 			"bucket_name": "summitroute.file.uploads",
11 | 			"access_key": "YOUR_ACCESS_KEY",
12 | 			"secret_key": "YOUR_SECRET_KEY",
13 | 			"region": "us-east-1"
14 | 		},
15 | 		"catalog_upload": {
16 | 			"bucket_name": "summitroute.catalog.uploads",
17 | 			"access_key": "YOUR_ACCESS_KEY",
18 | 			"secret_key": "YOUR_SECRET_KEY",
19 | 			"region": "us-east-1"
20 | 		}
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/CallbackServer/controllers/api/CatalogFileEvent.go:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////
  2 | //
  3 | // Summit Route End Point Protection
  4 | //
  5 | // This source code is licensed under the BSD-style license found in the
  6 | // LICENSE file in the root directory of this source tree.
  7 | //
  8 | /////////////////////////////////////////////////////////////////////////////
  9 | 
 10 | package api
 11 | 
 12 | import (
 13 | 	"encoding/hex"
 14 | 	"encoding/json"
 15 | 	"io/ioutil"
 16 | 	"net/http"
 17 | 
 18 | 	log "github.com/Sirupsen/logrus"
 19 | 	_ "github.com/lib/pq" // Needed for gorp
 20 | 	"github.com/zenazn/goji/web"
 21 | 
 22 | 	"qdserver/CallbackServer/command"
 23 | 	"qdserver/lib/models"
 24 | 	"qdserver/lib/utils"
 25 | )
 26 | 
 27 | // CatalogFileEvent route is called by clients when a catalog file is used
 28 | func (controller *Controller) CatalogFileEvent(c web.C, r *http.Request) (string, int) {
 29 | 	// Parse body into json
 30 | 	body, err := ioutil.ReadAll(r.Body)
 31 | 	if err != nil {
 32 | 		log.Errorf("Unable to read body")
 33 | 		return "", http.StatusBadRequest
 34 | 	}
 35 | 
 36 | 	type eventFromClient struct {
 37 | 		SystemUUID        string
 38 | 		CustomerUUID      string
 39 | 		CurrentClientTime int64
 40 | 		TimeOfEvent       int64
 41 | 		Path              string
 42 | 		Sha256            string // Sha256 of the file
 43 | 		Size              int
 44 | 	}
 45 | 
 46 | 	var event eventFromClient
 47 | 	err = json.Unmarshal(body, &event)
 48 | 	if err != nil {
 49 | 		log.Errorf("Unable to unmarshal json, %v", err)
 50 | 		return "", http.StatusBadRequest
 51 | 	}
 52 | 
 53 | 	db := controller.GetDatabase(c)
 54 | 
 55 | 	systemID, err := utils.GetSystemIDFromUUID(db, event.SystemUUID, event.CustomerUUID)
 56 | 	if err != nil {
 57 | 		log.Errorf("Unable to parse get System ID, %v", err)
 58 | 		return "", http.StatusBadRequest
 59 | 	}
 60 | 
 61 | 	// Add the Catalog to the DB
 62 | 	Sha256, err := hex.DecodeString(event.Sha256)
 63 | 	if err != nil {
 64 | 		log.Errorf("Unable to decode Sha256: %v", err)
 65 | 		return "", http.StatusBadRequest
 66 | 	}
 67 | 
 68 | 	timeOfEvent := (utils.DBTimeNow() - event.CurrentClientTime) + event.TimeOfEvent
 69 | 
 70 | 	// Check if we've seen this executable before
 71 | 	var catalogID int64
 72 | 	catalogID, err = db.SelectInt(`SELECT ID
 73 | 		FROM CatalogFiles
 74 | 		WHERE Sha256=:sha256`,
 75 | 		map[string]interface{}{
 76 | 			"sha256": Sha256,
 77 | 		})
 78 | 	if err != nil {
 79 | 		log.Errorf("Error checking for file: %v", err)
 80 | 		return "", http.StatusBadRequest
 81 | 	}
 82 | 	if catalogID == 0 {
 83 | 		log.Infof("New file, adding it to the DB")
 84 | 
 85 | 		// Assuming executable has not been found, so adding it to the DB
 86 | 		catalogFileInsert := &models.CatalogFile{
 87 | 			FilePath:  event.Path,
 88 | 			Sha256:    Sha256,
 89 | 			Size:      event.Size,
 90 | 			FirstSeen: timeOfEvent,
 91 | 		}
 92 | 
 93 | 		// Save it
 94 | 		if err = db.Insert(catalogFileInsert); err != nil {
 95 | 			log.Errorf("Error while creating processEvent: %v", err)
 96 | 			return "", http.StatusBadRequest
 97 | 		}
 98 | 
 99 | 		catalogID = catalogFileInsert.ID
100 | 
101 | 		// Create a task to tell this agent to get that file
102 | 		agentCommand := command.GetCatalogFileByHash(event.Sha256)
103 | 		if err = command.AddTask(db, systemID, agentCommand); err != nil {
104 | 			log.Errorf("Unable to add task for agent, %v", err)
105 | 			return "", http.StatusBadRequest
106 | 		}
107 | 	}
108 | 
109 | 	// Else if a catalogID exists, then we've seen this catalog before so we don't need to do anything
110 | 	// TODO Might be smart to keep track of all the agents that have this catalog
111 | 
112 | 	return GenerateResponseToAgent(db, systemID, command.Success())
113 | }
114 | 


--------------------------------------------------------------------------------
/CallbackServer/controllers/api/GetUpdate.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package api
11 | 
12 | import (
13 | 	"encoding/json"
14 | 	"fmt"
15 | 	"io/ioutil"
16 | 	"net/http"
17 | 	"path"
18 | 	"qdserver/lib/utils"
19 | 
20 | 	log "github.com/Sirupsen/logrus"
21 | 	_ "github.com/lib/pq" // Needed for gorp
22 | 	"github.com/zenazn/goji/web"
23 | )
24 | 
25 | // GetUpdate route
26 | func (controller *Controller) GetUpdate(c web.C, r *http.Request) (string, int) {
27 | 	db := controller.GetDatabase(c)
28 | 
29 | 	// Parse body into json
30 | 	body, err := ioutil.ReadAll(r.Body)
31 | 	if err != nil {
32 | 		log.Errorf("Unable to read body")
33 | 		return "", http.StatusBadRequest
34 | 	}
35 | 
36 | 	type ClientData struct {
37 | 		SystemUUID        string
38 | 		CustomerUUID      string
39 | 		CurrentClientTime int64
40 | 		Version           string
41 | 	}
42 | 	var clientData ClientData
43 | 	err = json.Unmarshal(body, &clientData)
44 | 	if err != nil {
45 | 		log.Errorf("Unable to unmarshal json")
46 | 		return "", http.StatusBadRequest
47 | 	}
48 | 
49 | 	// Search database for what update we can use
50 | 	var UpdateToVersion string
51 | 	err = db.SelectOne(&UpdateToVersion, `SELECT VersionTo
52 | 		FROM Updates
53 | 		WHERE VersionFrom=:version
54 | 		ORDER BY VersionTo
55 | 		Limit 1`,
56 | 		map[string]interface{}{
57 | 			"version": clientData.Version,
58 | 		})
59 | 	if err != nil {
60 | 		log.Errorf("Error checking version to update to: %v", err)
61 | 		return "", http.StatusBadRequest
62 | 	}
63 | 
64 | 	updaterName := fmt.Sprintf("update-%s-%s.exe", clientData.Version, UpdateToVersion)
65 | 	updatePath := path.Join("updates", updaterName)
66 | 
67 | 	if !utils.CheckExists(updatePath) {
68 | 		// TODO Need to get file from S3 to local
69 | 		log.Errorf("Update file does not exist: %v", err)
70 | 		return "", http.StatusBadRequest
71 | 	}
72 | 
73 | 	// File should now exist so read it
74 | 	contents, err := ioutil.ReadFile(updatePath)
75 | 	if err != nil {
76 | 		log.Errorf("Unable to read file, %v", err)
77 | 		return "", http.StatusBadRequest
78 | 	}
79 | 
80 | 	c.Env["Content-Type"] = "application/octet-stream"
81 | 	c.Env["Content-Length"] = fmt.Sprintf("%d", len(contents))
82 | 
83 | 	return string(contents), http.StatusOK
84 | }
85 | 


--------------------------------------------------------------------------------
/CallbackServer/controllers/api/Heartbeat.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package api
11 | 
12 | import (
13 | 	"encoding/json"
14 | 	"io/ioutil"
15 | 	"net/http"
16 | 
17 | 	log "github.com/Sirupsen/logrus"
18 | 	_ "github.com/lib/pq" // Needed for gorp
19 | 	"github.com/zenazn/goji/web"
20 | 
21 | 	"qdserver/CallbackServer/command"
22 | 	"qdserver/lib/utils"
23 | )
24 | 
25 | // Heartbeat route
26 | // curl -d '{"SystemUUID":"29c0b4f4-d6ab-46d8-604a-268863059f76","CustomerUUID":"3d794551-91a0-4db4-6296-ffcbfc5577f9","CurrentClientTime":1415296881 }' http://127.0.0.1:8080/api/v1/Heartbeat
27 | func (controller *Controller) Heartbeat(c web.C, r *http.Request) (string, int) {
28 | 	// Parse body into json
29 | 	body, err := ioutil.ReadAll(r.Body)
30 | 	if err != nil {
31 | 		log.Errorf("Unable to read body")
32 | 		return "", http.StatusBadRequest
33 | 	}
34 | 
35 | 	type Heartbeat struct {
36 | 		SystemUUID        string
37 | 		CustomerUUID      string
38 | 		CurrentClientTime int64
39 | 	}
40 | 	var heartbeat Heartbeat
41 | 	err = json.Unmarshal(body, &heartbeat)
42 | 	if err != nil {
43 | 		log.Errorf("Unable to unmarshal json")
44 | 		return "", http.StatusBadRequest
45 | 	}
46 | 
47 | 	db := controller.GetDatabase(c)
48 | 
49 | 	systemID, err := utils.GetSystemIDFromUUID(db, heartbeat.SystemUUID, heartbeat.CustomerUUID)
50 | 	if err != nil {
51 | 		log.Errorf("Unable to parse get System ID, %v", err)
52 | 		return "", http.StatusBadRequest
53 | 	}
54 | 	log.Infof("SystemID: %d", systemID)
55 | 
56 | 	return GenerateResponseToAgent(db, systemID, command.Nop())
57 | }
58 | 


--------------------------------------------------------------------------------
/CallbackServer/controllers/api/RegisterAgent.go:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////
  2 | //
  3 | // Summit Route End Point Protection
  4 | //
  5 | // This source code is licensed under the BSD-style license found in the
  6 | // LICENSE file in the root directory of this source tree.
  7 | //
  8 | /////////////////////////////////////////////////////////////////////////////
  9 | 
 10 | package api
 11 | 
 12 | import (
 13 | 	"encoding/json"
 14 | 	"io/ioutil"
 15 | 	"net/http"
 16 | 
 17 | 	log "github.com/Sirupsen/logrus"
 18 | 	_ "github.com/lib/pq" // Needed for gorp
 19 | 	uuid "github.com/nu7hatch/gouuid"
 20 | 	"github.com/zenazn/goji/web"
 21 | 
 22 | 	"qdserver/CallbackServer/command"
 23 | 	"qdserver/lib/models"
 24 | 	"qdserver/lib/utils"
 25 | )
 26 | 
 27 | // RegisterAgent route
 28 | func (controller *Controller) RegisterAgent(c web.C, r *http.Request) (string, int) {
 29 | 	// Parse body into json
 30 | 	body, err := ioutil.ReadAll(r.Body)
 31 | 	if err != nil {
 32 | 		log.Errorf("Unable to read body")
 33 | 		return "", http.StatusBadRequest
 34 | 	}
 35 | 
 36 | 	type Registration struct {
 37 | 		CustomerUUID string
 38 | 		AgentVersion string
 39 | 
 40 | 		OSHumanName  string
 41 | 		OSVersion    string
 42 | 		Manufacturer string
 43 | 		Model        string
 44 | 		Arch         string
 45 | 		MachineName  string
 46 | 		MachineGUID  string
 47 | 	}
 48 | 	var registration Registration
 49 | 	err = json.Unmarshal(body, &registration)
 50 | 	if err != nil {
 51 | 		log.Errorf("Unable to unmarshal json")
 52 | 		return "", http.StatusBadRequest
 53 | 	}
 54 | 
 55 | 	// Generate SystemUUID for the agent
 56 | 	SystemUUID, _ := uuid.NewV4()
 57 | 	// TODO Check for collisions on the UUID
 58 | 
 59 | 	//
 60 | 	// Record this in the database
 61 | 	//
 62 | 	db := controller.GetDatabase(c)
 63 | 
 64 | 	// Convert Customer UUID into a byte slice
 65 | 	customerUUIDslice, err := utils.UUIDStringToBytes(registration.CustomerUUID)
 66 | 	if err != nil {
 67 | 		log.Errorf("Unable to parse Customer UUID")
 68 | 		return "", http.StatusBadRequest
 69 | 	}
 70 | 
 71 | 	// Get Customer from UUID
 72 | 	var customer models.Customer
 73 | 	// TODO This needs a key or something so it isn't slow
 74 | 	err = db.SelectOne(&customer, "select * from customers where UUID=:uuid",
 75 | 		map[string]interface{}{
 76 | 			"uuid": customerUUIDslice,
 77 | 		})
 78 | 	if err != nil {
 79 | 		log.Errorf("Unable to find customer in DB")
 80 | 		return "", http.StatusBadRequest
 81 | 	}
 82 | 
 83 | 	// Look for Default SystemSet, and if you can't find it, add it
 84 | 	var systemSet models.SystemSet
 85 | 	var systemSetID int64
 86 | 
 87 | 	err = db.SelectOne(&systemSet, "select * from systemsets where CustomerID=:customerID and Name like :name",
 88 | 		map[string]interface{}{
 89 | 			"customerID": customer.ID,
 90 | 			"name":       "Default",
 91 | 		})
 92 | 	if err != nil {
 93 | 		// TODO Need to check the err means "not found" and not something bad
 94 | 
 95 | 		// Add SystemSet
 96 | 		systemSetInsert := &models.SystemSet{
 97 | 			CustomerID:   customer.ID,
 98 | 			Name:         "Default",
 99 | 			CreationDate: utils.DBTimeNow(),
100 | 		}
101 | 
102 | 		// Save it
103 | 		if err = db.Insert(systemSetInsert); err != nil {
104 | 			log.Errorf("Error while creating systemset: %v", err)
105 | 			return "", http.StatusBadRequest
106 | 		}
107 | 		systemSetID = systemSetInsert.ID
108 | 	} else {
109 | 		systemSetID = systemSet.ID
110 | 	}
111 | 
112 | 	var SystemUUIDslice []byte
113 | 	SystemUUIDslice = SystemUUID[0:16]
114 | 
115 | 	// Create system DB object
116 | 	systemInsert := &models.System{
117 | 		SystemSetID:  systemSetID,
118 | 		SystemUUID:   SystemUUIDslice,
119 | 		AgentVersion: registration.AgentVersion,
120 | 
121 | 		OSHumanName:  registration.OSHumanName,
122 | 		OSVersion:    registration.OSVersion,
123 | 		Manufacturer: registration.Manufacturer,
124 | 		Model:        registration.Model,
125 | 		Arch:         registration.Arch,
126 | 		MachineName:  registration.MachineName,
127 | 		MachineGUID:  registration.MachineGUID,
128 | 
129 | 		FirstSeen: utils.DBTimeNow(),
130 | 		LastSeen:  utils.DBTimeNow(),
131 | 	}
132 | 
133 | 	// Save it
134 | 	if err = db.Insert(systemInsert); err != nil {
135 | 		log.Errorf("Error while creating system: %v", err)
136 | 		return "", http.StatusBadRequest
137 | 	}
138 | 
139 | 	systemID := systemInsert.ID
140 | 
141 | 	return GenerateResponseToAgent(db, systemID, command.SetSystemUUID(SystemUUID.String()))
142 | }
143 | 


--------------------------------------------------------------------------------
/CallbackServer/controllers/api/helpers.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package api
11 | 
12 | import (
13 | 	"encoding/json"
14 | 	"net/http"
15 | 
16 | 	log "github.com/Sirupsen/logrus"
17 | 	"github.com/coopernurse/gorp"
18 | 
19 | 	"qdserver/CallbackServer/command"
20 | 	"qdserver/lib/models"
21 | 	"qdserver/lib/utils"
22 | )
23 | 
24 | // GenerateResponseToAgent creates a response the agent expects given a command
25 | // If the command is a NOP, check if we have any tasks
26 | func GenerateResponseToAgent(db *gorp.DbMap, systemID int64, response command.ResponseToAgent) (string, int) {
27 | 	if response == command.Nop() {
28 | 		var tasks []models.Task
29 | 		_, err := db.Select(&tasks, `SELECT *
30 | 						FROM Tasks t
31 | 						WHERE t.SystemID=:systemID and t.DeployedToAgentDate = 0
32 | 						ORDER BY CreationDate`,
33 | 			map[string]interface{}{
34 | 				"systemID": systemID,
35 | 			})
36 | 		if err != nil {
37 | 			log.Errorf("Problem searching Tasks table... this is bad, %v", err)
38 | 			// TODO Need to do something in case of this error
39 | 		} else if len(tasks) > 0 {
40 | 			task := tasks[0]
41 | 
42 | 			task.DeployedToAgentDate = utils.DBTimeNow()
43 | 			// TODO MUST I need to provide a task ID to the agent so when it responds I can mark this as completed.  Else if I send
44 | 			//   the agent a task and it fails, we never resend.
45 | 
46 | 			// Update it in the DB
47 | 			_, err := db.Update(&task)
48 | 			if err != nil {
49 | 				log.Errorf("Can't update task: %v", err)
50 | 				// TODO Need to do something smart with this error
51 | 			}
52 | 
53 | 			return task.Command, http.StatusOK
54 | 		}
55 | 	}
56 | 
57 | 	// json response
58 | 	responseBytes, err := json.Marshal(response)
59 | 	if err != nil {
60 | 		log.Errorf("Unable to marshal json response, %v", err)
61 | 		return "", http.StatusBadRequest
62 | 	}
63 | 
64 | 	return string(responseBytes), http.StatusOK
65 | }
66 | 


--------------------------------------------------------------------------------
/CallbackServer/controllers/api/routes.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package api
11 | 
12 | import (
13 | 	"net/http"
14 | 
15 | 	_ "github.com/lib/pq" // Needed for gorp
16 | 	"github.com/zenazn/goji/web"
17 | 
18 | 	"qdserver/CallbackServer/system"
19 | )
20 | 
21 | // Controller object
22 | type Controller struct {
23 | 	system.Controller
24 | }
25 | 
26 | // Status health check for the load balancer
27 | func (controller *Controller) Status(c web.C, r *http.Request) (string, int) {
28 | 	return "Summit Route callback server", http.StatusOK
29 | }
30 | 


--------------------------------------------------------------------------------
/CallbackServer/server.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package main
11 | 
12 | import (
13 | 	"flag"
14 | 	"fmt"
15 | 
16 | 	log "github.com/Sirupsen/logrus"
17 | 	"github.com/goji/glogrus"
18 | 	_ "github.com/lib/pq" // Needed for gorp
19 | 	"github.com/zenazn/goji"
20 | 	"github.com/zenazn/goji/graceful"
21 | 	"github.com/zenazn/goji/web/middleware"
22 | 
23 | 	"qdserver/CallbackServer/controllers/api"
24 | 	"qdserver/CallbackServer/system"
25 | )
26 | 
27 | func main() {
28 | 	configfile := flag.String("config", "config.json", "Path to configuration file")
29 | 	flag.Parse()
30 | 
31 | 	var application = &system.Application{}
32 | 	application.Init(configfile)
33 | 	application.ConnectToDatabase()
34 | 	application.ConnectToQueues()
35 | 
36 | 	//
37 | 	// Apply middleware
38 | 	//
39 | 
40 | 	goji.Use(application.ApplyConfig)
41 | 
42 | 	// User defined logs
43 | 	log.SetFormatter(new(log.JSONFormatter))
44 | 
45 | 	// Goji logs
46 | 	goji.Abandon(middleware.Logger)
47 | 	logr := log.New()
48 | 	logr.Formatter = new(log.JSONFormatter)
49 | 	goji.Use(glogrus.NewGlogrus(logr, "callbackserver"))
50 | 
51 | 	controller := &api.Controller{}
52 | 
53 | 	//
54 | 	// Setup routes
55 | 	//
56 | 
57 | 	goji.Get("/", application.Route(controller, "Status"))
58 | 
59 | 	// Clients call getRegisterSystem to inform the server they've been installed and to
60 | 	// get a system UUID
61 | 	goji.Post("/api/v1/Register", application.Route(controller, "RegisterAgent"))
62 | 	goji.Post("/api/v1/ProcessEvent", application.Route(controller, "ProcessEvent"))
63 | 	goji.Post("/api/v1/CatalogFileEvent", application.Route(controller, "CatalogFileEvent"))
64 | 	goji.Post("/api/v1/UploadFile", application.Route(controller, "UploadFile"))
65 | 	goji.Post("/api/v1/Heartbeat", application.Route(controller, "Heartbeat"))
66 | 	goji.Post("/api/v1/GetUpdate", application.Route(controller, "GetUpdate"))
67 | 
68 | 	graceful.PostHook(func() {
69 | 		application.Close()
70 | 	})
71 | 
72 | 	flag.Set("bind", fmt.Sprintf(":%s", application.Configuration.ListeningPort))
73 | 	goji.Serve()
74 | }
75 | 


--------------------------------------------------------------------------------
/CallbackServer/system/configuration.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package system
11 | 
12 | import (
13 | 	"encoding/json"
14 | 	"io/ioutil"
15 | 
16 | 	"qdserver/lib/utils"
17 | )
18 | 
19 | // ConfigurationDatabase is a sub-element of Configuration
20 | type ConfigurationDatabase struct {
21 | 	ConnectionString string `json:"connection_string"`
22 | }
23 | 
24 | // ConfigurationAWS is a sub-element of Configuration
25 | type ConfigurationAWS struct {
26 | 	ExeUpload     utils.AwsS3 `json:"exe_upload"`
27 | 	CatalogUpload utils.AwsS3 `json:"catalog_upload"`
28 | }
29 | 
30 | // Configuration is the main structure of our config.json file
31 | type Configuration struct {
32 | 	ListeningPort string                `json:"listening_port"`
33 | 	UploadPath    string                `json:"upload_path"`
34 | 	AMQPServer    string                `json:"amqp_server"`
35 | 	Database      ConfigurationDatabase `json:"database"`
36 | 	Aws           ConfigurationAWS      `json:"aws"`
37 | }
38 | 
39 | // Load parses our configuration file
40 | func (configuration *Configuration) Load(filename string) (err error) {
41 | 	data, err := ioutil.ReadFile(filename)
42 | 	if err != nil {
43 | 		return
44 | 	}
45 | 
46 | 	err = configuration.Parse(data)
47 | 
48 | 	return
49 | }
50 | 
51 | // Parse our configuration file
52 | func (configuration *Configuration) Parse(data []byte) (err error) {
53 | 	err = json.Unmarshal(data, &configuration)
54 | 
55 | 	return
56 | }
57 | 


--------------------------------------------------------------------------------
/CallbackServer/system/controller.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package system
11 | 
12 | import (
13 | 	"github.com/coopernurse/gorp"
14 | 	"github.com/streadway/amqp"
15 | 	"github.com/zenazn/goji/web"
16 | )
17 | 
18 | // Controller struct
19 | type Controller struct {
20 | }
21 | 
22 | // GetDatabase helper
23 | func (controller *Controller) GetDatabase(c web.C) *gorp.DbMap {
24 | 	if db, ok := c.Env["DBSession"].(*gorp.DbMap); ok {
25 | 		return db
26 | 	}
27 | 
28 | 	return nil
29 | }
30 | 
31 | // GetQueueChannel helper
32 | func (controller *Controller) GetQueueChannel(c web.C) *amqp.Channel {
33 | 	if ch, ok := c.Env["QueueChannel"].(*amqp.Channel); ok {
34 | 		return ch
35 | 	}
36 | 
37 | 	return nil
38 | }
39 | 


--------------------------------------------------------------------------------
/CallbackServer/system/core.go:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////
  2 | //
  3 | // Summit Route End Point Protection
  4 | //
  5 | // This source code is licensed under the BSD-style license found in the
  6 | // LICENSE file in the root directory of this source tree.
  7 | //
  8 | /////////////////////////////////////////////////////////////////////////////
  9 | 
 10 | package system
 11 | 
 12 | import (
 13 | 	"io"
 14 | 	"net/http"
 15 | 	"reflect"
 16 | 
 17 | 	log "github.com/Sirupsen/logrus"
 18 | 	"github.com/coopernurse/gorp"
 19 | 	_ "github.com/lib/pq" // Needed for gorp
 20 | 	"github.com/streadway/amqp"
 21 | 	"github.com/zenazn/goji/web"
 22 | 
 23 | 	"qdserver/lib/models"
 24 | 	"qdserver/lib/taskqueue"
 25 | )
 26 | 
 27 | // Application holds our app's global variables
 28 | type Application struct {
 29 | 	Configuration   *Configuration
 30 | 	DBSession       *gorp.DbMap
 31 | 	QueueConnection *amqp.Connection
 32 | 	QueueChannel    *amqp.Channel
 33 | }
 34 | 
 35 | // Init initializes our globals
 36 | func (application *Application) Init(filename *string) {
 37 | 	application.Configuration = &Configuration{}
 38 | 
 39 | 	// Load our configuration file
 40 | 	err := application.Configuration.Load(*filename)
 41 | 	if err != nil {
 42 | 		log.Fatalf("Can't read configuration file: %s", err)
 43 | 		panic(err)
 44 | 	}
 45 | }
 46 | 
 47 | // ConnectToDatabase initializes our database connection
 48 | func (application *Application) ConnectToDatabase() {
 49 | 	// Initialize the database
 50 | 	dbmap, err := models.InitDB(application.Configuration.Database.ConnectionString)
 51 | 	if err != nil {
 52 | 		log.Fatalf("Unable to initialize the database: %v", err)
 53 | 		panic(err)
 54 | 	}
 55 | 
 56 | 	// Store our session
 57 | 	application.DBSession = dbmap
 58 | }
 59 | 
 60 | // ConnectToQueues initializes our AMQP connection
 61 | func (application *Application) ConnectToQueues() {
 62 | 	conn, err := amqp.Dial(application.Configuration.AMQPServer)
 63 | 	if err != nil {
 64 | 		log.Fatalf("Failed to connect to RabbitMQ: %v", err)
 65 | 		panic(err)
 66 | 	}
 67 | 
 68 | 	ch, err := conn.Channel()
 69 | 	if err != nil {
 70 | 		log.Errorf("Failed to open a channel: %v", err)
 71 | 		panic(err)
 72 | 	}
 73 | 
 74 | 	// Create queues
 75 | 	for _, queueName := range []string{"analyzefile", "analyzecatalog"} {
 76 | 		err = TaskQueue.CreateQueue(ch, queueName)
 77 | 		if err != nil {
 78 | 			conn.Close()
 79 | 			ch.Close()
 80 | 			log.Errorf("Failed to create queue %s; %v", queueName, err)
 81 | 		}
 82 | 	}
 83 | 
 84 | 	application.QueueChannel = ch
 85 | 	application.QueueConnection = conn
 86 | }
 87 | 
 88 | // Close cleans up anything nicely before exiting the process
 89 | func (application *Application) Close() {
 90 | 	log.Info("Bye!")
 91 | 	application.DBSession.Db.Close()
 92 | 	application.QueueConnection.Close()
 93 | 	application.QueueChannel.Close()
 94 | }
 95 | 
 96 | // Route defines a web route
 97 | func (application *Application) Route(controller interface{}, route string) interface{} {
 98 | 	fn := func(c web.C, w http.ResponseWriter, r *http.Request) {
 99 | 		c.Env["Content-Type"] = "application/json"
100 | 
101 | 		methodValue := reflect.ValueOf(controller).MethodByName(route)
102 | 		methodInterface := methodValue.Interface()
103 | 		method := methodInterface.(func(c web.C, r *http.Request) (string, int))
104 | 
105 | 		body, code := method(c, r)
106 | 
107 | 		switch code {
108 | 		case http.StatusOK:
109 | 			if _, exists := c.Env["Content-Type"]; exists {
110 | 				w.Header().Set("Content-Type", c.Env["Content-Type"].(string))
111 | 			}
112 | 			if _, exists := c.Env["Content-Length"]; exists {
113 | 				w.Header().Set("Content-Length", c.Env["Content-Length"].(string))
114 | 			}
115 | 			io.WriteString(w, body)
116 | 		case http.StatusSeeOther, http.StatusFound:
117 | 			http.Redirect(w, r, body, code)
118 | 		default:
119 | 			w.WriteHeader(code)
120 | 			io.WriteString(w, body)
121 | 		}
122 | 	}
123 | 	return fn
124 | }
125 | 


--------------------------------------------------------------------------------
/CallbackServer/system/middleware.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package system
11 | 
12 | import (
13 | 	"net/http"
14 | 
15 | 	"github.com/zenazn/goji/web"
16 | )
17 | 
18 | // ApplyConfig makes sure controllers can have access to the database and other variables
19 | func (application *Application) ApplyConfig(c *web.C, h http.Handler) http.Handler {
20 | 	fn := func(w http.ResponseWriter, r *http.Request) {
21 | 		c.Env["DBSession"] = application.DBSession
22 | 		c.Env["Config"] = application.Configuration
23 | 		c.Env["QueueChannel"] = application.QueueChannel
24 | 
25 | 		h.ServeHTTP(w, r)
26 | 	}
27 | 	return http.HandlerFunc(fn)
28 | }
29 | 


--------------------------------------------------------------------------------
/Godeps:
--------------------------------------------------------------------------------
 1 | golang.org/x/crypto/bcrypt
 2 | github.com/bitly/go-simplejson 3378bdcb5cebedcbf8b5750edee28010f128fe24
 3 | github.com/coopernurse/gorp  v1.7
 4 | github.com/gorilla/sessions aa5e036e6c44aec69a32eb41097001978b29ad31
 5 | github.com/justinas/nosurf/ 100c24154ff2b869e95c043ab8f099c18e4d491f
 6 | github.com/lib/pq  7175accbed18058468c07811f76440d6e8d7cf19
 7 | github.com/nu7hatch/gouuid  179d4d0c4d8d407a32af483c2354df1d2c91e6c3
 8 | github.com/zenazn/goji  119938d4b94fdf713efb3340ebd4ba5f3286f520
 9 | github.com/streadway/amqp 6ffc9248c4b16699477e7411084c2402f2f0c351
10 | github.com/crowdmob/goamz cd22d9897beff6f3de22cec4bdb7d46b9e2dee67
11 | github.com/goji/glogrus 92ccdaf5e752d8c8d61733f574a9f637c5b2d40c
12 | github.com/Sirupsen/logrus d2f9ffa1d9cf25b25191b221229effac1b6de526
13 | github.com/unrolled/secure 7c5d20f5d23b4825dfe542a006b37d6bdb5950f6
14 | github.com/rcrowley/go-metrics
15 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD License
 2 | 
 3 | For Summit Route End Point Protection
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 |  * Redistributions of source code must retain the above copyright notice, this
 9 |    list of conditions and the following disclaimer.
10 | 
11 |  * Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 |  * Neither the name Summit Route nor the names of its contributors may be used to
16 |    endorse or promote products derived from this software without specific
17 |    prior written permission.
18 | 
19 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
23 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
26 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Project Abandoned
 2 | =================
 3 | This is a code dump of what I had hoped to turn into a business, but walked away from.  No support or maintenance will be provided.
 4 | 
 5 | 
 6 | Summit Route End Point Protection (SREPP) - Server code
 7 | ===============================================
 8 | 
 9 | Proof-of-concept code. Still needs lots of work to make it a complete product.
10 | 
11 | Architecture
12 | ------------
13 | The server is composed of 4 parts:
14 | 
15 | - frontend: ReactJS javascript project to display a UI for the customer.  Some parts of this are simply mocks with no functionality or fake data.
16 | - WebServer: Go code to provide the frontend pieces and APIs to collect data from the database
17 | - CallbackServer: Go code for APIs the agents to communicate with.  Agents beacon data which is written to the database, and potentially receiving tasking (such as collect an executable).  Copies of executables are also sent back to the callbackserver which writes them to disk and creates tasks for workers to analyze.
18 | - worker: Python code for analyzing the PE file signature on any executables.
19 | 
20 | 
21 | Running
22 | -------
23 | The project was built to both be runnable on AWS or locally in a VM, so it was not tied to AWS and could deployed on-prem if needed.  It was meant to be horizonally scalable, but this was barely tested.  Deployed on Debian 7.7 x86_64. It uses Postgress for it's database and RabbitMQ for it's queueing.
24 | 
25 | The WebServer runs on port 8000 but is connected to via an nginx proxy for load-balancing and SSL termination that receives traffic on 443.
26 | Likewise the Callback server runs on 8080, but has nginx in front of it receiving traffic on 8443. 
27 | 
28 | - Create and start the Postgress database.
29 | - Start RabbitMQ.
30 | - Rename this project `qdserver`
31 | - Build the frontend (run `gulp` in ./frontend)
32 | - In WebServer, run `go run server.go`
33 | - In CallbackServer, run `go run server.go`


--------------------------------------------------------------------------------
/WebServer/config.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"environment": "debug",
 3 | 	"listening_port": "8000",
 4 | 	"secret": "YOUR_SECRET_FOR_TOKEN",
 5 | 	"public_path": "./public",
 6 | 	"template_path": "./views",
 7 | 	"base_url": "http://192.168.106.129:8000",
 8 | 	"database": {
 9 | 		"connection_string": "user=postgres password=password dbname=srepp sslmode=disable"
10 | 	},
11 | 	"aws": {
12 | 		"ses": {
13 | 			"access_key": "YOUR_ACCESS_KEY",
14 | 			"secret_key": "YOUR_SECRET_KEY",
15 | 			"region_url": "https://email.us-east-1.amazonaws.com"
16 | 		}
17 | 	}
18 | }
19 | 


--------------------------------------------------------------------------------
/WebServer/controllers/api/main.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package api
11 | 
12 | import (
13 | 	"net/http"
14 | 
15 | 	"github.com/zenazn/goji/web"
16 | 
17 | 	"qdserver/WebServer/system"
18 | )
19 | 
20 | // Controller blah
21 | type Controller struct {
22 | 	system.Controller
23 | }
24 | 
25 | // TermsAPI route
26 | func (controller *Controller) TermsAPI(c web.C, r *http.Request) (string, int) {
27 | 	t := controller.GetTemplate(c)
28 | 	return controller.Parse(t, "terms_and_conditions", c.Env), http.StatusOK
29 | }
30 | 
31 | // PrivacyAPI route
32 | func (controller *Controller) PrivacyAPI(c web.C, r *http.Request) (string, int) {
33 | 	t := controller.GetTemplate(c)
34 | 	return controller.Parse(t, "privacy", c.Env), http.StatusOK
35 | }
36 | 
37 | // HelpAPI route
38 | func (controller *Controller) HelpAPI(c web.C, r *http.Request) (string, int) {
39 | 	t := controller.GetTemplate(c)
40 | 	return controller.Parse(t, "help", c.Env), http.StatusOK
41 | }
42 | 


--------------------------------------------------------------------------------
/WebServer/controllers/api/processes.go:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////
  2 | //
  3 | // Summit Route End Point Protection
  4 | //
  5 | // This source code is licensed under the BSD-style license found in the
  6 | // LICENSE file in the root directory of this source tree.
  7 | //
  8 | /////////////////////////////////////////////////////////////////////////////
  9 | 
 10 | package api
 11 | 
 12 | import (
 13 | 	"encoding/hex"
 14 | 	"encoding/json"
 15 | 	"net/http"
 16 | 	"strconv"
 17 | 
 18 | 	log "github.com/Sirupsen/logrus"
 19 | 	"github.com/zenazn/goji/web"
 20 | 
 21 | 	"qdserver/WebServer/helpers"
 22 | 	"qdserver/lib/models"
 23 | 	"qdserver/lib/utils"
 24 | )
 25 | 
 26 | // ProcessesJSON route
 27 | func (controller *Controller) ProcessesJSON(c web.C, r *http.Request) (string, int) {
 28 | 	db := controller.GetDatabase(c)
 29 | 
 30 | 	// Read parameters
 31 | 	start := helpers.GetParam(r.URL.Query(), "start", "^[0-9]*$", "0")
 32 | 	length := helpers.GetParam(r.URL.Query(), "length", "^[0-9]*$", "25")
 33 | 	ilength, err := strconv.Atoi(length)
 34 | 	if err != nil || ilength > 100 {
 35 | 		length = "100"
 36 | 	}
 37 | 	filter := helpers.GetParam(r.URL.Query(), "filter", "^[a-z]*$", "")
 38 | 
 39 | 	// Get our user object
 40 | 	var user models.User
 41 | 	user, ok := c.Env["User"].(models.User)
 42 | 	if !ok {
 43 | 		// This should not happen
 44 | 		log.Errorf("User was not of the expected form")
 45 | 		return "", http.StatusBadRequest
 46 | 	}
 47 | 
 48 | 	type ProcessData struct {
 49 | 		Sha256      []byte
 50 | 		FilePath    string
 51 | 		CommandLine string
 52 | 		EventTime   int64
 53 | 	}
 54 | 
 55 | 	var processes []ProcessData
 56 | 
 57 | 	// TODO Need to check count in a smarter way so I'm not duplicating all this code
 58 | 
 59 | 	// Get count
 60 | 	filter = "%" + filter + "%"
 61 | 	count, err := db.SelectInt(`SELECT count(*)
 62 | 			FROM systemSets ss, systems s, ProcessEvents p, ExecutableFiles f
 63 | 			WHERE ss.CustomerID=:CustomerID and ss.ID =s.SystemSetID and s.ID=p.SystemID and p.ExecutableFileID=f.ID
 64 | 				and p.FilePath ILIKE :filter`,
 65 | 		map[string]interface{}{
 66 | 			"CustomerID": user.CustomerID,
 67 | 			"filter":     filter,
 68 | 		})
 69 | 	if err != nil {
 70 | 		// TODO MUST This probably can happen if no processes are in the DB
 71 | 		log.Errorf("Unable to find processes in DB, %v", err)
 72 | 		return "", http.StatusBadRequest
 73 | 	}
 74 | 
 75 | 	_, err = db.Select(&processes, `SELECT
 76 | 			f.Sha256, p.FilePath, p.CommandLine, p.EventTime
 77 | 			FROM systemSets ss, systems s, ProcessEvents p, ExecutableFiles f
 78 | 			WHERE ss.CustomerID=:CustomerID and ss.ID =s.SystemSetID and s.ID=p.SystemID and p.ExecutableFileID=f.ID
 79 | 				and p.FilePath ILIKE :filter
 80 | 			ORDER BY p.EventTime DESC
 81 | 			LIMIT :limit OFFSET :offset`,
 82 | 		map[string]interface{}{
 83 | 			"CustomerID": user.CustomerID,
 84 | 			"filter":     filter,
 85 | 			"limit":      length,
 86 | 			"offset":     start,
 87 | 		})
 88 | 	if err != nil {
 89 | 		// TODO MUST This probably can happen if no processes are in the DB
 90 | 		log.Errorf("Unable to find processes in DB, %v", err)
 91 | 		return "", http.StatusBadRequest
 92 | 	}
 93 | 
 94 | 	type ProcessDataJSON struct {
 95 | 		Sha256      string
 96 | 		FilePath    string
 97 | 		CommandLine string
 98 | 		EventTime   string
 99 | 	}
100 | 
101 | 	type DataTablesJSON struct {
102 | 		ITotalRecords        int               `json:"iTotalRecords"`
103 | 		ITotalDisplayRecords int               `json:"iTotalDisplayRecords"`
104 | 		SEcho                string            `json:"sEcho"`
105 | 		AaData               []ProcessDataJSON `json:"aaData"`
106 | 	}
107 | 
108 | 	var dataTablesJSON DataTablesJSON
109 | 	dataTablesJSON.ITotalRecords = int(count)
110 | 	dataTablesJSON.ITotalDisplayRecords = len(processes)
111 | 	dataTablesJSON.AaData = make([]ProcessDataJSON, len(processes), len(processes))
112 | 
113 | 	for index, process := range processes {
114 | 		var processDataJSON ProcessDataJSON
115 | 		processDataJSON.Sha256 = hex.EncodeToString(process.Sha256)
116 | 		processDataJSON.FilePath = process.FilePath
117 | 		processDataJSON.CommandLine = process.CommandLine
118 | 
119 | 		processDataJSON.EventTime = utils.Int64ToUnixTimeString(process.EventTime, true)
120 | 
121 | 		dataTablesJSON.AaData[index] = processDataJSON
122 | 	}
123 | 
124 | 	contents, err := json.Marshal(dataTablesJSON)
125 | 	if err != nil {
126 | 		log.Errorf("Unable to marshal json")
127 | 		return "", http.StatusBadRequest
128 | 	}
129 | 
130 | 	return string(contents), http.StatusOK
131 | }
132 | 


--------------------------------------------------------------------------------
/WebServer/controllers/doc.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package controllers
11 | 
12 | /*
13 | 	Controllers contain following submodules:
14 | 
15 | 	/api - your REST methods
16 | 	/web - your Web methods
17 | 
18 | */
19 | 


--------------------------------------------------------------------------------
/WebServer/controllers/web/downloadInstaller.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package web
11 | 
12 | import (
13 | 	"fmt"
14 | 	"io/ioutil"
15 | 	"net/http"
16 | 	"path"
17 | 
18 | 	log "github.com/Sirupsen/logrus"
19 | 	uuid "github.com/nu7hatch/gouuid"
20 | 	"github.com/zenazn/goji/web"
21 | 
22 | 	"qdserver/WebServer/helpers"
23 | 	"qdserver/lib/models"
24 | 	"qdserver/lib/utils"
25 | )
26 | 
27 | // DownloadInstaller route
28 | func (controller *Controller) DownloadInstaller(c web.C, r *http.Request) (string, int) {
29 | 	db := controller.GetDatabase(c)
30 | 
31 | 	// Get our user object
32 | 	var user models.User
33 | 	user, ok := c.Env["User"].(models.User)
34 | 	if !ok {
35 | 		// This should not happen
36 | 		log.Errorf("User was not of the expected form")
37 | 		return "/signin", http.StatusSeeOther
38 | 	}
39 | 
40 | 	// Get the Customer UUID
41 | 	var customer models.Customer
42 | 	err := db.SelectOne(&customer, "select * from customers where ID=:id",
43 | 		map[string]interface{}{
44 | 			"id": user.CustomerID,
45 | 		})
46 | 	if err != nil {
47 | 		log.Errorf("Unable to find customer in DB")
48 | 		return "/signin", http.StatusSeeOther
49 | 	}
50 | 
51 | 	CustomerUUID, err := uuid.Parse(customer.UUID)
52 | 	if err != nil {
53 | 		log.Errorf("Unable to parse UUID from DB, %v", err)
54 | 		return "/signin", http.StatusSeeOther
55 | 	}
56 | 
57 | 	// Check for personalized installer
58 | 	// TODO Need to put this version number somewhere configurable
59 | 	version := "0.0.0.1"
60 | 	guid := CustomerUUID.String()
61 | 	installerName := fmt.Sprintf("srepp%s-%s.exe", version, guid)
62 | 	installerPath := path.Join("downloads", installerName)
63 | 
64 | 	// TODO this is racy
65 | 	if !utils.CheckExists(installerPath) {
66 | 		log.Infof("Installer does not exist so creating it")
67 | 
68 | 		if err := helpers.ConfigureInstaller(path.Join("downloads", "srepp_installer.exe"), installerPath, guid); err != nil {
69 | 			log.Errorf("Unable to configure installer, %v", err)
70 | 			return "/signin", http.StatusSeeOther
71 | 		}
72 | 
73 | 		// TODO need to periodically delete these installers
74 | 	}
75 | 
76 | 	c.Env["Content-Type"] = "application/octet-stream"
77 | 	contents, err := ioutil.ReadFile(installerPath)
78 | 	if err != nil {
79 | 		log.Errorf("Unable to read file, %v", err)
80 | 		return "/signin", http.StatusSeeOther
81 | 	}
82 | 
83 | 	c.Env["Content-Length"] = fmt.Sprintf("%d", len(contents))
84 | 
85 | 	return string(contents), http.StatusOK
86 | }
87 | 


--------------------------------------------------------------------------------
/WebServer/controllers/web/index.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package web
11 | 
12 | import (
13 | 	"net/http"
14 | 
15 | 	"github.com/justinas/nosurf"
16 | 	"github.com/zenazn/goji/web"
17 | )
18 | 
19 | // Index route shows the home page
20 | func (controller *Controller) Index(c web.C, r *http.Request) (string, int) {
21 | 	t := controller.GetTemplate(c)
22 | 
23 | 	c.Env["csrf_token"] = nosurf.Token(r)
24 | 
25 | 	return controller.Parse(t, "index", c.Env), http.StatusOK
26 | }
27 | 


--------------------------------------------------------------------------------
/WebServer/controllers/web/logout.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package web
11 | 
12 | import (
13 | 	"net/http"
14 | 
15 | 	"github.com/zenazn/goji/web"
16 | )
17 | 
18 | // Logout logs the user out
19 | func (controller *Controller) Logout(c web.C, r *http.Request) (string, int) {
20 | 	session := controller.GetSession(c)
21 | 
22 | 	session.Values["SessionID"] = nil
23 | 	session.Values["SessionNonce"] = nil
24 | 
25 | 	return "/", http.StatusSeeOther
26 | }
27 | 


--------------------------------------------------------------------------------
/WebServer/controllers/web/main.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package web
11 | 
12 | import (
13 | 	"qdserver/WebServer/system"
14 | )
15 | 
16 | // Controller blah
17 | type Controller struct {
18 | 	system.Controller
19 | }
20 | 


--------------------------------------------------------------------------------
/WebServer/controllers/web/register.go:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////
  2 | //
  3 | // Summit Route End Point Protection
  4 | //
  5 | // This source code is licensed under the BSD-style license found in the
  6 | // LICENSE file in the root directory of this source tree.
  7 | //
  8 | /////////////////////////////////////////////////////////////////////////////
  9 | 
 10 | package web
 11 | 
 12 | import (
 13 | 	"html/template"
 14 | 	"net/http"
 15 | 
 16 | 	log "github.com/Sirupsen/logrus"
 17 | 	"github.com/justinas/nosurf"
 18 | 	uuid "github.com/nu7hatch/gouuid"
 19 | 	"github.com/zenazn/goji/web"
 20 | 
 21 | 	"qdserver/WebServer/helpers"
 22 | 	"qdserver/lib/models"
 23 | 	"qdserver/lib/utils"
 24 | )
 25 | 
 26 | // Register route
 27 | func (controller *Controller) Register(c web.C, r *http.Request) (string, int) {
 28 | 	t := controller.GetTemplate(c)
 29 | 	session := controller.GetSession(c)
 30 | 
 31 | 	// With that kind of flags template can "figure out" what route is being rendered
 32 | 	c.Env["IsRegister"] = true
 33 | 
 34 | 	c.Env["Flash"] = session.Flashes("auth")
 35 | 	c.Env["csrf_token"] = nosurf.Token(r)
 36 | 	var widgets = controller.Parse(t, "auth/register", c.Env)
 37 | 
 38 | 	c.Env["Title"] = "Summit Route - Register"
 39 | 	c.Env["Content"] = template.HTML(widgets)
 40 | 
 41 | 	return controller.Parse(t, "main", c.Env), http.StatusOK
 42 | }
 43 | 
 44 | // RegisterPost registers new user or shows Register route with appropriate messages set in session
 45 | func (controller *Controller) RegisterPost(c web.C, r *http.Request) (string, int) {
 46 | 	// TODO Need to validate these
 47 | 	firstname, lastname := r.FormValue("firstname"), r.FormValue("lastname")
 48 | 	email, password := r.FormValue("email"), r.FormValue("password")
 49 | 
 50 | 	session := controller.GetSession(c)
 51 | 	database := controller.GetDatabase(c)
 52 | 
 53 | 	// Check if this user already exists (based on email)
 54 | 	user := models.GetUserByEmail(database, email)
 55 | 	if user != nil {
 56 | 		session.AddFlash("A user with that email address already exists", "auth")
 57 | 		return controller.Register(c, r)
 58 | 	}
 59 | 
 60 | 	// Create Customer UUID
 61 | 	CustomerUUID, err := uuid.NewV4()
 62 | 	if err != nil {
 63 | 		// This is bad
 64 | 		log.Errorf("Problem getting a new uuid, %v", err)
 65 | 		session.AddFlash("The server is experiencing a problem, try again later", "auth")
 66 | 		return controller.Register(c, r)
 67 | 	}
 68 | 
 69 | 	// Convert UUID to slice for DB
 70 | 	var CustomerUUIDslice []byte
 71 | 	CustomerUUIDslice = CustomerUUID[0:16]
 72 | 
 73 | 	// Create customer DB object
 74 | 	customer := &models.Customer{
 75 | 		UUID:         CustomerUUIDslice,
 76 | 		Active:       true,
 77 | 		CreationDate: utils.DBTimeNow(),
 78 | 	}
 79 | 	// TODO Check for collisions on the UUID
 80 | 
 81 | 	// Save it
 82 | 	if err = database.Insert(customer); err != nil {
 83 | 		session.AddFlash("Error while registering user.")
 84 | 		log.Errorf("Error while creating customer: %v", err)
 85 | 		return controller.Register(c, r)
 86 | 	}
 87 | 
 88 | 	// Create user DB object
 89 | 	user = &models.User{
 90 | 		CustomerID:   customer.ID,
 91 | 		FirstName:    firstname,
 92 | 		LastName:     lastname,
 93 | 		Email:        email,
 94 | 		Active:       true,
 95 | 		CreationDate: utils.DBTimeNow(),
 96 | 	}
 97 | 	err = user.HashPassword(password)
 98 | 	if err != nil {
 99 | 		session.AddFlash("Error while registering user.")
100 | 		log.Errorf("Can't hash password: %v", err)
101 | 		return controller.Register(c, r)
102 | 	}
103 | 
104 | 	// Save it
105 | 	if err = database.Insert(user); err != nil {
106 | 		session.AddFlash("Error while registering user.")
107 | 		log.Errorf("Error while registering user: %v", err)
108 | 		return controller.Register(c, r)
109 | 	}
110 | 
111 | 	// Create browser session (so the user is logged in)
112 | 	SessionID, SessionNonce, err := helpers.CreateBrowserSession(database, r, *user)
113 | 	if err != nil {
114 | 		session.AddFlash("Unexpected error, please come back later", "auth")
115 | 		return controller.Register(c, r)
116 | 	}
117 | 
118 | 	session.Values["SessionID"] = SessionID
119 | 	session.Values["SessionNonce"] = SessionNonce
120 | 	// Values automatically get saved due to a wrapper
121 | 
122 | 	return "/", http.StatusSeeOther
123 | }
124 | 


--------------------------------------------------------------------------------
/WebServer/controllers/web/static.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package web
11 | 
12 | import (
13 | 	"html/template"
14 | 	"net/http"
15 | 
16 | 	"github.com/zenazn/goji/web"
17 | )
18 | 
19 | // Help shows the help page
20 | func (controller *Controller) Help(c web.C, r *http.Request) (string, int) {
21 | 	t := controller.GetTemplate(c)
22 | 
23 | 	var widgets = controller.Parse(t, "help", c.Env)
24 | 
25 | 	c.Env["Title"] = "Summit Route - Help"
26 | 	c.Env["Content"] = template.HTML(widgets)
27 | 
28 | 	return controller.Parse(t, "main", c.Env), http.StatusOK
29 | }
30 | 
31 | // TermsAndConditions shows the terms and conditions page
32 | func (controller *Controller) TermsAndConditions(c web.C, r *http.Request) (string, int) {
33 | 	t := controller.GetTemplate(c)
34 | 
35 | 	var widgets = controller.Parse(t, "terms_and_conditions", c.Env)
36 | 
37 | 	c.Env["Title"] = "Summit Route - Terms and Conditions"
38 | 	c.Env["Content"] = template.HTML(widgets)
39 | 
40 | 	return controller.Parse(t, "main", c.Env), http.StatusOK
41 | }
42 | 
43 | // Privacy shows privacy policy
44 | func (controller *Controller) Privacy(c web.C, r *http.Request) (string, int) {
45 | 	t := controller.GetTemplate(c)
46 | 
47 | 	var widgets = controller.Parse(t, "privacy", c.Env)
48 | 
49 | 	c.Env["Title"] = "Summit Route - Privacy Policy"
50 | 	c.Env["Content"] = template.HTML(widgets)
51 | 
52 | 	return controller.Parse(t, "main", c.Env), http.StatusOK
53 | }
54 | 


--------------------------------------------------------------------------------
/WebServer/controllers/web/utils.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package web
11 | 
12 | import "github.com/gorilla/sessions"
13 | 
14 | // AddFlash adds a flash message to a page
15 | func AddFlash(session *sessions.Session, t string, msg string) {
16 | 	// TODO MUST Need to be able to show errors or success messages
17 | 	session.AddFlash(msg, "auth")
18 | }
19 | 


--------------------------------------------------------------------------------
/WebServer/helpers/auth.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package helpers
11 | 
12 | import (
13 | 	"code.google.com/p/go.crypto/bcrypt"
14 | 	log "github.com/Sirupsen/logrus"
15 | 	"github.com/coopernurse/gorp"
16 | 
17 | 	"qdserver/lib/models"
18 | )
19 | 
20 | // Login attempts to login with the provided credentials.
21 | // On success, returns the user model, else nil and the error
22 | func Login(db *gorp.DbMap, email string, password string) (user *models.User, err error) {
23 | 	err = db.SelectOne(&user, "select * from users where Email=:Email",
24 | 		map[string]interface{}{
25 | 			"Email": email,
26 | 		})
27 | 	if err != nil {
28 | 		log.Errorf("Failed to find user")
29 | 		return nil, err
30 | 	}
31 | 
32 | 	err = bcrypt.CompareHashAndPassword(user.PasswordHash, []byte(password))
33 | 	if err != nil {
34 | 		log.Info("Password hash did not match")
35 | 		return nil, err
36 | 	}
37 | 	return user, nil
38 | }
39 | 


--------------------------------------------------------------------------------
/WebServer/helpers/configureInstaller.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package helpers
11 | 
12 | import (
13 | 	"bytes"
14 | 	"errors"
15 | 	"io/ioutil"
16 | 	"os"
17 | 
18 | 	log "github.com/Sirupsen/logrus"
19 | 	uuid "github.com/nu7hatch/gouuid"
20 | )
21 | 
22 | // ConfigureInstaller configures an MSI with the required data
23 | func ConfigureInstaller(fileIn string, fileOut string, group string) error {
24 | 	// Open file to read in
25 | 	f, err := os.OpenFile(fileIn, os.O_RDONLY, 0)
26 | 	if err != nil {
27 | 		log.Errorf("Unable to open file")
28 | 		return err
29 | 	}
30 | 	defer f.Close()
31 | 
32 | 	// Read the entire file into memory
33 | 	// TODO I should remember where to read from and also use a stream reader
34 | 	fileBytes, err := ioutil.ReadAll(f)
35 | 	if err != nil {
36 | 		log.Errorf("Unable to read file")
37 | 		return err
38 | 	}
39 | 
40 | 	// Find our configuration blob
41 | 	prefix := []byte("---BEGIN_BLOB---")
42 | 	start := bytes.LastIndex(fileBytes, prefix)
43 | 	if start == -1 {
44 | 		return errors.New("Unable to find prefix string")
45 | 	}
46 | 	start = start + len(prefix)
47 | 	log.Infof("Start %d", start)
48 | 
49 | 	postfix := []byte("---END_BLOB---")
50 | 	end := bytes.LastIndex(fileBytes, postfix)
51 | 	if end == -1 {
52 | 		return errors.New("Unable to find postfix string")
53 | 	}
54 | 	log.Infof("End %d", end)
55 | 
56 | 	// Sanity check the blob size
57 | 	expectedBlobSize := 993
58 | 	if end-start != expectedBlobSize {
59 | 		return errors.New("Blob was not of the expected size")
60 | 	}
61 | 
62 | 	//
63 | 	// Set the configuration
64 | 	//
65 | 	groupID, err := uuid.ParseHex(group)
66 | 	if err != nil {
67 | 		log.Errorf("Unable to parse group")
68 | 		return err
69 | 	}
70 | 
71 | 	copy(fileBytes[start:end], (*groupID)[0:16])
72 | 
73 | 	// Open file for writing
74 | 	err = ioutil.WriteFile(fileOut, fileBytes, 0644)
75 | 	if err != nil {
76 | 		log.Errorf("Unable to write file")
77 | 		return err
78 | 	}
79 | 
80 | 	return nil
81 | }
82 | 


--------------------------------------------------------------------------------
/WebServer/helpers/session.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package helpers
11 | 
12 | import (
13 | 	"crypto/rand"
14 | 	"crypto/sha256"
15 | 	"net"
16 | 	"net/http"
17 | 
18 | 	log "github.com/Sirupsen/logrus"
19 | 	"github.com/coopernurse/gorp"
20 | 
21 | 	"qdserver/lib/models"
22 | 	"qdserver/lib/utils"
23 | )
24 | 
25 | // GetIP finds the IP address of the request
26 | func GetIP(r *http.Request) []byte {
27 | 	if ipProxy := r.Header.Get("X-FORWARDED-FOR"); len(ipProxy) > 0 {
28 | 		return []byte(ipProxy)
29 | 	}
30 | 	ip, _, _ := net.SplitHostPort(r.RemoteAddr)
31 | 	return []byte(ip)
32 | }
33 | 
34 | // CreateBrowserSession creates a browser session object and stores it in the DB
35 | func CreateBrowserSession(database *gorp.DbMap, r *http.Request, user models.User) (SessionID int64, SessionNonce []byte, err error) {
36 | 	// Create a random hash
37 | 	nonce := make([]byte, 32)
38 | 	n, err := rand.Read(nonce)
39 | 	if n != 32 || err != nil {
40 | 		log.Errorf("Problem obtaining random data")
41 | 	}
42 | 
43 | 	// Get a hash of the nonce
44 | 	hasher := sha256.New()
45 | 	hasher.Write(nonce)
46 | 	sessionNonceHash := hasher.Sum(nil)
47 | 
48 | 	// Create the DB object
49 | 	browserSession := &models.BrowserSession{
50 | 		NonceHash:    sessionNonceHash,
51 | 		UserID:       user.ID,
52 | 		CreationDate: utils.DBTimeNow(),
53 | 		LastActive:   utils.DBTimeNow(),
54 | 		IP:           GetIP(r),
55 | 		UserAgent:    []byte(r.UserAgent()),
56 | 	}
57 | 
58 | 	// Save it to the DB
59 | 	if err := models.InsertSession(database, browserSession); err != nil {
60 | 		log.Errorf("Error while adding session to DB: %v", err)
61 | 		return 0, nil, err
62 | 	}
63 | 
64 | 	// Return
65 | 	SessionID = browserSession.ID
66 | 	SessionNonce = nonce
67 | 
68 | 	return SessionID, SessionNonce, nil
69 | }
70 | 


--------------------------------------------------------------------------------
/WebServer/helpers/template.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package helpers
11 | 
12 | import (
13 | 	"bytes"
14 | 	"html/template"
15 | 	"net/url"
16 | 	"regexp"
17 | 	"strconv"
18 | )
19 | 
20 | // Parse parses the template file
21 | func Parse(t *template.Template, name string, data interface{}) string {
22 | 	var doc bytes.Buffer
23 | 	t.ExecuteTemplate(&doc, name, data)
24 | 	return doc.String()
25 | }
26 | 
27 | // GetParam looks for a given parameter
28 | // urlValues should be set to r.URL.Query()
29 | // param is the name of the parameter
30 | // regexMatcher is a regex string to ensure the string matches against, or "" for no regex
31 | func GetParam(urlValues url.Values, param string, regexMatcher string, defaultStr string) string {
32 | 	if urlValues[param] == nil {
33 | 		return defaultStr
34 | 	}
35 | 	response := urlValues[param][0]
36 | 
37 | 	// Check if we have a regex to match against
38 | 	if regexMatcher == "" {
39 | 		// No pattern to match against so return what we have
40 | 		return response
41 | 	}
42 | 
43 | 	match, _ := regexp.MatchString(regexMatcher, response)
44 | 	if !match {
45 | 		// Regex didn't match!
46 | 		return defaultStr
47 | 	}
48 | 
49 | 	// Regex matched, return it
50 | 	return response
51 | }
52 | 
53 | // DatatableParams sanitized parameters for SQL statements for returning info to datatables
54 | type DatatableParams struct {
55 | 	Start      string
56 | 	Length     string
57 | 	SortColumn string
58 | 	SortOrder  string
59 | }
60 | 
61 | // GetDatatableParams given query parameters, it finds the values relevant to the datatable and sets the response struct with those values
62 | func GetDatatableParams(urlValues url.Values, defaultSortColumn string) DatatableParams {
63 | 	var response DatatableParams
64 | 
65 | 	response.Start = GetParam(urlValues, "start", "^[0-9]*$", "0")
66 | 	response.Length = GetParam(urlValues, "length", "^[0-9]*$", "25")
67 | 	ilength, err := strconv.Atoi(response.Length)
68 | 	if err != nil || ilength > 100 {
69 | 		response.Length = "100"
70 | 	}
71 | 
72 | 	response.SortColumn = GetParam(urlValues, "sort", "^[a-zA-Z 0-9]*$", defaultSortColumn)
73 | 	if response.SortColumn == "" {
74 | 		response.SortColumn = defaultSortColumn
75 | 	}
76 | 
77 | 	sortAscending := GetParam(urlValues, "sa", "^[a-z]*$", "true")
78 | 
79 | 	if sortAscending == "true" {
80 | 		response.SortOrder = "ASC"
81 | 	} else {
82 | 		response.SortOrder = "DESC"
83 | 	}
84 | 
85 | 	return response
86 | }
87 | 


--------------------------------------------------------------------------------
/WebServer/public/css/griddle.css:
--------------------------------------------------------------------------------
  1 | .griddle-container{
  2 | 	border:1px solid #DDD;
  3 | }
  4 | 
  5 | .griddle th {
  6 | 	cursor: pointer;
  7 | }
  8 | 
  9 | .griddle .top-section{
 10 | 	clear:both;
 11 | 	display:table;
 12 | 	width:100%;
 13 | }
 14 | 
 15 | .griddle .griddle-filter {
 16 | 	float:left;
 17 | 	width:50%;
 18 | 	text-align:left;
 19 | 	color:#222;
 20 | 	min-height:1px;
 21 | 	margin-top:0px;
 22 | 	padding-top:0px;
 23 | 	margin-bottom:10px;
 24 | 	margin-bottom:10px;
 25 | }
 26 | 
 27 | .filter-container {
 28 | 	clear: both;
 29 | 	margin: 0px;
 30 | 	width: 100%;
 31 | }
 32 | 
 33 | 
 34 | .griddle .griddle-settings-toggle {
 35 | 	float:left;
 36 | 	width:50%;
 37 | 	text-align:right;
 38 | }
 39 | 
 40 | .griddle .griddle-settings{
 41 | 	background-color:#FFF;
 42 | 	border:1px solid #DDD;
 43 | 	color:#222;
 44 | 	padding:10px;
 45 | 	margin-bottom:10px;
 46 | }
 47 | 
 48 | 
 49 | .griddle .griddle-settings .griddle-columns{
 50 | 	clear:both;
 51 | 	display:table-row;
 52 | 	width:100%;
 53 | 	border-bottom:1px solid #EDEDED;
 54 | 	margin-bottom:10px;
 55 | }
 56 | 
 57 | .griddle .griddle-settings .griddle-columns .griddle-column-selection:first-child:before {
 58 | 	content: 'Show/hide columns:';
 59 | }
 60 | 
 61 | .griddle .griddle-settings .griddle-column-selection{
 62 | 	margin-top:0px;
 63 | 	float:left;
 64 | }
 65 | 
 66 | .griddle table{
 67 | 	width:100%;table-layout:fixed;
 68 | }
 69 | 
 70 | .griddle th{
 71 | 	background-color:#EDEDEF;
 72 | 	border:0px;
 73 | 	border-bottom:1px solid #DDD;
 74 | 	color:#222;
 75 | 	padding:5px;
 76 | }
 77 | 
 78 | .griddle td{
 79 | 	padding:5px;
 80 | 	border-top-color:#DDD;
 81 | 	color:#222;
 82 | }
 83 | 
 84 | .griddle .footer-container{
 85 | 	padding:0px;
 86 | 	background-color:#EDEDED;
 87 | 	border:0px;
 88 | 	color:#222;
 89 | }
 90 | 
 91 | .griddle .griddle-previous, .griddle .griddle-page, .griddle .griddle-next{
 92 | 	float:left;
 93 | 	width:33%;
 94 | 	min-height:1px;
 95 | 	margin-top:5px;
 96 | }
 97 | 
 98 | .griddle .griddle-page{
 99 | 	text-align:center;
100 | }
101 | 
102 | .griddle .griddle-next{
103 | 	text-align:right;
104 | }
105 | 


--------------------------------------------------------------------------------
/WebServer/public/css/lato.css:
--------------------------------------------------------------------------------
 1 | /* http://fonts.googleapis.com/css?family=Lato:300,400,700,300italic,400italic,700italic */
 2 | @font-face {
 3 |   font-family: 'Lato';
 4 |   font-style: normal;
 5 |   font-weight: 300;
 6 |   src: local('Lato Light'), local('Lato-Light'), url(/assets/fonts/lato-light.woff) format('woff');
 7 | }
 8 | @font-face {
 9 |   font-family: 'Lato';
10 |   font-style: normal;
11 |   font-weight: 400;
12 |   src: local('Lato Regular'), local('Lato-Regular'), url(/assets/fonts/lato-regular.woff) format('woff');
13 | }
14 | @font-face {
15 |   font-family: 'Lato';
16 |   font-style: normal;
17 |   font-weight: 700;
18 |   src: local('Lato Bold'), local('Lato-Bold'), url(/assets/fonts/lato-bold.woff) format('woff');
19 | }
20 | @font-face {
21 |   font-family: 'Lato';
22 |   font-style: italic;
23 |   font-weight: 300;
24 |   src: local('Lato Light Italic'), local('Lato-LightItalic'), url(/assets/fonts/lato-lightitalic.woff) format('woff');
25 | }
26 | @font-face {
27 |   font-family: 'Lato';
28 |   font-style: italic;
29 |   font-weight: 400;
30 |   src: local('Lato Italic'), local('Lato-Italic'), url(/assets/fonts/lato-italic.woff) format('woff');
31 | }
32 | @font-face {
33 |   font-family: 'Lato';
34 |   font-style: italic;
35 |   font-weight: 700;
36 |   src: local('Lato Bold Italic'), local('Lato-BoldItalic'), url(/assets/fonts/lato-bolditalic.woff) format('woff');
37 | }
38 | 


--------------------------------------------------------------------------------
/WebServer/public/fonts/FontAwesome.otf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/FontAwesome.otf


--------------------------------------------------------------------------------
/WebServer/public/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/WebServer/public/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/WebServer/public/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/WebServer/public/fonts/glyphicons-halflings-regular.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/glyphicons-halflings-regular.eot


--------------------------------------------------------------------------------
/WebServer/public/fonts/glyphicons-halflings-regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/glyphicons-halflings-regular.ttf


--------------------------------------------------------------------------------
/WebServer/public/fonts/glyphicons-halflings-regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/glyphicons-halflings-regular.woff


--------------------------------------------------------------------------------
/WebServer/public/fonts/lato-bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/lato-bold.woff


--------------------------------------------------------------------------------
/WebServer/public/fonts/lato-bolditalic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/lato-bolditalic.woff


--------------------------------------------------------------------------------
/WebServer/public/fonts/lato-italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/lato-italic.woff


--------------------------------------------------------------------------------
/WebServer/public/fonts/lato-light.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/lato-light.woff


--------------------------------------------------------------------------------
/WebServer/public/fonts/lato-lightitalic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/lato-lightitalic.woff


--------------------------------------------------------------------------------
/WebServer/public/fonts/lato-regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/fonts/lato-regular.woff


--------------------------------------------------------------------------------
/WebServer/public/images/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/images/favicon.ico


--------------------------------------------------------------------------------
/WebServer/public/images/loading.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/images/loading.gif


--------------------------------------------------------------------------------
/WebServer/public/images/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/images/logo.png


--------------------------------------------------------------------------------
/WebServer/public/images/sort_asc.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/images/sort_asc.png


--------------------------------------------------------------------------------
/WebServer/public/images/sort_both.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/images/sort_both.png


--------------------------------------------------------------------------------
/WebServer/public/images/sort_desc.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/WebServer/public/images/sort_desc.png


--------------------------------------------------------------------------------
/WebServer/public/js/html5shiv.js:
--------------------------------------------------------------------------------
1 | /*
2 |  HTML5 Shiv v3.7.0 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
3 | */
4 | (function(l,f){function m(){var a=e.elements;return"string"==typeof a?a.split(" "):a}function i(a){var b=n[a[o]];b||(b={},h++,a[o]=h,n[h]=b);return b}function p(a,b,c){b||(b=f);if(g)return b.createElement(a);c||(c=i(b));b=c.cache[a]?c.cache[a].cloneNode():r.test(a)?(c.cache[a]=c.createElem(a)).cloneNode():c.createElem(a);return b.canHaveChildren&&!s.test(a)?c.frag.appendChild(b):b}function t(a,b){if(!b.cache)b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag();
5 | a.createElement=function(c){return!e.shivMethods?b.createElem(c):p(c,a,b)};a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+m().join().replace(/[\w\-]+/g,function(a){b.createElem(a);b.frag.createElement(a);return'c("'+a+'")'})+");return n}")(e,b.frag)}function q(a){a||(a=f);var b=i(a);if(e.shivCSS&&!j&&!b.hasCSS){var c,d=a;c=d.createElement("p");d=d.getElementsByTagName("head")[0]||d.documentElement;c.innerHTML="x<style>article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}</style>";
6 | c=d.insertBefore(c.lastChild,d.firstChild);b.hasCSS=!!c}g||t(a,b);return a}var k=l.html5||{},s=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,r=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,j,o="_html5shiv",h=0,n={},g;(function(){try{var a=f.createElement("a");a.innerHTML="<xyz></xyz>";j="hidden"in a;var b;if(!(b=1==a.childNodes.length)){f.createElement("a");var c=f.createDocumentFragment();b="undefined"==typeof c.cloneNode||
7 | "undefined"==typeof c.createDocumentFragment||"undefined"==typeof c.createElement}g=b}catch(d){g=j=!0}})();var e={elements:k.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output progress section summary template time video",version:"3.7.0",shivCSS:!1!==k.shivCSS,supportsUnknownElements:g,shivMethods:!1!==k.shivMethods,type:"default",shivDocument:q,createElement:p,createDocumentFragment:function(a,b){a||(a=f);
8 | if(g)return a.createDocumentFragment();for(var b=b||i(a),c=b.frag.cloneNode(),d=0,e=m(),h=e.length;d<h;d++)c.createElement(e[d]);return c}};l.html5=e;q(f)})(this,document);


--------------------------------------------------------------------------------
/WebServer/public/js/respond.min.js:
--------------------------------------------------------------------------------
1 | /*! Respond.js v1.4.2: min/max-width media query polyfill * Copyright 2013 Scott Jehl
2 |  * Licensed under https://github.com/scottjehl/Respond/blob/master/LICENSE-MIT
3 |  *  */
4 | 
5 | !function(a){"use strict";a.matchMedia=a.matchMedia||function(a){var b,c=a.documentElement,d=c.firstElementChild||c.firstChild,e=a.createElement("body"),f=a.createElement("div");return f.id="mq-test-1",f.style.cssText="position:absolute;top:-100em",e.style.background="none",e.appendChild(f),function(a){return f.innerHTML='&shy;<style media="'+a+'"> #mq-test-1 { width: 42px; }</style>',c.insertBefore(e,d),b=42===f.offsetWidth,c.removeChild(e),{matches:b,media:a}}}(a.document)}(this),function(a){"use strict";function b(){u(!0)}var c={};a.respond=c,c.update=function(){};var d=[],e=function(){var b=!1;try{b=new a.XMLHttpRequest}catch(c){b=new a.ActiveXObject("Microsoft.XMLHTTP")}return function(){return b}}(),f=function(a,b){var c=e();c&&(c.open("GET",a,!0),c.onreadystatechange=function(){4!==c.readyState||200!==c.status&&304!==c.status||b(c.responseText)},4!==c.readyState&&c.send(null))};if(c.ajax=f,c.queue=d,c.regex={media:/@media[^\{]+\{([^\{\}]*\{[^\}\{]*\})+/gi,keyframes:/@(?:\-(?:o|moz|webkit)\-)?keyframes[^\{]+\{(?:[^\{\}]*\{[^\}\{]*\})+[^\}]*\}/gi,urls:/(url\()['"]?([^\/\)'"][^:\)'"]+)['"]?(\))/g,findStyles:/@media *([^\{]+)\{([\S\s]+?)$/,only:/(only\s+)?([a-zA-Z]+)\s?/,minw:/\([\s]*min\-width\s*:[\s]*([\s]*[0-9\.]+)(px|em)[\s]*\)/,maxw:/\([\s]*max\-width\s*:[\s]*([\s]*[0-9\.]+)(px|em)[\s]*\)/},c.mediaQueriesSupported=a.matchMedia&&null!==a.matchMedia("only all")&&a.matchMedia("only all").matches,!c.mediaQueriesSupported){var g,h,i,j=a.document,k=j.documentElement,l=[],m=[],n=[],o={},p=30,q=j.getElementsByTagName("head")[0]||k,r=j.getElementsByTagName("base")[0],s=q.getElementsByTagName("link"),t=function(){var a,b=j.createElement("div"),c=j.body,d=k.style.fontSize,e=c&&c.style.fontSize,f=!1;return b.style.cssText="position:absolute;font-size:1em;width:1em",c||(c=f=j.createElement("body"),c.style.background="none"),k.style.fontSize="100%",c.style.fontSize="100%",c.appendChild(b),f&&k.insertBefore(c,k.firstChild),a=b.offsetWidth,f?k.removeChild(c):c.removeChild(b),k.style.fontSize=d,e&&(c.style.fontSize=e),a=i=parseFloat(a)},u=function(b){var c="clientWidth",d=k[c],e="CSS1Compat"===j.compatMode&&d||j.body[c]||d,f={},o=s[s.length-1],r=(new Date).getTime();if(b&&g&&p>r-g)return a.clearTimeout(h),h=a.setTimeout(u,p),void 0;g=r;for(var v in l)if(l.hasOwnProperty(v)){var w=l[v],x=w.minw,y=w.maxw,z=null===x,A=null===y,B="em";x&&(x=parseFloat(x)*(x.indexOf(B)>-1?i||t():1)),y&&(y=parseFloat(y)*(y.indexOf(B)>-1?i||t():1)),w.hasquery&&(z&&A||!(z||e>=x)||!(A||y>=e))||(f[w.media]||(f[w.media]=[]),f[w.media].push(m[w.rules]))}for(var C in n)n.hasOwnProperty(C)&&n[C]&&n[C].parentNode===q&&q.removeChild(n[C]);n.length=0;for(var D in f)if(f.hasOwnProperty(D)){var E=j.createElement("style"),F=f[D].join("\n");E.type="text/css",E.media=D,q.insertBefore(E,o.nextSibling),E.styleSheet?E.styleSheet.cssText=F:E.appendChild(j.createTextNode(F)),n.push(E)}},v=function(a,b,d){var e=a.replace(c.regex.keyframes,"").match(c.regex.media),f=e&&e.length||0;b=b.substring(0,b.lastIndexOf("/"));var g=function(a){return a.replace(c.regex.urls,"$1"+b+"$2$3")},h=!f&&d;b.length&&(b+="/"),h&&(f=1);for(var i=0;f>i;i++){var j,k,n,o;h?(j=d,m.push(g(a))):(j=e[i].match(c.regex.findStyles)&&RegExp.$1,m.push(RegExp.$2&&g(RegExp.$2))),n=j.split(","),o=n.length;for(var p=0;o>p;p++)k=n[p],l.push({media:k.split("(")[0].match(c.regex.only)&&RegExp.$2||"all",rules:m.length-1,hasquery:k.indexOf("(")>-1,minw:k.match(c.regex.minw)&&parseFloat(RegExp.$1)+(RegExp.$2||""),maxw:k.match(c.regex.maxw)&&parseFloat(RegExp.$1)+(RegExp.$2||"")})}u()},w=function(){if(d.length){var b=d.shift();f(b.href,function(c){v(c,b.href,b.media),o[b.href]=!0,a.setTimeout(function(){w()},0)})}},x=function(){for(var b=0;b<s.length;b++){var c=s[b],e=c.href,f=c.media,g=c.rel&&"stylesheet"===c.rel.toLowerCase();e&&g&&!o[e]&&(c.styleSheet&&c.styleSheet.rawCssText?(v(c.styleSheet.rawCssText,e,f),o[e]=!0):(!/^([a-zA-Z:]*\/\/)/.test(e)&&!r||e.replace(RegExp.$1,"").split("/")[0]===a.location.host)&&("//"===e.substring(0,2)&&(e=a.location.protocol+e),d.push({href:e,media:f})))}w()};x(),c.update=x,c.getEmValue=t,a.addEventListener?a.addEventListener("resize",b,!1):a.attachEvent&&a.attachEvent("onresize",b)}}(this);


--------------------------------------------------------------------------------
/WebServer/public/js/srepp.js:
--------------------------------------------------------------------------------
 1 | // Custom JS for SREPP
 2 | 
 3 | window.setTimeout(function() {
 4 |   $(".flash").fadeTo(500, 0).slideUp(500, function(){
 5 |       $(this).remove();
 6 |   });
 7 | }, 3000);
 8 | 
 9 | 
10 | function getUrlParameter(sParam)
11 | {
12 |     var sPageURL = window.location.search.substring(1);
13 |     var sURLVariables = sPageURL.split('&');
14 |     for (var i = 0; i < sURLVariables.length; i++)
15 |     {
16 |         var sParameterName = sURLVariables[i].split('=');
17 |         if (sParameterName[0] == sParam)
18 |         {
19 |             return sParameterName[1];
20 |         }
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/WebServer/public/robots.txt:
--------------------------------------------------------------------------------
1 | # hello robots
2 | 
3 | User-agent: *
4 | Disallow: /logout/
5 | 
6 | 


--------------------------------------------------------------------------------
/WebServer/system/configuration.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package system
11 | 
12 | import (
13 | 	"encoding/json"
14 | 	"io/ioutil"
15 | 
16 | 	"qdserver/lib/utils"
17 | )
18 | 
19 | // ConfigurationDatabase is a sub-element of Configuration
20 | type ConfigurationDatabase struct {
21 | 	ConnectionString string `json:"connection_string"`
22 | }
23 | 
24 | // ConfigurationAWS is a sub-element of Configuration
25 | type ConfigurationAWS struct {
26 | 	Ses utils.AwsSes `json:"ses"`
27 | }
28 | 
29 | // Configuration is the main structure of our config.json file
30 | type Configuration struct {
31 | 	Environment   string                `json:"environment"`
32 | 	ListeningPort string                `json:"listening_port"`
33 | 	Secret        string                `json:"secret"`        // Secret value for crypto of cookies.  Change this periodically.
34 | 	PublicPath    string                `json:"public_path"`   // Public web files
35 | 	TemplatePath  string                `json:"template_path"` // Template directory (the views)
36 | 	BaseURL       string                `json:"base_url"`      // In production this is "https://app.summitroute.com"
37 | 	Database      ConfigurationDatabase `json:"database"`
38 | 	Aws           ConfigurationAWS      `json:"aws"`
39 | }
40 | 
41 | // Load parses our configuration file
42 | func (configuration *Configuration) Load(filename string) (err error) {
43 | 	data, err := ioutil.ReadFile(filename)
44 | 
45 | 	if err != nil {
46 | 		return
47 | 	}
48 | 
49 | 	err = configuration.Parse(data)
50 | 
51 | 	return
52 | }
53 | 
54 | // Parse parses the configuration file into a structure
55 | func (configuration *Configuration) Parse(data []byte) (err error) {
56 | 	err = json.Unmarshal(data, &configuration)
57 | 
58 | 	return
59 | }
60 | 


--------------------------------------------------------------------------------
/WebServer/system/controller.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package system
11 | 
12 | import (
13 | 	"bytes"
14 | 	"html/template"
15 | 
16 | 	"github.com/coopernurse/gorp"
17 | 	"github.com/gorilla/sessions"
18 | 	"github.com/zenazn/goji/web"
19 | )
20 | 
21 | // Controller blah
22 | type Controller struct {
23 | }
24 | 
25 | // GetSession blah
26 | func (controller *Controller) GetSession(c web.C) *sessions.Session {
27 | 	return c.Env["Session"].(*sessions.Session)
28 | }
29 | 
30 | // GetTemplate blah
31 | func (controller *Controller) GetTemplate(c web.C) *template.Template {
32 | 	return c.Env["Template"].(*template.Template)
33 | }
34 | 
35 | // GetDatabase blah
36 | func (controller *Controller) GetDatabase(c web.C) *gorp.DbMap {
37 | 	if db, ok := c.Env["DBSession"].(*gorp.DbMap); ok {
38 | 		return db
39 | 	}
40 | 
41 | 	return nil
42 | }
43 | 
44 | // Parse blah
45 | func (controller *Controller) Parse(t *template.Template, name string, data interface{}) string {
46 | 	var doc bytes.Buffer
47 | 	t.ExecuteTemplate(&doc, name, data)
48 | 	return doc.String()
49 | }
50 | 


--------------------------------------------------------------------------------
/WebServer/system/core.go:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////
  2 | //
  3 | // Summit Route End Point Protection
  4 | //
  5 | // This source code is licensed under the BSD-style license found in the
  6 | // LICENSE file in the root directory of this source tree.
  7 | //
  8 | /////////////////////////////////////////////////////////////////////////////
  9 | 
 10 | package system
 11 | 
 12 | import (
 13 | 	"html/template"
 14 | 	"io"
 15 | 	"net/http"
 16 | 	"os"
 17 | 	"path/filepath"
 18 | 	"reflect"
 19 | 	"strings"
 20 | 
 21 | 	log "github.com/Sirupsen/logrus"
 22 | 	"github.com/coopernurse/gorp"
 23 | 	"github.com/gorilla/sessions"
 24 | 	_ "github.com/lib/pq" // Needed for gorp
 25 | 	"github.com/zenazn/goji/web"
 26 | 
 27 | 	"qdserver/lib/models"
 28 | )
 29 | 
 30 | // Application holds our app's global variables
 31 | type Application struct {
 32 | 	Configuration *Configuration
 33 | 	Template      *template.Template
 34 | 	Store         *sessions.CookieStore
 35 | 	DBSession     *gorp.DbMap
 36 | }
 37 | 
 38 | const (
 39 | 	// RouteProtected means the user has to have logged in in order to access this route
 40 | 	RouteProtected = 1
 41 | 	// RoutePublic means this route is publicly accessible (no need for a log in)
 42 | 	RoutePublic = 0
 43 | )
 44 | 
 45 | // Init initializes our globals
 46 | func (application *Application) Init(filename *string) {
 47 | 	application.Configuration = &Configuration{}
 48 | 
 49 | 	// Load our configuration file
 50 | 	err := application.Configuration.Load(*filename)
 51 | 	if err != nil {
 52 | 		log.Fatalf("Can't read configuration file: %s", err)
 53 | 		panic(err)
 54 | 	}
 55 | 
 56 | 	// Set up cookie store
 57 | 	application.Store = sessions.NewCookieStore([]byte(application.Configuration.Secret))
 58 | }
 59 | 
 60 | // LoadTemplates initializes the template engine
 61 | func (application *Application) LoadTemplates() error {
 62 | 	var templates []string
 63 | 
 64 | 	// Create function to collect our template files
 65 | 	fn := func(path string, f os.FileInfo, err error) error {
 66 | 		if f.IsDir() != true && strings.HasSuffix(f.Name(), ".html") {
 67 | 			templates = append(templates, path)
 68 | 		}
 69 | 		return nil
 70 | 	}
 71 | 
 72 | 	// Look for all the template files
 73 | 	err := filepath.Walk(application.Configuration.TemplatePath, fn)
 74 | 	if err != nil {
 75 | 		return err
 76 | 	}
 77 | 
 78 | 	// Make sure we can parse all the template files
 79 | 	application.Template = template.Must(template.ParseFiles(templates...))
 80 | 	return nil
 81 | }
 82 | 
 83 | // ConnectToDatabase initializes our database connection
 84 | func (application *Application) ConnectToDatabase() {
 85 | 	// Initialize the database
 86 | 	dbmap, err := models.InitDB(application.Configuration.Database.ConnectionString)
 87 | 	if err != nil {
 88 | 		log.Fatalf("Unable to initialize the database: %v", err)
 89 | 		panic(err)
 90 | 	}
 91 | 
 92 | 	// Store our session
 93 | 	application.DBSession = dbmap
 94 | }
 95 | 
 96 | // Close cleans up anything nicely before exiting the process
 97 | func (application *Application) Close() {
 98 | 	log.Info("Bye!")
 99 | 	application.DBSession.Db.Close()
100 | }
101 | 
102 | // Route defines a web route
103 | func (application *Application) Route(controller interface{}, route string, protected int) interface{} {
104 | 	fn := func(c web.C, w http.ResponseWriter, r *http.Request) {
105 | 		c.Env["Content-Type"] = "text/html"
106 | 
107 | 		if protected == RouteProtected && c.Env["User"] == nil {
108 | 			http.Redirect(w, r, "/signin", http.StatusSeeOther)
109 | 			return
110 | 		}
111 | 
112 | 		methodValue := reflect.ValueOf(controller).MethodByName(route)
113 | 		methodInterface := methodValue.Interface()
114 | 		method := methodInterface.(func(c web.C, r *http.Request) (string, int))
115 | 
116 | 		body, code := method(c, r)
117 | 
118 | 		if session, exists := c.Env["Session"]; exists {
119 | 			err := session.(*sessions.Session).Save(r, w)
120 | 			if err != nil {
121 | 				log.Errorf("Can't save session: %v", err)
122 | 			}
123 | 		}
124 | 
125 | 		switch code {
126 | 		case http.StatusOK:
127 | 			if _, exists := c.Env["Content-Type"]; exists {
128 | 				w.Header().Set("Content-Type", c.Env["Content-Type"].(string))
129 | 			}
130 | 			if _, exists := c.Env["Content-Length"]; exists {
131 | 				w.Header().Set("Content-Length", c.Env["Content-Length"].(string))
132 | 			}
133 | 			io.WriteString(w, body)
134 | 		case http.StatusSeeOther, http.StatusFound:
135 | 			http.Redirect(w, r, body, code)
136 | 		default:
137 | 			w.WriteHeader(code)
138 | 			io.WriteString(w, body)
139 | 		}
140 | 	}
141 | 	return fn
142 | }
143 | 


--------------------------------------------------------------------------------
/WebServer/views/auth/forgot_password.html:
--------------------------------------------------------------------------------
 1 | {{define "auth/forgot_password"}}
 2 |       <form class="form-horizontal" method="post" data-parsley-validate>
 3 |         <input type="hidden" name="csrf_token" value="{{ .csrf_token }}">
 4 |       <fieldset>
 5 |         <legend>Forgot password</legend>
 6 |         {{range .Flash}}
 7 |           <div class="alert alert-danger">{{.}}</div><p>
 8 |         {{end}}
 9 | 
10 |         <div class="form-group">
11 |           <label class="col-md-4 control-label"></label>
12 |           <div class="col-md-6">
13 |             <span style="font-size:90%;">An email will be sent to your account with further instructions.</a></span>
14 |           </div>
15 |         </div>
16 | 
17 | 
18 |         <div class="form-group">
19 |           <label class="col-md-4 control-label" for="email">Email</label>
20 |           <div class="col-md-6">
21 |             <div class="input-group">
22 |               <span class="input-group-addon">
23 |                 <i class="fa fa-envelope"></i>
24 |               </span>
25 |               <input id="email" name="email" type="email" placeholder="Email address" class="form-control input-md" required="" data-parsley-required-message="Please enter your email">
26 |             </div>
27 |           </div>
28 |         </div>
29 | 
30 |         <div class="form-group">
31 |           <label class="col-md-4 control-label" for="signin"></label>
32 |           <div class="col-md-4">
33 |             <button id="signin" name="signin" class="btn btn-primary">Send password reset email</button>
34 |           </div>
35 |         </div>
36 | 
37 |       </fieldset>
38 |       </form>
39 | {{end}}
40 | 


--------------------------------------------------------------------------------
/WebServer/views/auth/forgot_password_post.html:
--------------------------------------------------------------------------------
1 | {{define "auth/forgot_password_post"}}
2 |         <div class="alert alert-success">Password reset email has been sent to: <tt>{{.Email}}</tt><br>It may take awhile for the email to arrive.</div><p>
3 |         <div>Return to the <a href="/signin">Sign In</a> page</div>
4 | {{end}}
5 | 


--------------------------------------------------------------------------------
/WebServer/views/auth/register.html:
--------------------------------------------------------------------------------
 1 | {{define "auth/register"}}
 2 | 		<form method="post" class="form-horizontal" data-parsley-validate>
 3 | 			<input type="hidden" name="csrf_token" value="{{.csrf_token}}">
 4 | 		<fieldset>
 5 | 
 6 | 			<legend>Register</legend>
 7 | 			{{range .Flash}}
 8 | 				<div class="alert alert-danger">{{.}}</div><p>
 9 | 			{{end}}
10 | 			<div class="form-group">
11 | 				<label class="col-md-4 control-label" for="firstname">Name</label>
12 | 				<div class="col-md-3">
13 | 					<input id="firstname" name="firstname" placeholder="First" class="form-control input-md" required="" data-parsley-required-message="Please enter your first name">
14 | 				</div>
15 | 				<div class="col-md-3">
16 | 					<input id="lastname" name="lastname" placeholder="Last" class="form-control input-md" required="" data-parsley-required-message="Please enter your last name">
17 | 				</div>
18 | 			</div>
19 | 
20 | 			<div class="form-group">
21 | 				<label class="col-md-4 control-label" for="email">Email</label>
22 | 				<div class="col-md-6">
23 | 					<div class="input-group">
24 | 						<span class="input-group-addon">
25 | 							<i class="fa fa-envelope"></i>
26 | 						</span>
27 | 						<input id="email" name="email" type="email" placeholder="Email address" class="form-control input-md" required="" data-parsley-required-message="Please enter your email">
28 | 					</div>
29 | 				</div>
30 | 			</div>
31 | 
32 | 			<div class="form-group">
33 | 				<label class="col-md-4 control-label" for="password">Password</label>
34 | 				<div class="col-md-6">
35 | 					<div class="input-group">
36 | 						<span class="input-group-addon">
37 | 							<i class="fa fa-key"></i>
38 | 						</span>
39 | 						<input id="password" name="password" type="password" placeholder="Password" class="form-control input-md" required="" data-parsley-required-message="Please enter your password">
40 | 					</div>
41 | 				</div>
42 | 			</div>
43 | 
44 | 			<div class="form-group">
45 | 				<label class="col-md-4 control-label" for="passwordrepear">Repeat password</label>
46 | 				<div class="col-md-6">
47 | 					<div class="input-group">
48 | 						<span class="input-group-addon">
49 | 							<i class="fa fa-key"></i>
50 | 						</span>
51 | 						<input id="passwordrepeat" name="passwordrepeat" type="password" placeholder="Repeat password" class="form-control input-md" required="" data-parsley-required-message="Please repeat your password" data-parsley-equalto="#password" data-parsley-equalto-message="Passwords do not match">
52 | 					</div>
53 | 				</div>
54 | 			</div>
55 | 
56 | 			<div class="form-group">
57 | 				<label class="col-md-4 control-label" for=""></label>
58 | 				<div class="col-md-6">
59 | 					<label class="checkbox-inline" for="terms">
60 | 						<input type="checkbox" name="terms" id="terms" required="" data-parsley-required-message="You can't continue without accepting our Terms and Conditions">
61 | 						I accept the <a href="/terms_and_conditions">terms and conditions</a>
62 | 					</label>
63 | 				</div>
64 | 			</div>
65 | 
66 | 			<div class="form-group">
67 | 				<label class="col-md-4 control-label" for="register"></label>
68 | 				<div class="col-md-4">
69 | 					<button id="register" name="register" class="btn btn-primary">Register</button>
70 | 				</div>
71 | 			</div>
72 | 
73 | 		</fieldset>
74 | 		</form>
75 | {{end}}
76 | 


--------------------------------------------------------------------------------
/WebServer/views/auth/signin.html:
--------------------------------------------------------------------------------
 1 | {{define "auth/signin"}}
 2 | 		<form class="form-horizontal" method="post" data-parsley-validate>
 3 | 			<input type="hidden" name="csrf_token" value="{{ .csrf_token }}">
 4 | 		<fieldset>
 5 | 			<legend>Sign In</legend>
 6 | 			{{range .Flash}}
 7 | 				<div class="alert alert-danger">{{.}} <a href="/forgot_password">Forgot your password?</a></div><p>
 8 | 			{{end}}
 9 | 
10 | 			<div class="form-group">
11 | 				<label class="col-md-4 control-label"></label>
12 | 				<div class="col-md-6">
13 | 					<span class="comment-text">Summit Route EPP Account <a href="https://SummitRoute.com">What's this?</a></span>
14 | 				</div>
15 | 			</div>
16 | 
17 | 			<div class="form-group">
18 | 				<label class="col-md-4 control-label" for="email">Email</label>
19 | 				<div class="col-md-6">
20 | 					<div class="input-group">
21 | 						<span class="input-group-addon">
22 | 							<i class="fa fa-envelope"></i>
23 | 						</span>
24 | 						<input id="email" name="email" type="email" placeholder="Email address" class="form-control input-md" required="" data-parsley-required-message="Please enter your email">
25 | 					</div>
26 | 				</div>
27 | 			</div>
28 | 
29 | 			<div class="form-group">
30 | 				<label class="col-md-4 control-label" for="password">Password</label>
31 | 				<div class="col-md-6">
32 | 					<div class="input-group">
33 | 						<span class="input-group-addon">
34 | 							<i class="fa fa-key"></i>
35 | 						</span>
36 | 						<input id="password" name="password" type="password" placeholder="Password" class="form-control input-md" required="" data-parsley-required-message="Please enter your password">
37 | 					</div>
38 | 				</div>
39 | 			</div>
40 | 
41 | 			<div class="form-group">
42 | 				<label class="col-md-4 control-label" for="signin"></label>
43 | 				<div class="col-md-4">
44 | 					<button id="signin" name="signin" class="btn btn-primary">Sign In</button>
45 | 				</div>
46 | 			</div>
47 | 
48 | 			<div class="form-group">
49 | 				<label class="col-md-4 control-label"></label>
50 | 				<div class="col-md-6">
51 | 					<span  class="comment-text"><a href="/forgot_password">Can't access your account?</a></span>
52 | 					<br><br>
53 | 					<h4>Don't have a Summit Route account? <a href="/register">Register now</a><h4>
54 | 				</div>
55 | 			</div>
56 | 		</fieldset>
57 | 		</form>
58 | 
59 | {{end}}
60 | 


--------------------------------------------------------------------------------
/WebServer/views/footer.html:
--------------------------------------------------------------------------------
 1 | {{define "footer"}}
 2 | 	<div id="footer" class="footer">
 3 | 	  <div class="container">
 4 | 	    <p class="text-muted">&copy; Summit Route LLC 2015 &mdash; <a href="/privacy_policy">Privacy Policy</a> &mdash; <a href="/terms_and_conditions">Terms of Use</a>
 5 | 	  </div>
 6 | 	</div>
 7 | 
 8 | 	<script src="/assets/js/jquery-1.11.0.js"></script>
 9 | 	<script src="/assets/js/bootstrap.min.js"></script>
10 | 	<script src="/assets/js/parsley.min.js"></script>
11 | 	<script src="/assets/js/jquery.dataTables.min.js"></script>
12 | 	<script src="/assets/js/dataTables.bootstrap.js"></script>
13 | 
14 | 	<script src="/assets/js/srepp.js"></script>
15 | 
16 | 	{{.Scripts}}
17 | 	</body>
18 | 
19 | 	</html>
20 | {{end}}
21 | 


--------------------------------------------------------------------------------
/WebServer/views/header.html:
--------------------------------------------------------------------------------
 1 | {{define "header"}}
 2 | <!DOCTYPE html>
 3 | <html lang="en">
 4 | 
 5 | <head>
 6 |   <meta charset="utf-8">
 7 |   <meta http-equiv="X-UA-Compatible" content="IE=edge">
 8 |   <meta name="viewport" content="width=device-width, initial-scale=1">
 9 |   <meta name="description" content="Summit Route - Developing the next-generation of cyber security solutions">
10 | 
11 |   <title>{{.Title}}</title>
12 | 
13 |   <link rel="stylesheet" href="/assets/css/bootstrap.min.css" >
14 |   <link rel="stylesheet" href="/assets/css/lato.css">
15 |   <link rel="stylesheet" href="/assets/css/font-awesome.min.css">
16 |   <link rel="stylesheet" href="/assets/css/style.css">
17 | 
18 |   <!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
19 |   <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
20 |   <!--[if lt IE 9]>
21 |       <script src="/assets/js/html5shiv.js"></script>
22 |       <script src="/assets/js/respond.min.js"></script>
23 |   <![endif]-->
24 | 
25 |   <link rel="icon" href="/favicon.ico" sizes="16x16 32x32 64x64" type="image/vnd.microsoft.icon">
26 | </head>
27 | 
28 | <body>
29 | {{end}}
30 | 


--------------------------------------------------------------------------------
/WebServer/views/help.html:
--------------------------------------------------------------------------------
 1 | {{define "help"}}
 2 |     <h1>Help</h1>
 3 |     Summit Route End Point Protection is software to protect your system.
 4 | 
 5 |     <h2>Support</h2>
 6 |     Contact us at <a href="mailto:support@SummitRoute.com">support@SummitRoute.com</a>
 7 | 
 8 |     <h2>Uninstall</h2>
 9 |     To uninstall the agent, you must have Administrator privileges.  To install follow these steps depending on your operating system:
10 |     <ul>
11 |       <li>Windows Vista and Windows 7
12 |         <ol>
13 |           <li>Click the Start Menu and select "Control Panel".
14 |           <li>In the Control Panel window, click on "Add or Remove Programs".
15 |           <li>Right-click "Summit Route EPP" from the list and select "Uninstall".
16 |         </ol>
17 |       <li>Windows 8</li>
18 |         <ol>
19 |           <li>From the Start Screen, click the Desktop tile. The Desktop view will open.
20 |           <li>From the Desktop, hover in the lower right-hand corner to access the Charms.
21 |           <li>Select Control Panel from the Settings charm. The Control Panel window will open.
22 |           <li>In the Control Panel window, click the "Uninstall a program" link under the Programs section.
23 |           <li>Right-click "Summit Route EPP" from the list and select "Uninstall".
24 |         </ol>
25 |       </ul>
26 | 
27 | {{end}}
28 | 


--------------------------------------------------------------------------------
/WebServer/views/index.html:
--------------------------------------------------------------------------------
 1 | {{define "index"}}
 2 | <!DOCTYPE html>
 3 | <html lang="en">
 4 | <head>
 5 |   <meta charset="UTF-8">
 6 |   <meta http-equiv="X-UA-Compatible" content="IE=edge">
 7 |   <meta name="viewport" content="width=device-width, initial-scale=1">
 8 |   <meta name="description" content="Summit Route - Developing the next-generation of cyber security solutions">
 9 |   <meta name="csrf-token" content="{{.csrf_token}}">
10 | 
11 |   <title>Summit Route End Point Protection</title>
12 |   <link rel="stylesheet" media="screen" href="/assets/css/bootstrap.min.css">
13 |   <link rel="stylesheet" href="/assets/css/font-awesome.min.css">
14 |   <link rel="stylesheet" href="/assets/css/lato.css">
15 |   <link rel="stylesheet" href="/assets/css/griddle.css">
16 |   <link rel="stylesheet" href="/assets/css/style.css">
17 | 
18 |   <link rel="icon" href="/favicon.ico" sizes="16x16 32x32 64x64" type="image/vnd.microsoft.icon">
19 | </head>
20 | 
21 | <body>
22 |   <div id="main"></div>
23 |   <script src="/assets/js/main.js"></script>
24 | </body>
25 | </html>
26 | {{end}}
27 | 


--------------------------------------------------------------------------------
/WebServer/views/main.html:
--------------------------------------------------------------------------------
 1 | {{define "main"}}
 2 | 	{{template "header" .}}
 3 | 	<!-- Fixed navbar -->
 4 | 	<div class="navbar navbar-default" role="navigation">
 5 | 	  <div class="container">
 6 | 	    <div class="navbar-header">
 7 | 	      <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
 8 | 	        <span class="sr-only">Toggle navigation</span>
 9 | 	        <span class="icon-bar"></span>
10 | 	        <span class="icon-bar"></span>
11 | 	        <span class="icon-bar"></span>
12 | 	      </button>
13 | 	      <a class="navbar-brand" href="/"></a>
14 | 	    </div>
15 | 
16 | 	    <!--/.nav-collapse -->
17 | 			<div class="navbar-collapse collapse">
18 | 				<ul class="nav navbar-nav navbar-right">
19 | 					<li {{if .IsSignIn }}class="active" {{end}}><a href="/signin">Sign In</a>
20 | 					</li>
21 | 					<li {{if .IsRegister }}class="active" {{end}}><a href="/register">Register</a>
22 | 					</li>
23 | 				</ul>
24 | 			</div>
25 | 
26 | 	  </div>
27 | 	</div>
28 | 	<div class="container" role="main">
29 | 		<div class="panel panel-default container">
30 | 			<div class="panel-body">
31 | 	  	  {{.Content}}
32 | 		  </div>
33 | 		</div>
34 | 	</div>
35 | 	{{template "footer" .}}
36 | {{end}}
37 | 


--------------------------------------------------------------------------------
/docs/frontend.txt:
--------------------------------------------------------------------------------
1 | 
2 | # Front-end building
3 | 
4 | # cd to the frontend dir and run this to download all the libraries
5 | npm install --no-bin-links
6 | 
7 | # To "compile" just run
8 | gulp
9 | 


--------------------------------------------------------------------------------
/docs/go.txt:
--------------------------------------------------------------------------------
 1 | cd to the directory WebServer and CallbackServer and run `go run server.go` in each.
 2 | 
 3 | 
 4 | 
 5 | Docs
 6 | ====
 7 | To see documentation, cd to /gocode/src (the parent dir of this directory).  Then run
 8 | ```
 9 | godoc -http=:6060 -path="qdserver"
10 | ```
11 | 
12 | This will show docs at http://192.168.106.129:6060/pkg/qdserver/WebServer/
13 | 


--------------------------------------------------------------------------------
/docs/sysadmin/aws.txt:
--------------------------------------------------------------------------------
 1 | ################################################################################
 2 | # EC2
 3 | Use HVM instances that are EBS backed
 4 | 
 5 | #############
 6 | Upload cert to cloudfront with:
 7 | aws iam upload-server-certificate \
 8 |   --server-certificate-name SummitRouteSha256 \
 9 |   --certificate-body file://summitroute.com.pem \
10 |   --private-key file://summitroute.com.key \
11 |   --certificate-chain file://intermediate.pem \
12 |   --path /cloudfront/summitroute/
13 | 
14 | 
15 | 
16 | ################################################################################
17 | # RDS
18 | 
19 | psql -h srepp.cr8gss9rmqsb.us-east-1.rds.amazonaws.com --port=5432 --dbname=srepp --username=masteruser --password
20 | 
21 | #
22 | # Set up db
23 | #
24 | 
25 | root@ip-172-31-19-122:/etc/nginx# sudo -u postgres psql srepp
26 | psql (9.1.14)
27 | Type "help" for help.
28 | 
29 | srepp=# \password postgres
30 | Enter new password:
31 | Enter it again:
32 | srepp=# \q
33 | 
34 | ### Create aggregate First function as defined: https://wiki.postgresql.org/wiki/First/last_(aggregate)
35 | # Run psql again
36 | CREATE OR REPLACE FUNCTION public.first_agg ( anyelement, anyelement )
37 | RETURNS anyelement LANGUAGE sql IMMUTABLE STRICT AS $$
38 |         SELECT $1;
39 | $$;
40 | 
41 | -- And then wrap an aggregate around it
42 | CREATE AGGREGATE public.first (
43 |         sfunc    = public.first_agg,
44 |         basetype = anyelement,
45 |         stype    = anyelement
46 | );
47 | 
48 | 
49 | 
50 | ################################################################################
51 | # S3
52 | 
53 | # Buckets should have policies such as the following
54 | {
55 |   "Version": "2008-10-17",
56 |   "Id": "Policy1420511327413",
57 |   "Statement": [
58 |     {
59 |       "Sid": "Stmt1420511326310",
60 |       "Effect": "Allow",
61 |       "Principal": {
62 |         "AWS": "arn:aws:iam::393727464233:user/upload_files"
63 |       },
64 |       "Action": "s3:*",
65 |       "Resource": "arn:aws:s3:::summitroute.file.uploads/*"
66 |     },
67 |     {
68 |       "Sid": "Stmt14205113263102",
69 |       "Effect": "Allow",
70 |       "Principal": {
71 |         "AWS": "arn:aws:iam::393727464233:user/upload_files"
72 |       },
73 |       "Action": "s3:ListBucket",
74 |       "Resource": "arn:aws:s3:::summitroute.file.uploads"
75 |     }
76 |   ]
77 | }
78 | 


--------------------------------------------------------------------------------
/docs/sysadmin/ec2.txt:
--------------------------------------------------------------------------------
 1 | # TODO: Should review https://www.nsa.gov/ia/_files/os/redhat/rhel5-guide-i731.pdf
 2 | # TODO: Should set ulimit's
 3 | 
 4 | ################################################################################
 5 | # AWS
 6 | ################################################################################
 7 | apt-get update
 8 | apt-get dist-upgrade
 9 | # Helpful
10 | apt-get -y install vim screen unzip dnsutils postgresql-client curl
11 | 
12 | # Syncronize time
13 | apt-get -y install ntp
14 | 
15 | # For logging
16 | apt-get -y install rsyslog rsyslog-gnutls
17 | 
18 | 
19 | 
20 | ################################################################################
21 | # Stop ssh inactivity timeouts
22 | echo >> /etc/ssh/sshd_config
23 | echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config
24 | service ssh restart
25 | # Should also set your putty configs
26 | 
27 | 
28 | 
29 | ################################################################################
30 | # Install RabbitMQ
31 | 
32 | # - Instructions: http://www.rabbitmq.com/install-debian.html
33 | 
34 | # Add to /etc/apt/sources.list:
35 | echo >> /etc/apt/sources.list
36 | echo 'deb http://www.rabbitmq.com/debian/ testing main' >> /etc/apt/sources.list
37 | 
38 | # Get key
39 | wget http://www.rabbitmq.com/rabbitmq-signing-key-public.asc
40 | # Check against
41 |  sha1sum rabbitmq-signing-key-public.asc
42 | 34bce0bc9189d428b116898e12d7f20868173105  rabbitmq-signing-key-public.asc
43 | # Add it
44 | apt-key add rabbitmq-signing-key-public.asc
45 | 
46 | # Update and install
47 |  apt-get update
48 |  apt-get install rabbitmq-server
49 | 
50 | # Check rabbitmq version:
51 | root@deb:~# rabbitmqctl status
52 |  {running_applications,[{rabbit,"RabbitMQ","3.4.2"},
53 | 
54 | 
55 | ################################################################################
56 | # Install Python
57 | apt-get install python
58 | 
59 | # Install pip
60 | wget https://bootstrap.pypa.io/get-pip.py
61 | # Check
62 | sha1sum get-pip.py
63 | # 506b689dd920fbcc64e9b0057601a4a555d4e47b  get-pip.py
64 | 
65 | python get-pip.py
66 | 
67 | # Install libraries
68 | pip install pika sqlalchemy pyasn1
69 | 
70 | # Must install libpq-dev for the postgres driver
71 | apt-get install libpq-dev build-essential python-dev
72 | pip install sqlalchemy psycopg2
73 | 
74 | # For AWS
75 | pip install boto
76 | 
77 | 
78 | 
79 | ################################################################################
80 | # Setup supervisord
81 | apt-get install supervisor
82 | 
83 | # Upload it
84 | scp etc.supervisor.conf.d.summitroute.conf admin@aws:/etc/supervisor/conf.d/summitroute.conf
85 | 
86 | supervisorctl reload
87 | 
88 | 
89 | 
90 | 


--------------------------------------------------------------------------------
/docs/sysadmin/no_aws.txt:
--------------------------------------------------------------------------------
 1 | ################################################################################
 2 | # Nginx
 3 | # Debian wheezy comes with nginx 1.2.1, but we want at least 1.3.7 to take advantage of OCSP stapling, so need to upgrade it.
 4 | # The following adds the testing distro of debian, which seems to add a lot of stuff
 5 | # I'd prefer not adding so much non-nginx
 6 | 
 7 | # Follow instructions on: http://nginxlibrary.com/debian-latest-nginx/
 8 | # Edit /etc/apt/sources.list and add
 9 | deb http://ftp.debian.org/debian/ testing main contrib non-free
10 | deb-src http://ftp.debian.org/debian/ testing main contrib non-free
11 | # Edit /etc/apt/preferences (currently empty) and add
12 | Package: nginx
13 | Pin: release a=testing
14 | Pin-Priority: 900
15 | apt-get install nginx
16 | # This updates a ton of stuff, I accepted everything, except I kept my local grub file.
17 | 
18 | 
19 | #
20 | # Configure nginx
21 | #
22 | 
23 | # Replace /etc/nginx/sites-enabled/default
24 | scp etc.nginx.site-enabled.default.txt {aws_server}:/etc/nginx/sites-enabled/default.conf
25 | scp etc.nginx.nginx.conf {aws_server}:/etc/nginx/nginx.conf
26 | 
27 | 
28 | /etc/nginx# mkdir certs
29 |  mv /tmp/summitroute.com.* certs/.
30 | 
31 |  # Testing OSCP use: https://blog.kempkens.io/posts/ocsp-stapling-with-nginx/
32 |  # And run
33 | openssl s_client -servername app.summitroute.com -connect app.summitroute.com:443 -tls1  -tlsextdebug  -status
34 | 
35 | 
36 | ################################################################################
37 | # Set up db
38 | apt-get install postgresql
39 | 


--------------------------------------------------------------------------------
/docs/sysadmin/rabbitmq.txt:
--------------------------------------------------------------------------------
 1 | RabbitMQ clustering
 2 | 
 3 | # Set hostname
 4 | echo node01 > /etc/hostname
 5 | hostname -F /etc/hostname
 6 | 
 7 | # Edit /etc/hosts with
 8 | 172.31.16.58    node01
 9 | 172.31.31.110   node02
10 | 
11 | # Copy /var/lib/rabbitmq/.erlang.cookie to hosts
12 | scp /var/lib/rabbitmq/.erlang.cookie
13 | 
14 | # Restart RabbitMQ servers
15 | service rabbitmq-server restart
16 | 
17 | # Ensure ports are open in security group between hosts.  These are 4369, 5672, and 25672
18 | # Double check with:
19 | root@node01:~# epmd -names
20 | epmd: up and running on port 4369 with data:
21 | name rabbit at port 25672
22 | 
23 | 
24 | # On all hosts except node01 join to node01
25 | rabbitmqctl stop_app
26 | rabbitmqctl join_cluster --disk rabbit@node01
27 | rabbitmqctl start_app
28 | 
29 | # Double-check everything
30 | root@node01:~# rabbitmqctl cluster_status
31 | Cluster status of node rabbit@node01 ...
32 | [{nodes,[{disc,[rabbit@node01,rabbit@node02]}]},
33 |  {running_nodes,[rabbit@node02,rabbit@node01]},
34 |  {cluster_name,<<"rabbit@node02">>},
35 |  {partitions,[]}]
36 | 
37 | 
38 | 
39 | # Guest user's can't access the queues remotely, so need to create a new account
40 | 
41 | rabbitmqctl add_user rabbit YOUR_PASSWORD
42 | rabbitmqctl set_user_tags rabbit administrator
43 | rabbitmqctl set_permissions -p / rabbit ".*" ".*" ".*"
44 | 


--------------------------------------------------------------------------------
/frontend/gulpfile.js:
--------------------------------------------------------------------------------
 1 | // Install with:  npm install gulp-util  --no-bin-link
 2 | 
 3 | 
 4 | var gulp = require('gulp');
 5 | var source = require('vinyl-source-stream'); // Used to stream bundle for further handling
 6 | var browserify = require('browserify');
 7 | var watchify = require('watchify');
 8 | var reactify = require('reactify');
 9 | var concat = require('gulp-concat');
10 | 
11 | // This code is largely from: http://christianalfoni.github.io/javascript/2014/08/15/react-js-workflow.html
12 | gulp.task('browserify', function() {
13 |   var bundler = browserify({
14 |     entries: ['./src/js/main.js'], // Only need initial file, browserify finds the deps
15 |     transform: [reactify], // We want to convert JSX to normal javascript
16 |     debug: true, // Gives us sourcemapping
17 |     cache: {}, packageCache: {},
18 |     fullPaths: true, // Requirement of watchify
19 |     paths: ['./node_modules','./src/js/']
20 |   });
21 |   var watcher  = watchify(bundler);
22 | 
23 |   return watcher
24 |   .on('update', function () { // When any files update
25 |     var updateStart = Date.now();
26 |     console.log('Updating!');
27 |     watcher.bundle() // Create new bundle that uses the cache for high performance
28 |     .pipe(source('main.js'))
29 |     // This is where you add uglifying etc.
30 |     .pipe(gulp.dest('../WebServer/public/js'));
31 |     console.log('Updated!', (Date.now() - updateStart) + 'ms');
32 |   })
33 |   .bundle() // Create the initial bundle when starting the task
34 |   .pipe(source('main.js'))
35 |   .pipe(gulp.dest('../WebServer/public/js'));
36 | });
37 | 
38 | gulp.task('watch', function() {
39 |   gulp.src('src/**/*.*')
40 |   .pipe(watch('src/**/*.*', function (files, cb) {
41 |     gulp.start('default', cb);
42 |   }));
43 | });
44 | 
45 | 
46 | // Just running the two tasks
47 | gulp.task('default', ['browserify']);
48 | 


--------------------------------------------------------------------------------
/frontend/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "flux",
 3 |   "version": "0.0.0",
 4 |   "description": "",
 5 |   "main": "gulpfile.js",
 6 |   "dependencies": {
 7 |     "envify": "^1.2.1",
 8 |     "es6-promise": "*",
 9 |     "fuzzy": "^0.1.0",
10 |     "gulp": "*",
11 |     "gulp-browserify": "*",
12 |     "gulp-uglify": "*",
13 |     "gulp-util": "*",
14 |     "gulp-concat": "*",
15 |     "gulp-watch": "*",
16 |     "react": "0.12.0",
17 |     "react-async": "^2.0.1",
18 |     "react-router-component": "git://github.com/STRML/react-router-component.git#react-0.12",
19 |     "moment": "*",
20 |     "tether": "*",
21 |     "react-onclickoutside": "*",
22 |     "reactify": "git://github.com/andreypopp/reactify.git#v0.16.0",
23 |     "reqwest": "*",
24 |     "griddle-react": "0.2.4",
25 |     "griddle-callback": "0.2.0",
26 |     "react-bootstrap": "0.17.0",
27 |     "react-micro-bar-chart": "*",
28 |     "underscore.string": "*"
29 |   },
30 |   "devDependencies": {},
31 |   "scripts": {
32 |     "test": "echo \"Error: no test specified\" && exit 1"
33 |   },
34 |   "author": "",
35 |   "license": "ISC"
36 | }
37 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/app-help.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var Reqwest = require("reqwest");
 3 | 
 4 | var Help =
 5 |   React.createClass({
 6 |     getInitialState:function(){
 7 | 			return {data:""}
 8 | 		},
 9 | 		componentWillMount:function(){
10 | 			Reqwest({
11 | 				url: '/api/help',
12 | 				type: '',
13 | 				success:function(resp){
14 | 					this.setState({data:resp})
15 | 				}.bind(this)
16 | 			})
17 | 		},
18 |     render:function(){
19 |       return (
20 |           <div dangerouslySetInnerHTML={{__html: this.state.data}} />
21 |         )
22 |     }
23 |   });
24 | module.exports = Help;
25 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/app-privacy_policy.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var Reqwest = require("reqwest");
 3 | 
 4 | var PrivacyPolicy =
 5 |   React.createClass({
 6 |     getInitialState:function(){
 7 | 			return {data:""}
 8 | 		},
 9 | 		componentWillMount:function(){
10 | 			Reqwest({
11 | 				url: '/api/privacy_policy',
12 | 				type: '',
13 | 				success:function(resp){
14 | 					this.setState({data:resp})
15 | 				}.bind(this)
16 | 			})
17 | 		},
18 |     render:function(){
19 |       return (
20 |           <div dangerouslySetInnerHTML={{__html: this.state.data}} />
21 |         )
22 |     }
23 |   });
24 | module.exports = PrivacyPolicy;
25 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/app-template.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | 
 3 | var Header = require('./header/app-header.jsx');
 4 | var Footer = require('./footer/app-footer.jsx');
 5 | 
 6 | var Template =
 7 |   React.createClass({
 8 |     render:function(){
 9 |       return  (
10 |         <div>
11 |           <Header />
12 |           <div className="container">
13 |             {this.props.children}
14 |           </div>
15 |           <Footer />
16 |         </div>
17 |         )
18 |     }
19 |   });
20 | module.exports = Template;
21 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/app-terms_and_conditions.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var Reqwest = require("reqwest");
 3 | 
 4 | var TermsAndConditions =
 5 |   React.createClass({
 6 |     getInitialState:function(){
 7 | 			return {data:""}
 8 | 		},
 9 | 		componentWillMount:function(){
10 | 			Reqwest({
11 | 				url: '/api/terms_and_conditions',
12 | 				type: '',
13 | 				success:function(resp){
14 | 					this.setState({data:resp})
15 | 				}.bind(this)
16 | 			})
17 | 		},
18 |     render:function(){
19 |       return (
20 |           <div dangerouslySetInnerHTML={{__html: this.state.data}} />
21 |         )
22 |     }
23 |   });
24 | module.exports = TermsAndConditions;
25 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/app.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var Router = require('react-router-component');
 3 | 
 4 | var Template = require('./app-template.jsx');
 5 | var Dashboard = require('./dashboard/app-dashboard.jsx');
 6 | 
 7 | var Systems = require('./systems/app-systems.jsx');
 8 | var SystemInfo = require('./systems/app-systeminfo.jsx');
 9 | 
10 | var ProcessEvents = require('./process_events/app-process_events.jsx');
11 | 
12 | var File = require('./file/app-file.jsx');
13 | var Executables = require('./executables/app-executables.jsx');
14 | 
15 | var Profile = require('./profile/app-profile.jsx');
16 | var PasswordChange = require('./password_change/app-password_change.jsx');
17 | var PasswordReset = require('./password_reset/app-password_reset.jsx');
18 | 
19 | var PrivacyPolicy = require('./app-privacy_policy.jsx');
20 | var TermsAndConditions = require('./app-terms_and_conditions.jsx');
21 | var Help = require('./app-help.jsx');
22 | 
23 | var Locations = Router.Locations;
24 | var Location = Router.Location;
25 | var NotFound = Router.NotFound;
26 | 
27 | var APP =
28 |   React.createClass({
29 |     render:function(){
30 |       return (
31 |         <Template>
32 |           <Locations>
33 |             <Location path="/" handler={Dashboard} />
34 |             <Location path="/systems" handler={Systems} />
35 |             <Location path="/systeminfo*" handler={SystemInfo} />
36 |             <Location path="/process_events" handler={ProcessEvents} />
37 |             <Location path="/file*" handler={File} />
38 |             <Location path="/executables" handler={Executables} />
39 |             <Location path="/profile" handler={Profile} />
40 |             <Location path="/change_password" handler={PasswordChange} />
41 |             <Location path="/password_reset" handler={PasswordReset} />
42 |             <Location path="/privacy_policy" handler={PrivacyPolicy} />
43 |             <Location path="/terms_and_conditions" handler={TermsAndConditions} />
44 |             <Location path="/help" handler={Help} />
45 |             <NotFound handler={Dashboard} />
46 |           </Locations>
47 |         </Template>
48 |       )
49 |     }
50 |   });
51 | module.exports = APP;
52 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/csrf.jsx:
--------------------------------------------------------------------------------
 1 | var CSRF = function() {
 2 |   var csrf = "";
 3 |   var metas = document.getElementsByTagName('meta');
 4 | 
 5 |   for (i=0; i<metas.length; i++) {
 6 |     if (metas[i].getAttribute("name") == "csrf-token") {
 7 |       csrf = metas[i].getAttribute("content");
 8 |     }
 9 |   }
10 |   return csrf;
11 | };
12 | module.exports = CSRF;
13 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/dashboard/app-dashboard.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var DashboardItem = require('./dashboard-item.jsx');
 3 | 
 4 | var Dashboard =
 5 |   React.createClass({
 6 |     render:function(){
 7 |       return (
 8 |           <div>
 9 |             <div className="row">
10 |               <div className="col-md-12">
11 |                 <div className="panel panel-default">
12 |                   <div className="panel-body">
13 |                     <h2>Summit Route &mdash; EPP</h2>
14 |                     <p>
15 |                       <a href="/download/SREPP.exe"><span className="glyphicon glyphicon-download"></span> Download your agent</a>
16 |                       &mdash; Your agent installer is pre-configured so the data it collects will show up in your dashboard.
17 |                     </p>
18 |                   </div>
19 |                 </div>
20 |               </div>
21 |             </div>
22 |           </div>
23 |         )
24 |     }
25 |   });
26 | module.exports = Dashboard;
27 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/dashboard/dashboard-item.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var MicroBarChart = require('react-micro-bar-chart');
 3 | var _string = require('underscore.string');
 4 | 
 5 | var Dashboard =
 6 |   React.createClass({
 7 |     getDefaultProps: function(){
 8 |       return {
 9 |         title: '0 new events',
10 |         data: [0,0,0,0,0,0,0],
11 |         tooltipText: "%d events"
12 |       }
13 |     },
14 | 
15 |     tooltipTemplate: function (d, i, data){
16 |       return _string.sprintf(this.props.tooltipText, d)
17 |     },
18 | 
19 |     render:function(){
20 |       return (
21 |         <div className="row">
22 |           <div className="col-md-6">
23 |             <p>{this.props.title}</p>
24 |           </div>
25 |           <div className="col-md-6 barchart">
26 |             <MicroBarChart
27 |               width="150" height="40"
28 |               data={this.props.data}
29 |               tooltip="true"
30 |               tipOffset={[0,20]}
31 |               tipTemplate={this.tooltipTemplate}
32 |               hoverColor="#80B5FF"
33 |               fillColor="#2b82ff"
34 |             />
35 |           </div>
36 |         </div>
37 |         )
38 |     }
39 |   });
40 | module.exports = Dashboard;
41 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/executables/app-executables.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var ExecutablesTable = require('./app-executables_table.jsx');
 3 | 
 4 | var Executables =
 5 |   React.createClass({
 6 |     render:function(){
 7 |       return (
 8 |             <div>
 9 |               <h2>Executables</h2>
10 |               <ExecutablesTable/>
11 |             </div>
12 |         )
13 |     }
14 |   });
15 | module.exports = Executables;
16 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/flash.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var Alert = require('react-bootstrap').Alert;
 3 | 
 4 | var Flash = React.createClass({
 5 |   getInitialState:function(){
 6 |     return {
 7 |       style:"flash",
 8 |       alertType:"danger",
 9 |       msg:"Error"
10 |     }
11 |   },
12 | 
13 |   render: function() {
14 |       return (
15 |         <div ref="flash" className={this.state.style}>
16 |           <Alert bsStyle={this.state.alertType} onDismiss={this.handleAlertDismiss}>
17 |             {this.state.msg}
18 |           </Alert>
19 |         </div>
20 |       );
21 |   },
22 | 
23 | 
24 |   handleAlertDismiss: function() {
25 |     this.setState({style: 'flash'});
26 |   },
27 | 
28 |   Show: function(alertType, msg) {
29 |     this.setState({style: 'flash show', alertType:alertType, msg:msg});
30 |   }
31 | });
32 | module.exports = Flash;
33 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/footer/app-footer.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var Link = require('react-router-component').Link;
 3 | 
 4 | var Footer =
 5 |   React.createClass({
 6 |     render:function(){
 7 |       return (
 8 |         <div className="footer">
 9 |           <div className="container">
10 |             <p className="text-muted">
11 |               &copy; Summit Route LLC 2015 &mdash;
12 |               <Link href="/privacy_policy">Privacy Policy</Link> &mdash;
13 |               <Link href="/terms_and_conditions">Terms of Use</Link>
14 |             </p>
15 |           </div>
16 |         </div>
17 |       )
18 |     }
19 |   });
20 | module.exports = Footer;
21 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/form_input.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var Input = require('react-bootstrap').Input;
 3 | 
 4 | var FormInput = React.createClass({
 5 |   propTypes: {
 6 |     addon: React.PropTypes.string,
 7 |     type: React.PropTypes.string,
 8 |     label: React.PropTypes.string.isRequired,
 9 |     defaultVal: React.PropTypes.string.isRequired,
10 |     whenChanged: React.PropTypes.func
11 |   },
12 | 
13 |   getDefaultProps: function() {
14 |     return {
15 |       addon: "",
16 |       type: "text"
17 |     };
18 |   },
19 | 
20 |   getInitialState: function() {
21 |     return {
22 |       hasChanged: false,
23 |       isBad: false,
24 |       value: this.props.defaultVal
25 |     };
26 |   },
27 | 
28 |   Reset: function(val) {
29 |     if (val != undefined) {
30 |       this.setState({value: val});
31 |     }
32 |     this.setState({hasChanged: false});
33 |   },
34 | 
35 |   SetBad: function() {
36 |     this.setState({hasChanged: true, isBad: true});
37 |   },
38 | 
39 |   SetGood: function() {
40 |     this.setState({hasChanged: true, isBad: false});
41 |   },
42 | 
43 |   validationState: function() {
44 |     if (this.state.isBad) {
45 |       return 'error'
46 |     } else if (this.state.hasChanged) {
47 |       var length = this.state.value.length;
48 |       if (length > 0) return 'success';
49 |     }
50 |     // Else return nothing
51 |     return;
52 |   },
53 | 
54 |   handleChange: function() {
55 |     this.setState({
56 |       value: this.refs.input.getValue(),
57 |       hasChanged: true,
58 |       isBad: false,
59 |     });
60 |     if (this.props.whenChanged != null) {
61 |       this.props.whenChanged();
62 |     }
63 |   },
64 | 
65 |   getInput: function() {
66 |     return this.refs.input.getValue();
67 |   },
68 | 
69 | 
70 |   render: function() {
71 |     var addonComponent = null;
72 |     if (this.props.addon == "email") {
73 |       addonComponent = <i  className="fa fa-envelope"/>;
74 |     } else if (this.props.addon.indexOf("password") > -1) {
75 |       addonComponent = <i  className="fa fa-key"/>;
76 |     }
77 | 
78 |     return (
79 |         <Input
80 |           type={this.props.type}
81 |           value={this.state.value}
82 |           label={this.props.label}
83 |           bsStyle={this.validationState()}
84 |           ref="input"
85 |           onChange={this.handleChange} addonBefore={addonComponent}/>
86 |     );
87 |   }
88 | });
89 | module.exports = FormInput;
90 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/header/app-header.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var Link = require('react-router-component').Link;
 3 | 
 4 | var Header =
 5 |   React.createClass({
 6 |     render:function(){
 7 |       return (
 8 |         <div className="navbar navbar-default" role="navigation">
 9 |           <div className="container">
10 |             <div className="navbar-header">
11 |               <button type="button" className="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
12 |                 <span className="sr-only">Toggle navigation</span>
13 |                 <span className="icon-bar"></span>
14 |                 <span className="icon-bar"></span>
15 |                 <span className="icon-bar"></span>
16 |               </button>
17 |               <Link className="navbar-brand" href="/"></Link>
18 |             </div>
19 | 
20 |             <div className="navbar-collapse collapse">
21 |               <ul className="nav navbar-nav">
22 |                 <li><Link href="/"><span className="glyphicon glyphicon-home"></span> Home</Link></li>
23 |                 <li><Link href="/systems">Systems</Link></li>
24 |                 <li><Link href="/executables">Executables</Link></li>
25 |               </ul>
26 | 
27 |               <ul className="nav navbar-nav navbar-right">
28 |                 <li>
29 |                   <p className="navbar-text">
30 |                     <Link href="/profile"><span className="glyphicon glyphicon-user"></span>Profile</Link>
31 |                   </p>
32 |                 </li>
33 |                 <li><a href="/logout">Logout</a></li>
34 |                 <li><Link href="/help">Help</Link></li>
35 |               </ul>
36 | 
37 |             </div>
38 |           </div>
39 |         </div>
40 |         )
41 |     }
42 |   });
43 | module.exports = Header;
44 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/password_change/app-password_change.jsx:
--------------------------------------------------------------------------------
  1 | var React = require('react');
  2 | var Reqwest = require("reqwest");
  3 | 
  4 | var FormInput = require('../form_input.jsx');
  5 | var Flash = require('../flash.jsx');
  6 | var CSRF = require('../csrf.jsx');
  7 | 
  8 | var PasswordChange =
  9 |   React.createClass({
 10 |     getInitialState: function() {
 11 |       return {
 12 |         isSaving: false,
 13 |         canSave: false,
 14 |       }
 15 |     },
 16 | 
 17 |     handleChange: function() {
 18 |       password1 = this.refs.new_password.getInput();
 19 |       password2 = this.refs.new_password2.getInput();
 20 | 
 21 |       if (password2 != "") {
 22 |         if (password2 != password1) {
 23 |           this.refs.new_password2.SetBad();
 24 |           this.setState({canSave: false});
 25 |           return;
 26 |         } else {
 27 |           this.refs.new_password2.SetGood();
 28 |         }
 29 |       }
 30 | 
 31 |       if (
 32 |         this.refs.new_password.getInput() != "" &&
 33 |         this.refs.new_password2.getInput() != "" &&
 34 |         this.refs.current_password.getInput() != ""
 35 |       ) {
 36 |         this.setState({canSave: true});
 37 |       }
 38 |     },
 39 | 
 40 |     handleSubmit: function() {
 41 |       if (this.state.isSaving == true) { return; }
 42 | 
 43 |       this.setState({isSaving: true, canSave: false});
 44 | 
 45 |       var thisComponent = this;
 46 | 
 47 |       Reqwest({
 48 |         url: '/api/change_password.json',
 49 |         type: 'json',
 50 |         method: 'post',
 51 |         headers: {
 52 |           'X-CSRF-Token': CSRF()
 53 |         },
 54 |         data: {
 55 |           NewPassword: thisComponent.refs.new_password.getInput(),
 56 |           CurrentPassword: thisComponent.refs.current_password.getInput()
 57 |         },
 58 |         success:function(resp){
 59 |           thisComponent.refs.new_password.Reset("");
 60 |           thisComponent.refs.new_password2.Reset("");
 61 |           thisComponent.refs.current_password.Reset("");
 62 |           thisComponent.setState({isSaving: false});
 63 | 
 64 |           thisComponent.refs.flash.Show("success", "Password changed");
 65 |         },
 66 |         error: function (err) {
 67 |           msg = "Server error, try again later";
 68 |           if (err.response == "old password incorrect") {
 69 |             msg = "Current password was incorrect";
 70 |           }
 71 |           thisComponent.setState({isSaving: false});
 72 |           thisComponent.refs.flash.Show("danger", msg);
 73 |         }
 74 |       })
 75 |     },
 76 | 
 77 | 
 78 |     isSavingDenied: function() {
 79 |       if (this.state.isSaving) {
 80 |         return true;
 81 |       }
 82 |       if (this.state.canSave) {
 83 |         return false;
 84 |       }
 85 |       return true;
 86 |     },
 87 | 
 88 |     render:function(){
 89 |       return (
 90 |         <form>
 91 |           <Flash ref="flash"/>
 92 |           <fieldset>
 93 |             <legend>Change Password</legend>
 94 | 
 95 |             <FormInput label="New password" type="password" defaultVal="" whenChanged={this.handleChange} ref="new_password" addon="password" />
 96 |             <FormInput label="Re-enter new password" type="password" defaultVal="" whenChanged={this.handleChange} ref="new_password2" addon="password"/>
 97 |             <FormInput label="Current Password" type="password" defaultVal="" whenChanged={this.handleChange} ref="current_password" addon="password"/>
 98 | 
 99 |             <button id="changePassword" name="changePassword" className="btn btn-primary"
100 |               disabled={this.isSavingDenied()}
101 |               onClick={!this.state.isSaving ? this.handleSubmit : null}>
102 |               {this.state.isSaving ? 'Changing...' : 'Change Password'}</button>
103 | 
104 |           </fieldset>
105 | 
106 |         </form>
107 |         )
108 |     }
109 |   });
110 | module.exports = PasswordChange;
111 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/password_reset/app-password_reset.jsx:
--------------------------------------------------------------------------------
  1 | var React = require('react');
  2 | var Reqwest = require("reqwest");
  3 | 
  4 | var FormInput = require('../form_input.jsx');
  5 | var Flash = require('../flash.jsx');
  6 | var CSRF = require('../csrf.jsx');
  7 | 
  8 | var PasswordReset =
  9 |   React.createClass({
 10 |     getInitialState: function() {
 11 |       return {
 12 |         isSaving: false,
 13 |         canSave: false,
 14 |       }
 15 |     },
 16 | 
 17 |     handleChange: function() {
 18 |       password1 = this.refs.new_password.getInput();
 19 |       password2 = this.refs.new_password2.getInput();
 20 | 
 21 |       if (password2 != "") {
 22 |         if (password2 != password1) {
 23 |           this.refs.new_password2.SetBad();
 24 |           this.setState({canSave: false});
 25 |           return;
 26 |         } else {
 27 |           this.refs.new_password2.SetGood();
 28 |         }
 29 |       }
 30 | 
 31 |       if (
 32 |         this.refs.new_password.getInput() != "" &&
 33 |         this.refs.new_password2.getInput() != ""
 34 |       ) {
 35 |         this.setState({canSave: true});
 36 |       }
 37 |     },
 38 | 
 39 |     handleSubmit: function() {
 40 |       if (this.state.isSaving == true) { return; }
 41 | 
 42 |       this.setState({isSaving: true, canSave: false});
 43 | 
 44 |       var thisComponent = this;
 45 | 
 46 |       Reqwest({
 47 |         url: '/api/reset_password.json',
 48 |         type: 'json',
 49 |         method: 'post',
 50 |         headers: {
 51 |           'X-CSRF-Token': CSRF()
 52 |         },
 53 |         data: {
 54 |           NewPassword: thisComponent.refs.new_password.getInput()
 55 |         },
 56 |         success:function(resp){
 57 |           thisComponent.refs.new_password.Reset("");
 58 |           thisComponent.refs.new_password2.Reset("");
 59 |           thisComponent.setState({isSaving: false});
 60 | 
 61 |           thisComponent.refs.flash.Show("success", "Password changed");
 62 |         },
 63 |         error: function (err) {
 64 |           msg = "Server error, try again later";
 65 |           thisComponent.setState({isSaving: false});
 66 |           thisComponent.refs.flash.Show("danger", msg);
 67 |         }
 68 |       })
 69 |     },
 70 | 
 71 | 
 72 |     isSavingDenied: function() {
 73 |       if (this.state.isSaving) {
 74 |         return true;
 75 |       }
 76 |       if (this.state.canSave) {
 77 |         return false;
 78 |       }
 79 |       return true;
 80 |     },
 81 | 
 82 |     render:function(){
 83 |       return (
 84 |         <form>
 85 |           <Flash ref="flash"/>
 86 |           <fieldset>
 87 |             <legend>Change Password</legend>
 88 | 
 89 |             <FormInput label="New password" type="password" defaultVal="" whenChanged={this.handleChange} ref="new_password" addon="password" />
 90 |             <FormInput label="Re-enter new password" type="password" defaultVal="" whenChanged={this.handleChange} ref="new_password2" addon="password"/>
 91 | 
 92 |             <button id="changePassword" name="changePassword" className="btn btn-primary"
 93 |               disabled={this.isSavingDenied()}
 94 |               onClick={!this.state.isSaving ? this.handleSubmit : null}>
 95 |             {this.state.isSaving ? 'Changing...' : 'Set New Password'}</button>
 96 | 
 97 |           </fieldset>
 98 | 
 99 |         </form>
100 |         )
101 |     }
102 |   });
103 | module.exports = PasswordReset;
104 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/process_events/app-process_events.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var ProcessEventsTable = require('./app-process_events_table.jsx');
 3 | 
 4 | var ProcessEvents =
 5 |   React.createClass({
 6 |     render:function(){
 7 |       return (
 8 |             <div>
 9 |               <h2>Process Events</h2>
10 |               <ProcessEventsTable/>
11 |             </div>
12 |         )
13 |     }
14 |   });
15 | module.exports = ProcessEvents;
16 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/process_events/app-process_events_table.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var Reqwest = require("reqwest");
 3 | var Griddle = require('griddle-react');
 4 | var Link = require('react-router-component').Link;
 5 | 
 6 | var ProcessEventsTable = React.createClass({
 7 |  	render: function(){
 8 |   var getJsonData = function(filterString, sortColumn, sortAscending, page, pageSize, callback) {
 9 |     Reqwest({
10 |       url: '/api/processes.json?start='+page*pageSize+"&length="+pageSize+"&filter="+filterString+"&sort="+sortColumn+"&sa="+sortAscending,
11 |       type: 'json',
12 |       success: function (resp) {
13 |         var results = [];
14 |         for (var i=0; i<resp.iTotalDisplayRecords; i++)
15 |         {
16 |           results[i] = {
17 |             "Path" : Link({href:"/fileinfo?sha256="+resp.aaData[i]["Sha256"], children:resp.aaData[i]["FilePath"]}),
18 |             "Command" : resp.aaData[i]["CommandLine"],
19 |             "Time": resp.aaData[i]["EventTime"]
20 |           };
21 |         }
22 | 
23 |         callback({
24 |           results: results,
25 |           totalResults: resp.iTotalRecords
26 |         });
27 |       }
28 |     });
29 |   };
30 | 
31 |     return (
32 |       <Griddle getExternalResults={getJsonData} noDataMessage={"Loading data..."}
33 |         tableClassName="table" resultsPerPage="25"
34 |         showFilter={false} showSettings={true}/>
35 |     )
36 |   }
37 | });
38 | module.exports = ProcessEventsTable;
39 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-datepicker/calendar.js:
--------------------------------------------------------------------------------
  1 | /** @jsx React.DOM */
  2 | var React = require('react/addons');
  3 | 
  4 | var Day = require('./day');
  5 | var DateUtil = require('./util/date');
  6 | var moment = require('moment');
  7 | 
  8 | var Calendar = React.createClass({
  9 |   mixins: [require('react-onclickoutside')],
 10 | 
 11 |   handleClickOutside: function() {
 12 |     this.props.hideCalendar();
 13 |   },
 14 | 
 15 |   getInitialState: function() {
 16 |     return {
 17 |       date: new DateUtil(this.props.selected).safeClone(moment())
 18 |     };
 19 |   },
 20 | 
 21 |   increaseMonth: function() {
 22 |     this.setState({
 23 |       date: this.state.date.addMonth()
 24 |     });
 25 |   },
 26 | 
 27 |   decreaseMonth: function() {
 28 |     this.setState({
 29 |       date: this.state.date.subtractMonth()
 30 |     });
 31 |   },
 32 | 
 33 |   weeks: function() {
 34 |     return this.state.date.mapWeeksInMonth(this.renderWeek);
 35 |   },
 36 | 
 37 |   handleDayClick: function(day) {
 38 |     this.props.onSelect(day);
 39 |   },
 40 | 
 41 |   renderWeek: function(weekStart, key) {
 42 |     if(! weekStart.weekInMonth(this.state.date)) {
 43 |       return;
 44 |     }
 45 | 
 46 |     return (
 47 |       <div key={key}>
 48 |         {this.days(weekStart)}
 49 |       </div>
 50 |     );
 51 |   },
 52 | 
 53 |   renderDay: function(day, key) {
 54 |     var minDate = new DateUtil(this.props.minDate).safeClone(),
 55 |         maxDate = new DateUtil(this.props.maxDate).safeClone(),
 56 |         disabled = day.isBefore(minDate) || day.isAfter(maxDate);
 57 | 
 58 |     return (
 59 |       <Day
 60 |         key={key}
 61 |         day={day}
 62 |         date={this.state.date}
 63 |         onClick={this.handleDayClick.bind(this, day)}
 64 |         selected={new DateUtil(this.props.selected)}
 65 |         disabled={disabled} />
 66 |     );
 67 |   },
 68 | 
 69 |   days: function(weekStart) {
 70 |     return weekStart.mapDaysInWeek(this.renderDay);
 71 |   },
 72 | 
 73 |   render: function() {
 74 |     return (
 75 |       <div className="datepicker">
 76 |         <div className="datepicker__triangle"></div>
 77 |         <div className="datepicker__header">
 78 |           <a className="datepicker__navigation datepicker__navigation--previous"
 79 |               onClick={this.decreaseMonth}>
 80 |           </a>
 81 |           <span className="datepicker__current-month">
 82 |             {this.state.date.format("MMMM YYYY")}
 83 |           </span>
 84 |           <a className="datepicker__navigation datepicker__navigation--next"
 85 |               onClick={this.increaseMonth}>
 86 |           </a>
 87 |           <div>
 88 |             <div className="datepicker__day">Mo</div>
 89 |             <div className="datepicker__day">Tu</div>
 90 |             <div className="datepicker__day">We</div>
 91 |             <div className="datepicker__day">Th</div>
 92 |             <div className="datepicker__day">Fr</div>
 93 |             <div className="datepicker__day">Sa</div>
 94 |             <div className="datepicker__day">Su</div>
 95 |           </div>
 96 |         </div>
 97 |         <div className="datepicker__month">
 98 |           {this.weeks()}
 99 |         </div>
100 |       </div>
101 |     );
102 |   }
103 | });
104 | 
105 | module.exports = Calendar;
106 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-datepicker/date_input.js:
--------------------------------------------------------------------------------
  1 | /** @jsx React.DOM */
  2 | 
  3 | var React = require('react/addons');
  4 | var moment = require('moment');
  5 | 
  6 | 
  7 | var DateUtil = require('./util/date');
  8 | 
  9 | var DateInput = React.createClass({
 10 |   propTypes: {
 11 |     onKeyDown: React.PropTypes.func
 12 |   },
 13 | 
 14 |   getDefaultProps: function() {
 15 |     return {
 16 |       dateFormat: 'YYYY-MM-DD'
 17 |     };
 18 |   },
 19 | 
 20 |   getInitialState: function() {
 21 |     return {
 22 |       value: this.safeDateFormat(this.props.date)
 23 |     };
 24 |   },
 25 | 
 26 |   componentDidMount: function() {
 27 |     this.toggleFocus(this.props.focus);
 28 |   },
 29 | 
 30 |   componentWillReceiveProps: function(newProps) {
 31 |     this.toggleFocus(newProps.focus);
 32 | 
 33 |     this.setState({
 34 |       value: this.safeDateFormat(newProps.date)
 35 |     });
 36 |   },
 37 | 
 38 |   toggleFocus: function(focus) {
 39 |     if (focus) {
 40 |       this.refs.entry.getDOMNode().focus();
 41 |     } else {
 42 |       this.refs.entry.getDOMNode().blur();
 43 |     }
 44 |   },
 45 | 
 46 |   handleChange: function(event) {
 47 |     var date = moment(event.target.value, this.props.dateFormat, true);
 48 | 
 49 |     this.setState({
 50 |       value: event.target.value
 51 |     });
 52 |   },
 53 | 
 54 |   safeDateFormat: function(date) {
 55 |     return !! date ? date.format(this.props.dateFormat) : null;
 56 |   },
 57 | 
 58 |   isValueAValidDate: function() {
 59 |     var date = moment(event.target.value, this.props.dateFormat, true);
 60 | 
 61 |     return date.isValid();
 62 |   },
 63 | 
 64 |   handleEnter: function(event) {
 65 |     if (this.isValueAValidDate()) {
 66 |       var date = moment(event.target.value, this.props.dateFormat, true);
 67 |       this.props.setSelected(new DateUtil(date));
 68 |     }
 69 |   },
 70 | 
 71 |   handleKeyDown: function(event) {
 72 |     switch(event.key) {
 73 |     case "Enter":
 74 |       event.preventDefault();
 75 |       this.handleEnter(event);
 76 |       break;
 77 |     case "Backspace":
 78 |       this.props.onKeyDown(event);
 79 |       break;
 80 |     }
 81 |   },
 82 | 
 83 |   handleClick: function(event) {
 84 |     this.props.handleClick(event);
 85 |   },
 86 | 
 87 |   render: function() {
 88 |     return <input
 89 |       ref="entry"
 90 |       type="text"
 91 |       value={this.state.value}
 92 |       onClick={this.handleClick}
 93 |       onKeyDown={this.handleKeyDown}
 94 |       onFocus={this.props.onFocus}
 95 |       onChange={this.handleChange}
 96 |       className="datepicker__input"
 97 |       placeholder={this.props.placeholderText} />;
 98 |   }
 99 | });
100 | 
101 | module.exports = DateInput;
102 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-datepicker/datepicker.js:
--------------------------------------------------------------------------------
 1 | /** @jsx React.DOM */
 2 | 
 3 | var React = require('react/addons');
 4 | 
 5 | var Popover   = require('./popover');
 6 | var DateUtil  = require('./util/date');
 7 | var Calendar  = require('./calendar');
 8 | var DateInput = require('./date_input');
 9 | 
10 | var DatePicker = React.createClass({
11 |   propTypes: {
12 |     onChange: React.PropTypes.func,
13 |     onKeyDown: React.PropTypes.func
14 |   },
15 | 
16 |   getInitialState: function() {
17 |     return {
18 |       focus: true
19 |     };
20 |   },
21 | 
22 |   handleFocus: function() {
23 |     this.setState({
24 |       focus: true
25 |     });
26 |   },
27 | 
28 |   hideCalendar: function() {
29 |       this.setState({
30 |         focus: false
31 |       });
32 |   },
33 | 
34 |   handleSelect: function(date) {
35 |     this.hideCalendar();
36 |     this.setSelected(date);
37 |   },
38 | 
39 |   setSelected: function(date) {
40 |     this.props.onChange(date.moment());
41 |   },
42 | 
43 |   onInputClick: function() {
44 |     this.setState({
45 |       focus: true
46 |     });
47 |   },
48 | 
49 |   calendar: function() {
50 |     if (this.state.focus) {
51 |       return (
52 |         <Popover>
53 |           <Calendar
54 |             selected={this.props.selected}
55 |             onSelect={this.handleSelect}
56 |             hideCalendar={this.hideCalendar}
57 |             minDate={this.props.minDate}
58 |             maxDate={this.props.maxDate} />
59 |         </Popover>
60 |       );
61 |     }
62 |   },
63 | 
64 |   render: function() {
65 |     return (
66 |       <div>
67 |         <DateInput
68 |           ref="dateinput"
69 |           date={this.props.selected}
70 |           dateFormat={this.props.dateFormat}
71 |           focus={this.state.focus}
72 |           onFocus={this.handleFocus}
73 |           onKeyDown={this.props.onKeyDown}
74 |           handleClick={this.onInputClick}
75 |           handleEnter={this.hideCalendar}
76 |           setSelected={this.setSelected}
77 |           hideCalendar={this.hideCalendar}
78 |           placeholderText={this.props.placeholderText} />
79 |         {this.calendar()}
80 |       </div>
81 |     );
82 |   }
83 | });
84 | 
85 | module.exports = DatePicker;
86 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-datepicker/day.js:
--------------------------------------------------------------------------------
 1 | /** @jsx React.DOM */
 2 | 
 3 | var React = require('react/addons');
 4 | var moment = require('moment');
 5 | 
 6 | var Day = React.createClass({
 7 |   handleClick: function(event) {
 8 |     if (this.props.disabled) return;
 9 | 
10 |     this.props.onClick(event);
11 |   },
12 | 
13 |   render: function() {
14 |     classes = React.addons.classSet({
15 |       'datepicker__day': true,
16 |       'datepicker__day--disabled': this.props.disabled,
17 |       'datepicker__day--selected': this.props.day.sameDay(this.props.selected),
18 |       'datepicker__day--today': this.props.day.sameDay(moment())
19 |     });
20 | 
21 |     return (
22 |       <div className={classes} onClick={this.handleClick}>
23 |         {this.props.day.day()}
24 |       </div>
25 |     );
26 |   }
27 | });
28 | 
29 | module.exports = Day;
30 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-datepicker/popover.js:
--------------------------------------------------------------------------------
 1 | /** @jsx React.DOM */
 2 | 
 3 | var React = require('react/addons');
 4 | var Tether = require('tether/tether');
 5 | 
 6 | 
 7 | var Popover = React.createClass({
 8 |   displayName: 'Popover',
 9 | 
10 |   componentWillMount: function() {
11 |     popoverContainer = document.createElement('span');
12 |     popoverContainer.className = 'datepicker__container';
13 | 
14 |     this._popoverElement = popoverContainer;
15 | 
16 |     document.querySelector('body').appendChild(this._popoverElement);
17 |   },
18 | 
19 |   componentDidMount: function() {
20 |     this._renderPopover();
21 |   },
22 | 
23 |   componentDidUpdate: function() {
24 |     this._renderPopover();
25 |   },
26 | 
27 |   _popoverComponent: function() {
28 |     var className = this.props.className;
29 |     return (
30 |       <div className={className}>
31 |         {this.props.children}
32 |       </div>
33 |     );
34 |   },
35 | 
36 |   _tetherOptions: function() {
37 |     return {
38 |       element: this._popoverElement,
39 |       target: this.getDOMNode().parentElement,
40 |       attachment: 'bottom left',
41 |       targetAttachment: 'top left',
42 |       targetOffset: '10px 0',
43 |       optimizations: {
44 |         moveElement: false // always moves to <body> anyway!
45 |       },
46 |       constraints: [
47 |         {
48 |           to: 'window',
49 |           attachment: 'together',
50 |           pin: true
51 |         }
52 |       ]
53 |     };
54 |   },
55 | 
56 |   _renderPopover: function() {
57 |     React.render(this._popoverComponent(), this._popoverElement);
58 | 
59 |     if (this._tether != null) {
60 |       this._tether.setOptions(this._tetherOptions());
61 |     } else {
62 |       this._tether = new Tether(this._tetherOptions());
63 |     }
64 |   },
65 | 
66 |   componentWillUnmount: function() {
67 |     this._tether.destroy();
68 |     React.unmountComponentAtNode(this._popoverElement);
69 |     if (this._popoverElement.parentNode) {
70 |       this._popoverElement.parentNode.removeChild(this._popoverElement);
71 |     }
72 |   },
73 | 
74 |   render: function() {
75 |     return <span/>;
76 |   }
77 | });
78 | 
79 | module.exports = Popover;
80 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-datepicker/util/date.js:
--------------------------------------------------------------------------------
 1 | function DateUtil(date) {
 2 |   this._date = date;
 3 | }
 4 | 
 5 | DateUtil.prototype.isBefore = function(other) {
 6 |   return this._date.isBefore(other._date, 'day');
 7 | };
 8 | 
 9 | DateUtil.prototype.isAfter = function(other) {
10 |   return this._date.isAfter(other._date, 'day');
11 | };
12 | 
13 | DateUtil.prototype.sameDay = function(other) {
14 |   return this._date.isSame(other._date, 'day');
15 | };
16 | 
17 | DateUtil.prototype.sameMonth = function(other) {
18 |   return this._date.isSame(other._date, 'month');
19 | };
20 | 
21 | DateUtil.prototype.day = function() {
22 |   return this._date.date();
23 | };
24 | 
25 | DateUtil.prototype.mapDaysInWeek = function(callback) {
26 |   var week = [];
27 |   var firstDay = this._date.clone().startOf('isoWeek');
28 | 
29 |   for(var i = 0; i < 7; i++) {
30 |     var day = new DateUtil(firstDay.clone().add(i, 'days'));
31 | 
32 |     week[i] = callback(day, i);
33 |   }
34 | 
35 |   return week;
36 | };
37 | 
38 | DateUtil.prototype.mapWeeksInMonth = function(callback) {
39 |   var month = [];
40 |   var firstDay = this._date.clone().startOf('month').startOf('isoWeek');
41 | 
42 |   for(var i = 0; i < 6; i++) {
43 |     var weekStart = new DateUtil(firstDay.clone().add(i, 'weeks'));
44 | 
45 |     month[i] = callback(weekStart, i);
46 |   }
47 | 
48 |   return month;
49 | };
50 | 
51 | DateUtil.prototype.weekInMonth = function(other) {
52 |   var firstDayInWeek = this._date.clone();
53 |   var lastDayInWeek = this._date.clone().isoWeekday(7);
54 | 
55 |   return firstDayInWeek.isSame(other._date, 'month') ||
56 |     lastDayInWeek.isSame(other._date, 'month');
57 | };
58 | 
59 | DateUtil.prototype.format = function() {
60 |   return this._date.format.apply(this._date, arguments);
61 | };
62 | 
63 | DateUtil.prototype.addMonth = function() {
64 |   return new DateUtil(this._date.clone().add(1, 'month'));
65 | };
66 | 
67 | DateUtil.prototype.subtractMonth = function() {
68 |   return new DateUtil(this._date.clone().subtract(1, 'month'));
69 | };
70 | 
71 | DateUtil.prototype.clone = function() {
72 |   return new DateUtil(this._date.clone());
73 | };
74 | 
75 | DateUtil.prototype.safeClone = function(alternative) {
76 |   if (!! this._date) return this.clone();
77 | 
78 |   if (alternative === undefined) alternative = null;
79 |   return new DateUtil(alternative);
80 | };
81 | 
82 | DateUtil.prototype.moment = function() {
83 |   return this._date;
84 | };
85 | 
86 | module.exports = DateUtil;
87 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-typeahead/keyevent.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * PolyFills make me sad
 3 |  */
 4 | var KeyEvent = KeyEvent || {};
 5 | KeyEvent.DOM_VK_UP = KeyEvent.DOM_VK_UP || 38;
 6 | KeyEvent.DOM_VK_DOWN = KeyEvent.DOM_VK_DOWN || 40;
 7 | KeyEvent.DOM_VK_BACK_SPACE = KeyEvent.DOM_VK_BACK_SPACE || 8;
 8 | KeyEvent.DOM_VK_RETURN = KeyEvent.DOM_VK_RETURN || 13;
 9 | KeyEvent.DOM_VK_ENTER = KeyEvent.DOM_VK_ENTER || 14;
10 | KeyEvent.DOM_VK_ESCAPE = KeyEvent.DOM_VK_ESCAPE || 27;
11 | KeyEvent.DOM_VK_TAB = KeyEvent.DOM_VK_TAB || 9;
12 | 
13 | module.exports = KeyEvent;
14 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-typeahead/react-typeahead.js:
--------------------------------------------------------------------------------
1 | var Typeahead = require('./typeahead');
2 | var Tokenizer = require('./tokenizer');
3 | 
4 | module.exports = {
5 |   Typeahead: Typeahead,
6 |   Tokenizer: Tokenizer
7 | };
8 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-typeahead/tokenizer/token.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @jsx React.DOM
 3 |  */
 4 | 
 5 | var React = window.React || require('react');
 6 | 
 7 | /**
 8 |  * Encapsulates the rendering of an option that has been "selected" in a
 9 |  * TypeaheadTokenizer
10 |  */
11 | var Token = React.createClass({
12 |   propTypes: {
13 |     children: React.PropTypes.object,
14 |     onRemove: React.PropTypes.func
15 |   },
16 | 
17 |   render: function() {
18 |     return (
19 |       <div {...this.props} className="typeahead-token">
20 |         {this.props.children["category"]} {this.props.children["operator"]} "{this.props.children["value"]}"
21 |         {this._makeCloseButton()}
22 |       </div>
23 |     );
24 |   },
25 | 
26 |   _makeCloseButton: function() {
27 |     if (!this.props.onRemove) {
28 |       return "";
29 |     }
30 |     return (
31 |       <a className="typeahead-token-close" href="#" onClick={function(event) {
32 |           this.props.onRemove(this.props.children);
33 |           event.preventDefault();
34 |         }.bind(this)}>&#x00d7;</a>
35 |     );
36 |   }
37 | });
38 | 
39 | module.exports = Token;
40 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-typeahead/typeahead/option.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @jsx React.DOM
 3 |  */
 4 | 
 5 | var React = window.React || require('react/addons');
 6 | 
 7 | /**
 8 |  * A single option within the TypeaheadSelector
 9 |  */
10 | var TypeaheadOption = React.createClass({
11 |   propTypes: {
12 |     customClasses: React.PropTypes.object,
13 |     onClick: React.PropTypes.func,
14 |     children: React.PropTypes.string
15 |   },
16 | 
17 |   getDefaultProps: function() {
18 |     return {
19 |       customClasses: {},
20 |       onClick: function(event) { 
21 |         event.preventDefault(); 
22 |       }
23 |     };
24 |   },
25 | 
26 |   getInitialState: function() {
27 |     return {
28 |       hover: false
29 |     };
30 |   },
31 | 
32 |   render: function() {
33 |     var classes = {
34 |       hover: this.props.hover
35 |     }
36 |     classes[this.props.customClasses.listItem] = !!this.props.customClasses.listItem;
37 |     var classList = React.addons.classSet(classes);
38 | 
39 |     return (
40 |       <li className={classList} onClick={this._onClick}>
41 |         <a href="#" className={this._getClasses()} ref="anchor">
42 |           { this.props.children }
43 |         </a>
44 |       </li>
45 |     );
46 |   },
47 | 
48 |   _getClasses: function() {
49 |     var classes = {
50 |       "typeahead-option": true,
51 |     };
52 |     classes[this.props.customClasses.listAnchor] = !!this.props.customClasses.listAnchor;
53 |     return React.addons.classSet(classes);
54 |   },
55 | 
56 |   _onClick: function() {
57 |     return this.props.onClick();
58 |   }
59 | });
60 | 
61 | 
62 | module.exports = TypeaheadOption;
63 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/react-typeahead/typeahead/selector.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @jsx React.DOM
  3 |  */
  4 | 
  5 | var React = window.React || require('react/addons');
  6 | var TypeaheadOption = require('./option');
  7 | 
  8 | /**
  9 |  * Container for the options rendered as part of the autocompletion process
 10 |  * of the typeahead
 11 |  */
 12 | var TypeaheadSelector = React.createClass({
 13 |   propTypes: {
 14 |     options: React.PropTypes.array,
 15 |     header: React.PropTypes.string,
 16 |     customClasses: React.PropTypes.object,
 17 |     selectionIndex: React.PropTypes.number,
 18 |     onOptionSelected: React.PropTypes.func
 19 |   },
 20 | 
 21 |   getDefaultProps: function() {
 22 |     return {
 23 |       selectionIndex: null,
 24 |       customClasses: {},
 25 |       onOptionSelected: function(option) { }
 26 |     };
 27 |   },
 28 | 
 29 |   getInitialState: function() {
 30 |     return {
 31 |       selectionIndex: this.props.selectionIndex,
 32 |       selection: this.getSelectionForIndex(this.props.selectionIndex)
 33 |     };
 34 |   },
 35 | 
 36 |   componentWillReceiveProps: function(nextProps) {
 37 |     this.setState({selectionIndex: null});
 38 |   },
 39 | 
 40 |   render: function() {
 41 |     var classes = {
 42 |       "typeahead-selector": true
 43 |     };
 44 |     classes[this.props.customClasses.results] = this.props.customClasses.results;
 45 |     var classList = React.addons.classSet(classes);
 46 | 
 47 |     var results = this.props.options.map(function(result, i) {
 48 |       return (
 49 |         <TypeaheadOption ref={result} key={result}
 50 |           hover={this.state.selectionIndex === i}
 51 |           customClasses={this.props.customClasses}
 52 |           onClick={this._onClick.bind(this, result)}>
 53 |           { result }
 54 |         </TypeaheadOption>
 55 |       );
 56 |     }, this);
 57 |     return <ul className={classList}>
 58 |       <li className="header">{this.props.header}</li>
 59 |         { results }
 60 |       </ul>;
 61 |   },
 62 | 
 63 |   setSelectionIndex: function(index) {
 64 |     this.setState({
 65 |       selectionIndex: index,
 66 |       selection: this.getSelectionForIndex(index),
 67 |     });
 68 |   },
 69 | 
 70 |   getSelectionForIndex: function(index) {
 71 |     if (index === null) {
 72 |       return null;
 73 |     }
 74 |     return this.props.options[index];
 75 |   },
 76 | 
 77 |   _onClick: function(result) {
 78 |     this.props.onOptionSelected(result);
 79 |   },
 80 | 
 81 |   _nav: function(delta) {
 82 |     if (!this.props.options) {
 83 |       return;
 84 |     }
 85 |     var newIndex;
 86 |     if (this.state.selectionIndex === null) {
 87 |       if (delta == 1) {
 88 |         newIndex = 0;
 89 |       } else {
 90 |         newIndex = delta;
 91 |       }
 92 |     } else {
 93 |       newIndex = this.state.selectionIndex + delta;
 94 |     }
 95 |     if (newIndex < 0) {
 96 |       newIndex += this.props.options.length;
 97 |     } else if (newIndex >= this.props.options.length) {
 98 |       newIndex -= this.props.options.length;
 99 |     }
100 |     var newSelection = this.getSelectionForIndex(newIndex);
101 |     this.setState({selectionIndex: newIndex,
102 |                    selection: newSelection});
103 |   },
104 | 
105 |   navDown: function() {
106 |     this._nav(1);
107 |   },
108 | 
109 |   navUp: function() {
110 |     this._nav(-1);
111 |   }
112 | 
113 | });
114 | 
115 | module.exports = TypeaheadSelector;
116 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/systems/app-systems.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var SystemsTable = require('./app-systems_table.jsx');
 3 | 
 4 | var Systems =
 5 |   React.createClass({
 6 |     render:function(){
 7 |       return (
 8 |           <div>
 9 |             <h2>Systems</h2>
10 |             <SystemsTable/>
11 |           </div>
12 |         )
13 |     }
14 |   });
15 | module.exports = Systems;
16 | 


--------------------------------------------------------------------------------
/frontend/src/js/components/systems/app-systems_table.jsx:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | var Reqwest = require("reqwest");
 3 | var Griddle = require('griddle-react');
 4 | var GriddleWithCallback = require('../GriddleWithCallback.jsx');
 5 | var Link = require('react-router-component').Link;
 6 | var Alert = require('react-bootstrap').Alert;
 7 | 
 8 | var SystemsTable = React.createClass({
 9 |   getInitialState: function() {
10 |     return {
11 |       errMsg: "",
12 |     }
13 |   },
14 | 
15 |   getJsonData: function(filterString, sortColumn, sortAscending, page, pageSize, callback) {
16 |     thisComponent = this;
17 | 
18 |     if (filterString==undefined) {
19 |       filterString = "";
20 |     }
21 |     if (sortColumn==undefined) {
22 |       sortColumn = "";
23 |     }
24 | 
25 |     Reqwest({
26 |       url: '/api/systems.json?start='+page*pageSize+"&length="+pageSize+"&filter="+filterString+"&sort="+sortColumn+"&sa="+sortAscending,
27 |       type: 'json',
28 |       success: function (resp) {
29 |         var results = [];
30 |         for (var i=0; i<resp.iTotalDisplayRecords; i++)
31 |         {
32 |           results[i] = {
33 |             "Machine Name" : Link({href:"/systeminfo?uuid="+resp.aaData[i]["System"], children:resp.aaData[i]["MachineName"]}),
34 |             "Comment": resp.aaData[i]["Comment"],
35 |             "Agent Version": resp.aaData[i]["AgentVersion"],
36 |             "OS": resp.aaData[i]["OSHumanName"],
37 |             "Manufacturer": resp.aaData[i]["Manufacturer"],
38 |             "Model": resp.aaData[i]["Model"],
39 |             "Last Seen": resp.aaData[i]["LastSeen"],
40 |             "First Seen": resp.aaData[i]["FirstSeen"]
41 |           };
42 |         }
43 | 
44 |         callback({
45 |           results: results,
46 |           totalResults: resp.iTotalRecords,
47 |           pageSize: pageSize
48 |         });
49 |       },
50 |       error: function (err) {
51 |         var msg = "The server was unable to handle that request.";
52 |         thisComponent.setState({errMsg:msg});
53 |       }
54 |     });
55 |   },
56 | 
57 |  	render: function(){
58 |     if (this.state.errMsg != "") {
59 |       return (
60 |        <Alert bsStyle="danger">{this.state.errMsg}</Alert>
61 |       );
62 |     }
63 | 
64 |     return (
65 |       <GriddleWithCallback
66 |         getExternalResults={this.getJsonData}
67 |         showFilter={false}
68 |       />
69 |     )
70 |   }
71 | });
72 | module.exports = SystemsTable;
73 | 


--------------------------------------------------------------------------------
/frontend/src/js/main.js:
--------------------------------------------------------------------------------
1 | /** @jsx React.DOM */
2 | var React = require('react');
3 | 
4 | var APP = require('./components/app.jsx');
5 | 
6 | React.render(
7 |   <APP />,
8 |   document.getElementById('main'));
9 | 


--------------------------------------------------------------------------------
/frontend/update_libs.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | npm install --no-bin-links
3 | 


--------------------------------------------------------------------------------
/lib/TaskQueue/taskqueue.go:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////
  2 | //
  3 | // Summit Route End Point Protection
  4 | //
  5 | // This source code is licensed under the BSD-style license found in the
  6 | // LICENSE file in the root directory of this source tree.
  7 | //
  8 | /////////////////////////////////////////////////////////////////////////////
  9 | 
 10 | 
 11 | package TaskQueue
 12 | 
 13 | import (
 14 | 	"encoding/json"
 15 | 
 16 | 	log "github.com/Sirupsen/logrus"
 17 | 	"github.com/streadway/amqp"
 18 | )
 19 | 
 20 | // analyzeFile used for creating a task to analyze a file
 21 | type analyzeFile struct {
 22 | 	FileID int64
 23 | }
 24 | 
 25 | // createAnalyzeFileMessage returns message to be sent to the queue for analyzing file messages
 26 | func createAnalyzeFileMessage(fileID int64) ([]byte, error) {
 27 | 	var task analyzeFile
 28 | 	task.FileID = fileID
 29 | 	return json.Marshal(task)
 30 | }
 31 | 
 32 | // CreateTaskToAnalyzeFile creates a rabbitMQ task for a worker to pick up
 33 | func CreateTaskToAnalyzeFile(ch *amqp.Channel, fileID int64) (err error) {
 34 | 	taskMsg, err := createAnalyzeFileMessage(fileID)
 35 | 	if err != nil {
 36 | 		log.Errorf("Failed to create task")
 37 | 		panic(err)
 38 | 	}
 39 | 
 40 | 	err = QueueTask(ch, "analyzefile", taskMsg)
 41 | 	if err != nil {
 42 | 		log.Errorf("Failed to queue task")
 43 | 		panic(err)
 44 | 	}
 45 | 	return nil
 46 | }
 47 | 
 48 | // analyzeCatalog used for creating a task to analyze a catalog
 49 | type analyzeCatalog struct {
 50 | 	CatalogID int64
 51 | }
 52 | 
 53 | // createAnalyzeCatalogMessage returns message to be sent to the queue for analyzing catalog messages
 54 | func createAnalyzeCatalogMessage(catalogID int64) ([]byte, error) {
 55 | 	var task analyzeCatalog
 56 | 	task.CatalogID = catalogID
 57 | 	return json.Marshal(task)
 58 | }
 59 | 
 60 | // CreateTaskToAnalyzeCatalog creates a rabbitMQ task for a worker to pick up
 61 | func CreateTaskToAnalyzeCatalog(ch *amqp.Channel, catalogID int64) (err error) {
 62 | 	taskMsg, err := createAnalyzeCatalogMessage(catalogID)
 63 | 	if err != nil {
 64 | 		log.Errorf("Failed to create task")
 65 | 		panic(err)
 66 | 	}
 67 | 
 68 | 	err = QueueTask(ch, "analyzecatalog", taskMsg)
 69 | 	if err != nil {
 70 | 		log.Errorf("Failed to queue task")
 71 | 		panic(err)
 72 | 	}
 73 | 	return nil
 74 | }
 75 | 
 76 | // QueueTask sends the message to the queueing server
 77 | func QueueTask(ch *amqp.Channel, channelName string, msg []byte) error {
 78 | 	err := ch.Publish(
 79 | 		"",          // exchange
 80 | 		channelName, // routing key
 81 | 		false,       // mandatory
 82 | 		false,       // immediate
 83 | 		amqp.Publishing{
 84 | 			ContentType: "text/plain",
 85 | 			Body:        msg,
 86 | 		})
 87 | 	return err
 88 | }
 89 | 
 90 | // CreateQueue declares durable queues
 91 | func CreateQueue(ch *amqp.Channel, queueName string) (err error) {
 92 | 	// TODO Need to deal with re-connects.  Should probably look at: https://github.com/richardiux/rabbitmq-to-resque
 93 | 
 94 | 	queueArguments := amqp.Table{"x-ha-policy": "all"}
 95 | 	_, err = ch.QueueDeclare(
 96 | 		queueName,      // name
 97 | 		true,           // durable
 98 | 		false,          // delete when unused
 99 | 		false,          // exclusive
100 | 		false,          // no-wait
101 | 		queueArguments, // arguments
102 | 	)
103 | 
104 | 	return err
105 | }
106 | 


--------------------------------------------------------------------------------
/lib/models/create_tables.sql:
--------------------------------------------------------------------------------
 1 | create table filetosystemmap (fileid bigint not null, systemid bigint not null, filepath text not null, firstseen bigint not null, lastseen bigint not null, PRIMARY KEY(fileid, systemid));
 2 | 
 3 | 
 4 | -- Must create aggregate First function as defined: https://wiki.postgresql.org/wiki/First/last_(aggregate)
 5 | 
 6 | CREATE OR REPLACE FUNCTION public.first_agg ( anyelement, anyelement )
 7 | RETURNS anyelement LANGUAGE sql IMMUTABLE STRICT AS $$
 8 |         SELECT $1;
 9 | $$;
10 |  
11 | -- And then wrap an aggregate around it
12 | CREATE AGGREGATE public.first (
13 |         sfunc    = public.first_agg,
14 |         basetype = anyelement,
15 |         stype    = anyelement
16 | );
17 | 


--------------------------------------------------------------------------------
/lib/models/mappings.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | 
11 | 
12 | package models
13 | 
14 | import (
15 | 	"database/sql"
16 | 
17 | 	"github.com/coopernurse/gorp"
18 | )
19 | 
20 | // InitDB initialize the database by creating the needed tables
21 | func InitDB(ConnectionString string) (*gorp.DbMap, error) {
22 | 	// Connect to db
23 | 	db, err := sql.Open("postgres", ConnectionString)
24 | 	if err != nil {
25 | 		return nil, err
26 | 	}
27 | 
28 | 	// Construct a gorp DbMap
29 | 	dbmap := &gorp.DbMap{Db: db, Dialect: gorp.PostgresDialect{}}
30 | 
31 | 	// Add a table, setting the table
32 | 	dbmap.AddTableWithName(SystemSet{}, "systemsets").SetKeys(true, "ID")
33 | 	dbmap.AddTableWithName(System{}, "systems").SetKeys(true, "ID")
34 | 	dbmap.AddTableWithName(RuleSet{}, "rulesets").SetKeys(true, "ID")
35 | 	dbmap.AddTableWithName(Rule{}, "rules").SetKeys(true, "ID")
36 | 
37 | 	tbl := dbmap.AddTableWithName(ExecutableFile{}, "executablefiles").SetKeys(true, "ID")
38 | 	tbl.ColMap("Md5").SetMaxSize(32)
39 | 	tbl.ColMap("Sha1").SetMaxSize(40)
40 | 	tbl.ColMap("Sha256").SetMaxSize(64)
41 | 	tbl.ColMap("CodeSectionSha256").SetMaxSize(64)
42 | 	tbl.ColMap("AuthenticodeMd5").SetMaxSize(32)
43 | 	tbl.ColMap("AuthenticodeSha1").SetMaxSize(40)
44 | 	tbl.ColMap("AuthenticodeSha256").SetMaxSize(64)
45 | 
46 | 	dbmap.AddTableWithName(FileToSignerMap{}, "filetosignermap").SetKeys(false, "FileID", "SignerID")
47 | 	dbmap.AddTableWithName(FileToCounterSignerMap{}, "filetocountersignermap").SetKeys(false, "FileID", "SignerID")
48 | 	dbmap.AddTableWithName(Signer{}, "signers").SetKeys(true, "ID")
49 | 	dbmap.AddTableWithName(CatalogFile{}, "catalogfiles").SetKeys(true, "ID")
50 | 	dbmap.AddTableWithName(CertificateTrustList{}, "certificatetrustlist").SetKeys(false, "CatalogID", "Hash")
51 | 
52 | 	dbmap.AddTableWithName(ProcessEvent{}, "processevents").SetKeys(true, "ID")
53 | 	dbmap.AddTableWithName(FileToSystemMap{}, "filetosystemmap").SetKeys(false, "FileID", "SystemID")
54 | 
55 | 	tbl = dbmap.AddTableWithName(Customer{}, "customers").SetKeys(true, "ID")
56 | 	tbl.ColMap("UUID").SetMaxSize(16)
57 | 	tbl.ColMap("UUID").SetUnique(true)
58 | 
59 | 	tbl = dbmap.AddTableWithName(User{}, "users").SetKeys(true, "ID")
60 | 	tbl.ColMap("PasswordHash").SetMaxSize(60)
61 | 
62 | 	tbl = dbmap.AddTableWithName(BrowserSession{}, "browserSessions").SetKeys(true, "ID")
63 | 	tbl.ColMap("NonceHash").SetMaxSize(32)
64 | 	tbl = dbmap.AddTableWithName(PasswordReset{}, "passwordResets").SetKeys(true, "ID")
65 | 	tbl.ColMap("Nonce").SetMaxSize(64)
66 | 
67 | 	dbmap.AddTableWithName(Task{}, "tasks").SetKeys(true, "ID")
68 | 
69 | 	dbmap.AddTableWithName(Updates{}, "updates").SetKeys(true, "ID")
70 | 
71 | 	// Create the tables
72 | 	err = dbmap.CreateTablesIfNotExists()
73 | 	if err != nil {
74 | 		return nil, err
75 | 	}
76 | 
77 | 	return dbmap, nil
78 | }
79 | 


--------------------------------------------------------------------------------
/lib/models/users.go:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////
  2 | //
  3 | // Summit Route End Point Protection
  4 | //
  5 | // This source code is licensed under the BSD-style license found in the
  6 | // LICENSE file in the root directory of this source tree.
  7 | //
  8 | /////////////////////////////////////////////////////////////////////////////
  9 | 
 10 | package models
 11 | 
 12 | import (
 13 | 	"code.google.com/p/go.crypto/bcrypt"
 14 | 	log "github.com/Sirupsen/logrus"
 15 | 	"github.com/coopernurse/gorp"
 16 | )
 17 | 
 18 | // Customer is a collection of systems.  Likely an entire business.
 19 | // When a new customer is creater
 20 | type Customer struct {
 21 | 	ID   int64  // Internal ID for the DB
 22 | 	UUID []byte // Customer ID the client knows
 23 | 
 24 | 	Active       bool // In case we want to disable the customer
 25 | 	CreationDate int64
 26 | }
 27 | 
 28 | // User of the webapp
 29 | //
 30 | // Example: insert into users (customerid, firstname, lastname, email, passwordhash, verified, active, mustsetpassword, creationdate, lastlogin) values (1, 'scott', 'piper', 'scott@summitroute.com', '\x24326124313024355566457671715563332f79436653447a32646a434f477278434b466c5861536f476b4f4e465a353141774c55376342345a777a2e', TRUE, TRUE, FALSE,  1414698750, 0);
 31 | //   Password is "abc"
 32 | type User struct {
 33 | 	ID           int64
 34 | 	CustomerID   int64
 35 | 	FirstName    string
 36 | 	LastName     string
 37 | 	Email        string // Used for both login and contacting
 38 | 	PasswordHash []byte // PasswordHash (bcrypt hash, so it includes a salt)
 39 | 
 40 | 	Verified                   bool  // True when the user has verified their email
 41 | 	Active                     bool  // In case we want to disable the user
 42 | 	MustSetPassword            bool  // True when the user needs to set their password (from password resets)
 43 | 	LastPasswordResetEmailDate int64 // Last time we sent them a password reset email, so we don't flood them
 44 | 	CreationDate               int64
 45 | 	LastLogin                  int64
 46 | }
 47 | 
 48 | // BrowserSession keeps track of browser sessions where a user has logged in
 49 | // TODO ONEDAY I tried researching best practices regarding what to keep in the cookie,
 50 | // and what to store in the DB, and couldn't find anything.  So I've taken a best guess here at what to do.
 51 | type BrowserSession struct {
 52 | 	ID        int64  // TODO Need to use random, non-repeating numbers for the ID
 53 | 	NonceHash []byte // Random value to avoid session hijacking, since the session ID really should be at least 128-bits
 54 | 	UserID    int64  // Ties this back to the user that logged in
 55 | 
 56 | 	CreationDate int64  // For expiration purposes
 57 | 	LastActive   int64  // Need to keep track of this so we don't log the user out while they are doing something
 58 | 	IP           []byte // Keep track of where this was originally logged in from
 59 | 	UserAgent    []byte // Keep track of what browser was used to login with
 60 | }
 61 | 
 62 | // PasswordReset Used by password reset emails to re-login a user
 63 | type PasswordReset struct {
 64 | 	ID     int64
 65 | 	Nonce  []byte // Random value 256-bit value
 66 | 	UserID int64  // Ties this back to the user that logged in
 67 | 
 68 | 	CreationDate int64 // For expiration purposes
 69 | 	Valid        bool  // Set to zero after first use so this can't be re-used
 70 | }
 71 | 
 72 | // HashPassword generates a bcrypt hash (includes salt) of the password
 73 | func (user *User) HashPassword(password string) (err error) {
 74 | 	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
 75 | 	if err != nil {
 76 | 		log.Errorf("Couldn't hash password: %v", err)
 77 | 		return err
 78 | 	}
 79 | 	user.PasswordHash = hash
 80 | 	return nil
 81 | }
 82 | 
 83 | // GetUserByEmail looks up the user in the database by their email
 84 | func GetUserByEmail(db *gorp.DbMap, email string) (user *User) {
 85 | 	db.SelectOne(&user, "select * from users where Email=:email",
 86 | 		map[string]interface{}{
 87 | 			"email": email,
 88 | 		})
 89 | 	// No error checking because it throws errors when there are no matches
 90 | 	/*
 91 | 		if err != nil {
 92 | 			log.Warningf("Can't get user by email: %v", err)
 93 | 		}
 94 | 	*/
 95 | 	return
 96 | }
 97 | 
 98 | // InsertUser adds a user to the DB
 99 | func InsertUser(db *gorp.DbMap, user *User) error {
100 | 	return db.Insert(user)
101 | }
102 | 
103 | // InsertSession adds a broser session to the DB
104 | func InsertSession(db *gorp.DbMap, browserSession *BrowserSession) error {
105 | 	return db.Insert(browserSession)
106 | }
107 | 


--------------------------------------------------------------------------------
/lib/utils/conversions.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | 
11 | package utils
12 | 
13 | import (
14 | 	"encoding/hex"
15 | 	"fmt"
16 | 	"time"
17 | 
18 | 	log "github.com/Sirupsen/logrus"
19 | 	uuid "github.com/nu7hatch/gouuid"
20 | )
21 | 
22 | // UUIDStringToBytes Given a UUID string, converts it to a byte slice for use with the DB
23 | func UUIDStringToBytes(UUIDString string) ([]byte, error) {
24 | 	UUIDByteArray, err := uuid.ParseHex(UUIDString)
25 | 	if err != nil {
26 | 		return nil, err
27 | 	}
28 | 
29 | 	var UUIDSlice []byte
30 | 	UUIDSlice = UUIDByteArray[0:16]
31 | 
32 | 	return UUIDSlice, nil
33 | }
34 | 
35 | // ByteArrayToUUIDString Given a byte array converts it to a UUID string
36 | func ByteArrayToUUIDString(byteArray []byte) (UUIDString string, err error) {
37 | 	parsedUUID, err := uuid.Parse(byteArray)
38 | 	if err != nil {
39 | 		return
40 | 	}
41 | 
42 | 	return parsedUUID.String(), nil
43 | 
44 | }
45 | 
46 | // ByteArrayToHexString converter
47 | func ByteArrayToHexString(byteArray []byte) string {
48 | 	return hex.EncodeToString(byteArray)
49 | }
50 | 
51 | // Int64ToUnixTimeString returns a human readable time and date string
52 | func Int64ToUnixTimeString(secondsFromEpoch int64, dateOnly bool) string {
53 | 	// TODO need to display the user's timezone
54 | 	timezone, err := time.LoadLocation("MST")
55 | 	if err != nil {
56 | 		log.Errorf("Unable to set timezone, %v", err)
57 | 		timezone = time.Local
58 | 	}
59 | 
60 | 	t := time.Unix(secondsFromEpoch, 0).In(timezone)
61 | 	if dateOnly {
62 | 		return fmt.Sprintf("%04d-%02d-%02d", t.Year(), t.Month(), t.Day())
63 | 	}
64 | 	return fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d", t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
65 | }
66 | 


--------------------------------------------------------------------------------
/lib/utils/crypto.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | 
11 | package utils
12 | 
13 | import (
14 | 	"crypto/aes"
15 | 	"crypto/cipher"
16 | 	"crypto/rand"
17 | 	"errors"
18 | 	"io"
19 | )
20 | 
21 | // KeyForObfuscation is a crypto key that should only be used for obfuscating data
22 | var KeyForObfuscation = []byte("1sf2324knkfnsfff")
23 | 
24 | // SymmetricEncrypt to be used for small symmetric crypto operations
25 | // Taken from: http://stackoverflow.com/questions/18817336/golang-encrypting-a-string-with-aes-and-base64
26 | func SymmetricEncrypt(key []byte, plaintext []byte) ([]byte, error) {
27 | 	block, err := aes.NewCipher(key)
28 | 	if err != nil {
29 | 		return nil, err
30 | 	}
31 | 	ciphertext := make([]byte, aes.BlockSize+len(plaintext))
32 | 	iv := ciphertext[:aes.BlockSize]
33 | 	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
34 | 		return nil, err
35 | 	}
36 | 
37 | 	cfb := cipher.NewCFBEncrypter(block, iv)
38 | 	cfb.XORKeyStream(ciphertext[aes.BlockSize:], []byte(plaintext))
39 | 	return ciphertext, nil
40 | }
41 | 
42 | // SymmetricDecrypt to be used for small symmetric crypto operations
43 | func SymmetricDecrypt(key []byte, input []byte) ([]byte, error) {
44 | 	block, err := aes.NewCipher(key)
45 | 	if err != nil {
46 | 		return nil, err
47 | 	}
48 | 	if len(input) < aes.BlockSize {
49 | 		return nil, errors.New("ciphertext too short")
50 | 	}
51 | 
52 | 	iv := input[:aes.BlockSize]
53 | 	text := input[aes.BlockSize:]
54 | 	cfb := cipher.NewCFBDecrypter(block, iv)
55 | 	cfb.XORKeyStream(text, text)
56 | 
57 | 	return text, nil
58 | }
59 | 


--------------------------------------------------------------------------------
/lib/utils/files.go:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////
  2 | //
  3 | // Summit Route End Point Protection
  4 | //
  5 | // This source code is licensed under the BSD-style license found in the
  6 | // LICENSE file in the root directory of this source tree.
  7 | //
  8 | /////////////////////////////////////////////////////////////////////////////
  9 | 
 10 | package utils
 11 | 
 12 | import (
 13 | 	"crypto/sha256"
 14 | 	"fmt"
 15 | 	"io/ioutil"
 16 | 	"os"
 17 | 	"path"
 18 | 	"strings"
 19 | 
 20 | 	"github.com/crowdmob/goamz/aws"
 21 | 	"github.com/crowdmob/goamz/s3"
 22 | )
 23 | 
 24 | // ExpandSha256HexstringToPath converts a sha hash like
 25 | // "0a8ce026714e03e72c619307bd598add5f9b639cfd91437cb8d9c847bf9f6894" to
 26 | // "0a/8c/0a8ce026714e03e72c619307bd598add5f9b639cfd91437cb8d9c847bf9f6894"
 27 | // Assumes the string has already been sanity checked to ensure it's a lowercase sha256
 28 | func ExpandSha256HexstringToPath(fileName string) string {
 29 | 	nameChars := strings.Split(fileName, "")
 30 | 	root := nameChars[0] + nameChars[1]
 31 | 	child := nameChars[2] + nameChars[3]
 32 | 	return path.Join(root, child, fileName)
 33 | }
 34 | 
 35 | // Sha256File returns the sha256 hash of a file
 36 | func Sha256File(f *os.File) (hash []byte, err error) {
 37 | 	offset, err := f.Seek(0, 0) // Seek to the start of the file
 38 | 	if err != nil || offset != 0 {
 39 | 		return nil, fmt.Errorf("Unable to seek to start of file: %v", err)
 40 | 	}
 41 | 
 42 | 	hasher := sha256.New()
 43 | 	// TODO Should read chunks at a time
 44 | 	fileBytes, err := ioutil.ReadAll(f)
 45 | 	if err != nil {
 46 | 		return nil, fmt.Errorf("Unable to read file: %v", err)
 47 | 	}
 48 | 
 49 | 	hasher.Write(fileBytes)
 50 | 	hash = hasher.Sum(nil)
 51 | 
 52 | 	return hash, nil
 53 | }
 54 | 
 55 | // AwsS3 is used in config.json files
 56 | type AwsS3 struct {
 57 | 	BucketName string `json:"bucket_name"`
 58 | 	AccessKey  string `json:"access_key"`
 59 | 	SecretKey  string `json:"secret_key"`
 60 | 	Region     string `json:"region"`
 61 | }
 62 | 
 63 | // UploadToS3HashPath given a filename that is a hex encoded hash, create a special directory structure for this file
 64 | // and upload to S3
 65 | func UploadToS3HashPath(awsS3 AwsS3, filename string, f *os.File) (err error) {
 66 | 	return UploadToS3(awsS3, ExpandSha256HexstringToPath(filename), filename, f)
 67 | 
 68 | }
 69 | 
 70 | // UploadToS3 uploads the file to the AwsS3 bucket
 71 | // AwsS3 is the credentials
 72 | // filepath is the path inside the S3 bucket to upload to
 73 | // filename is name of the file
 74 | // f is the file handle for the file to upload
 75 | func UploadToS3(awsS3 AwsS3, filepath, filename string, f *os.File) (err error) {
 76 | 	auth := aws.Auth{AccessKey: awsS3.AccessKey, SecretKey: awsS3.SecretKey}
 77 | 	s3Service := s3.New(auth, aws.Regions["us-east-1"])
 78 | 	bucket := s3Service.Bucket(awsS3.BucketName)
 79 | 
 80 | 	// TODO Should read f in chunks
 81 | 
 82 | 	// Seek to the start of the file
 83 | 	offset, err := f.Seek(0, 0)
 84 | 	if err != nil || offset != 0 {
 85 | 		return fmt.Errorf("Unable to seek to start of: %v", err)
 86 | 	}
 87 | 
 88 | 	contents, err := ioutil.ReadAll(f)
 89 | 	if err != nil {
 90 | 		return fmt.Errorf("Unable to read file: %v", err)
 91 | 	}
 92 | 
 93 | 	disposition := fmt.Sprintf("attachment; filename=\"%s\"", filename)
 94 | 	err = bucket.Put(filepath, contents, "binary/octet-stream", s3.Private, s3.Options{ContentDisposition: disposition})
 95 | 	return err
 96 | }
 97 | 
 98 | // CheckExists returns true if the file exists, else false
 99 | func CheckExists(path string) (doesExist bool) {
100 | 	if _, err := os.Stat(path); os.IsNotExist(err) {
101 | 		return false
102 | 	}
103 | 	return true
104 | }
105 | 


--------------------------------------------------------------------------------
/utilities/commander/config.json:
--------------------------------------------------------------------------------
1 | {
2 |   "db_connection_string":"user=postgres password=password dbname=srepp sslmode=disable"
3 | }
4 | 


--------------------------------------------------------------------------------
/utilities/hashpasswd/hashpasswd.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package main
11 | 
12 | import (
13 | 	"encoding/hex"
14 | 	"fmt"
15 | 	"os"
16 | 
17 | 	"code.google.com/p/go.crypto/bcrypt"
18 | )
19 | 
20 | func main() {
21 | 	if len(os.Args) != 2 {
22 | 		fmt.Printf("Usage: hashpassword <password>\n")
23 | 		fmt.Printf("Then on the server, in psql, run something like:")
24 | 		fmt.Printf("update \"users\" set passwordhash='\\x2432612431302433666e424a5a794d622e623450334539655832585765333164336b6a5855684c49474d76354543456a365a39386d6d6d6132726c65' where id=1;")
25 | 		return
26 | 	}
27 | 	password := os.Args[1]
28 | 	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
29 | 	if err != nil {
30 | 		fmt.Printf("Couldn't hash password: %v", err)
31 | 		return
32 | 	}
33 | 
34 | 	fmt.Printf("%s\n", hex.EncodeToString(hash))
35 | }
36 | 


--------------------------------------------------------------------------------
/utilities/uploadfile/uploadfile.go:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////
 2 | //
 3 | // Summit Route End Point Protection
 4 | //
 5 | // This source code is licensed under the BSD-style license found in the
 6 | // LICENSE file in the root directory of this source tree.
 7 | //
 8 | /////////////////////////////////////////////////////////////////////////////
 9 | 
10 | package main
11 | 
12 | import (
13 | 	"fmt"
14 | 	"os"
15 | 
16 | 	"qdserver/lib/utils"
17 | )
18 | 
19 | func main() {
20 | 	if len(os.Args) != 2 {
21 | 		fmt.Printf("Usage: uploadfile <filepath>\n")
22 | 		fmt.Printf("Simple test utility to ensure I can upload files to S3.\n")
23 | 		fmt.Printf("Given a file, generates a SHA256 hash and upload the binary to the hash path on S3\n")
24 | 		return
25 | 	}
26 | 
27 | 	filename := os.Args[1]
28 | 
29 | 	f, err := os.Open(filename)
30 | 	if err != nil {
31 | 		fmt.Printf("ERROR: %v", err)
32 | 		return
33 | 	}
34 | 
35 | 	defer f.Close()
36 | 
37 | 	ExeUpload := utils.AwsS3{
38 | 		BucketName: "summitroute.file.uploads",
39 | 		AccessKey:  "YOUR_ACCESS_KEY",
40 | 		SecretKey:  "YOUR_SECRET_KEY",
41 | 		Region:     "us-east-1",
42 | 	}
43 | 
44 | 	sha256, err := utils.Sha256File(f)
45 | 	if err != nil {
46 | 		fmt.Printf("ERROR: %v\n", err)
47 | 		return
48 | 	}
49 | 
50 | 	sha256String := utils.ByteArrayToHexString(sha256)
51 | 
52 | 	err = utils.UploadToS3HashPath(ExeUpload, sha256String, f)
53 | 	if err != nil {
54 | 		fmt.Printf("ERROR: %v\n", err)
55 | 		return
56 | 	}
57 | 
58 | 	fmt.Printf("Success\n")
59 | }
60 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/config.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "db": {
 3 |     "connection_string": "postgresql://postgres:password@localhost/srepp"
 4 |   },
 5 |   "queue" : {
 6 |     "username": "guest",
 7 |     "password": "guest",
 8 |     "host": "localhost"
 9 |   },
10 |   "tmp_file_path" : "/tmp/fileanalysis/",
11 |   "aws" : {
12 |      "s3": {
13 |        "exe": {
14 |          "bucket_name": "summitroute.file.uploads",
15 |          "access_key": "YOUR_ACCESS_KEY",
16 |          "secret_key": "YOUR_SECRET_KEY",
17 |          "region": "us-east-1"
18 |        },
19 |        "catalog": {
20 |          "bucket_name": "summitroute.catalog.uploads",
21 |          "access_key": "YOUR_ACCESS_KEY",
22 |          "secret_key": "YOUR_SECRET_KEY",
23 |          "region": "us-east-1"
24 |        }
25 |      }
26 |   },
27 |   "logpath": "/tmp/taskworker.log"
28 | }
29 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/model.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | ###############################################################################
 4 | #
 5 | # Summit Route End Point Protection
 6 | #
 7 | # This source code is licensed under the BSD-style license found in the
 8 | # LICENSE file in the root directory of this source tree.
 9 | #
10 | ###############################################################################
11 | 
12 | from sqlalchemy import *
13 | from sqlalchemy.ext.declarative import declarative_base
14 | 
15 | Base = declarative_base()
16 | 
17 | 
18 | class ExecutableFiles(Base):
19 |     __tablename__ = 'executablefiles'
20 |     id = Column(BigInteger, primary_key=True)
21 |     md5 = Column(LargeBinary(length=32))
22 |     sha1 = Column(LargeBinary(length=40))
23 |     sha256 = Column(LargeBinary(length=64))
24 | 
25 |     authenticodemd5 = Column(LargeBinary(length=32))
26 |     authenticodesha1 = Column(LargeBinary(length=40))
27 |     authenticodesha256 = Column(LargeBinary(length=64))
28 | 
29 |     codesectionsha256 = Column(LargeBinary(length=64))
30 |     size = Column(Integer)
31 |     issigned = Column(Boolean)
32 |     firstseen = Column(BigInteger)
33 |     executiontype = Column(Integer)
34 | 
35 |     uploaddate = Column(BigInteger)
36 | 
37 |     analysisdate = Column(BigInteger)
38 | 
39 |     companyname = Column(String)
40 |     productversion = Column(String)
41 |     productname = Column(String)
42 |     filedescription = Column(String)
43 |     internalname = Column(String)
44 |     fileversion = Column(String)
45 |     originalfilename = Column(String)
46 |     architecture = Column(Integer)
47 | 
48 | 
49 | class FileToSignerMap(Base):
50 |     __tablename__ = 'filetosignermap'
51 |     fileid = Column(BigInteger, primary_key=True)
52 |     signerid = Column(BigInteger, primary_key=True)
53 | 
54 | 
55 | class FileToCounterSignerMap(Base):
56 |     __tablename__ = 'filetocountersignermap'
57 |     fileid = Column(BigInteger, primary_key=True)
58 |     timestamp = Column(BigInteger)
59 |     signerid = Column(BigInteger, primary_key=True)
60 | 
61 | 
62 | class Signer(Base):
63 |     __tablename__ = 'signers'
64 |     id = Column(BigInteger, primary_key=True)
65 |     version = Column(Integer)
66 |     subject = Column(String)
67 |     subjectshortname = Column(String)
68 |     serialnumber = Column(LargeBinary)
69 |     digestalgorithm = Column(String)
70 |     digestencryptionalgorithm = Column(String)
71 |     digestencryptionalgorithmkeysize = Column(Integer)
72 |     issuerid = Column(BigInteger)
73 | 
74 | class CatalogFile(Base):
75 |     __tablename__ = 'catalogfiles'
76 |     id = Column(BigInteger, primary_key=True)
77 |     filepath  = Column(String)
78 |     sha256    = Column(LargeBinary)
79 |     size      = Column(Integer)
80 |     firstseen = Column(BigInteger)
81 |     uploaddate = Column(BigInteger)
82 |     analysisdate = Column(BigInteger)
83 |     signerid = Column(BigInteger)
84 | 
85 | 
86 | class CertificateTrustList(Base):
87 |     __tablename__ = 'certificatetrustlist'
88 |     catalogid = Column(BigInteger, primary_key=True)
89 |     hash    = Column(LargeBinary, primary_key=True)
90 |     hashtype = Column(String)
91 |     fileid = Column(BigInteger)
92 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/pefile/COPYING:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2004-2013 Ero Carrera <ero@dkbza.org>. All rights reserved.
 2 | 
 3 | Redistribution and use in source and binary forms, with or without
 4 | modification, are permitted provided that the following conditions are met:
 5 | 
 6 | 1. Redistributions of source code must retain the above copyright notice, this
 7 | list of conditions and the following disclaimer.
 8 | 
 9 | 2. Redistributions in binary form must reproduce the above copyright notice,
10 | this list of conditions and the following disclaimer in the documentation
11 | and/or other materials provided with the distribution.
12 | 
13 | 3. The name of the author may not be used to endorse or promote products
14 | derived from this software without specific prior written permission.
15 | 
16 | THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 | WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 | EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
21 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
24 | IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
25 | OF SUCH DAMAGE.
26 | 
27 | 
28 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/pefile/MANIFEST:
--------------------------------------------------------------------------------
1 | COPYING
2 | CHANGES
3 | README
4 | pefile.py
5 | peutils.py
6 | setup.py
7 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/pefile/README:
--------------------------------------------------------------------------------
 1 | 
 2 | --------------------------------------------------------------------
 3 |              pefile - Portable Executable reader module
 4 | --------------------------------------------------------------------
 5 | 
 6 | 
 7 | INTRODUCTION
 8 | 
 9 | pefile will allow to access from any Python script all (or most) of the contents
10 | of a given PE file.
11 | 
12 | The structures defined in the Windows header files will be accessible as the
13 | PE instance attributes and will have the same names as defined there.
14 | (The main structures will have the standard capitalized names and will be
15 | attributes of the PE instance. Their members will be attributes.)
16 | 
17 | Other attributes and data, which require further processing but are very useful
18 | will be available as lowercase attributes. Some of those are, the imported and
19 | exported symbols and the sections, with direct access to their data (if any) and
20 | convenient methods to retrieve data based on the address as if the file were
21 | loaded, instead of needing to dig the offsets into the file.
22 | 
23 | WRITTING SUPPORT
24 | 
25 | Starting from pefile 1.2 it's possible to write back any changes done to the PE
26 | file. One has to be careful with this functionality as it will not be very
27 | intelligent reconstructing the PE file. That is, it will not handle displacing
28 | structures if that would be needed because a new section has been added.
29 | The rule of thumb is, if there's room for an additional header/structure to fit
30 | then there'll be no problem and pefile will write it.
31 | All other modifications, i.e. changing individual values in header/structure
32 | members should work well.
33 | One possible useful application of this could be to correct malformed headers
34 | used by some malware in order to cause certain analysis tools to malfunction.
35 | 
36 | 
37 | AVAILABILITY
38 | 
39 | Last versions are available at:
40 | 
41 | http://dkbza.org/pefile.html
42 | 
43 | 
44 | INSTALLATION/USAGE
45 | 
46 | Just importing it should suffice. The module should be endianness independent and
47 | it's known to work on OS X, Windows, and Linux.
48 | 
49 | 
50 | TODO
51 | 
52 | There might be some obscure info which is not readily accessible, this may be
53 | due to my ignorance or laziness. Patches or suggestions are, as usual, welcomed.
54 | 
55 | Thinks known to be missing so far:
56 | 
57 | -Reading and processing the exceptions directory entry. (Architecture dependent
58 | info)
59 | 
60 | BUGS
61 | 
62 | Given the amount of information embedded in the PE file format it is difficult
63 | to test all the data retrieved thoroughly. I did my best trying and verifying
64 | the accuracy of all the parsing. Most of the basic data has been tested by using
65 | this module, so no outrageously obvious problems should exist. Any feedback on
66 | inconsistent or faulty behavior will be welcome.
67 | 
68 | -------------------------------------------------------------------------
69 | Copyright (c) 2005-2013 Ero Carrera <ero@dkbza.org>. All rights reserved.
70 | -------------------------------------------------------------------------
71 | 
72 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/pefile/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/worker/fileanalyzer/pefile/__init__.py


--------------------------------------------------------------------------------
/worker/fileanalyzer/pefile/ordlookup/__init__.py:
--------------------------------------------------------------------------------
 1 | import ws2_32
 2 | import oleaut32
 3 | 
 4 | '''
 5 | A small module for keeping a database of ordinal to symbol
 6 | mappings for DLLs which frequently get linked without symbolic
 7 | infoz.
 8 | '''
 9 | 
10 | ords = {
11 |     'ws2_32.dll':ws2_32.ord_names,
12 |     'wsock32.dll':ws2_32.ord_names,
13 |     'oleaut32.dll':oleaut32.ord_names,
14 | }
15 | 
16 | def ordLookup(libname, ord, make_name=False):
17 |     '''
18 |     Lookup a name for the given ordinal if it's in our
19 |     database.
20 |     '''
21 |     names = ords.get(libname.lower())
22 |     if names == None:
23 |         if make_name is True:
24 |             return 'ord%d' % ord
25 |         return None
26 |     name = names.get(ord)
27 |     if name == None:
28 |         return 'ord%d' % ord
29 |     return name
30 | 
31 | 
32 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/pefile/ordlookup/ws2_32.py:
--------------------------------------------------------------------------------
  1 | 
  2 | ord_names = {
  3 |     1:'accept',
  4 |     2:'bind',
  5 |     3:'closesocket',
  6 |     4:'connect',
  7 |     5:'getpeername',
  8 |     6:'getsockname',
  9 |     7:'getsockopt',
 10 |     8:'htonl',
 11 |     9:'htons',
 12 |     10:'ioctlsocket',
 13 |     11:'inet_addr',
 14 |     12:'inet_ntoa',
 15 |     13:'listen',
 16 |     14:'ntohl',
 17 |     15:'ntohs',
 18 |     16:'recv',
 19 |     17:'recvfrom',
 20 |     18:'select',
 21 |     19:'send',
 22 |     20:'sendto',
 23 |     21:'setsockopt',
 24 |     22:'shutdown',
 25 |     23:'socket',
 26 |     24:'GetAddrInfoW',
 27 |     25:'GetNameInfoW',
 28 |     26:'WSApSetPostRoutine',
 29 |     27:'FreeAddrInfoW',
 30 |     28:'WPUCompleteOverlappedRequest',
 31 |     29:'WSAAccept',
 32 |     30:'WSAAddressToStringA',
 33 |     31:'WSAAddressToStringW',
 34 |     32:'WSACloseEvent',
 35 |     33:'WSAConnect',
 36 |     34:'WSACreateEvent',
 37 |     35:'WSADuplicateSocketA',
 38 |     36:'WSADuplicateSocketW',
 39 |     37:'WSAEnumNameSpaceProvidersA',
 40 |     38:'WSAEnumNameSpaceProvidersW',
 41 |     39:'WSAEnumNetworkEvents',
 42 |     40:'WSAEnumProtocolsA',
 43 |     41:'WSAEnumProtocolsW',
 44 |     42:'WSAEventSelect',
 45 |     43:'WSAGetOverlappedResult',
 46 |     44:'WSAGetQOSByName',
 47 |     45:'WSAGetServiceClassInfoA',
 48 |     46:'WSAGetServiceClassInfoW',
 49 |     47:'WSAGetServiceClassNameByClassIdA',
 50 |     48:'WSAGetServiceClassNameByClassIdW',
 51 |     49:'WSAHtonl',
 52 |     50:'WSAHtons',
 53 |     51:'gethostbyaddr',
 54 |     52:'gethostbyname',
 55 |     53:'getprotobyname',
 56 |     54:'getprotobynumber',
 57 |     55:'getservbyname',
 58 |     56:'getservbyport',
 59 |     57:'gethostname',
 60 |     58:'WSAInstallServiceClassA',
 61 |     59:'WSAInstallServiceClassW',
 62 |     60:'WSAIoctl',
 63 |     61:'WSAJoinLeaf',
 64 |     62:'WSALookupServiceBeginA',
 65 |     63:'WSALookupServiceBeginW',
 66 |     64:'WSALookupServiceEnd',
 67 |     65:'WSALookupServiceNextA',
 68 |     66:'WSALookupServiceNextW',
 69 |     67:'WSANSPIoctl',
 70 |     68:'WSANtohl',
 71 |     69:'WSANtohs',
 72 |     70:'WSAProviderConfigChange',
 73 |     71:'WSARecv',
 74 |     72:'WSARecvDisconnect',
 75 |     73:'WSARecvFrom',
 76 |     74:'WSARemoveServiceClass',
 77 |     75:'WSAResetEvent',
 78 |     76:'WSASend',
 79 |     77:'WSASendDisconnect',
 80 |     78:'WSASendTo',
 81 |     79:'WSASetEvent',
 82 |     80:'WSASetServiceA',
 83 |     81:'WSASetServiceW',
 84 |     82:'WSASocketA',
 85 |     83:'WSASocketW',
 86 |     84:'WSAStringToAddressA',
 87 |     85:'WSAStringToAddressW',
 88 |     86:'WSAWaitForMultipleEvents',
 89 |     87:'WSCDeinstallProvider',
 90 |     88:'WSCEnableNSProvider',
 91 |     89:'WSCEnumProtocols',
 92 |     90:'WSCGetProviderPath',
 93 |     91:'WSCInstallNameSpace',
 94 |     92:'WSCInstallProvider',
 95 |     93:'WSCUnInstallNameSpace',
 96 |     94:'WSCUpdateProvider',
 97 |     95:'WSCWriteNameSpaceOrder',
 98 |     96:'WSCWriteProviderOrder',
 99 |     97:'freeaddrinfo',
100 |     98:'getaddrinfo',
101 |     99:'getnameinfo',
102 |     101:'WSAAsyncSelect',
103 |     102:'WSAAsyncGetHostByAddr',
104 |     103:'WSAAsyncGetHostByName',
105 |     104:'WSAAsyncGetProtoByNumber',
106 |     105:'WSAAsyncGetProtoByName',
107 |     106:'WSAAsyncGetServByPort',
108 |     107:'WSAAsyncGetServByName',
109 |     108:'WSACancelAsyncRequest',
110 |     109:'WSASetBlockingHook',
111 |     110:'WSAUnhookBlockingHook',
112 |     111:'WSAGetLastError',
113 |     112:'WSASetLastError',
114 |     113:'WSACancelBlockingCall',
115 |     114:'WSAIsBlocking',
116 |     115:'WSAStartup',
117 |     116:'WSACleanup',
118 |     151:'__WSAFDIsSet',
119 |     500:'WEP',
120 | }
121 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/pefile/setup.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | try:
 4 |     from setuptools import setup
 5 | except ImportError, excp:
 6 |     from distutils.core import setup
 7 | 
 8 | import pefile
 9 | import os
10 | 
11 | os.environ['COPY_EXTENDED_ATTRIBUTES_DISABLE'] = 'true'
12 | os.environ['COPYFILE_DISABLE'] = 'true'
13 | 
14 | 
15 | setup(name = 'pefile',
16 |     version = pefile.__version__,
17 |     description = 'Python PE parsing module',
18 |     author = pefile.__author__,
19 |     author_email = pefile.__contact__,
20 |     url = 'http://code.google.com/p/pefile/',
21 |     download_url = 'http://pefile.googlecode.com/files/pefile-%s.tar.gz' % pefile.__version__,
22 |     platforms = ['any'],
23 |     classifiers = ['Development Status :: 5 - Production/Stable',
24 |     	'Intended Audience :: Developers',
25 |     	'Intended Audience :: Science/Research',
26 |     	'Natural Language :: English',
27 |     	'Operating System :: OS Independent',
28 |     	'Programming Language :: Python',
29 |     	'Topic :: Software Development :: Libraries :: Python Modules'],
30 |     long_description = "\n".join(pefile.__doc__.split('\n')),
31 |     py_modules = ['pefile', 'peutils'],
32 |     packages = ['ordlookup'] )
33 | 
34 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/CHANGES:
--------------------------------------------------------------------------------
 1 | 2012/05/08: 1.2
 2 | - Tiny fixes
 3 | - Validating certificate chains in Authenticode binaries
 4 | 
 5 | 2011/06/06: 1.1
 6 | - Bugfixes:
 7 |   - More permissive handling of trailing data blobs when ASN.1 parsing.
 8 |   - Correct initialisation of signature verification hash function for
 9 |     non-SHA1 hashes.
10 |   - Correct validation of alternate signature data encoding raw hashes.
11 | 
12 | 2011/05/11: 1.0
13 | - Initial release
14 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/README:
--------------------------------------------------------------------------------
 1 | ABSTRACT
 2 | --------
 3 | verify_sigs contains library functions to compute and validate hashes
 4 | on different file types, and signatures on PECOFF Authenticode-signed
 5 | binaries.
 6 | 
 7 | 
 8 | DEPENDENCIES
 9 | ------------
10 | You need pyasn1 == 0.13b or >= pyasn1-0.1.4rc4
11 | and M2Crypto to parse and validate signatures.
12 | To exercise some demonstrator code, you may need pefile.
13 | M2Crypto: http://chandlerproject.org/Projects/MeTooCrypto/
14 | pyasn1: http://pyasn1.sourceforge.net/
15 | pefile: http://code.google.com/p/pefile/
16 | 
17 | 
18 | DETAILS
19 | -------
20 | Currently the following hashing methods are supported:
21 | - generic files:
22 |   md5, sha1, sha256, sha512
23 | - PE-COFF authenticode (windows executables, drivers, dll's, ...):
24 |   md5, sha1
25 | 
26 | fingerprint.py
27 | The actual library of hashing algorithms, deployable as library and on
28 | 'naked' client systems, running under python 2.7. See embedded docstrings
29 | and tests for usage scenarios. Does not use third party libraries.
30 | 
31 | fingerprinter_test.py
32 | Set of tests on the fingerprinter, using pregenerated data.
33 | 
34 | generate_test_data.py
35 | Run-once code supposed to be run by hand, creates some of the files
36 | in test_data, that then need to be checked in.
37 | 
38 | auth_data.py
39 | Basic container for authenticode data, as represented in ASN.1 together
40 | with accessor and validator functions. Currently provides limited validation,
41 | in particular certificate chain validation is missing.
42 | 
43 | auth_data_test.py
44 | Set of tests on auth_data, assuring that pregenerated data still
45 | produces the same reuslts.
46 | 
47 | pecoff_blob.py
48 | Container for PECOFF format part of authenticode blobs, as provided
49 | by the fingerprinter library in the SignedData structure.
50 | 
51 | print_pe_certs.py
52 | Exercises authenticode validation routines, prints out hashes and certs.
53 | 
54 | 
55 | 
56 | 
57 | THANKS
58 | ------
59 | Many thanks to Darren and Michael for motivating me to work through tangled
60 | standards.
61 | Many thanks to Ero for pefile, and to Ilya Etingof for pyasn1, very useful
62 | examples code for x509 and pkcs7 parsing, and finally for extending the 
63 | parser to handle 'any' type!
64 | 
65 | Germano Caronni, 2012/4/26
66 | caronni@google.com , gec@acm.org
67 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SummitRoute/srepp_server/e4e8516d0f7e5594c2de6491e5d5b0fcf4996633/worker/fileanalyzer/verifysigs/__init__.py


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/asn1/__init__.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/asn1/dn.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | # Copyright 2011 Google Inc. All Rights Reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | #
17 | # Author: caronni@google.com (Germano Caronni)
18 | 
19 | """dn converts ASN.1 Distinguished Names to strings.
20 | 
21 |    TODO(user): TraverseRdn should build a better string representation,
22 |    see comments below. RFC2253 provides the right way to do this. Instead of
23 |    returning a dict, return a string.
24 |    May also want an inverse function, parsing a string into an RDN sequence.
25 | """
26 | 
27 | 
28 | from pyasn1.codec.ber import decoder
29 | 
30 | 
31 | class DistinguishedName(object):
32 |   """Container for relevant OIDs and static conversion methods."""
33 | 
34 |   # I want the formatting to make sense and be readable, really.
35 |   # pylint: disable-msg=C6007
36 |   OIDs = {
37 |       (2, 5, 4, 3)                       : 'CN',   # common name
38 |       (2, 5, 4, 6)                       : 'C',    # country
39 |       (2, 5, 4, 7)                       : 'L',    # locality
40 |       (2, 5, 4, 8)                       : 'ST',   # stateOrProvince
41 |       (2, 5, 4, 10)                      : 'O',    # organization
42 |       (2, 5, 4, 11)                      : 'OU',   # organizationalUnit
43 |       (0, 9, 2342, 19200300, 100, 1, 25) : 'DC',   # domainComponent
44 |       (1, 2, 840, 113549, 1, 9, 1)       : 'EMAIL',# emailaddress
45 |   }
46 |   # pylint: enable-msg=C6007
47 | 
48 |   @staticmethod
49 |   def OidToName(oid):
50 |     return DistinguishedName.OIDs.get(oid, str(oid))
51 | 
52 |   @staticmethod
53 |   def TraverseRdn(rdn):
54 |     """Traverses RDN structure and returns string encoding of the DN.
55 | 
56 |     Args:
57 |       rdn: ASN.1 SET (or SEQUENCE) containing RDNs (relative distinguished
58 |            names), as identified by type / value pairs. A typical input would
59 |           be of type X.509 RelativeDistinguishedName.
60 | 
61 |     Returns:
62 |       A dict representing the Distinguished Name.
63 |     """
64 |     val = dict()
65 |     for n in rdn:
66 |       # Note that this does not work for e.g. DC which is present
67 |       # multiple times.
68 |       # For a real DN parser, make sure to follow the spec in regards
69 |       # to multiple occurence of a field in subsequent RDNs, maintaining
70 |       # original ordering etc.
71 |       # TODO(user): What about elements other than [0]??
72 |       name = DistinguishedName.OidToName(n[0]['type'])
73 |       value = decoder.decode(n[0]['value'])
74 |       if name in val:
75 |         val[name] = str(value[0]) + ', ' + val.get(name, '')
76 |       else:
77 |         val[name] = str(value[0])
78 |     return val
79 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/asn1/oids.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | # Copyright 2011 Google Inc. All Rights Reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | #
17 | # Author: caronni@google.com (Germano Caronni)
18 | 
19 | """ASN.1 OIDs mappings to parser classes or strings, where there is no class."""
20 | 
21 | import hashlib
22 | 
23 | 
24 | import pkcs7
25 | import spc
26 | 
27 | # I want the formatting to make sense and be readable, really.
28 | # pylint: disable-msg=C6006,C6007
29 | OID_TO_CLASS = {
30 |     (1,2,840,113549,1,7,1)   : 'PKCS#7 Data',
31 |     (1,2,840,113549,1,7,2)   : pkcs7.SignedData,
32 |     (1,2,840,113549,2,5)     : hashlib.md5,
33 |     (1,3,14,3,2,26)          : hashlib.sha1,
34 |     (2,16,840,1,101,3,4,2,1) : hashlib.sha256,
35 |     (2,16,840,1,101,3,4,2,2) : hashlib.sha384,
36 |     (2,16,840,1,101,3,4,2,3) : hashlib.sha512,
37 |     (1,3,6,1,4,1,311,2,1,4)  : spc.SpcIndirectDataContent,
38 |     (1,2,840,113549,1,9,3)   : pkcs7.ContentType,
39 |     (1,2,840,113549,1,9,4)   : pkcs7.DigestInfo,
40 |     (1,3,6,1,4,1,311,2,1,12) : spc.SpcSpOpusInfo,
41 |     (1,2,840,113549,1,9,6)   : pkcs7.CountersignInfo,  # 'RSA_counterSign'
42 |     (1,2,840,113549,1,9,5)   : pkcs7.SigningTime,
43 | }
44 | 
45 | OID_TO_PUBKEY = {
46 |     (1,2,840,113549,1,1,1)   : 'rsa',
47 |     (1,2,840,113549,1,1,5)   : 'rsa-sha1',
48 |     (1,2,840,113549,1,1,11)  : 'rsa-sha256',
49 |     (1,2,840,113549,1,1,13)  : 'rsa-sha512',
50 |     (1,2,840,10040,4,1)      : 'dsa',
51 | }
52 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/asn1/spc.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | # Copyright 2011 Google Inc. All Rights Reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | #
17 | # Author: caronni@google.com (Germano Caronni)
18 | 
19 | """Authenticode-specific ASN.1 data structures."""
20 | 
21 | 
22 | from pkcs7 import DigestInfo
23 | from pyasn1.type import char
24 | from pyasn1.type import namedtype
25 | from pyasn1.type import tag
26 | from pyasn1.type import univ
27 | import x509
28 | 
29 | 
30 | class SpcAttributeTypeAndOptionalValue(univ.Sequence):
31 |   componentType = namedtype.NamedTypes(
32 |       namedtype.NamedType('type', x509.AttributeType()),
33 |       namedtype.OptionalNamedType('value', x509.AttributeValue()))
34 | 
35 | 
36 | class SpcIndirectDataContent(univ.Sequence):
37 |   componentType = namedtype.NamedTypes(
38 |       namedtype.NamedType('data', SpcAttributeTypeAndOptionalValue()),
39 |       namedtype.NamedType('messageDigest', DigestInfo()))
40 | 
41 | 
42 | class SpcUuid(univ.OctetString):
43 |   pass
44 | 
45 | 
46 | class SpcSerializedObject(univ.Sequence):
47 |   componentType = namedtype.NamedTypes(
48 |       namedtype.NamedType('classId', SpcUuid()),
49 |       namedtype.NamedType('serializedData', univ.OctetString()))
50 | 
51 | 
52 | class SpcString(univ.Choice):
53 |   componentType = namedtype.NamedTypes(
54 |       namedtype.NamedType('unicode', char.BMPString().subtype(
55 |           implicitTag=tag.Tag(tag.tagClassContext,
56 |                               tag.tagFormatConstructed, 0))),
57 |       namedtype.NamedType('ascii', char.IA5String().subtype(
58 |           implicitTag=tag.Tag(tag.tagClassContext,
59 |                               tag.tagFormatConstructed, 1))))
60 | 
61 | 
62 | class SpcLink(univ.Choice):
63 |   """According to Authenticode specification."""
64 |   componentType = namedtype.NamedTypes(
65 |       namedtype.NamedType('url', char.IA5String().subtype(
66 |           implicitTag=tag.Tag(tag.tagClassContext,
67 |                               tag.tagFormatConstructed, 0))),
68 |       namedtype.NamedType('moniker', SpcSerializedObject().subtype(
69 |           implicitTag=tag.Tag(tag.tagClassContext,
70 |                               tag.tagFormatConstructed, 1))),
71 |       namedtype.NamedType('file', SpcString().subtype(
72 |           explicitTag=tag.Tag(tag.tagClassContext,
73 |                               tag.tagFormatConstructed, 2))))
74 | 
75 | 
76 | class SpcSpOpusInfo(univ.Sequence):
77 |   componentType = namedtype.NamedTypes(
78 |       namedtype.OptionalNamedType('programName', SpcString().subtype(
79 |           explicitTag=tag.Tag(tag.tagClassContext,
80 |                               tag.tagFormatConstructed, 0))),
81 |       namedtype.OptionalNamedType('moreInfo', SpcLink().subtype(
82 |           explicitTag=tag.Tag(tag.tagClassContext,
83 |                               tag.tagFormatConstructed, 1))))
84 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/asn1/time_test.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | # Copyright 2012 Google Inc. All Rights Reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | #
17 | # Author: caronni@google.com (Germano Caronni)
18 | 
19 | """Tests for time conversion utility."""
20 | 
21 | import time
22 | 
23 | 
24 | from pyasn1.type import useful
25 | 
26 | import unittest as test
27 | 
28 | from x509_time import Time
29 | 
30 | 
31 | class TimeTest(test.TestCase):
32 | 
33 |   def testConvert(self):
34 |     utctime = useful.UTCTime('120614235959Z')
35 |     t = Time()
36 |     t.setComponentByName('utcTime', utctime)
37 |     t_str = time.asctime(time.gmtime(t.ToPythonEpochTime()))
38 |     self.assertEquals(t_str, 'Thu Jun 14 23:59:59 2012')
39 | 
40 | 
41 | def main():
42 |   test.main()
43 | 
44 | if __name__ == '__main__':
45 |   main()
46 | 
47 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/asn1/x509_time.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | # Copyright 2012 Google Inc. All Rights Reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | #
17 | # Author: caronni@google.com (Germano Caronni)
18 | 
19 | """X.509 Time class and utility functions.
20 | 
21 |    Limited interpretation of ASN.1 time formats,
22 |    as specified in RFC2459, section 4.1.2.5
23 | """
24 | 
25 | import calendar
26 | import time
27 | 
28 | 
29 | from pyasn1 import error
30 | from pyasn1.type import namedtype
31 | from pyasn1.type import univ
32 | from pyasn1.type import useful
33 | 
34 | 
35 | class Time(univ.Choice):
36 |   componentType = namedtype.NamedTypes(
37 |       namedtype.NamedType('utcTime', useful.UTCTime()),
38 |       namedtype.NamedType('generalTime', useful.GeneralizedTime()))
39 | 
40 |   def ToPythonEpochTime(self):
41 |     """Takes a ASN.1 Time choice, and returns seconds since epoch in UTC."""
42 |     utc_time = self.getComponentByName('utcTime')
43 |     general_time = self.getComponentByName('generalTime')
44 |     if utc_time and general_time:
45 |       raise error.PyAsn1Error('Both elements of a choice are present.')
46 |     if general_time:
47 |       format_str = '%Y%m%d%H%M%SZ'
48 |       time_str = str(general_time)
49 |     else:
50 |       format_str = '%y%m%d%H%M%SZ'
51 |       time_str = str(utc_time)
52 |     time_tpl = time.strptime(time_str, format_str)
53 |     return calendar.timegm(time_tpl)
54 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/auth_data_test.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | # Copyright 2012 Google Inc. All Rights Reserved.
  4 | #
  5 | # Licensed under the Apache License, Version 2.0 (the "License");
  6 | # you may not use this file except in compliance with the License.
  7 | # You may obtain a copy of the License at
  8 | #
  9 | #     http://www.apache.org/licenses/LICENSE-2.0
 10 | #
 11 | # Unless required by applicable law or agreed to in writing, software
 12 | # distributed under the License is distributed on an "AS IS" BASIS,
 13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14 | # See the License for the specific language governing permissions and
 15 | # limitations under the License.
 16 | #
 17 | # Author: caronni@google.com (Germano Caronni)
 18 | 
 19 | """Test for auth_data parser of Authenticode signatures."""
 20 | 
 21 | import os
 22 | import pickle
 23 | import time
 24 | 
 25 | 
 26 | import unittest as test
 27 | 
 28 | import auth_data
 29 | import pecoff_blob
 30 | 
 31 | 
 32 | # EVIL EVIL -- Monkeypatch to extend accessor
 33 | # TODO(user): This was submitted to pyasn1. Remove when we have it back.
 34 | def F(self, idx):
 35 |   if type(idx) is int:
 36 |     return self.getComponentByPosition(idx)
 37 |   else: return self.getComponentByName(idx)
 38 | from pyasn1.type import univ  # pylint: disable-msg=C6204,C6203
 39 | univ.SequenceAndSetBase.__getitem__ = F
 40 | del F, univ
 41 | # EVIL EVIL
 42 | 
 43 | 
 44 | class AuthenticodeTest(test.TestCase):
 45 | 
 46 |   def testRunTestData(self):
 47 |     # Walk through one data file in the test_data folder, and compare output
 48 |     # with precomputed expected output.
 49 |     data_file = os.path.join('test_data', 'SoftwareUpdate.exe.res')
 50 | 
 51 |     with file(data_file, 'rb') as resf:
 52 |       exp_results = pickle.load(resf)
 53 | 
 54 |     # Make sure we have loaded the right data.
 55 |     expected_generic_sha1 = '8322f1c2c355d88432f1f03a1f231f63912186bd'
 56 |     loaded_generic_hashes = [x for x in exp_results if x['name'] == 'generic']
 57 |     loaded_generic_sha1 = loaded_generic_hashes[0]['sha1'].encode('hex')
 58 |     self.assertEquals(expected_generic_sha1, loaded_generic_sha1)
 59 | 
 60 |     signed_pecoffs = [x for x in exp_results if x['name'] == 'pecoff' and
 61 |                       'SignedData' in x]
 62 |     # If the invoker of the fingerprinter specified multiple fingers for pecoff
 63 |     # hashing (possible, even if not sensible), then there can be more than one
 64 |     # entry in this list. Should not be the case for this sample.
 65 |     self.assertEquals(len(signed_pecoffs), 1)
 66 |     signed_pecoff = signed_pecoffs[0]
 67 | 
 68 |     # Make sure PE/COFF hashes match as well. Again, just a sanity check.
 69 |     expected_auth_sha1 = '978b90ace99c764841d2dd17d278fac4149962a3'
 70 |     loaded_auth_sha1 = signed_pecoff['sha1'].encode('hex')
 71 |     self.assertEquals(expected_auth_sha1, loaded_auth_sha1)
 72 | 
 73 |     signed_datas = signed_pecoff['SignedData']
 74 |     # There may be multiple of these, if the windows binary was signed multiple
 75 |     # times, e.g. by different entities. Each of them adds a complete SignedData
 76 |     # blob to the binary. For our sample, there is only one blob.
 77 |     self.assertEquals(len(signed_datas), 1)
 78 |     signed_data = signed_datas[0]
 79 | 
 80 |     blob = pecoff_blob.PecoffBlob(signed_data)
 81 | 
 82 |     auth = auth_data.AuthData(blob.getCertificateBlob())
 83 |     content_hasher_name = auth.digest_algorithm().name
 84 |     computed_content_hash = signed_pecoff[content_hasher_name]
 85 | 
 86 |     try:
 87 |       auth.ValidateAsn1()
 88 |       auth.ValidateHashes(computed_content_hash)
 89 |       auth.ValidateSignatures()
 90 |       auth.ValidateCertChains(time.gmtime())
 91 |     except auth_data.Asn1Error:
 92 |       if auth.openssl_error:
 93 |         print('OpenSSL Errors:\n%s' % auth.openssl_error)
 94 |       raise
 95 | 
 96 |     print('Program: %s, URL: %s' % (auth.program_name, auth.program_url))
 97 |     print('countersig: %d' % auth.has_countersignature)
 98 |     print('Timestamp: %s' % auth.counter_timestamp)
 99 | 
100 |     self.assertEquals(auth.trailing_data.encode('hex'), '00')
101 | 
102 | 
103 | def main():
104 |   test.main()
105 | 
106 | if __name__ == '__main__':
107 |   main()
108 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/generate_test_data.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | # Copyright 2010 Google Inc. All Rights Reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | #
17 | # Author: caronni@google.com (Germano Caronni)
18 | 
19 | """Generates reference data for fingerprinter_test.py.
20 | 
21 |    Please note that this is supposed to be run only for updating
22 |    test data in case more data is added or the format changes.
23 |    This is a manual operation, that needs to be followed by a
24 |    g4 submit of the changed test data.
25 | """
26 | 
27 | import os
28 | import pickle
29 | 
30 | import fingerprint
31 | 
32 | 
33 | def main():
34 |   os.chdir('test_data')
35 |   files = os.listdir('.')
36 |   for fnam in files:
37 |     if not fnam.lower().endswith('.res'):
38 |       print 'Scanning %s' % fnam
39 |       with file(fnam, 'rb') as objf:
40 |         fingerprinter = fingerprint.Fingerprinter(objf)
41 |         fingerprinter.EvalPecoff()
42 |         fingerprinter.EvalGeneric()
43 |         results = fingerprinter.HashIt()
44 |         with file(fnam + '.res', 'wb') as resf:
45 |           pickle.dump(results, resf, pickle.HIGHEST_PROTOCOL)
46 | 
47 | if __name__ == '__main__':
48 |   main()
49 | 


--------------------------------------------------------------------------------
/worker/fileanalyzer/verifysigs/pecoff_blob.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | # Copyright 2011 Google Inc. All Rights Reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | #
17 | # Author: caronni@google.com (Germano Caronni)
18 | 
19 | """Deal with Microsoft-specific Authenticode data."""
20 | 
21 | # Comments and constant names as extracted from pecoff_v8 specs.
22 | # Variable names are also used as defined in the PECOFF specification.
23 | # pylint: disable-msg=C6409
24 | 
25 | # Version 1, legacy version of Win_Certificate structure. It is supported
26 | # only for purposes of verifying legacy Authenticode signatures.
27 | WIN_CERT_REVISION_1_0 = 0x100
28 | 
29 | # Version 2 is the current version of the Win_Certificate structure. 
30 | WIN_CERT_REVISION_2_0 = 0x200
31 | 
32 | # Only type PKCS is supported by the pecoff specification.
33 | WIN_CERT_TYPE_X509 = 1
34 | WIN_CERT_TYPE_PKCS_SIGNED_DATA = 2
35 | WIN_CERT_TYPE_RESERVED_1 = 3
36 | WIN_CERT_TYPE_TS_STACK_SIGNED = 4
37 | 
38 | 
39 | class PecoffBlob(object):
40 |   """Encapsulating class for Microsoft-specific Authenticode data.
41 | 
42 |   As defined in the PECOFF (v8) and Authenticode specifications.
43 |   This is data as it is extracted from the signature_data field by
44 |   the fingerprinter.
45 |   """
46 | 
47 |   def __init__(self, signed_data_tuple):
48 |     self._wRevision = signed_data_tuple[0]
49 |     self._wCertificateType = signed_data_tuple[1]
50 |     self._bCertificate = signed_data_tuple[2]
51 | 
52 |     if self._wRevision != WIN_CERT_REVISION_2_0:
53 |       raise RuntimeError("Unknown revision %#x." % self._wRevision)
54 |     if self._wCertificateType != WIN_CERT_TYPE_PKCS_SIGNED_DATA:
55 |       raise RuntimeError("Unknown cert type %#x." % self._wCertificateType)
56 | 
57 |   def getCertificateBlob(self):
58 |     return self._bCertificate
59 | 


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