From 9c6453d7fe5d4bc8fd7e5d98242c729a9b847483 Mon Sep 17 00:00:00 2001 From: Alex Levinson Date: Sat, 10 Mar 2018 21:33:34 -0800 Subject: [PATCH] finishing up 0.1.0 release --- DEVELOP.md => DEVELOPERS.md | 0 README.md | 331 +++++++++++++++- cmd/gscript/main.go | 57 ++- compiler/bindata.go | 6 +- debugger/repl.go | 3 +- deprecated/core.go | 88 ----- deprecated/core_vm.go | 119 ------ deprecated/core_vm_test.go | 43 -- deprecated/crypto_vm.go | 161 -------- deprecated/crypto_vm_test.go | 27 -- deprecated/engine.go | 48 --- deprecated/exec.go | 38 -- deprecated/exec_vm.go | 133 ------- deprecated/exec_vm_test.go | 96 ----- deprecated/file.go | 228 ----------- deprecated/file_vm.go | 370 ------------------ deprecated/file_vm_test.go | 323 --------------- deprecated/hooks.go | 150 ------- deprecated/injection.go | 9 - deprecated/injection_windows.go | 66 ---- deprecated/logger.go | 167 -------- deprecated/net.go | 160 -------- deprecated/net_vm.go | 244 ------------ deprecated/net_vm_test.go | 153 -------- deprecated/os.go | 133 ------- deprecated/os_vm.go | 306 --------------- deprecated/os_vm_test.go | 100 ----- deprecated/preload.go | 66 ---- deprecated/registry.go | 17 - deprecated/registry_windows.go | 84 ---- deprecated/responses.go | 11 - deprecated/util.go | 117 ------ deprecated/vm.go | 72 ---- deprecated/vm_functions.go | 68 ---- engine/engine.go | 8 +- engine/executor.go | 2 +- engine/lib_file.go | 4 - {spec => examples/spec}/asset.gs | 0 {spec => examples/spec}/bad.gs | 0 {spec => examples/spec}/basic.gs | 0 .../compiler_parallelism/large_embed_a.gs | 0 .../compiler_parallelism/large_embed_b.gs | 0 .../compiler_parallelism/large_embed_c.gs | 0 .../compiler_parallelism/large_embed_d.gs | 0 .../spec}/darwin_service_test.gs | 0 {spec => examples/spec}/good.gs | 0 {spec => examples/spec}/halt.gs | 0 {spec => examples/spec}/large_file.gs | 0 {spec => examples/spec}/logging.gs | 0 {spec => examples/spec}/md5.gs | 0 .../spec}/priority/priority_test_a.gs | 0 .../spec}/priority/priority_test_b.gs | 0 .../spec}/priority/priority_test_c.gs | 0 {spec => examples/spec}/repl.gs | 0 {spec => examples/spec}/sleep.gs | 0 {spec => examples/spec}/test.gs | 0 {spec => examples/spec}/timeout_test.gs | 0 {spec => examples/spec}/timestamp.gs | 0 {spec => examples/spec}/windows_path.gs | 0 {spec => examples/spec}/write_file.gs | 0 gscript.go | 2 +- templates/entrypoint.go.tmpl | 2 +- windowsBuild.ps1 | 7 - 63 files changed, 347 insertions(+), 3672 deletions(-) rename DEVELOP.md => DEVELOPERS.md (100%) delete mode 100644 deprecated/core.go delete mode 100644 deprecated/core_vm.go delete mode 100644 deprecated/core_vm_test.go delete mode 100644 deprecated/crypto_vm.go delete mode 100644 deprecated/crypto_vm_test.go delete mode 100644 deprecated/engine.go delete mode 100644 deprecated/exec.go delete mode 100644 deprecated/exec_vm.go delete mode 100644 deprecated/exec_vm_test.go delete mode 100644 deprecated/file.go delete mode 100644 deprecated/file_vm.go delete mode 100644 deprecated/file_vm_test.go delete mode 100644 deprecated/hooks.go delete mode 100644 deprecated/injection.go delete mode 100644 deprecated/injection_windows.go delete mode 100644 deprecated/logger.go delete mode 100644 deprecated/net.go delete mode 100644 deprecated/net_vm.go delete mode 100644 deprecated/net_vm_test.go delete mode 100644 deprecated/os.go delete mode 100644 deprecated/os_vm.go delete mode 100644 deprecated/os_vm_test.go delete mode 100644 deprecated/preload.go delete mode 100644 deprecated/registry.go delete mode 100644 deprecated/registry_windows.go delete mode 100644 deprecated/responses.go delete mode 100644 deprecated/util.go delete mode 100644 deprecated/vm.go delete mode 100644 deprecated/vm_functions.go rename {spec => examples/spec}/asset.gs (100%) rename {spec => examples/spec}/bad.gs (100%) rename {spec => examples/spec}/basic.gs (100%) rename {spec => examples/spec}/compiler_parallelism/large_embed_a.gs (100%) rename {spec => examples/spec}/compiler_parallelism/large_embed_b.gs (100%) rename {spec => examples/spec}/compiler_parallelism/large_embed_c.gs (100%) rename {spec => examples/spec}/compiler_parallelism/large_embed_d.gs (100%) rename {spec => examples/spec}/darwin_service_test.gs (100%) rename {spec => examples/spec}/good.gs (100%) rename {spec => examples/spec}/halt.gs (100%) rename {spec => examples/spec}/large_file.gs (100%) rename {spec => examples/spec}/logging.gs (100%) rename {spec => examples/spec}/md5.gs (100%) rename {spec => examples/spec}/priority/priority_test_a.gs (100%) rename {spec => examples/spec}/priority/priority_test_b.gs (100%) rename {spec => examples/spec}/priority/priority_test_c.gs (100%) rename {spec => examples/spec}/repl.gs (100%) rename {spec => examples/spec}/sleep.gs (100%) rename {spec => examples/spec}/test.gs (100%) rename {spec => examples/spec}/timeout_test.gs (100%) rename {spec => examples/spec}/timestamp.gs (100%) rename {spec => examples/spec}/windows_path.gs (100%) rename {spec => examples/spec}/write_file.gs (100%) delete mode 100755 windowsBuild.ps1 diff --git a/DEVELOP.md b/DEVELOPERS.md similarity index 100% rename from DEVELOP.md rename to DEVELOPERS.md diff --git a/README.md b/README.md index 228d5ed..d135c70 100644 --- a/README.md +++ b/README.md @@ -4,28 +4,92 @@ Genesis Scripting Engine ![Genesis Logo](http://www.city-church.org.uk/sites/default/files/styles/sidebar_series_image/public/series/image/genesis-in-the-beginning.jpg?itok=EJFz0LWt) -**WARNING**: This library is under active development. API is ***NOT*** stable and will have breaking changes for the foreseeable future. ## Description -GENESIS Scripting (gscript for short) is a technology I've developed to allow dynamic runtime execution of malware installation based on parameters determined at runtime. +Genesis Scripting (gscript for short) is a technology I've developed to enable more intelligent malware stagers. Typically, stagers are pretty dumb. Most stagers are unique to the malware they deploy and do not allow for "bundling" of multiple payloads. Sophisticated attackers *do* in fact bundle their payloads, which makes runtime uncertainty even more assured. -Inspiration for this comes from my old AutoRune™ days and from the need for malware to basically become self aware without a bunch of duplicate overhead code. +GScript changes that. GScript allows for dynamic execution logic *per payload*. This is achieved by a modified Javascript runtime that is statically embedded in the final stager binary. This runtime/virtual machine runs "hook" functions that you've defined in your script, checking to ensure the script wishes to proceed after each hook. -GScript uses a JS V8 Virtual Machine to interpret your genesis script and allow it to hook into the malware initialization. +This has significant benefits over traditional tactics: -The Engine itself is referred commonly as "GSE" - Genesis Scripting Engine. + * Scripts are far more "sandboxed" from each other. If you're bundling 10 payloads and 1 of them has a syntax error in its script, with gscript, only that scripts VM dies, not the entire program. + * GScript's VM, while sandboxed, has native hooks injected into it. This allows the VM to interact with things outside of the VM (filesystem, network, registry, etc.). + * These functions are by and large, completely cross platform. This allows someone to only learn GScript to write scripts without having to learn a different programming language. + * Execution is also parallelized using the very effective go routine paradigm, resulting in much faster execution of stagers with multiple payloads. + +This development process is incredibly efficient with our gscript CLI utility. -## Installation +The VM's custom runtime (Engine) is referred commonly as "GSE" - Genesis Scripting Engine. + +## Architecture + +### Compiler + +The compiler is what translates your gscripts and their assets into a finalized binary. Some features of the compiler: + + * Support native binary compilation for all major operating systems: Windows, Linux, OS X + * Can support large numbers of scripts and assets into a single executable. + * Built-in lossless compression and obfuscation of both scripts and embedded assets. + * **VERY FAST**. Compilation times generally less than 5 seconds. + * Post compilation obfuscation to remove references to the library. + * Defaults to a null logger for the final binary (no output ever!), but can be overridden to inject a development logger into the final binary for testing. + +### VM Engine + +The final binary contains the gscript engine with all scripts and their imported assets. It will initialize VMs, one for each script, and execute them generally in parallel (theres priority overrides, but more on that below!). -We have created a command line SDK for gscript. You can download it from our Releases page: +The VMs cannot interact with one another and errors in one VM will be gracefully handled by the engine. This prohibits one VM from causing instability or fatal errors preventing other scripts from executing. - +![GScript Architecture Diagram](https://i.imgur.com/C1avFt7.png) -If you want to compile final binaries using gscripts compiler, you'll need the following dependencies installed and configured on your system: +The Engine has been designed to be lean and free from bloated imports. It's come a long way, but there will be more improvements here in the future as well. + +#### Execution Flow + +The VM expects your scripts to implement three functions (called "hooks" in our documentation): + + * `BeforeDeploy()` - *intended to function as the reconnaissance function to determine if the script should attempt to deploy it's second stage.* + * `Deploy()` - *contains the stage two deployment logic.* + * `AfterDeploy()` - *allows the script to clean up after a successful deployment.* + +If any of these functions returns `false`, the engine will prevent subsequent execution of the functions proceeding for that script. + +When either hooks return false or all hooks run successfully, the VM will destroy itself and notify the scheduling engine that the VM is finished executing. + +## CLI + +The gscript command line utility is the primary interface for writing, testing, debugging, and compiling your Genesis binaries. + +``` +NAME: + gscript - Command Line application for interacting with the GENESIS Scripting Engine. + +USAGE: + gscript [global options] command [command options] [arguments...] + +COMMANDS: + compile, c Compile genesis scripts into a stand alone binary. + new, n Writes an example gscript to either the given path or STDOUT. + run, r Run a Genesis script locally (Careful not to infect yourself). + shell, s Run an interactive gscript REPL. + test, t Check a GSE script for syntax errors. + update, u Update the gscript CLI binary to the latest version. + help, h Shows a list of commands or help for one command + +GLOBAL OPTIONS: + --debug, -d Enable verbose output of runtime debugging logs. + --help, -h show help + --version, -v print the version +``` + +You can use `-h` on any subcommand as well to see subcommand specific options. + +## Installation + +You'll need the following dependencies installed and configured on your system. Regardless of the target OS, we recommend (and generally only test) the CLI utility on Linux/OSX based systems. You can still compile binaries **for** Windows though! * Golang v1.10 or higher - * jshint After you have both of those, run: @@ -33,19 +97,228 @@ After you have both of those, run: $ go get github.com/gen0cide/gscript/cmd/gscript ``` -## What is GENESIS btw? -GENESIS was created by @vyrus, @gen0cide, @emperorcow, and @ahhh for dynamically bundling multiple payloads into one dropper for faster deployment of implants for the CCDC Red Team. +## Scripting -For more information on this work we do every year, see my blog post outlining our toolbox: +Writing a Genesis script is simple and easy to learn. A few things to know about writing genesis scripts: - * + * A genesis script (.gs) is written in Javascript. This allows any editors or IDE that can work with Javascript to also apply to genesis scripts. + * The VM targets ES5, so ES6 syntax will not be valid. + * You can define your own functions and variables within your script. + * GScript injects a standard library of functions into the VM to facilitate interaction outside of the Javascript sandbox. These functions, while called from Javascript, are actually implemented natively in code. For more information about function development, take a look at `DEVELOPMENT.md`. + * Logging functions (LogInfo, LogError, etc.) will log output when using the `run` subcommand, or when a final binary is compiled with the flag `--enable-logging`. You do not have to remove your logging statements to keep your final binary from logging output - the compiler does this by default. + +### Basic Example + +In the Execution Flow section, we covered the "hook" functions a gscript needs to implement. Here is the most basic example of a valid Genesis script: + +``` +// A standard javascript comment. Totally valid! + +function BeforeDeploy() { + return true; +} + +function Deploy() { + return true; +} + +function AfterDeploy() { + return true; +} +``` + +And that's it! The only requirement is that you implement those three functions and return `true` when you wish your script to continue to the next function, or `false` when you do not want the VM to continue executing this script. + +Now let's use some of the built in functions: + +``` +// A standard javascript comment. Totally valid! + +// We can declare our own globals +var val = null; + +// As well as our own custom functions. +function Greet(name) { + return "Hello, " + name; +} + +function BeforeDeploy() { + // LogInfo is a VM function. Also: LogDebug(), LogWarn(), LogError() + LogInfo("*** EXAMPLE BEFORE DEPLOY ***"); + + // HOSTNAME is a constant injected into the VM at runtime by the Engine + // See the section below on "Embedded Variables" for more info. + val = HOSTNAME; + return true; +} + +function Deploy() { + // We can reference our val variable within these functions. + LogInfo(Greet(val)); + return true; +} + +function AfterDeploy() { + LogInfo("*** EXAMPLE AFTER DEPLOY ***"); + return true; +} +``` + +Now let's talk about test and run our script! + +#### Testing your script + +I saved the above script to `example.gs` and ran the command `gscript test example.gs`: + +![Testing Script Example](https://i.imgur.com/y6AjwG5.png) + +#### Running your script +Now what about if we want to execute the script? Let's use the `run` subcommand (`gscript run example.gs`) + +![Running Script Example](https://i.imgur.com/H8TcOwV.png) + + +#### Debugging your script + +Lets say there was an unexpected error and I wanted to investigate. You can use the `DebugConsole()` function (only enabled with `run`, not in a final binary) to drop into an interactive gscript REPL. + + +I've modified the `Deploy()` function of our script to look like this: + +``` +function Deploy() { + DebugConsole(); + + // We can reference our val variable within these functions. + LogInfo(Greet(val)); + return true; +} +``` + +Now when I re-run our script with the same command above, a breakpoint is set and I can now use the interactive debugger: + +![Debugging Script Example](https://i.imgur.com/2TUZpiT.png) + +Notice the auto complete will hint at special VM functions that GScript has injected into the Javascript VM. -GSE's goal is to allow intelligent deployment of those payloads. +#### Compiling your script -## Variables +So you've done everything except build a final binary. Let's walk you through what to do here. -These variables are pre-defined and injected into the GENESIS VM at runtime for your convenience. +We will use the following command: + +``` +$ gscript compile --outfile ./example.bin example.gs +``` +If you do not specify the `--os` or `--arch` flag, GScript will default to whatever your operating system and architecture is. Here's the results: + +![Compiling Script Example](https://i.imgur.com/PvXXK4c.png) + +And now if I run our binary, what do you think we'll see? + +![Normal Execution Script Example](https://i.imgur.com/wg6Fh9z.png) + +Aha! Where's all our output? Remember, logging is **DISABLED** by default in a final binary. Let's add some debug logging into the compiled binary: + +``` +$ gscript compile --outfile ./example2.bin --enable-logging example.gs +``` + +![Compiling With Logging Example](https://i.imgur.com/uyK4VtN.png) + +And now if I run the binary: + +![Running Binary with Logging Example](https://i.imgur.com/hdY1UyK.png) + +Notice the original `example.bin` did nothing, while the `example2.bin` allowed you to see execution output. + +You can also combine multiple scripts into the same compiled binary. Here's an example of the syntax: + +``` +$ gscript compile --outfile /tmp/foo.bin a.gs b.gs c.gs +``` + +This will embed all three GScripts into the final binary, isolate them from one another, and parallelize their execution. + +Next, we will explore how to embed files into your binary and look at a few new VM functions (Full VM function documentation is linked to in the **VM Functions** section). + +### Compiler Macros + +GScript has it's own compiler macro implementation. This lets you add syntactically valid Javascript statements while extending the functionality of the VM. The most common use for this is embedding files (also called assets). + +I've copied a file "tater.jpg" into our example directory. In addition, I've noted our current working directory as well as taken an MD5 of the image. + +![Asset Example](https://i.imgur.com/CRVUOHD.png) + +With the asset in the directory, I'm going to write a new genesis script to `example-asset.gs`: + +``` +// A standard javascript comment. Totally valid! + +// Adding tater.jpg to this file +//import:/tmp/gscript_demo/tater.jpg +// ^ Example usage of the "import" compiler macro + +function BeforeDeploy() { + return true; +} + +function Deploy() { + // We will use a new function Timestamp() to get a unique filename. + var filename = "/tmp/gscript_demo/" + Timestamp().value + ".jpg"; + + // WriteFile() is part of the file package in the standard library. + // Asset() is how you retrieve your asset's data (core package). + WriteFile(filename, Asset("tater.jpg").fileData, 0644); + + // Still need to return true! + return true; +} + +function AfterDeploy() { + return true; +} +``` + +Line 4 is the compiler macro: + +``` +//import:/tmp/gscript_demo/tater.jpg +``` + +When you either perform a `run` or a `compile`, the Engine will embed "tater.jpg" in the runtime (retrieving with Asset function). When compiled, this asset is embedded within the binary itself. Now lets compile and run it! + +![Compiling an imported asset](https://i.imgur.com/kbS8DlL.png) + +I've highlighted the line where the compiler found the asset. Now if I run it, I will see the new JPG file in my directory. An MD5 of the files show them to be identical. + +![Embedded Asset Final Binary Example](https://i.imgur.com/xIsmSEM.png) + +Some final notes about file assets: + + * You can embed multiple assets per script, just make sure they have unique filenames. + * You will reference the file in your script by the filename: `Asset("tater.jpg")`. Whatever the file was called, thats how it will be referenced in the runtime. + * Embedding works as well for the `gscript run` command. This allows you to test your assets easily. + * There are more macros below. All are optional, but available if you need them. + +#### List of Macros + +| Macro Name | Default | Example | Purpose | +|---------------|----------|---------------------------------------------------------|--------------------------------------------------------------------------------------------------------------| +| `import` | `null` | `//import:/tmp/gscript_demo/tater.jpg` | Embeds a local file into your scripts runtime. | +| `import_url` | `null` | `//import_url:https://example.com/tater.jpg` | Embeds a remote file into your scripts runtime. | +| `timeout` | `30` | `//timeout:120` | Overrides the default timeout for this specific VM instance. | +| `priority` | `100` | `//priority:50` | *Overrides the runtime priority of a VM. + +* *The priority macro allows you to tune the execution flow of your final binary. If you compile multiple scripts (`gscript compile --outfile /tmp/foo.bin a.gs b.gs c.gs`) your scripts by default will all execute in parallel since the default priority is 100. Any scripts that override this will be executed either before or after the default. The lower the priority, the earlier in the execution chain it will occur. Note that each unique priority blocks until all VMs for that priority have returned.* + +*For example, if `a.gs` and `b.gs` have a priority of 15, and `c.gs` has a priority of 100, `c.gs` will not begin execution until BOTH `a.gs` and `b.gs` have returned or timed out.* + + +### Embedded Variables + +These variables are pre-defined and injected into the Genesis VM at runtime: | Variable Name | Type | Example | Purpose | |---------------|----------|---------------------------------------------------------|--------------------------------------------------------------------------------------------------------------| @@ -55,9 +328,27 @@ These variables are pre-defined and injected into the GENESIS VM at runtime for | `OS` | `string` | `linux` | The operating system (basically `runtime.GOOS`) | | `ARCH` | `string` | `amd64` | The CPU architecture (basically `runtime.GOARCH`) | -## Function Docs +### VM Functions + +The VM functions are documented in the Godoc for the Engine. It includes examples of Javascript calling as well as examples of all the values functions return within the VM. + +https://godoc.org/github.com/gen0cide/gscript/engine + +### Interactive Debugger + +In addition to the `DebugConsole()` command in your script, you can explore the GScript VM directly from an interactive REPL using the `gscript shell` command: + +![Interactive REPL Example](https://i.imgur.com/EPuzHLJ.png) + +## What is GENESIS btw? + +GENESIS was created by @vyrus, @gen0cide, @emperorcow, and @ahhh for dynamically bundling multiple payloads into one dropper for faster deployment of implants for the CCDC Red Team. + +For more information on this work we do every year, see my blog post outlining our toolbox: + + * -Check out `FUNCTIONS.md` in the root of this repo. +Inspiration for this comes from my old AutoRune™ days and from the need for malware to basically become self aware without a bunch of duplicate overhead code. ## Credits @@ -70,4 +361,4 @@ Shoutouts to the homies: * indi303 * emperorcow * rossja -\n\ntest + * jackson5 diff --git a/cmd/gscript/main.go b/cmd/gscript/main.go index 18abbd2..8fe965b 100644 --- a/cmd/gscript/main.go +++ b/cmd/gscript/main.go @@ -10,7 +10,6 @@ import ( "io/ioutil" "net/http" "os" - "os/exec" "path/filepath" "runtime" "sort" @@ -48,7 +47,7 @@ func main() { app.Writer = color.Output app.ErrWriter = color.Output app.Name = "gscript" - app.Usage = "Command Line SDK for the Genesis Scripting Engine (GSE)" + app.Usage = "Command Line application for interacting with the GENESIS Scripting Engine." app.Version = gscript.Version app.Authors = []cli.Author{ { @@ -61,7 +60,7 @@ func main() { app.Flags = []cli.Flag{ cli.BoolFlag{ Name: "debug, d", - Usage: "Run gscript in debug mode.", + Usage: "Enable verbose output of runtime debugging logs.", Destination: &enableDebug, }, } @@ -76,13 +75,13 @@ func main() { { Name: "shell", Aliases: []string{"s"}, - Usage: "Run an interactive GSE console session.", + Usage: "Run an interactive gscript REPL.", Action: InteractiveShell, }, { Name: "update", Aliases: []string{"u"}, - Usage: "Update Genesis Scripting Engine to the latest version.", + Usage: "Update the gscript CLI binary to the latest version.", Action: UpdateCLI, }, { @@ -135,7 +134,7 @@ func main() { { Name: "run", Aliases: []string{"r"}, - Usage: "Run a Genesis script (Careful, don't infect yourself!).", + Usage: "Run a Genesis script locally (Careful not to infect yourself).", Action: RunScript, }, } @@ -146,46 +145,31 @@ func main() { app.Run(os.Args) } -func TraceScript(c *cli.Context) error { - files := c.Args() - for _, f := range files { - fmt.Printf("Argument: %s\n", f) - fmt.Printf("Base: %s\n", filepath.Base(f)) - } - return nil -} - func TestScript(c *cli.Context) error { - logger := logrus.New() - logger.Formatter = &logging.GSEFormatter{} - logger.Out = logging.LogWriter{Name: "test"} - logger.Level = logrus.DebugLevel logging.PrintLogo() + dbg := debugger.New("runner") + dbg.SetupDebugEngine() filename := c.Args().Get(0) if len(filename) == 0 { - logger.Fatalf("You did not supply a filename!") + dbg.Engine.Logger.Fatalf("You did not supply a filename!") } if _, err := os.Stat(filename); os.IsNotExist(err) { - logger.Fatalf("File does not exist: %s", filename) - } - _, err := exec.LookPath("jshint") - if err != nil { - logger.Fatalf("You do not have jshint in your path. Run: npm install -g jshint") + dbg.Engine.Logger.Fatalf("File does not exist: %s", filename) } - - jshCmd := exec.Command("jshint", filename) - jshOutput, err := jshCmd.CombinedOutput() + dbg = debugger.New(filepath.Base(filename)) + dbg.SetupDebugEngine() + data, err := ioutil.ReadFile(filename) if err != nil { - logger.Fatalf("File Not Valid Javascript!\n -- JSHint Output:\n%s", jshOutput) + dbg.Engine.Logger.Fatalf("Error reading file: %s", err.Error()) } - data, err := ioutil.ReadFile(filename) - err = compiler.ValidateAST(data) + dbg.LoadScript(string(data), filepath.Base(filename)) if err != nil { - logger.Errorf("Invalid Script Error: %s", err.Error()) - } else { - logger.Infof("Script Valid: %s", filename) + dbg.Engine.Logger.Errorf("Script Error: %s", err.Error()) + return err } + dbg.Engine.Logger.Infof("Script is passed static analysis") return nil + } func InteractiveShell(c *cli.Context) error { @@ -271,6 +255,9 @@ func RunScript(c *cli.Context) error { } dbg = debugger.New(filepath.Base(filename)) dbg.SetupDebugEngine() + if !enableDebug { + dbg.Logger.Level = logrus.InfoLevel + } data, err := ioutil.ReadFile(filename) if err != nil { dbg.Engine.Logger.Fatalf("Error reading file: %s", err.Error()) @@ -285,7 +272,7 @@ func RunScript(c *cli.Context) error { if err != nil { dbg.Engine.Logger.Fatalf("Hooks Failure: %s", err.Error()) } - dbg.Engine.Logger.Infof("Hooks executed successfully") + dbg.Engine.Logger.Debugf("Hooks executed successfully") return nil } diff --git a/compiler/bindata.go b/compiler/bindata.go index fb254f0..656b4aa 100644 --- a/compiler/bindata.go +++ b/compiler/bindata.go @@ -113,7 +113,7 @@ func templatesEmbedGoTmpl() (*asset, error) { return a, nil } -var _templatesEntrypointGoTmpl = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x54\x4d\x4f\xdb\x40\x10\xbd\xfb\x57\x8c\xac\xa8\xb2\x45\xd8\x50\x8e\x48\x39\xa0\x12\x28\x12\x50\xa4\x14\x38\x20\x8a\xd6\xf6\x64\x19\x25\xde\x75\xf6\x23\xa1\x8d\xfc\xdf\xab\x59\x3b\x40\xc2\xa1\xbd\x44\x3b\xe3\x37\x6f\xde\xbc\x9d\x4d\x23\xcb\xb9\x54\x08\xb5\x24\x9d\x24\x54\x37\xc6\x7a\xc8\x12\x80\xb4\x34\x75\x63\xd1\xb9\x91\xfa\x43\x4d\xca\x19\x32\x23\x32\xc1\xd3\x22\x46\xee\xb7\x2e\xbb\x83\xb7\xa5\xd1\xab\xed\x99\xb4\x72\x69\xc2\x81\x22\xff\x12\x0a\x51\x9a\x7a\xa4\x50\x1f\x95\x54\xe1\x48\xb9\xd2\x52\xe3\x47\xa8\x15\x69\xe4\x9a\xcd\xe6\x10\x68\x06\xb8\x84\x81\x98\x68\x59\x2c\xf0\xca\x28\x45\x5a\x81\xb7\x01\xa1\x6d\xff\x45\xb5\xe8\xe0\xe9\x1e\xce\x91\x0d\x8d\x43\xcd\xdf\x6d\x70\x5d\x2b\x40\x5d\x31\x65\x9e\x24\xb3\xa0\xcb\x38\x76\x96\xc3\x26\x01\x58\x49\x0b\x6b\x05\x3c\x96\x78\x90\xe4\x2f\xac\x09\x4d\xaf\xcf\x4a\xad\x10\x06\xcf\x43\x18\x34\x96\xe0\x64\x0c\x03\x71\xa7\x69\x79\x6b\xc9\x58\xf2\x84\xae\xd3\xb9\x87\x5d\xd5\x0c\xcd\x48\x57\xf8\x0a\x03\x31\x35\xd6\x63\x75\x7f\xed\x22\x4b\xde\x95\xac\x95\x38\xad\xaa\xec\x6b\x9e\x00\x28\x03\xac\xaa\x17\x04\x50\xe1\x0c\x59\x94\x38\x33\x1a\xb3\x3c\xe6\x94\x43\x26\xed\xfc\x13\x37\xb8\xce\xd2\xcd\x86\x5b\x89\xcb\x33\x68\xdb\xb4\x43\xfd\x8f\xa9\x91\x4b\x70\x1e\xad\x38\x37\xb6\x96\xde\xa3\x85\x31\x7c\xe9\x1d\x15\x17\xd3\xc9\x5b\x7e\xf3\xa9\xe4\x47\xf0\x30\x86\x2d\xf6\xca\xa8\x07\x4b\x0c\xbc\x91\x35\x9e\xc0\xae\xaa\x4f\xc5\x57\xb8\xc2\x45\x57\x6e\x83\x13\x67\x58\x04\x15\x73\x6f\xf2\xfb\x9b\xda\xd6\x7d\xb3\x28\x3d\xde\x5f\xbf\xdb\x20\xa6\xe8\x7f\x52\x8d\x26\xf8\xac\x6f\xd6\x87\xd0\xb6\x5b\x1b\x3e\x5e\x07\xd6\x05\x56\xf1\xf2\x56\xb5\x98\x70\xe0\xe0\xf0\x43\x8b\xd3\xaa\xba\x8c\x0f\xa0\xb3\x34\xc2\xc5\x39\x2d\x50\xcb\x9a\x3d\x4b\x87\xf0\x9e\xe7\x29\xbf\x4b\xf7\xf2\xb1\x17\x4b\x3e\xdc\xf1\x56\x56\xd3\xb8\xa4\x19\x87\x1d\xb9\x7b\xdc\xb1\x46\x28\x97\x3e\x65\xf9\xfb\x54\x93\x57\x2c\x83\xc7\xdb\x85\xd4\x71\xd6\x36\xfe\xee\xb0\xaf\x55\xdc\xd0\xfd\x0f\x6d\xbf\xd4\x2a\x9b\x83\x0d\x1a\x87\x50\xc0\xe3\x13\x9f\x72\xe8\x1e\x66\xdc\xab\x99\xb1\x40\x43\x78\x66\x27\x3a\x77\x8a\x7e\xdf\x8a\x47\x7a\x82\x5f\x63\x98\xc7\x68\xce\x47\x4e\xb1\x88\x04\x60\xc9\x05\x1d\x4f\x76\xf4\x7a\x7c\xcc\xdd\x5d\xcf\xd3\xff\x07\x88\x3b\xbd\x0c\xc6\x63\xb6\x84\x83\x2d\xb4\xc8\xe1\x00\x96\x0c\xb6\xe8\x83\xd5\xe0\x92\x36\xf9\x1b\x00\x00\xff\xff\x90\x4b\x40\x84\x77\x04\x00\x00" +var _templatesEntrypointGoTmpl = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x54\x4d\x4f\xdb\x40\x10\xbd\xfb\x57\x8c\xac\xa8\xb2\x45\xd8\x50\x8e\x48\x39\xa0\x12\x28\x12\x50\xa4\x14\x38\x20\x8a\xd6\xf6\x64\x19\x25\xde\x75\xf6\x23\xa1\x8d\xfc\xdf\xab\x59\x3b\x40\xc2\xa1\xbd\x44\x3b\xb3\x6f\xe6\xbd\x79\x3b\x4e\x23\xcb\xb9\x54\x08\xb5\x24\x9d\x24\x54\x37\xc6\x7a\xc8\x12\x80\xb4\x34\x75\x63\xd1\xb9\x91\xfa\x43\x4d\xca\x19\x32\x23\x32\xc1\xd3\x22\x46\xee\xb7\x2e\xbb\x83\xb7\xa5\xd1\xab\xed\x99\xb4\x72\x69\xc2\x81\x22\xff\x12\x0a\x51\x9a\x7a\xa4\x50\x1f\x95\x54\xe1\x48\xb9\xd2\x52\xe3\x47\xa8\x15\x69\xe4\x9a\xcd\xe6\x10\x68\x06\xb8\x84\x81\x98\x68\x59\x2c\xf0\xca\x28\x45\x5a\x81\xb7\x01\xa1\x6d\xff\xd5\x6a\xd1\xc1\xd3\x3d\x9c\x23\x1b\x1a\x87\x9a\xef\x6d\x70\x1d\x15\xa0\xae\xb8\x65\x9e\x24\xb3\xa0\xcb\x38\x76\x96\xc3\x26\x01\x58\x49\x0b\x6b\x05\x3c\x96\x78\x90\xe4\x2f\xac\x09\x4d\xaf\xcf\x4a\xad\x10\x06\xcf\x43\x18\x34\x96\xe0\x64\x0c\x03\x71\xa7\x69\x79\x6b\xc9\x58\xf2\x84\xae\xd3\xb9\x87\x5d\xd5\x0c\xcd\x48\x57\xf8\x0a\x03\x31\x35\xd6\x63\x75\x7f\xed\x62\x97\xbc\x2b\x59\x2b\x71\x5a\x55\xd9\xd7\x3c\x01\x50\x06\x58\x55\x2f\x08\xa0\xc2\x19\xb2\x28\x71\x66\x34\x66\x79\xcc\x29\x87\xdc\xb4\xf3\x4f\xdc\xe0\x3a\x4b\x37\x1b\xa6\x12\x97\x67\xd0\xb6\x69\x87\xfa\x1f\x53\x63\x2f\xc1\x79\xb4\xe2\xdc\xd8\x5a\x7a\x8f\x16\xc6\xf0\xa5\x77\x54\x5c\x4c\x27\x6f\xf9\xcd\xa7\x92\x1f\xc1\xc3\x18\xb6\xd8\x2b\xa3\x1e\x2c\x31\xf0\x46\xd6\x78\x02\xbb\xaa\x3e\x15\x5f\xe1\x0a\x17\x5d\xb9\x0d\x4e\x9c\x61\x11\x54\xcc\xbd\xc9\xef\x5f\x6a\x5b\xf7\xcd\xa2\xf4\x78\x7f\xfd\x6e\x83\x98\xa2\xff\x49\x35\x9a\xe0\xb3\x9e\xac\x0f\xa1\x6d\xb7\x36\x7c\x7c\x0e\xac\x0b\xac\xe2\xe3\xad\x6a\x31\xe1\xc0\xc1\xe1\x07\x8a\xd3\xaa\xba\x8c\x1f\x40\x67\x69\x84\x8b\x73\x5a\xa0\x96\x35\x7b\x96\x0e\xe1\x3d\xcf\x53\x7e\x97\xee\xe5\x23\x17\x4b\x3e\xdc\xf1\x56\x56\xd3\xb8\xa4\x7b\x8f\x34\x8c\xd7\x1d\x99\x7b\xdc\xb9\x13\xca\xa5\x4f\x59\xfe\x3e\xe5\xe4\x15\xcb\xe0\xf1\x76\x21\x75\x9c\xbd\x8d\xbf\x3b\x6c\x6b\x15\x37\x76\xff\xa2\xed\x97\x5c\x65\x73\xb0\x41\xe3\x10\x0a\x78\x7c\xe2\x53\x0e\xdd\x87\x1a\xf7\x6c\x66\x2c\xd0\x10\x9e\xd9\x99\xce\xad\xa2\xdf\xbf\xe2\x91\x9e\xe0\xd7\x18\xe6\x31\x9a\xf3\x91\x53\x2c\x22\x01\x58\x72\x41\xd7\x27\x3b\x7a\x3d\x3e\x66\x76\xd7\xf7\xe9\xff\x13\xc4\x9d\x5e\x06\xe3\x31\x5b\xc2\xc1\x16\x5a\xe4\x70\x00\x4b\x06\x5b\xf4\xc1\x6a\x70\x49\x9b\xfc\x0d\x00\x00\xff\xff\xe8\x29\xf6\xc4\x87\x04\x00\x00" func templatesEntrypointGoTmplBytes() ([]byte, error) { return bindataRead( @@ -128,7 +128,7 @@ func templatesEntrypointGoTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "templates/entrypoint.go.tmpl", size: 1143, mode: os.FileMode(420), modTime: time.Unix(1520147848, 0)} + info := bindataFileInfo{name: "templates/entrypoint.go.tmpl", size: 1159, mode: os.FileMode(420), modTime: time.Unix(1520734132, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -168,7 +168,7 @@ func templatesFunctionsYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "templates/functions.yml", size: 13722, mode: os.FileMode(420), modTime: time.Unix(1520732904, 0)} + info := bindataFileInfo{name: "templates/functions.yml", size: 13722, mode: os.FileMode(420), modTime: time.Unix(1520745177, 0)} a := &asset{bytes: bytes, info: info} return a, nil } diff --git a/debugger/repl.go b/debugger/repl.go index 605b845..90f9c0c 100644 --- a/debugger/repl.go +++ b/debugger/repl.go @@ -140,7 +140,8 @@ func (d *Debugger) LoadScript(script, filename string) error { }) d.Logger.WithField("file", filename).Debugf("Importing Remote File: %s", name) } - return d.Engine.LoadScript([]byte(script)) + d.Engine.LoadScript(filename, []byte(script)) + return nil } func (d *Debugger) InteractiveSession() { diff --git a/deprecated/core.go b/deprecated/core.go deleted file mode 100644 index 0494e95..0000000 --- a/deprecated/core.go +++ /dev/null @@ -1,88 +0,0 @@ -package engine - -import ( - "crypto/rand" - "errors" - "math/big" - "strings" - "unicode" -) - -var letterRunes = []rune("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") - -func XorBytes(a []byte, b []byte) []byte { - n := len(a) - if len(b) < n { - n = len(b) - } - var byteDst [20]byte - for i := 0; i < n; i++ { - byteDst[i] = a[i] ^ b[i] - } - return byteDst[:] -} - -func StripSpaces(str string) string { - return strings.Map(func(r rune) rune { - if unicode.IsSpace(r) { - return -1 - } - return r - }, str) -} - -func DeobfuscateString(Data string) string { - var ClearText string - for i := 0; i < len(Data); i++ { - ClearText += string(int(Data[i]) - 1) - } - return ClearText -} - -func ObfuscateString(Data string) string { - var ObfuscateText string - for i := 0; i < len(Data); i++ { - ObfuscateText += string(int(Data[i]) + 1) - } - return ObfuscateText -} - -func RandString(strlen int) string { - const chars = "abcdefghijklmnopqrstuvwxyz0123456789" - result := make([]byte, strlen) - for i := range result { - val, err := rand.Int(rand.Reader, big.NewInt(int64(len(chars)))) - if err != nil { - panic(err) - } - result[i] = chars[val.Int64()] - } - return string(result) -} - -func RandomInt(min, max int) int { - r, _ := rand.Int(rand.Reader, big.NewInt(int64(max-min))) - return int(r.Int64()) + min -} - -func RandStringRunes(n int) string { - b := make([]rune, n) - for i := range b { - val, err := rand.Int(rand.Reader, big.NewInt(int64(len(letterRunes)))) - if err != nil { - panic(err) - } - b[i] = letterRunes[val.Int64()] - } - return string(b) -} - -func (e *Engine) Asset(filename string) ([]byte, error) { - if dataFunc, ok := e.Imports[filename]; ok { - byteData := dataFunc() - return byteData, nil - } - e.Logger.WithField("trace", "true").Errorf("Asset File Not Found: %s", filename) - err := errors.New("Asset not found: " + filename) - return []byte{}, err -} diff --git a/deprecated/core_vm.go b/deprecated/core_vm.go deleted file mode 100644 index 068f80d..0000000 --- a/deprecated/core_vm.go +++ /dev/null @@ -1,119 +0,0 @@ -package engine - -import ( - "path/filepath" - "time" - - "github.com/robertkrimen/otto" -) - -func (e *Engine) VMIsVM(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMImplode(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMMatches(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMHalt(call otto.FunctionCall) otto.Value { - e.Halted = true - e.VM.Interrupt <- func() { - panic(errTimeout) - } - return otto.FalseValue() -} - -func (e *Engine) VMAsset(call otto.FunctionCall) otto.Value { - if len(call.ArgumentList) > 1 { - e.Logger.WithField("function", "Asset").Error("Too many arguments in call.") - return otto.FalseValue() - } - - if len(call.ArgumentList) < 1 { - e.Logger.WithField("function", "Asset").Error("Too few arguments in call.") - return otto.FalseValue() - } - - var assetName string - - rawArg0, err := call.Argument(0).Export() - if err != nil { - e.Logger.WithField("function", "Asset").Error("Could not export field: %s", "assetName") - return otto.FalseValue() - } - - switch v := rawArg0.(type) { - case string: - assetName = rawArg0.(string) - default: - e.Logger.WithField("function", "Asset").Error("Argument type mismatch: expected %s, got %T", "string", v) - return otto.FalseValue() - } - - fileData, err := e.Asset(assetName) - - rawVMRet := VMResponse{} - - rawVMRet["fileData"] = fileData - - rawVMRet["err"] = err - - vmRet, vmRetError := e.VM.ToValue(rawVMRet) - if vmRetError != nil { - e.Logger.WithField("function", "Asset").Error("Return conversion failed: %s", vmRetError.Error()) - return otto.FalseValue() - } - - return vmRet - -} - -func (e *Engine) VMTimestamp(call otto.FunctionCall) otto.Value { - ts := time.Now().Unix() - ret, err := otto.ToValue(ts) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - } - return ret -} - -func (e *Engine) VMIsAWS(call otto.FunctionCall) otto.Value { - respCode, _, err := HTTPGetFile("http://169.254.169.254/latest/meta-data/") - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Net error: %s", err.Error()) - return otto.FalseValue() - } else if respCode == 200 { - return otto.TrueValue() - } else { - return otto.FalseValue() - } -} - -func (e *Engine) VMLogTester(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Debug("testing debug") - e.Logger.WithField("trace", "true").Info("testing info") - e.Logger.WithField("trace", "true").Warn("testing warning") - e.Logger.WithField("trace", "true").Error("testing error") - - return otto.NullValue() -} - -func (e *Engine) VMPathTester(call otto.FunctionCall) otto.Value { - arg, err := call.Argument(0).ToString() - if err != nil { - e.Logger.Errorf("Path Error: %s", err.Error()) - return otto.NullValue() - } - - argPath := filepath.Clean(arg) - e.Logger.Infof("Original: %s", arg) - e.Logger.Infof("Cleaned: %s", argPath) - return otto.NullValue() -} diff --git a/deprecated/core_vm_test.go b/deprecated/core_vm_test.go deleted file mode 100644 index 72ea991..0000000 --- a/deprecated/core_vm_test.go +++ /dev/null @@ -1,43 +0,0 @@ -package engine - -import ( - "testing" - "time" - - "github.com/stretchr/testify/assert" -) - -func TestVMTimestamp(t *testing.T) { - currTime := time.Now().Unix() - - testScript := ` - var test_time = Timestamp(); - ` - e := New("Timestamp") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("test_time") - assert.Nil(t, err) - assert.True(t, retVal.IsNumber()) - retValAsNumber, err := retVal.ToInteger() - assert.Nil(t, err) - assert.True(t, (retValAsNumber >= currTime)) -} - -func TestVMIsAWS(t *testing.T) { - testScript := ` - var return_value = IsAWS(); - ` - e := New("AWSTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "false", retValAsString) -} diff --git a/deprecated/crypto_vm.go b/deprecated/crypto_vm.go deleted file mode 100644 index 6a9b484..0000000 --- a/deprecated/crypto_vm.go +++ /dev/null @@ -1,161 +0,0 @@ -package engine - -import ( - "crypto/md5" - "crypto/sha1" - "encoding/base64" - "encoding/hex" - - "github.com/robertkrimen/otto" -) - -func (e *Engine) VMMD5(call otto.FunctionCall) otto.Value { - var HashVal string - if len(call.ArgumentList) > 0 { - arg := call.ArgumentList[0] - switch arg.Class() { - case "Array": - rawBytes := []byte{} - expVal, err := arg.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.Value{} - } - for _, i := range expVal.([]interface{}) { - rawBytes = append(rawBytes, i.(byte)) - } - hasher := md5.New() - hasher.Write(rawBytes) - HashVal = hex.EncodeToString(hasher.Sum(nil)) - default: - val, err := call.ArgumentList[0].ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.Value{} - } - hasher := md5.New() - hasher.Write([]byte(val)) - HashVal = hex.EncodeToString(hasher.Sum(nil)) - } - } - var ret = otto.Value{} - var err error - if len(HashVal) > 0 { - ret, err = otto.ToValue(HashVal) - } else { - ret, err = otto.ToValue(nil) - } - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - } - return ret -} - -func (e *Engine) VMSHA1(call otto.FunctionCall) otto.Value { - var HashVal string - if len(call.ArgumentList) > 0 { - arg := call.ArgumentList[0] - switch arg.Class() { - case "Array": - rawBytes := []byte{} - expVal, err := arg.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.Value{} - } - for _, i := range expVal.([]interface{}) { - rawBytes = append(rawBytes, i.(byte)) - } - hasher := sha1.New() - hasher.Write(rawBytes) - HashVal = hex.EncodeToString(hasher.Sum(nil)) - default: - val, err := call.ArgumentList[0].ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.Value{} - } - hasher := sha1.New() - hasher.Write([]byte(val)) - HashVal = hex.EncodeToString(hasher.Sum(nil)) - } - } - var ret = otto.Value{} - var err error - if len(HashVal) > 0 { - ret, err = otto.ToValue(HashVal) - } else { - ret, err = otto.ToValue(nil) - } - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - } - return ret -} - -func (e *Engine) VMB64Decode(call otto.FunctionCall) otto.Value { - var NewVal string - if len(call.ArgumentList) > 0 { - arg := call.ArgumentList[0] - val, err := arg.ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.Value{} - } - valBytes, err := base64.StdEncoding.DecodeString(val) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Crypto error: %s", err.Error()) - return otto.Value{} - } - NewVal = string(valBytes) - } - var ret = otto.Value{} - var err error - if len(NewVal) > 0 { - ret, err = otto.ToValue(NewVal) - } else { - ret, err = otto.ToValue(nil) - } - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - } - return ret -} - -func (e *Engine) VMB64Encode(call otto.FunctionCall) otto.Value { - var EncVal string - if len(call.ArgumentList) > 0 { - arg := call.ArgumentList[0] - switch arg.Class() { - case "Array": - rawBytes := []byte{} - expVal, err := arg.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.Value{} - } - for _, i := range expVal.([]interface{}) { - rawBytes = append(rawBytes, i.(byte)) - } - EncVal = base64.StdEncoding.EncodeToString([]byte(rawBytes)) - default: - val, err := call.ArgumentList[0].ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.Value{} - } - EncVal = base64.StdEncoding.EncodeToString([]byte(val)) - } - } - var ret = otto.Value{} - var err error - if len(EncVal) > 0 { - ret, err = otto.ToValue(EncVal) - } else { - ret, err = otto.ToValue(nil) - } - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - } - return ret -} diff --git a/deprecated/crypto_vm_test.go b/deprecated/crypto_vm_test.go deleted file mode 100644 index b16fde3..0000000 --- a/deprecated/crypto_vm_test.go +++ /dev/null @@ -1,27 +0,0 @@ -package engine - -import ( - "testing" - - "github.com/stretchr/testify/assert" -) - -func TestVMMD5(t *testing.T) { - testScript := ` - var hash_val = "helloworld"; - var return_value = MD5(hash_val); - ` - // "helloworld" = fc5e038d38a57032085441e7fe7010b0 - - e := New("MD5") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "fc5e038d38a57032085441e7fe7010b0", retValAsString) -} diff --git a/deprecated/engine.go b/deprecated/engine.go deleted file mode 100644 index 5badc0f..0000000 --- a/deprecated/engine.go +++ /dev/null @@ -1,48 +0,0 @@ -package engine - -import ( - "io/ioutil" - - "github.com/robertkrimen/otto" - "github.com/sirupsen/logrus" -) - -type Engine struct { - VM *otto.Otto - Logger *logrus.Logger - Imports map[string]func() []byte - Name string - DebuggerEnabled bool - Timeout int - Halted bool -} - -func New(name string) *Engine { - logger := logrus.New() - logger.Formatter = new(logrus.TextFormatter) - logger.Out = ioutil.Discard - return &Engine{ - Name: name, - Imports: map[string]func() []byte{}, - Logger: logger, - DebuggerEnabled: false, - Halted: false, - Timeout: 30, - } -} - -func (e *Engine) SetLogger(logger *logrus.Logger) { - e.Logger = logger -} - -func (e *Engine) SetTimeout(timeout int) { - e.Timeout = timeout -} - -func (e *Engine) AddImport(name string, data func() []byte) { - e.Imports[name] = data -} - -func (e *Engine) SetName(name string) { - e.Name = name -} diff --git a/deprecated/exec.go b/deprecated/exec.go deleted file mode 100644 index 3bad454..0000000 --- a/deprecated/exec.go +++ /dev/null @@ -1,38 +0,0 @@ -package engine - -import ( - "bytes" - "os/exec" - "strings" -) - -func ExecuteCommand(c string, args ...string) VMExecResponse { - cmd := exec.Command(c, args...) - var stdout bytes.Buffer - var stderr bytes.Buffer - cmd.Stdout = &stdout - cmd.Stderr = &stderr - err := cmd.Run() - respObj := VMExecResponse{ - Stdout: strings.Split(stdout.String(), "\n"), - Stderr: strings.Split(stderr.String(), "\n"), - PID: cmd.Process.Pid, - } - if err != nil { - respObj.ErrorMsg = err.Error() - respObj.Success = false - } else { - respObj.Success = true - } - return respObj -} - -func ForkExecuteCommand(c string, args ...string) (int, error) { - cmd := exec.Command(c, args...) - err := cmd.Start() - if err != nil { - return 0, err - } - pid := cmd.Process.Pid - return pid, nil -} diff --git a/deprecated/exec_vm.go b/deprecated/exec_vm.go deleted file mode 100644 index 9bf9aef..0000000 --- a/deprecated/exec_vm.go +++ /dev/null @@ -1,133 +0,0 @@ -package engine - -import ( - "os/exec" - - "github.com/robertkrimen/otto" -) - -func (e *Engine) VMExec(call otto.FunctionCall) otto.Value { - baseCmd, err := call.Argument(0).ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - cmdArgs := call.Argument(1) - argList := []string{} - if !cmdArgs.IsNull() { - argArray, err := cmdArgs.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - argList = argArray.([]string) - } - cmdOutput := ExecuteCommand(baseCmd, argList...) - vmResponse, err := e.VM.ToValue(cmdOutput) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} - -func (e *Engine) VMShellcodeExec(call otto.FunctionCall) otto.Value { - shellcode, err := call.Argument(0).ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - - pid, err := call.Argument(1).ToInteger() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - - err = InjectIntoProc(shellcode, pid) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Injection error: %s", err.Error()) - return otto.FalseValue() - } - return otto.TrueValue() -} - -func (e *Engine) VMForkExec(call otto.FunctionCall) otto.Value { - baseCmd, err := call.Argument(0).ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - cmdArgs := call.Argument(1) - argList := []string{} - if !cmdArgs.IsNull() { - argArray, err := cmdArgs.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - argList = argArray.([]string) - } - _, err = ForkExecuteCommand(baseCmd, argList...) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("OS error: %s", err.Error()) - return otto.FalseValue() - } - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return otto.TrueValue() -} - -func (e *Engine) VMCmdSuccessful(call otto.FunctionCall) otto.Value { - cmd := call.Argument(0) - cmdString, err := cmd.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - arg := call.Argument(1) - argString, err := arg.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - resp := ExecuteCommand(cmdString.(string), argString.(string)) - if resp.Success == false { - e.Logger.WithField("trace", "true").Errorf("OS error: %s", resp.ErrorMsg) - return otto.FalseValue() - } else if resp.Success == true { - return otto.TrueValue() - } - return otto.FalseValue() -} - -func (e *Engine) VMCanSudo(call otto.FunctionCall) otto.Value { - resp := ExecuteCommand("sudo", "-v") - if resp.Success == false { - e.Logger.WithField("trace", "true").Errorf("OS error: %s", resp.ErrorMsg) - return otto.FalseValue() - } else if resp.Success == true { - return otto.TrueValue() - } - return otto.FalseValue() -} - -func (e *Engine) VMExistsInPath(call otto.FunctionCall) otto.Value { - cmd := call.Argument(0) - cmdString, err := cmd.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - path, err := exec.LookPath(cmdString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("OS error: %s", err.Error()) - return otto.FalseValue() - } else if path != "" { - return otto.TrueValue() - } else { - return otto.FalseValue() - } -} diff --git a/deprecated/exec_vm_test.go b/deprecated/exec_vm_test.go deleted file mode 100644 index 4e63e3c..0000000 --- a/deprecated/exec_vm_test.go +++ /dev/null @@ -1,96 +0,0 @@ -package engine - -import ( - "fmt" - "testing" - - "github.com/stretchr/testify/assert" -) - -func TestVMExec(t *testing.T) { - testCmd := ExecuteCommand("ls", "-lah") - - testScript := ` - var test_exec = Exec("ls", ["-lah"]); - ` - e := New("Exec") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("test_exec") - assert.Nil(t, err) - assert.True(t, retVal.IsObject()) - retValAsInterface, err := retVal.Export() - assert.Nil(t, err) - realRetVal := retValAsInterface.(VMExecResponse) - - assert.Equal(t, testCmd.Stdout, realRetVal.Stdout) -} - -func TestVMForkExec(t *testing.T) { - - testScript := ` - var test_exec = ForkExec("nc", ["-l", "8080"]); - ` - e := New("ForkExec") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("test_exec") - assert.Nil(t, err) - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString) -} - -func TestVMCanSudo(t *testing.T) { - testScript := fmt.Sprintf(` - var return_value2 = CanSudo(); - `) - - e := New("SudoTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal2, err := e.VM.Get("return_value2") - assert.Nil(t, err) - retValAsString2, err := retVal2.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString2) -} - -func TestVMExistsInPath(t *testing.T) { - testScript := fmt.Sprintf(` - var cmd = "whoami" - var return_value2 = ExistsInPath(cmd); - `) - - e := New("CmdInPathTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal2, err := e.VM.Get("return_value2") - assert.Nil(t, err) - retValAsString2, err := retVal2.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString2) -} - -func TestVMCmdSuccessful(t *testing.T) { - testScript := ` - var name = "ls"; - var arg = "-al" - var return_value = CmdSuccessful(name, arg); - ` - e := New("TestCmdSuccessful") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} diff --git a/deprecated/file.go b/deprecated/file.go deleted file mode 100644 index 36dcdcc..0000000 --- a/deprecated/file.go +++ /dev/null @@ -1,228 +0,0 @@ -package engine - -import ( - "errors" - "io" - "io/ioutil" - "os" - "path/filepath" - "strings" - - "github.com/davecgh/go-spew/spew" -) - -func LocalFileExists(path string) bool { - _, err := os.Stat(path) - if err == nil { - return true - } - return false -} - -//These two functions break compiling on windows -/* -func LocalFileWritable(path string) bool { - return unix.Access(path, unix.W_OK) == nil -} - -func LocalFileExecutable(path string) bool { - return unix.Access(path, unix.X_OK) == nil -} -*/ - -func LocalDirCreate(path string) error { - err := os.MkdirAll(path, 0700) - if err != nil { - return err - } - return nil -} - -func LocalDirRemoveAll(dir string) error { - d, err := os.Open(dir) - if err != nil { - return err - } - defer d.Close() - names, err := d.Readdirnames(-1) - if err != nil { - return err - } - for _, name := range names { - err = os.RemoveAll(filepath.Join(dir, name)) - if err != nil { - return err - } - } - err = os.RemoveAll(dir) - if err != nil { - return err - } - return nil -} - -func LocalFileDelete(path string) error { - if LocalFileExists(path) { - err := os.Remove(path) - if err != nil { - return err - } - return nil - } - return errors.New("The file dosn't exist to delete") -} - -func LocalFileCreate(path string, bytes []byte, perms int) error { - if LocalFileExists(path) { - return errors.New("The file to create already exists so we won't overwite it") - } - var p os.FileMode - // pInt, err := strconv.Atoi(perms) - // if err != nil { - // return err - // } - p = os.FileMode(perms) - spew.Dump(perms) - spew.Dump(p) - err := ioutil.WriteFile(path, bytes, p) - if err != nil { - return err - } - return nil -} - -func LocalFileAppendBytes(filename string, bytes []byte) error { - if LocalFileExists(filename) { - fileInfo, err := os.Stat(filename) - if err != nil { - return err - } - file, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY, fileInfo.Mode()) - if err != nil { - return err - } - if _, err = file.Write(bytes); err != nil { - return err - } - file.Close() - return nil - } - err := LocalFileCreate(filename, bytes, 0644) - if err != nil { - return err - } - return nil -} - -func LocalFileAppendString(input, filename string) error { - fileInfo, err := os.Stat(filename) - if err != nil { - return err - } - file, err := os.OpenFile(filename, os.O_APPEND, fileInfo.Mode()) - if err != nil { - return err - } - if _, err = file.WriteString(input); err != nil { - return err - } - file.Close() - return nil -} - -func LocalFileReplace(file, match, replacement string) error { - if LocalFileExists(file) { - fileInfo, err := os.Stat(file) - if err != nil { - return err - } - contents, err := ioutil.ReadFile(file) - if err != nil { - return err - } - lines := strings.Split(string(contents), "\n") - for index, line := range lines { - if strings.Contains(line, match) { - lines[index] = strings.Replace(line, match, replacement, 10) - } - } - - ioutil.WriteFile(file, []byte(strings.Join(lines, "\n")), fileInfo.Mode()) - return nil - } else { - return errors.New("The file to read does not exist") - } -} - -func LocalFileReplaceMulti(file string, matches []string, replacement string) error { - if LocalFileExists(file) { - fileInfo, err := os.Stat(file) - if err != nil { - return err - } - contents, err := ioutil.ReadFile(file) - if err != nil { - return err - } - lines := strings.Split(string(contents), "\n") - for index, line := range lines { - for _, match := range matches { - if strings.Contains(line, match) { - lines[index] = replacement - } - } - } - ioutil.WriteFile(file, []byte(strings.Join(lines, "\n")), fileInfo.Mode()) - return nil - } else { - return errors.New("The file to read does not exist") - } -} - -func LocalFileRead(path string) ([]byte, error) { - if LocalFileExists(path) { - dat, err := ioutil.ReadFile(path) - if err != nil { - return nil, err - } - return dat, nil - } - return nil, errors.New("The file to read does not exist") -} - -func XorFiles(file1 string, file2 string, outPut string) error { - dat1, err := ioutil.ReadFile(file1) - if err != nil { - return err - } - dat2, err := ioutil.ReadFile(file2) - if err != nil { - return err - } - dat3 := XorBytes(dat1[:], dat2[:]) - err = LocalFileCreate(outPut, dat3[:], 0644) - if err != nil { - return err - } - return nil -} - -func LocalCopyFile(src, dst string) error { - from, err := os.Open(src) - if err != nil { - return err - } - defer from.Close() - - to, err := os.OpenFile(dst, os.O_RDWR|os.O_CREATE, 0666) - if err != nil { - return err - } - defer to.Close() - - _, err = io.Copy(to, from) - if err != nil { - return err - } - return nil -} diff --git a/deprecated/file_vm.go b/deprecated/file_vm.go deleted file mode 100644 index 791e446..0000000 --- a/deprecated/file_vm.go +++ /dev/null @@ -1,370 +0,0 @@ -package engine - -import ( - "os" - "strings" - - "github.com/djherbis/times" - "github.com/robertkrimen/otto" -) - -func (e *Engine) VMGetDirsInPath(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMCanWriteFile(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() - //Following code breaks building for windows :( - /* - filePath := call.Argument(0) - filePathString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Function Error: error=ARY_ARG_NOT_String arg=%s", err.Error()) - return otto.FalseValue() - } - result := LocalFileWritable(filePathString.(string)) - if result == true { - return otto.TrueValue() - } else { - return otto.FalseValue() - } - */ -} - -func (e *Engine) VMCanExecFile(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() - //Following code breaks building for windows :( - /* - filePath := call.Argument(0) - filePathString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Function Error: error=ARY_ARG_NOT_String arg=%s", err.Error()) - return otto.FalseValue() - } - result := LocalFileExecutable(filePathString.(string)) - if result { - return otto.TrueValue() - } else { - return otto.FalseValue() - } - */ -} - -func (e *Engine) VMFileExists(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - if LocalFileExists(filePathString.(string)) { - return otto.TrueValue() - } else { - return otto.FalseValue() - } -} - -func (e *Engine) VMDirExists(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - if LocalFileExists(filePathString.(string)) { - return otto.TrueValue() - } else { - return otto.FalseValue() - } -} - -func (e *Engine) VMFileContains(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - search := call.Argument(1) - searchString, err := search.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - fileData, err := LocalFileRead(filePathString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("File error: %s", err.Error()) - return otto.FalseValue() - } - fileStrings := string(fileData) - if strings.Contains(fileStrings, searchString.(string)) { - return otto.TrueValue() - } else { - return otto.FalseValue() - } -} - -func (e *Engine) VMCanReadFile(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - data, err := LocalFileRead(filePathString.(string)) - if data != nil && err == nil { - return otto.TrueValue() - } else if err != nil { - e.Logger.WithField("trace", "true").Errorf("File error: %s", err.Error()) - return otto.FalseValue() - } else { - return otto.FalseValue() - } -} - -func (e *Engine) VMDeleteFile(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathAsString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - err = LocalFileDelete(filePathAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Error deleting the file: %s", err.Error()) - return otto.FalseValue() - } - return otto.TrueValue() -} - -func (e *Engine) VMWriteFile(call otto.FunctionCall) otto.Value { - filePath, err := call.Argument(0).ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - fileData := call.Argument(1) - fileMode, err := call.Argument(2).ToInteger() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - fileBytes := e.ValueToByteSlice(fileData) - err = LocalFileCreate(filePath, fileBytes, int(fileMode)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Error writing the file: %s", err.Error()) - return otto.FalseValue() - } - return otto.TrueValue() -} - -func (e *Engine) VMReadFile(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathAsString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - bytes, err := LocalFileRead(filePathAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Error reading the file: %s", err.Error()) - return otto.FalseValue() - } - - vmResponse, err := e.VM.ToValue(string(bytes)) - - return vmResponse -} - -func (e *Engine) VMCopyFile(call otto.FunctionCall) otto.Value { - readPath, err := call.ArgumentList[0].ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - writePath, err := call.ArgumentList[1].ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - bytes, err := LocalFileRead(readPath) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Error reading the file: %s", err.Error()) - return otto.FalseValue() - } - filePerms, err := os.Stat(readPath) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("OS Error: %s", err.Error()) - return otto.FalseValue() - } - err = LocalFileCreate(writePath, bytes, int(filePerms.Mode())) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Error writing the file: %s", err.Error()) - return otto.FalseValue() - } - return otto.TrueValue() -} - -func (e *Engine) VMExecuteFile(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathAsString, err := filePath.ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - cmdArgs := call.Argument(1) - argList := []string{} - if !cmdArgs.IsNull() { - argArray, err := cmdArgs.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - argList = argArray.([]string) - } - - cmdOutput := ExecuteCommand(filePathAsString, argList...) - vmResponse, err := e.VM.ToValue(cmdOutput) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} - -func (e *Engine) VMAppendFile(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - fileData := call.Argument(1) - fileBytes := e.ValueToByteSlice(fileData) - filePathAsString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - err = LocalFileAppendBytes(filePathAsString.(string), fileBytes) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Error appending the file: %s", err.Error()) - return otto.FalseValue() - } - return otto.TrueValue() -} - -func (e *Engine) VMReplaceInFile(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathAsString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - sFind := call.Argument(1) - sFindAsString, err := sFind.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - sReplace := call.Argument(2) - sReplaceAsString, err := sReplace.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - err = LocalFileReplace(filePathAsString.(string), sFindAsString.(string), sReplaceAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Error editing the file: %s", err.Error()) - return otto.FalseValue() - } - return otto.TrueValue() -} - -func (e *Engine) VMFileChangeTime(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathAsString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - t, err := times.Stat(filePathAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("File error: %s", err.Error()) - return otto.FalseValue() - } - if t.HasChangeTime() { - vmResponse, err := e.VM.ToValue(t.ChangeTime().String()) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse - } else { - e.Logger.WithField("trace", "true").Errorf("File error: no ctime") - return otto.FalseValue() - } -} - -func (e *Engine) VMFileBirthTime(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathAsString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - t, err := times.Stat(filePathAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("File error: %s", err.Error()) - return otto.FalseValue() - } - if t.HasBirthTime() { - vmResponse, err := e.VM.ToValue(t.BirthTime().String()) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse - } else { - e.Logger.WithField("trace", "true").Errorf("File error: no ctime") - return otto.FalseValue() - } -} - -func (e *Engine) VMFileModifyTime(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathAsString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - t, err := times.Stat(filePathAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("File error: %s", err.Error()) - return otto.FalseValue() - } - vmResponse, err := e.VM.ToValue(t.ModTime().String()) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} - -func (e *Engine) VMFileAccessTime(call otto.FunctionCall) otto.Value { - filePath := call.Argument(0) - filePathAsString, err := filePath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - t, err := times.Stat(filePathAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("File error: %s", err.Error()) - return otto.FalseValue() - } - vmResponse, err := e.VM.ToValue(t.AccessTime().String()) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} diff --git a/deprecated/file_vm_test.go b/deprecated/file_vm_test.go deleted file mode 100644 index 844e662..0000000 --- a/deprecated/file_vm_test.go +++ /dev/null @@ -1,323 +0,0 @@ -package engine - -import ( - "fmt" - "testing" - - "github.com/stretchr/testify/assert" -) - -var g_file_1 = fmt.Sprintf("/tmp/%s", RandString(6)) -var g_file_2 = fmt.Sprintf("/tmp/%s", RandString(6)) -var g_file_3 = fmt.Sprintf("/tmp/%s", RandString(6)) - -func TestVMCopyFile(t *testing.T) { - file_2 := g_file_1 - testScript := fmt.Sprintf(` - var file_1 = "/etc/passwd"; - var file_2 = "%s"; - var return_value = CopyFile(file_1, file_2); - `, file_2) - - e := New("CopyFile") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString) -} - -func TestVMAppendFile(t *testing.T) { - bytes := "60,104,116,109,108,62,10,32,32,60,98,111,100,121,62,10,32,32,32,32" - testScript := fmt.Sprintf(` - var file_1 = "%s"; - var file_2 = "%s"; - var bytes = [%s]; - var return_value1 = AppendFile(file_1, bytes); - var return_value2 = AppendFile(file_2, bytes); - `, g_file_1, g_file_2, bytes) - - e := New("AppendFile") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value1") - assert.Nil(t, err) - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString) - retVal2, err := e.VM.Get("return_value2") - assert.Nil(t, err) - retValAsString2, err := retVal2.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString2) -} - -func TestVMReplaceInFile(t *testing.T) { - string01 := "root" - string02 := "lol" - testScript := fmt.Sprintf(` - var file_1 = "%s"; - var string01 = "%s"; - var string02 = "%s"; - var return_value1 = ReplaceInFile(file_1, string01, string02); - `, g_file_1, string01, string02) - - e := New("ReplaceInFile") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value1") - assert.Nil(t, err) - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString) -} - -func TestVMRetrieveFileFromURL(t *testing.T) { - url := "https://alexlevinson.com/" - file_3 := g_file_3 - testScript2 := fmt.Sprintf(` - var url = "%s"; - var file_3 = "%s"; - var response2 = RetrieveFileFromURL(url); - var return_value2 = response2; - var response3 = WriteFile(file_3, response2); - `, url, file_3) - e := New("RetrieveFileFromURL") - e.CreateVM() - - e.VM.Run(testScript2) - retVal, err := e.VM.Get("return_value2") - assert.Nil(t, err) - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - assert.Equal(t, "60,104,116,109,108,62,10,32,32,60,98,111,100,121,62,10,32,32,32,32,60,99,101,110,116,101,114,62,10,32,32,32,32,32,32,60,105,109,103,32,115,114,99,61,34,114,111,111,116,46,106,112,103,34,32,47,62,10,32,32,32,32,60,47,99,101,110,116,101,114,62,10,32,32,60,47,98,111,100,121,62,10,60,47,104,116,109,108,62,10", retValAsString) -} - -func TestVMDeleteFile(t *testing.T) { - testScript := fmt.Sprintf(` - var file_1 = "%s"; - var return_value1 = DeleteFile(file_1); - var file_2 = "%s"; - var return_value2 = DeleteFile(file_2); - var file_3 = "%s"; - var return_value3 = DeleteFile(file_3); - `, g_file_1, g_file_2, g_file_3) - - e := New("DeleteFile") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value1") - assert.Nil(t, err) - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString) - retVal2, err := e.VM.Get("return_value2") - assert.Nil(t, err) - retValAsString2, err := retVal2.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString2) - retVal3, err := e.VM.Get("return_value3") - assert.Nil(t, err) - retValAsString3, err := retVal3.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString3) -} - -func TestVMExecuteFile(t *testing.T) { - testScript := ` - var file_path = "uname"; - var args = ["-o"]; - var results = ExecuteFile(file_path, args); - ` - e := New("ExecuteFileTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("results") - assert.Nil(t, err) - assert.True(t, retVal.IsObject()) - retValAsInterface, err := retVal.Export() - assert.Nil(t, err) - realRetVal := retValAsInterface.(VMExecResponse) - assert.Nil(t, err) - assert.Equal(t, "GNU/Linux", realRetVal.Stdout[0]) -} - -func TestVMFileAccessTime(t *testing.T) { - testScript := ` - var file = "/etc/passwd"; - var results1 = FileAccessTime(file); - ` - e := New("GetAccessTimeTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal1, err := e.VM.Get("results1") - assert.Nil(t, err) - _, er := retVal1.ToString() - assert.Nil(t, er) - //assert.Equal(t, "asdf", retValAsString1) -} - -func TestVMFileModifyTime(t *testing.T) { - testScript := ` - var file = "/etc/passwd"; - var results1 = FileModifyTime(file); - ` - e := New("GetModifyTimeTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal1, err := e.VM.Get("results1") - assert.Nil(t, err) - _, er := retVal1.ToString() - assert.Nil(t, er) - //assert.Equal(t, "asdf", retValAsString1) -} - -func TestVMFileChangeTime(t *testing.T) { - testScript := ` - var file = "/etc/passwd"; - var results1 = FileChangeTime(file); - ` - e := New("GetChangeTimeTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal1, err := e.VM.Get("results1") - assert.Nil(t, err) - _, er := retVal1.ToString() - assert.Nil(t, er) - //assert.Equal(t, "asdf", retValAsString1) -} - -func TestVMFileBirthTime(t *testing.T) { - testScript := ` - var file = "/etc/passwd"; - var results1 = FileBirthTime(file); - ` - e := New("GetChangeTimeTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal1, err := e.VM.Get("results1") - assert.Nil(t, err) - _, er := retVal1.ToString() - assert.Nil(t, er) - //assert.Equal(t, "asdf", retValAsString1) -} - -func TestVMFileContains(t *testing.T) { - testScript := ` - var wordz = "root"; - var file = "/etc/passwd"; - var return_value = FileContains(file, wordz); - ` - e := New("FileContainsTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} - -func TestVMDirExists(t *testing.T) { - testScript := ` - var name = "/etc/"; - var return_value = DirExists(name); - ` - e := New("TestDirExists") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} - -func TestVMFileExists(t *testing.T) { - testScript := ` - var name = "/etc/passwd"; - var return_value = FileExists(name); - ` - e := New("TestFileExists") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} - -func TestVMCanReadFile(t *testing.T) { - testScript := ` - var name = "/etc/passwd"; - var return_value = CanReadFile(name); - ` - e := New("TestCanReadFile") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} - -func TestVMCanWriteFile(t *testing.T) { - testScript := ` - var name = "/etc/passwd"; - var return_value = CanWriteFile(name); - ` - e := New("TestCanWriteFile") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} - -func TestVMCanExecFile(t *testing.T) { - testScript := ` - var name = "/bin/bash"; - var return_value = CanExecFile(name); - ` - e := New("TestCanExecFile") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} diff --git a/deprecated/hooks.go b/deprecated/hooks.go deleted file mode 100644 index e8b6949..0000000 --- a/deprecated/hooks.go +++ /dev/null @@ -1,150 +0,0 @@ -package engine - -import ( - "errors" - "strconv" - "time" - - "github.com/robertkrimen/otto" -) - -var ( - Debugger = true - errTimeout = errors.New("GSE VM Timeout") -) - -func (e *Engine) RunWithTimeout(command string) (otto.Value, error) { - start := time.Now() - defer func() { - duration := time.Since(start) - if caught := recover(); caught != nil { - if caught == errTimeout { - e.Logger.WithField("trace", "true").Errorf("Some code took to long! Stopping after: %v", duration) - return - } - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).Fatalf("Timer experienced fatal error: %s", caught) - } - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).Infof("%s Execution Time: %v", command, duration) - }() - - e.VM.Interrupt = make(chan func(), 1) // The buffer prevents blocking - - go func() { - time.Sleep(time.Duration(e.Timeout) * time.Second) // Stop after two seconds - e.VM.Interrupt <- func() { - panic(errTimeout) - } - }() - - return e.VM.Run(command) -} - -func (e *Engine) RunBeforeDeploy() error { - if e.Halted { - return errors.New("VM Halted") - } - result, err := e.RunWithTimeout(`BeforeDeploy()`) - if err != nil { - return err - } - boolResult, err := result.ToBoolean() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return err - } - if !boolResult { - e.Logger.WithField("trace", "true").Errorf("BeforeDeploy() returned false.") - return errors.New("failed BeforeDeploy()") - } - e.Logger.WithField("trace", "true").Debugf("Completed BeforeDeploy()") - return nil -} - -func (e *Engine) RunDeploy() error { - if e.Halted { - return errors.New("VM Halted") - } - result, err := e.RunWithTimeout(`Deploy()`) - if err != nil { - return err - } - boolResult, err := result.ToBoolean() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return err - } - if !boolResult { - e.Logger.WithField("trace", "true").Errorf("Deploy() returned false.") - return errors.New("failed Deploy()") - } - e.Logger.WithField("trace", "true").Debugf("Completed Deploy()") - return nil -} - -func (e *Engine) RunAfterDeploy() error { - if e.Halted { - return errors.New("VM Halted") - } - result, err := e.RunWithTimeout(`AfterDeploy()`) - if err != nil { - return err - } - boolResult, err := result.ToBoolean() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return err - } - if !boolResult { - e.Logger.WithField("trace", "true").Errorf("AfterDeploy() returned false.") - return errors.New("failed AfterDeploy()") - } - e.Logger.WithField("trace", "true").Debugf("Completed AfterDeploy()") - return nil -} - -func (e *Engine) RunOnError() error { - if e.Halted { - return errors.New("VM Halted") - } - result, err := e.RunWithTimeout(`OnError()`) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("OnError() Error: %s", err.Error()) - return err - } - if Debugger { - e.Logger.WithField("trace", "true").Errorf("OnError(): %s", result.String()) - return nil - } - return nil -} - -func (e *Engine) ExecutePlan() error { - err := e.RunBeforeDeploy() - if err != nil { - e.RunOnError() - return err - } - err = e.RunDeploy() - if err != nil { - e.RunOnError() - return err - } - err = e.RunAfterDeploy() - if err != nil { - e.RunOnError() - return err - } - return nil -} diff --git a/deprecated/injection.go b/deprecated/injection.go deleted file mode 100644 index 8f477ba..0000000 --- a/deprecated/injection.go +++ /dev/null @@ -1,9 +0,0 @@ -// +build !windows - -package engine - -import "errors" - -func InjectIntoProc(shellcode string, proccessID int64) error { - return errors.New("not implemented for this platform") -} diff --git a/deprecated/injection_windows.go b/deprecated/injection_windows.go deleted file mode 100644 index 3962725..0000000 --- a/deprecated/injection_windows.go +++ /dev/null @@ -1,66 +0,0 @@ -// +build windows - -package engine - -import ( - "encoding/hex" - "errors" - "syscall" - "unsafe" -) - -const ( - wmc = 0x1000 - wmr = 0x2000 - wam = 0x40 - wpc = 0x0002 - wpq = 0x0400 - wpo = 0x0008 - wpw = 0x0020 - wpr = 0x0010 - zero = 0 -) - -var ( - kernel = syscall.NewLazyDLL("kernel32.dll") - valloc = kernel.NewProc("VirtualAlloc") - openProc = kernel.NewProc("OpenProcess") - writeProc = kernel.NewProc("WriteProcessMemory") - allocExMem = kernel.NewProc("VirtualAllocEx") - createThread = kernel.NewProc("CreateRemoteThread") -) - -func allocate(size uintptr) (uintptr, error) { - addr, _, _ := valloc.Call(0, size, wmr|wmc, wam) - if addr == 0 { - return 0, errors.New("could not allocate memory") - } - return addr, nil -} - -func InjectIntoProc(shellcode string, pid int64) error { - sc, err := hex.DecodeString(shellcode) - if err != nil { - return errors.New("conversion from hex-encoded string failed") - } - - scAddr, err := allocate(uintptr(len(sc))) - if err != nil { - return err - } - - addrPtr := (*[990000]byte)(unsafe.Pointer(scAddr)) - for scIdx, scByte := range sc { - addrPtr[scIdx] = scByte - } - - remoteProc, _, _ := openProc.Call(wpc|wpq|wpo|wpw|wpr, uintptr(zero), uintptr(pid)) - remoteMem, _, _ := allocExMem.Call(remoteProc, uintptr(zero), uintptr(len(sc)), wmr|wmc, wam) - writeProc.Call(remoteProc, remoteMem, scAddr, uintptr(len(sc)), uintptr(zero)) - status, _, _ := createThread.Call(remoteProc, uintptr(zero), 0, remoteMem, uintptr(zero), 0, uintptr(zero)) - if status != 0 { - return nil - } - - return errors.New("could not inject into given process") -} diff --git a/deprecated/logger.go b/deprecated/logger.go deleted file mode 100644 index 1378012..0000000 --- a/deprecated/logger.go +++ /dev/null @@ -1,167 +0,0 @@ -package engine - -import ( - "strconv" - - "github.com/robertkrimen/otto" -) - -func (e *Engine) VMLogWarn(call otto.FunctionCall) otto.Value { - if e.Logger != nil { - for _, arg := range call.ArgumentList { - newArg, err := arg.ToString() - if err != nil { - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).WithField( - "caller", - e.VM.Context().Callee, - ).Errorf("Parameter parsing error: %s", err.Error()) - continue - } - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).WithField( - "caller", - e.VM.Context().Callee, - ).Warnf("%s", newArg) - } - } - return otto.Value{} -} - -func (e *Engine) VMLogError(call otto.FunctionCall) otto.Value { - if e.Logger != nil { - for _, arg := range call.ArgumentList { - newArg, err := arg.ToString() - if err != nil { - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).WithField( - "caller", - e.VM.Context().Callee, - ).Errorf("Parameter parsing error: %s", err.Error()) - continue - } - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).WithField( - "caller", - e.VM.Context().Callee, - ).Errorf("%s", newArg) - } - } - return otto.Value{} -} - -func (e *Engine) VMLogDebug(call otto.FunctionCall) otto.Value { - if e.Logger != nil { - for _, arg := range call.ArgumentList { - newArg, err := arg.ToString() - if err != nil { - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).WithField( - "caller", - e.VM.Context().Callee, - ).Errorf("Parameter parsing error: %s", err.Error()) - continue - } - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).WithField( - "caller", - e.VM.Context().Callee, - ).Debugf("%s", newArg) - } - } - return otto.Value{} -} - -func (e *Engine) VMLogCrit(call otto.FunctionCall) otto.Value { - if e.Logger != nil { - for _, arg := range call.ArgumentList { - newArg, err := arg.ToString() - if err != nil { - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).WithField( - "caller", - e.VM.Context().Callee, - ).Errorf("Parameter parsing error: %s", err.Error()) - continue - } - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).WithField( - "caller", - e.VM.Context().Callee, - ).Fatalf("%s", newArg) - } - } - return otto.Value{} -} - -func (e *Engine) VMLogInfo(call otto.FunctionCall) otto.Value { - if e.Logger != nil { - for _, arg := range call.ArgumentList { - newArg, err := arg.ToString() - if err != nil { - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).WithField( - "caller", - e.VM.Context().Callee, - ).Errorf("Parameter parsing error: %s", err.Error()) - continue - } - e.Logger.WithField( - "script", - e.Name, - ).WithField( - "line", - strconv.Itoa(e.VM.Context().Line), - ).WithField( - "caller", - e.VM.Context().Callee, - ).Infof("%s", newArg) - } - } - return otto.Value{} -} diff --git a/deprecated/net.go b/deprecated/net.go deleted file mode 100644 index 71702a8..0000000 --- a/deprecated/net.go +++ /dev/null @@ -1,160 +0,0 @@ -package engine - -import ( - "bytes" - "encoding/json" - "io/ioutil" - "net" - "net/http" - "strings" -) - -func DNSQuestion(target, request string) (string, error) { - if request == "A" { - var stringAnswerArray []string - answerPTR, err := net.LookupIP(target) - if err != nil { - return "failed", err - } - for _, answrPTR := range answerPTR { - stringAnswerArray = append(stringAnswerArray, answrPTR.String()) - } - stringAnswer := strings.Join(stringAnswerArray, "/n") - return stringAnswer, nil - } else if request == "TXT" { - answerTXT, err := net.LookupTXT(target) - if err != nil { - return "failed", err - } - stringAnswer := strings.Join(answerTXT, "/n") - return stringAnswer, nil - } else if request == "PTR" { - answerA, err := net.LookupAddr(target) - if err != nil { - return "failed", err - } - stringAnswer := strings.Join(answerA, "/n") - return stringAnswer, nil - } else if request == "MX" { - var stringAnswerArray []string - answerMX, err := net.LookupMX(target) - if err != nil { - return "failed", err - } - for _, answrMX := range answerMX { - stringAnswerArray = append(stringAnswerArray, answrMX.Host) - } - stringAnswer := strings.Join(stringAnswerArray, "/n") - return stringAnswer, nil - } else if request == "NS" { - var stringAnswerArray []string - answerNS, err := net.LookupNS(target) - if err != nil { - return "failed", err - } - for _, answrNS := range answerNS { - stringAnswerArray = append(stringAnswerArray, answrNS.Host) - } - stringAnswer := strings.Join(stringAnswerArray, "/n") - return stringAnswer, nil - } else if request == "CNAME" { - answerCNAME, err := net.LookupCNAME(target) - if err != nil { - return "failed", err - } - return string(answerCNAME), nil - } else { - answerA, err := net.LookupHost(target) - if err != nil { - return "failed", err - } - stringAnswer := strings.Join(answerA, "/n") - return stringAnswer, nil - } -} - -func HTTPGetFile(url string) (int, []byte, error) { - resp, err := http.Get(url) - if err != nil { - return 0, nil, err - } - respCode := resp.StatusCode - pageData, err := ioutil.ReadAll(resp.Body) - resp.Body.Close() - return respCode, pageData, nil -} - -func PostJSON(url string, jsonString []byte) (int, []byte, error) { - // encode json to sanity check, then decode to ensure the transmition syntax is clean - var jsonObj interface{} - if err := json.Unmarshal(jsonString, &jsonObj); err != nil { - return 0, nil, err - } - jsonStringCleaned, err := json.Marshal(jsonObj) - if err != nil { - return 0, nil, err - } - resp, err := http.Post(url, " application/json", bytes.NewReader(jsonStringCleaned)) - if err != nil { - return 0, nil, err - } - respCode := resp.StatusCode - pageData, err := ioutil.ReadAll(resp.Body) - resp.Body.Close() - return respCode, pageData, nil -} - -func TCPRead(ip, port string) ([]byte, error) { - host := ip + ":" + port - conn, err := net.Dial("tcp", host) - if err != nil { - return nil, err - } - defer conn.Close() - buffer := make([]byte, 1024) - conn.Read(buffer) - return buffer, nil -} - -func TCPWrite(writeData []byte, ip, port string) ([]byte, error) { - host := ip + ":" + port - conn, err := net.Dial("tcp", host) - if err != nil { - return nil, err - } - defer conn.Close() - buffer := make([]byte, 1024) - conn.Read(buffer) - conn.Write(writeData) - buffer2 := make([]byte, 1024) - conn.Read(buffer2) - return buffer2, nil -} - -func UDPWrite(writeData []byte, ip, port string) error { - host := ip + ":" + port - conn, err := net.Dial("tcp", host) - if err != nil { - return err - } - defer conn.Close() - conn.Write(writeData) - return nil -} - -func GetLocalIPs() []string { - addresses := []string{} - addrs, err := net.InterfaceAddrs() - if err != nil { - return addresses - } - - for _, a := range addrs { - if ipnet, ok := a.(*net.IPNet); ok && !ipnet.IP.IsLoopback() { - if ipnet.IP.To4() != nil { - addresses = append(addresses, ipnet.IP.String()) - } - } - } - return addresses -} diff --git a/deprecated/net_vm.go b/deprecated/net_vm.go deleted file mode 100644 index b7da2dd..0000000 --- a/deprecated/net_vm.go +++ /dev/null @@ -1,244 +0,0 @@ -package engine - -import ( - "fmt" - "net" - - "github.com/robertkrimen/otto" -) - -func (e *Engine) VMHTTPRequest(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMSSHCmd(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMGetTweet(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMServeFileOverHTTP(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMDetectSSLMITM(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMCanPing(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMCanSSHLogin(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMRetrieveFileFromURL(call otto.FunctionCall) otto.Value { - readURL, err := call.ArgumentList[0].ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - _, bytes, err := HTTPGetFile(readURL) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("HTTP Error: %s", err.Error()) - return otto.FalseValue() - } - vmResponse, err := e.VM.ToValue(bytes) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} - -func (e *Engine) VMPostJSON(call otto.FunctionCall) otto.Value { - readURL, err := call.ArgumentList[0].ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - readJSONString, err := call.ArgumentList[1].ToString() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - _, bytes, err := PostJSON(readURL, []byte(readJSONString)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("HTTP Error: %s", err.Error()) - return otto.FalseValue() - } - vmResponse, err := e.VM.ToValue(bytes) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} - -func (e *Engine) VMDNSQuery(call otto.FunctionCall) otto.Value { - targetDomain := call.Argument(0) - queryType := call.Argument(1) - targetDomainAsString, err := targetDomain.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - queryTypeAsString, err := queryType.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - result, err := DNSQuestion(targetDomainAsString.(string), queryTypeAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("DNS Error: %s", err.Error()) - return otto.FalseValue() - } - vmResult, err := e.VM.ToValue(result) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResult -} - -func (e *Engine) VMGetHostname(call otto.FunctionCall) otto.Value { - hostString, err := GetHostname() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("OS error: %s", err.Error()) - return otto.FalseValue() - } - vmResponse, err := e.VM.ToValue(hostString) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} - -func (e *Engine) VMHasPublicIP(call otto.FunctionCall) otto.Value { - respCode, _, err := HTTPGetFile("http://icanhazip.com") - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Net error: %s", err.Error()) - return otto.FalseValue() - } else if respCode == 200 { - return otto.TrueValue() - } else { - return otto.FalseValue() - } -} - -func (e *Engine) VMCanMakeTCPConn(call otto.FunctionCall) otto.Value { - ip := call.Argument(0) - ipString, err := ip.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - port := call.Argument(1) - portString, err := port.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - tcpResponse, err := TCPRead(ipString.(string), portString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Net error: %s", err.Error()) - return otto.FalseValue() - } - if tcpResponse != nil { - return otto.TrueValue() - } - return otto.FalseValue() -} - -func (e *Engine) VMExpectedDNS(call otto.FunctionCall) otto.Value { - targetDomain := call.Argument(0) - queryType := call.Argument(1) - expectedResult := call.Argument(2) - targetDomainAsString, err := targetDomain.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - queryTypeAsString, err := queryType.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - expectedResultAsString, err := expectedResult.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - result, err := DNSQuestion(targetDomainAsString.(string), queryTypeAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Net error: %s", err.Error()) - return otto.FalseValue() - } - if expectedResultAsString.(string) == string(result) { - return otto.TrueValue() - } - return otto.FalseValue() -} - -func (e *Engine) VMCanMakeHTTPConn(call otto.FunctionCall) otto.Value { - url1 := call.Argument(0) - url1String, err := url1.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - respCode, _, err := HTTPGetFile(url1String.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Net error: %s", err.Error()) - return otto.FalseValue() - } else if respCode >= 200 && respCode < 300 { - return otto.TrueValue() - } else { - return otto.FalseValue() - } -} - -func (e *Engine) VMTCPPortInUse(call otto.FunctionCall) otto.Value { - port, err := call.Argument(0).ToInteger() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - if port < 0 || port > 65535 { - return otto.FalseValue() - } - conn, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", port)) - if err != nil { - return otto.TrueValue() - } - conn.Close() - return otto.FalseValue() -} - -func (e *Engine) VMUDPPortInUse(call otto.FunctionCall) otto.Value { - port, err := call.Argument(0).ToInteger() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - if port < 0 || port > 65535 { - return otto.FalseValue() - } - conn, err := net.Listen("udp", fmt.Sprintf("127.0.0.1:%d", port)) - if err != nil { - return otto.TrueValue() - } - conn.Close() - return otto.FalseValue() -} diff --git a/deprecated/net_vm_test.go b/deprecated/net_vm_test.go deleted file mode 100644 index 324c1c8..0000000 --- a/deprecated/net_vm_test.go +++ /dev/null @@ -1,153 +0,0 @@ -package engine - -import ( - "fmt" - "testing" - - "github.com/stretchr/testify/assert" -) - -func TestVMDNSQuery(t *testing.T) { - testScript := fmt.Sprintf(` - var url = "google.com"; - var ip = "8.8.8.8"; - var type1 = "A"; - var return_value1 = DNSQuery(url, type1); - var type2 = "CNAME"; - var return_value2 = DNSQuery(url, type2); - var type3 = "TXT"; - var return_value3 = DNSQuery(url, type3); - var type4 = "MX"; - var return_value4 = DNSQuery(url, type4); - var type5 = "NS"; - var return_value5 = DNSQuery(url, type5); - var type6 = "PTR"; - var return_value6 = DNSQuery(ip, type6); - `) - - e := New("DNSQuery") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value1") - assert.Nil(t, err) - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString) - retVal2, err := e.VM.Get("return_value2") - assert.Nil(t, err) - retValAsString2, err := retVal2.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString2) - retVal3, err := e.VM.Get("return_value3") - assert.Nil(t, err) - retValAsString3, err := retVal3.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString3) - retVal4, err := e.VM.Get("return_value4") - assert.Nil(t, err) - retValAsString4, err := retVal4.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString4) - retVal5, err := e.VM.Get("return_value5") - assert.Nil(t, err) - retValAsString5, err := retVal5.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString5) - retVal6, err := e.VM.Get("return_value6") - assert.Nil(t, err) - retValAsString6, err := retVal6.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString6) -} - -func TestVMCanMakeHTTPConn(t *testing.T) { - testScript := ` - var url1 = "https://www.google.com"; - var return_value = CanMakeHTTPConn(url1); - ` - - e := New("HTTPTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} - -func TestVMCanMakeTCPConn(t *testing.T) { - testScript := ` - var ip = "towel.blinkenlights.nl"; - var port = "23"; - var return_value = CanMakeTCPConn(ip,port); - ` - e := New("TCPTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} - -func TestVMHasPublicIP(t *testing.T) { - testScript := ` - var return_value = HasPublicIP(); - ` - e := New("PublicIPTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} - -func TestVMTCPPortInUse(t *testing.T) { - testScript := ` - var port = 8080; - var return_value = TCPPortInUse(port); - ` - e := New("TCPPortInUseTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "false", retValAsString) -} - -func TestVMExpectedDNS(t *testing.T) { - testScript := fmt.Sprintf(` - var url = "google.com"; - var type2 = "CNAME"; - var return_value2 = ExpectedDNS(url, type2, "google.com."); - `) - - e := New("DNSQueryTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal2, err := e.VM.Get("return_value2") - assert.Nil(t, err) - retValAsString2, err := retVal2.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString2) -} diff --git a/deprecated/os.go b/deprecated/os.go deleted file mode 100644 index ff0df24..0000000 --- a/deprecated/os.go +++ /dev/null @@ -1,133 +0,0 @@ -package engine - -import ( - "errors" - "fmt" - - services "github.com/gen0cide/service-go" - "github.com/matishsiao/goInfo" - ps "github.com/mitchellh/go-ps" -) - -func LocalSystemInfo() ([]string, error) { - var InfoDump []string - gi := goInfo.GetInfo() - InfoDump = append(InfoDump, fmt.Sprintf("GoOS: %s", gi.GoOS)) - InfoDump = append(InfoDump, fmt.Sprintf("Kernel: %s", gi.Kernel)) - InfoDump = append(InfoDump, fmt.Sprintf("Core: %s", gi.Core)) - InfoDump = append(InfoDump, fmt.Sprintf("Platform: %s", gi.Platform)) - InfoDump = append(InfoDump, fmt.Sprintf("OS: %s", gi.OS)) - InfoDump = append(InfoDump, fmt.Sprintf("Hostname: %s", gi.Hostname)) - InfoDump = append(InfoDump, fmt.Sprintf("CPUs: %v", gi.CPUs)) - if InfoDump != nil { - return InfoDump, nil - } - return nil, errors.New("Failed to retrieve local system information") -} - -func GetHostname() (string, error) { - gi := goInfo.GetInfo() - hostname := gi.Hostname - if hostname != "" { - return hostname, nil - } - return "", errors.New("Failed to retrieve local hostname") -} - -func ProcExists2(pidBoi int) bool { - process, err := ps.FindProcess(pidBoi) - if err == nil && process == nil { - return false - } else { - return true - } -} - -func FindProcessPid(key string) (int, error) { - pid := 0 - err := errors.New("Not found") - ps, _ := ps.Processes() - for i, _ := range ps { - if ps[i].Executable() == key { - pid = ps[i].Pid() - err = nil - break - } - } - return pid, err -} - -func (e *Engine) InstallSystemService(path, name, displayName, description string) error { - c := &services.Config{ - Path: path, - Name: name, - DisplayName: displayName, - Description: description, - } - - s, err := services.NewServiceConfig(c) - if err != nil { - return err - } - - err = s.Install() - if err != nil { - return err - } - - return nil -} - -func (e *Engine) StartServiceByName(name string) error { - c := &services.Config{ - Name: name, - } - - s, err := services.NewServiceConfig(c) - if err != nil { - return err - } - - err = s.Start() - if err != nil { - return err - } - - return nil -} - -func (e *Engine) StopServiceByName(name string) error { - c := &services.Config{ - Name: name, - } - - s, err := services.NewServiceConfig(c) - if err != nil { - return err - } - - err = s.Stop() - if err != nil { - return err - } - - return nil -} - -func (e *Engine) RemoveServiceByName(name string) error { - c := &services.Config{ - Name: name, - } - - s, err := services.NewServiceConfig(c) - if err != nil { - return err - } - - err = s.Remove() - if err != nil { - return err - } - - return nil -} diff --git a/deprecated/os_vm.go b/deprecated/os_vm.go deleted file mode 100644 index b757778..0000000 --- a/deprecated/os_vm.go +++ /dev/null @@ -1,306 +0,0 @@ -package engine - -import ( - "os" - "strings" - - "github.com/robertkrimen/otto" -) - -func (e *Engine) VMSignal(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMLoggedInUsers(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMUsersRunningProcs(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMMemStats(call otto.FunctionCall) otto.Value { - e.Logger.WithField("trace", "true").Errorf("Function Not Implemented") - return otto.FalseValue() -} - -func (e *Engine) VMCPUStats(call otto.FunctionCall) otto.Value { - cpuInfo, err := LocalSystemInfo() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("OS Error: %s", err.Error()) - return otto.FalseValue() - } - cpuStats := strings.Join(cpuInfo, "\n") - vmResponse, err := otto.ToValue(cpuStats) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} - -func (e *Engine) VMEnvVars(call otto.FunctionCall) otto.Value { - rezultz := map[string]string{} - for _, v := range os.Environ() { - pair := strings.Split(v, "=") - rezultz[pair[0]] = pair[1] - } - vmResponse, err := e.VM.ToValue(rezultz) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} - -func (e *Engine) VMGetEnv(call otto.FunctionCall) otto.Value { - envVar := call.Argument(0) - envVarAsString, err := envVar.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - finalVal := os.Getenv(envVarAsString.(string)) - vmResponse, err := e.VM.ToValue(finalVal) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} - -func (e *Engine) VMAddRegKey(call otto.FunctionCall) otto.Value { - regHive := call.Argument(0) - keyPath := call.Argument(1) - keyObject := call.Argument(2) - keyValue := call.Argument(3) - keyValueInterface, err := keyValue.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - regHiveAsString, err := regHive.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - keyPathAsString, err := keyPath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - keyObjectAsString, err := keyObject.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - err = CreateRegKeyAndValue(regHiveAsString.(string), keyPathAsString.(string), keyObjectAsString.(string), keyValueInterface) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Registry error: %s", err.Error()) - return otto.FalseValue() - } - return otto.TrueValue() -} - -func (e *Engine) VMDelRegKey(call otto.FunctionCall) otto.Value { - regHive := call.Argument(0) - keyPath := call.Argument(1) - keyObject := call.Argument(2) - regHiveAsString, err := regHive.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - keyPathAsString, err := keyPath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - keyObjectAsString, err := keyObject.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - err = DeleteRegKeysValue(regHiveAsString.(string), keyPathAsString.(string), keyObjectAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Registry error: %s", err.Error()) - return otto.FalseValue() - } - return otto.TrueValue() -} - -func (e *Engine) VMQueryRegKey(call otto.FunctionCall) otto.Value { - regHive := call.Argument(0) - keyPath := call.Argument(1) - keyObject := call.Argument(2) - regHiveAsString, err := regHive.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - keyPathAsString, err := keyPath.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - keyObjectAsString, err := keyObject.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - resultStringValue, err := QueryRegKeyString(regHiveAsString.(string), keyPathAsString.(string), keyObjectAsString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Registry error: %s", err.Error()) - return otto.FalseValue() - } - vmResponse, err := e.VM.ToValue(resultStringValue) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Return value casting error: %s", err.Error()) - return otto.FalseValue() - } - return vmResponse -} - -func (e *Engine) VMLocalUserExists(call otto.FunctionCall) otto.Value { - filePathString := "/etc/passwd" - search := call.Argument(0) - searchString, err := search.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - fileData, err := LocalFileRead(filePathString) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("File error: %s", err.Error()) - return otto.FalseValue() - } - fileStrings := string(fileData) - if strings.Contains(fileStrings, searchString.(string)) { - return otto.TrueValue() - } - return otto.FalseValue() -} - -func (e *Engine) VMProcExistsWithName(call otto.FunctionCall) otto.Value { - searchProc := call.Argument(0) - searchProcString, err := searchProc.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Parameter parsing error: %s", err.Error()) - return otto.FalseValue() - } - ProcPID, err := FindProcessPid(searchProcString.(string)) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("OS error: %s", err.Error()) - return otto.FalseValue() - } - ProcExistsResult := ProcExists2(ProcPID) - if ProcExistsResult { - return otto.TrueValue() - } - return otto.FalseValue() -} - -func (e *Engine) VMInstallSystemService(call otto.FunctionCall) otto.Value { - if len(call.ArgumentList) != 4 { - e.Logger.Errorf("Not enough arguments provided.") - return otto.FalseValue() - } - - path, err := call.Argument(0).ToString() - if err != nil { - e.Logger.Errorf("Error converting path to string: %s", err.Error()) - return otto.FalseValue() - } - - name, err := call.Argument(1).ToString() - if err != nil { - e.Logger.Errorf("Error converting name to string: %s", err.Error()) - return otto.FalseValue() - } - - displayName, err := call.Argument(2).ToString() - if err != nil { - e.Logger.Errorf("Error converting displayName to string: %s", err.Error()) - return otto.FalseValue() - } - - description, err := call.Argument(3).ToString() - if err != nil { - e.Logger.Errorf("Error converting description to string: %s", err.Error()) - return otto.FalseValue() - } - - err = e.InstallSystemService(path, name, displayName, description) - if err != nil { - e.Logger.Errorf("Error installing system service: %s", err.Error()) - return otto.FalseValue() - } - - return otto.TrueValue() -} - -func (e *Engine) VMStartServiceByName(call otto.FunctionCall) otto.Value { - if len(call.ArgumentList) != 1 { - e.Logger.Errorf("Not enough arguments provided.") - return otto.FalseValue() - } - - name, err := call.Argument(0).ToString() - if err != nil { - e.Logger.Errorf("Error converting name to string: %s", err.Error()) - return otto.FalseValue() - } - - err = e.StartServiceByName(name) - if err != nil { - e.Logger.Errorf("Error starting system service: %s", err.Error()) - return otto.FalseValue() - } - - return otto.TrueValue() -} - -func (e *Engine) VMStopServiceByName(call otto.FunctionCall) otto.Value { - if len(call.ArgumentList) != 1 { - e.Logger.Errorf("Not enough arguments provided.") - return otto.FalseValue() - } - - name, err := call.Argument(0).ToString() - if err != nil { - e.Logger.Errorf("Error converting name to string: %s", err.Error()) - return otto.FalseValue() - } - - err = e.StopServiceByName(name) - if err != nil { - e.Logger.Errorf("Error starting system service: %s", err.Error()) - return otto.FalseValue() - } - - return otto.TrueValue() -} - -func (e *Engine) VMRemoveServiceByName(call otto.FunctionCall) otto.Value { - if len(call.ArgumentList) != 1 { - e.Logger.Errorf("Not enough arguments provided.") - return otto.FalseValue() - } - - name, err := call.Argument(0).ToString() - if err != nil { - e.Logger.Errorf("Error converting name to string: %s", err.Error()) - return otto.FalseValue() - } - - err = e.RemoveServiceByName(name) - if err != nil { - e.Logger.Errorf("Error starting system service: %s", err.Error()) - return otto.FalseValue() - } - - return otto.TrueValue() -} diff --git a/deprecated/os_vm_test.go b/deprecated/os_vm_test.go deleted file mode 100644 index f6d0c36..0000000 --- a/deprecated/os_vm_test.go +++ /dev/null @@ -1,100 +0,0 @@ -package engine - -import ( - "testing" - - "github.com/stretchr/testify/assert" -) - -func TestCPUStats(t *testing.T) { - //resultz := CPUStats() - testScript := ` - var results = CPUStats(); - ` - e := New("CPUStats") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("results") - assert.Nil(t, err) - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - assert.Equal(t, "true", retValAsString) -} - -func TestVMEnvVars(t *testing.T) { - testScript := ` - var results = EnvVars(); - ` - e := New("EnvVarsTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("results") - assert.Nil(t, err) - assert.True(t, retVal.IsObject()) - retValAsInterface, err := retVal.Export() - assert.Nil(t, err) - realRetVal := retValAsInterface.(map[string]string) - assert.Nil(t, err) - assert.Equal(t, "root", realRetVal["LOGNAME"]) -} - -func TestVMEGetEnv(t *testing.T) { - testScript := ` - var envvar1 = "USERNAME"; - var envvar2 = "DECKARDCAIN" - var results1 = GetEnv(envvar1); - var results2 = GetEnv(envvar2); - ` - e := New("GetEnvVarTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal1, err := e.VM.Get("results1") - assert.Nil(t, err) - retValAsString1, err := retVal1.ToString() - assert.Nil(t, err) - assert.Equal(t, "root", retValAsString1) - retVal2, err := e.VM.Get("results2") - assert.Nil(t, err) - retValAsString2, err := retVal2.ToString() - assert.Nil(t, err) - assert.Equal(t, "", retValAsString2) -} - -func TestVMLocalUserExists(t *testing.T) { - testScript := ` - var user = "root"; - var return_value = LocalUserExists(user); - ` - e := New("LocaUserTest") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "true", retValAsString) -} - -func TestVMProcExistsWithName(t *testing.T) { - testScript := ` - var name = "notbash"; - var return_value = ProcExistsWithName(name); - ` - e := New("TestProcExists") - e.CreateVM() - - e.VM.Run(testScript) - retVal, err := e.VM.Get("return_value") - assert.Nil(t, err) - - retValAsString, err := retVal.ToString() - assert.Nil(t, err) - - assert.Equal(t, "false", retValAsString) -} diff --git a/deprecated/preload.go b/deprecated/preload.go deleted file mode 100644 index 2620bad..0000000 --- a/deprecated/preload.go +++ /dev/null @@ -1,66 +0,0 @@ -package engine - -var VMPreload = ` -function StringToByteArray(s) { - var data = []; - for (var i = 0; i < s.length; i++ ) { - data.push(s.charCodeAt(i)); - } - return data; -} - -function ByteArrayToString(a) { - return String.fromCharCode.apply(String, a); -} - -function DumpObjectIndented(obj, indent) { - var result = ""; - if (indent == null) indent = ""; - - for (var property in obj) { - var value = obj[property]; - if (typeof value == 'string') { - value = "'" + value + "'"; - } - else if (typeof value == 'object') { - if (value instanceof Array) { - value = "[ " + value + " ]"; - } else { - var od = DumpObjectIndented(value, indent + " "); - value = "\n" + indent + "{\n" + od + "\n" + indent + "}"; - } - } - result += indent + "'" + property + "' : " + value + ",\n"; - } - return result.replace(/,\n$/, ""); -} - -function BeforeDeploy() { - return false; -} - -function Deploy() { - return false; -} - -function AfterDeploy() { - return true; -} - -function OnError() { - return false; -} - -function Sleep(seconds) { - var start = new Date().getTime(); - for (var i = 0; i < 1e7; i++) { - if ((new Date().getTime() - start) > (seconds * 1000)){ - break; - } - } -} - -function DebugConsole() { - return true; -} -` diff --git a/deprecated/registry.go b/deprecated/registry.go deleted file mode 100644 index d1c7f07..0000000 --- a/deprecated/registry.go +++ /dev/null @@ -1,17 +0,0 @@ -// +build !windows - -package engine - -import "errors" - -func CreateRegKeyAndValue(regHive string, keyPath string, keyObject string, keyValue interface{}) error { - return errors.New("not implemented for this platform") -} - -func DeleteRegKeysValue(regHive string, keypath string, keyobject string) error { - return errors.New("not implemented for this platform") -} - -func QueryRegKeyString(regHive string, keypath string, keyobject string) (string, error) { - return "error", errors.New("not implemented for this platform") -} diff --git a/deprecated/registry_windows.go b/deprecated/registry_windows.go deleted file mode 100644 index 4cb381b..0000000 --- a/deprecated/registry_windows.go +++ /dev/null @@ -1,84 +0,0 @@ -// +build windows - -package engine - -import ( - "errors" - "fmt" - - reg "golang.org/x/sys/windows/registry" -) - -// CreateRegKeyAndValue creates a new regestry key in a dynamic hive, dynamic path, dynamic object, and infers the type as either string or uint32 and creats the correct key type accordingly -func CreateRegKeyAndValue(regHive string, keyPath string, keyObject string, keyValue interface{}) error { - var hive reg.Key - if regHive == "LM" { - hive = reg.LOCAL_MACHINE - } else if regHive == "CU" { - hive = reg.CURRENT_USER - } else { - return errors.New("invalid reg hive provided") - } - // Create our key or see if it exists - k, _, err := reg.CreateKey(hive, keyPath, reg.ALL_ACCESS) - if err != nil { - return errors.New("create key error") - } - // regardless if its new or created it we set it to our value - defer k.Close() - // switch on keyValue type to create different key type values - switch v := keyValue.(type) { - case string: - keyValueSZ := keyValue.(string) - k.SetStringValue(keyObject, keyValueSZ) - case uint32: - keyValueUI32 := keyValue.(uint32) - k.SetDWordValue(keyObject, keyValueUI32) - default: - vstring := fmt.Sprintf("Info: %v", v) - return errors.New("add value error, Value " + vstring) - } - return nil -} - -// DeleteRegKeysValue deletes a dynamic keyobject in a dynamic hive and path -func DeleteRegKeysValue(regHive string, keypath string, keyobject string) error { - var hive reg.Key - if regHive == "LM" { - hive = reg.LOCAL_MACHINE - } else if regHive == "CU" { - hive = reg.CURRENT_USER - } else { - return errors.New("invalid reg hive provided") - } - k, err := reg.OpenKey(hive, keypath, reg.ALL_ACCESS) - if err != nil { - //log.Fatal(err) - return errors.New("couldn't open key") - } - defer k.Close() - k.DeleteValue(keyobject) - return nil -} - -// QueryRegKeyString reads and returns a registry key for windows -func QueryRegKeyString(regHive string, keypath string, keyobject string) (string, error) { - var hive reg.Key - if regHive == "LM" { - hive = reg.LOCAL_MACHINE - } else if regHive == "CU" { - hive = reg.CURRENT_USER - } else { - return "error", errors.New("invalid reg hive provided") - } - k, err := reg.OpenKey(hive, keypath, reg.QUERY_VALUE) - if err != nil { - return "error", errors.New("invalid reg path") - } - defer k.Close() - s, _, err := k.GetStringValue(keyobject) - if err != nil { - return "error", errors.New("invalid key to query for") - } - return s, nil -} diff --git a/deprecated/responses.go b/deprecated/responses.go deleted file mode 100644 index f715763..0000000 --- a/deprecated/responses.go +++ /dev/null @@ -1,11 +0,0 @@ -package engine - -type VMResponse map[string]interface{} - -type VMExecResponse struct { - Stdout []string `json:"stdout"` - Stderr []string `json:"stderr"` - Success bool `json:"success"` - PID int `json:"pid"` - ErrorMsg string `json:"error_message"` -} diff --git a/deprecated/util.go b/deprecated/util.go deleted file mode 100644 index c8841a4..0000000 --- a/deprecated/util.go +++ /dev/null @@ -1,117 +0,0 @@ -package engine - -import ( - "bytes" - "encoding/binary" - "fmt" - - "github.com/robertkrimen/otto" -) - -type FunctionDef struct { - Name string `yaml:"func"` - Description string `yaml:"description"` - Package string `yaml:"package"` - ExpectedArgTypes []TypeDef `yaml:"args"` - ExpectedReturnTypes []TypeDef `yaml:"returns"` - ReturnValueName string `yaml:"return_var_name"` -} - -type TypeDef struct { - Name string - Type string -} - -// func (e *Engine) ParseArgs(c otto.FunctionCall, ...types string) [] - -func (e *Engine) ValueToByteSlice(v otto.Value) []byte { - valueBytes := []byte{} - if v.IsNull() || v.IsUndefined() { - return valueBytes - } - if v.IsString() { - str, err := v.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Cannot convert string to byte slice: %s", v) - return valueBytes - } - valueBytes = []byte(str.(string)) - } else if v.IsNumber() { - num, err := v.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Cannot convert string to byte slice: %s", v) - return valueBytes - } - buf := new(bytes.Buffer) - err = binary.Write(buf, binary.LittleEndian, num) - if err != nil { - fmt.Println("binary.Write failed:", err) - } - valueBytes = buf.Bytes() - } else if v.Class() == "Array" || v.Class() == "GoArray" { - arr, err := v.Export() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Cannot convert array to byte slice: %x", v) - return valueBytes - } - switch t := arr.(type) { - case []uint: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []uint8: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []uint16: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []uint32: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []uint64: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []int: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []int16: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []int32: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []int64: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []float32: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []float64: - for _, i := range t { - valueBytes = append(valueBytes, byte(i)) - } - case []string: - for _, i := range t { - for _, c := range i { - valueBytes = append(valueBytes, byte(c)) - } - } - default: - _ = t - e.Logger.WithField("trace", "true").Errorf("Failed to cast array to byte slice array=%v", arr) - } - } else { - e.Logger.WithField("trace", "true").Errorf("Unknown class to cast to byte slice") - } - - return valueBytes -} diff --git a/deprecated/vm.go b/deprecated/vm.go deleted file mode 100644 index 2fb4acb..0000000 --- a/deprecated/vm.go +++ /dev/null @@ -1,72 +0,0 @@ -package engine - -import ( - "os" - "os/user" - "runtime" - "strings" -) - -func (e *Engine) LoadScript(source []byte) error { - _, err := e.VM.Run(string(source)) - return err -} - -func (e *Engine) CurrentUser() map[string]string { - userInfo := map[string]string{} - u, err := user.Current() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("User Loading Error: %s", err.Error()) - return userInfo - } - userInfo["uid"] = u.Uid - userInfo["gid"] = u.Gid - userInfo["username"] = u.Username - userInfo["name"] = u.Name - userInfo["home_dir"] = u.HomeDir - groups, err := u.GroupIds() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Group Loading Error: %s", err.Error()) - return userInfo - } - userInfo["groups"] = strings.Join(groups, ":") - return userInfo -} - -func (e *Engine) InjectVars() { - userInfo, err := e.VM.ToValue(e.CurrentUser()) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Could not inject user info into VM: %s", err.Error()) - } else { - e.VM.Set("USER_INFO", userInfo) - } - osVal, err := e.VM.ToValue(runtime.GOOS) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Could not inject os info into VM: %s", err.Error()) - } else { - e.VM.Set("OS", osVal) - } - hn, err := os.Hostname() - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Could not obtain hostname info: %s", err.Error()) - } else { - hostnameVal, err := e.VM.ToValue(hn) - if err != nil { - e.Logger.Errorf("Could not inject hostname info into VM: %s", err.Error()) - } else { - e.VM.Set("HOSTNAME", hostnameVal) - } - } - archVal, err := e.VM.ToValue(runtime.GOARCH) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Could not inject arch info into VM: %s", err.Error()) - } else { - e.VM.Set("ARCH", archVal) - } - ipVals, err := e.VM.ToValue(GetLocalIPs()) - if err != nil { - e.Logger.WithField("trace", "true").Errorf("Could not inject ip info into VM: %s", err.Error()) - } else { - e.VM.Set("IP_ADDRS", ipVals) - } -} diff --git a/deprecated/vm_functions.go b/deprecated/vm_functions.go deleted file mode 100644 index a5042c9..0000000 --- a/deprecated/vm_functions.go +++ /dev/null @@ -1,68 +0,0 @@ -// Code generated by go generate; DO NOT EDIT. -package engine - -import ( - "github.com/robertkrimen/otto" -) - -func (e *Engine) CreateVM() { - e.VM = otto.New() - e.InjectVars() - - e.VM.Set("Asset", e.VMAsset) - - _, err := e.VM.Run(VMPreload) - if err != nil { - e.Logger.WithField("trace", "true").Fatalf("Syntax error in preload: %s", err.Error()) - } -} - -// VMAsset is an autogenerated function. -// Function: Asset -// Package: core -// Description: Retrieves a packed asset from the VM embedded file store. -// Author: Alex -func (e *Engine) VMAsset(call otto.FunctionCall) otto.Value { - if len(call.ArgumentList) > 1 { - e.Logger.WithField("function", "Asset").Error("Too many arguments in call.") - return otto.FalseValue() - } - - if len(call.ArgumentList) < 1 { - e.Logger.WithField("function", "Asset").Error("Too few arguments in call.") - return otto.FalseValue() - } - - var assetName string - - rawArg0, err := call.Argument(0).Export() - if err != nil { - e.Logger.WithField("function", "Asset").Error("Could not export field: %s", "assetName") - return otto.FalseValue() - } - - switch v := rawArg0.(type) { - case string: - assetName = rawArg0.(string) - default: - e.Logger.WithField("function", "Asset").Error("Argument type mismatch: expected %s, got %T", "string", v) - return otto.FalseValue() - } - - fileData, err := e.Asset(assetName) - - rawVMRet := VMResponse{} - - rawVMRet["fileData"] = fileData - - rawVMRet["err"] = err - - vmRet, vmRetError := e.VM.ToValue(rawVMRet) - if vmRetError != nil { - e.Logger.WithField("function", "Asset").Error("Return conversion failed: %s", vmRetError.Error()) - return otto.FalseValue() - } - - return vmRet - -} diff --git a/engine/engine.go b/engine/engine.go index 19a965b..8684ed3 100644 --- a/engine/engine.go +++ b/engine/engine.go @@ -53,8 +53,12 @@ func (e *Engine) SetName(name string) { e.Name = name } -func (e *Engine) LoadScript(source []byte) error { - _, err := e.VM.Run(string(source)) +func (e *Engine) LoadScript(filename string, source []byte) error { + script, err := e.VM.Compile(filename, source) + if err != nil { + return err + } + _, err = e.VM.Eval(script) return err } diff --git a/engine/executor.go b/engine/executor.go index b44e9da..83b4a68 100644 --- a/engine/executor.go +++ b/engine/executor.go @@ -36,7 +36,7 @@ func (e *Engine) RunWithTimeout(command string) (otto.Value, error) { ).WithField( "line", strconv.Itoa(e.VM.Context().Line), - ).Infof("%s Execution Time: %v", command, duration) + ).Debugf("%s Execution Time: %v", command, duration) }() e.VM.Interrupt = make(chan func(), 1) diff --git a/engine/lib_file.go b/engine/lib_file.go index e6a4929..32abebb 100644 --- a/engine/lib_file.go +++ b/engine/lib_file.go @@ -41,10 +41,6 @@ import ( // // obj.fileError // func (e *Engine) WriteFile(path string, fileData []byte, perms int64) (int, error) { - if _, err := os.Stat(path); os.IsNotExist(err) { - e.Logger.WithField("trace", "true").Errorf("File error: %s", err.Error()) - return 0, err - } err := ioutil.WriteFile(path, fileData, os.FileMode(uint32(perms))) if err != nil { e.Logger.WithField("trace", "true").Errorf("Error writing the file: %s", err.Error()) diff --git a/spec/asset.gs b/examples/spec/asset.gs similarity index 100% rename from spec/asset.gs rename to examples/spec/asset.gs diff --git a/spec/bad.gs b/examples/spec/bad.gs similarity index 100% rename from spec/bad.gs rename to examples/spec/bad.gs diff --git a/spec/basic.gs b/examples/spec/basic.gs similarity index 100% rename from spec/basic.gs rename to examples/spec/basic.gs diff --git a/spec/compiler_parallelism/large_embed_a.gs b/examples/spec/compiler_parallelism/large_embed_a.gs similarity index 100% rename from spec/compiler_parallelism/large_embed_a.gs rename to examples/spec/compiler_parallelism/large_embed_a.gs diff --git a/spec/compiler_parallelism/large_embed_b.gs b/examples/spec/compiler_parallelism/large_embed_b.gs similarity index 100% rename from spec/compiler_parallelism/large_embed_b.gs rename to examples/spec/compiler_parallelism/large_embed_b.gs diff --git a/spec/compiler_parallelism/large_embed_c.gs b/examples/spec/compiler_parallelism/large_embed_c.gs similarity index 100% rename from spec/compiler_parallelism/large_embed_c.gs rename to examples/spec/compiler_parallelism/large_embed_c.gs diff --git a/spec/compiler_parallelism/large_embed_d.gs b/examples/spec/compiler_parallelism/large_embed_d.gs similarity index 100% rename from spec/compiler_parallelism/large_embed_d.gs rename to examples/spec/compiler_parallelism/large_embed_d.gs diff --git a/spec/darwin_service_test.gs b/examples/spec/darwin_service_test.gs similarity index 100% rename from spec/darwin_service_test.gs rename to examples/spec/darwin_service_test.gs diff --git a/spec/good.gs b/examples/spec/good.gs similarity index 100% rename from spec/good.gs rename to examples/spec/good.gs diff --git a/spec/halt.gs b/examples/spec/halt.gs similarity index 100% rename from spec/halt.gs rename to examples/spec/halt.gs diff --git a/spec/large_file.gs b/examples/spec/large_file.gs similarity index 100% rename from spec/large_file.gs rename to examples/spec/large_file.gs diff --git a/spec/logging.gs b/examples/spec/logging.gs similarity index 100% rename from spec/logging.gs rename to examples/spec/logging.gs diff --git a/spec/md5.gs b/examples/spec/md5.gs similarity index 100% rename from spec/md5.gs rename to examples/spec/md5.gs diff --git a/spec/priority/priority_test_a.gs b/examples/spec/priority/priority_test_a.gs similarity index 100% rename from spec/priority/priority_test_a.gs rename to examples/spec/priority/priority_test_a.gs diff --git a/spec/priority/priority_test_b.gs b/examples/spec/priority/priority_test_b.gs similarity index 100% rename from spec/priority/priority_test_b.gs rename to examples/spec/priority/priority_test_b.gs diff --git a/spec/priority/priority_test_c.gs b/examples/spec/priority/priority_test_c.gs similarity index 100% rename from spec/priority/priority_test_c.gs rename to examples/spec/priority/priority_test_c.gs diff --git a/spec/repl.gs b/examples/spec/repl.gs similarity index 100% rename from spec/repl.gs rename to examples/spec/repl.gs diff --git a/spec/sleep.gs b/examples/spec/sleep.gs similarity index 100% rename from spec/sleep.gs rename to examples/spec/sleep.gs diff --git a/spec/test.gs b/examples/spec/test.gs similarity index 100% rename from spec/test.gs rename to examples/spec/test.gs diff --git a/spec/timeout_test.gs b/examples/spec/timeout_test.gs similarity index 100% rename from spec/timeout_test.gs rename to examples/spec/timeout_test.gs diff --git a/spec/timestamp.gs b/examples/spec/timestamp.gs similarity index 100% rename from spec/timestamp.gs rename to examples/spec/timestamp.gs diff --git a/spec/windows_path.gs b/examples/spec/windows_path.gs similarity index 100% rename from spec/windows_path.gs rename to examples/spec/windows_path.gs diff --git a/spec/write_file.gs b/examples/spec/write_file.gs similarity index 100% rename from spec/write_file.gs rename to examples/spec/write_file.gs diff --git a/gscript.go b/gscript.go index 7a965fb..895a5e2 100644 --- a/gscript.go +++ b/gscript.go @@ -1,4 +1,4 @@ package gscript // Version defines the version of gscript -const Version = "v0.0.19" +const Version = "v0.1.0" diff --git a/templates/entrypoint.go.tmpl b/templates/entrypoint.go.tmpl index 0c20ad9..7286ea3 100644 --- a/templates/entrypoint.go.tmpl +++ b/templates/entrypoint.go.tmpl @@ -32,7 +32,7 @@ func main() { {{ range $_, $embed := $vm.Embeds -}} gse.AddImport("{{ $embed.Filename }}", {{ $embed.NameHash }}) {{ end -}} - gse.LoadScript(gse.Imports["{{ $vm.ID }}.gs"]()) + gse.LoadScript("{{ $vm.ID }}", gse.Imports["{{ $vm.ID }}.gs"]()) gse.ExecutePlan() }() {{ end -}} diff --git a/windowsBuild.ps1 b/windowsBuild.ps1 deleted file mode 100755 index 51e8980..0000000 --- a/windowsBuild.ps1 +++ /dev/null @@ -1,7 +0,0 @@ -$myCwd = (Get-Item -Path ".\" -Verbose).FullName -go-bindata -pkg main -nomemcopy -o $env:GOPATH\src\github.com\gen0cide\gscript\generator\bindata.go -prefix 'generator' generator\templates\... -go run generator\main.go generator\bindata.go generate --config $env:GOPATH\src\github.com\gen0cide\gscript\functions.yml --out $env:GOPATH\src\github.com\gen0cide\gscript\engine\vm_functions.go --docs $env:GOPATH\src\github.com\gen0cide\gscript\FUNCTIONS.md -cd $env:GOPATH\src\github.com\gen0cide\gscript\cmd\gscript -go-bindata -pkg compiler -nomemcopy -o $env:GOPATH\src\github.com\gen0cide\gscript\compiler\bindata.go -prefix '..\..' ..\..\templates\... -go build -o $env:GOPATH\bin\gscript -cd $myCwd \ No newline at end of file