CVE-2018-6574

This PoC demonstrates CVE-2018-6574, a vulnerability in Go's `go get` command that allows arbitrary code execution via malicious plugins. The exploit uses platform-specific shared libraries to execute commands (e.g., launching a calculator or creating a file).

This PoC exploits CVE-2018-6574 in Go versions before 1.8.7, 1.9.x before 1.9.4, and 1.10 pre-releases by leveraging the gcc/clang plugin feature to execute arbitrary commands during `go get`. The exploit uses a dynamic library to trigger remote command execution.

This PoC exploits CVE-2018-6574 by leveraging a constructor function in a shared library to execute arbitrary commands. The Go program loads the malicious library via cgo, triggering the exploit during initialization.

This PoC demonstrates a dynamic library injection exploit via Go's cgo, leveraging a malicious constructor in a shared object to execute arbitrary commands. The attack.c file contains a constructor that runs a system command, while main.go loads it as a plugin.

This PoC exploits CVE-2018-6574, a vulnerability in Go's cgo that allows arbitrary command execution via a malicious plugin. The exploit uses a shared library with a constructor function to execute commands when loaded.

This PoC demonstrates CVE-2018-6574, a remote command execution vulnerability in Go's `go get` command via malicious C compiler plugins. The exploit leverages the `-fplugin` flag in gcc/clang to load a shared library containing arbitrary code execution.

This PoC exploits CVE-2018-6574 by leveraging a malicious shared library (attack.so) loaded via Go's cgo to execute arbitrary commands. The attack.c file contains a constructor function that triggers a system command upon library load.

This code is a minimal Go program that prints a string via C interop, but it does not demonstrate any exploit or vulnerability. It lacks any offensive techniques or payloads related to CVE-2018-6574.

The repository contains deceptive code with a malicious constructor in 'attack.c' that executes an arbitrary command unrelated to CVE-2018-6574. The Go code imports this malicious C function, disguising it as a legitimate PoC.

This PoC demonstrates a dynamic library injection via CGo in Go, exploiting CVE-2018-6574. The `attack.c` file contains a constructor function that executes a command when loaded, while `main.go` loads the malicious library through CGo directives.

This PoC demonstrates a dynamic library injection via a Go program using cgo to load a malicious shared object (attack.so). The attack.c file contains a constructor function that executes arbitrary commands upon library load.

This is a minimal Go stub demonstrating a C function call via cgo, but it does not exploit CVE-2018-6574. The code lacks any offensive techniques or vulnerability-specific logic.

This PoC demonstrates a constructor-based code execution via a shared library (exploit.so) loaded by a Go program. The exploit leverages the CGO mechanism to execute arbitrary code during initialization.

This PoC demonstrates a dynamic library injection vulnerability (CVE-2018-6574) by using a Go program to load a malicious shared object (attack.so) via cgo, which executes arbitrary code during initialization. The attack.c file contains a constructor function that triggers a system command execution.

This PoC exploits CVE-2018-6574 by leveraging Go's cgo plugin feature to load a malicious shared library (attack.so) during compilation, achieving arbitrary command execution. The attack involves tricking a target into compiling a Go program with a malicious plugin.

This PoC demonstrates a shared library injection attack via a Go program using cgo. The attack.c file contains a constructor function that executes a command to submit a score, likely for a PentesterLab exercise.

This PoC demonstrates CVE-2018-6574 by exploiting a vulnerability in Go's cgo to execute arbitrary code via a malicious shared library. The attack.c file contains a constructor function that executes a command when loaded.

The repository contains a C-based exploit leveraging a constructor attribute to execute arbitrary commands via system() and a Go-based component that interfaces with the C code. The exploit appears to target a specific vulnerability (CVE-2018-6574) by executing a predefined command.

This PoC exploits CVE-2018-6574, a vulnerability in Go's `go get` command that allows arbitrary code execution via malicious plugins. The `attack.c` file contains a constructor function that executes a command, while `main.go` demonstrates the exploitation by loading the malicious plugin.

This PoC demonstrates a shared library injection attack via a constructor function in C, which executes arbitrary code when loaded. The Go component serves as a test harness to trigger the malicious payload.

This PoC demonstrates a dynamic library injection vulnerability (CVE-2018-6574) by using a malicious constructor in a shared object (attack.so) loaded via cgo in a Go program. The exploit executes arbitrary code (a system command) when the shared library is loaded.

This repository contains a minimal Go program that prints a string, but it does not demonstrate any exploit for CVE-2018-6574. The code lacks any offensive techniques or vulnerability exploitation logic.

This PoC demonstrates a dynamic library injection via Go's cgo to execute arbitrary code during program initialization. The `attack.c` file uses a constructor attribute to run a system command, while `main.go` loads the malicious library.

This PoC demonstrates CVE-2018-6574 by exploiting a vulnerability in Go's cgo plugin system to execute arbitrary code via a malicious shared library. The attack.c file contains a constructor function that executes a command when loaded.

This exploit leverages a constructor function in C to execute arbitrary commands via the `system` call. It targets a specific binary (`/usr/local/bin/score`) with a predefined UUID, suggesting it is designed for a capture-the-flag (CTF) or controlled testing environment.

This exploit leverages a shared library (attack.so) with a constructor function to execute arbitrary commands via system(). The Go program loads this library, demonstrating a potential RCE vector.

This PoC demonstrates a vulnerability in Go's cgo by exploiting a constructor function in a malicious shared library (attack.so) to execute arbitrary code during program initialization. The attack.c file contains a constructor function that triggers a reverse shell via netcat, while main.go is a benign program that loads the malicious library.

This PoC demonstrates a dynamic linker hijacking vulnerability (CVE-2018-6574) by using a malicious constructor in a shared object (attack.so) to execute arbitrary code when loaded via cgo in a Go program. The exploit leverages the LD_PRELOAD-like behavior in Go's cgo to trigger the malicious payload.

This PoC exploits CVE-2018-6574 by leveraging a malicious constructor in a shared library (exploit.so) loaded via cgo in a Go program. The exploit executes arbitrary code (a system command) when the library is loaded.

This PoC demonstrates CVE-2018-6574, a vulnerability in Golang's 'go get' command allowing remote code execution via malicious library installation. The exploit leverages compiler flags to execute arbitrary code during native extension builds.

The repository contains a C file with a constructor function that executes a system command, which is unusual for a PoC. The Go file appears unrelated to the CVE and does not demonstrate exploitation. No clear exploitation of CVE-2018-6574 is present.

This PoC exploits CVE-2018-6574 by leveraging Go's `go get` command to execute arbitrary code via malicious CFLAGS during package installation. The attack involves a shared library (`attack.so`) that executes a command when loaded.

This PoC demonstrates a dynamic library injection via Go's cgo to execute arbitrary code during program initialization. The attack.c file uses a constructor attribute to run a malicious function before main(), while main.go loads the shared library to trigger the exploit.

This PoC demonstrates CVE-2018-6574, a vulnerability in the Go compiler's plugin system that allows arbitrary code execution via a malicious shared object. The exploit uses a constructor function in a shared library to execute arbitrary commands (e.g., 'sleep 10') when loaded by a Go program.

The provided code is a minimal Go program that imports a C function and calls it, but it lacks any exploitative logic or reference to CVE-2018-6574. It appears to be a placeholder or incomplete PoC.

This PoC demonstrates CVE-2018-6574, a vulnerability in Go's cgo that allows arbitrary code execution via a malicious plugin. The exploit uses a crafted shared library (attack.so) to hijack function execution.

This PoC demonstrates CVE-2018-6574 by exploiting a vulnerability in Go's cgo to execute arbitrary code via a malicious shared library. The `a.c` file contains a constructor function that executes a command, while `main.go` loads it as a plugin.

This PoC demonstrates a dynamic library injection vulnerability (CVE-2018-6574) in Go's cgo by using a malicious shared object (attack.so) to execute arbitrary commands during program initialization. The Go program (rce.go) loads the malicious library via cgo, triggering the constructor-based payload.

This PoC demonstrates a dynamic library injection vulnerability (CVE-2018-6574) by compiling a malicious shared object (attack.so) that executes arbitrary commands via a constructor function. The main.go file loads this library using cgo, triggering the malicious payload.

This PoC demonstrates CVE-2018-6574 by exploiting a vulnerability in Go's cgo plugin system to execute arbitrary code via a malicious shared library. The attack.c file contains a constructor function that executes a command when loaded.

This PoC demonstrates a vulnerability in Go's cgo by loading a malicious shared object (attack.so) via a constructor function, which executes arbitrary code. The main.go file triggers the malicious payload by calling a function bridged through cgo.

This PoC demonstrates CVE-2018-6574, a vulnerability in Go's cgo that allows arbitrary code execution via a malicious plugin. The attack.c file contains a constructor that executes a system command, while main.go loads the plugin and triggers the malicious code.

This PoC demonstrates a dynamic library injection attack via a Go program that loads a malicious shared object (attack.so) using cgo. The attack.c file contains a constructor function that executes arbitrary code upon library load.

This PoC demonstrates CVE-2018-6574, a Go `go get` RCE vulnerability via malicious C plugin execution. The `attack.c` file contains a constructor-based payload, while `main.go` loads it via cgo, triggering arbitrary command execution.

This PoC demonstrates a shared library injection attack via a Go program that loads a malicious C shared object. The C code executes a command via the constructor attribute, simulating arbitrary code execution.

This PoC demonstrates a dynamic linker hijacking vulnerability (CVE-2018-6574) by using a malicious shared object (attack.so) loaded via a Go program with cgo. The attack.c file contains a constructor function that executes arbitrary commands (e.g., 'ls').

The repository claims to be a PoC for CVE-2018-6574 but contains a malicious constructor in 'attack.c' that executes arbitrary code via 'system()'. The Go code is a benign wrapper that loads the malicious shared object, disguising the attack as a legitimate PoC.

This PoC demonstrates a dynamic library injection via CGO in Go, exploiting CVE-2018-6574 by loading a malicious shared object (attack.so) that executes arbitrary code during initialization. The attack.c file contains a constructor function that triggers a system command, while main.go loads the malicious library via CGO flags.

This PoC demonstrates a dynamic library injection vulnerability (CVE-2018-6574) by using a Go program to load a malicious shared object (attack.so) via cgo. The shared object executes arbitrary code during initialization via the constructor attribute.

This PoC demonstrates CVE-2018-6574, a vulnerability in Go's cgo that allows arbitrary code execution via a malicious plugin. The attack.c file compiles into a shared object that executes a command when loaded, while main.go loads this plugin.

This PoC demonstrates a shared library injection exploit for CVE-2018-6574, leveraging a constructor function to execute arbitrary code (e.g., 'sleep 20') when loaded via a Go program using cgo. The exploit abuses dynamic linking to achieve code execution.

This PoC exploits CVE-2018-6574 by leveraging a shared library (exploit.so) with a constructor function that executes arbitrary commands. The Go program loads this library, triggering the malicious payload.

This PoC demonstrates a dynamic library injection via Go's cgo directive to execute arbitrary code during program initialization. The attack.c file uses a constructor attribute to trigger a system command upon library load.

This PoC demonstrates a dynamic library injection via Go's cgo to execute arbitrary code during program initialization. The `attack.c` file uses a constructor attribute to run a malicious function, while `main.go` loads the shared library and triggers the payload.

This PoC demonstrates a vulnerability in Go's cgo by exploiting a constructor function in a malicious shared library (attack.so) to execute arbitrary commands. The main.go file loads the library and triggers the malicious code via a function call.

The repository claims to be a PoC for CVE-2018-6574 but instead uses a malicious C plugin to execute arbitrary commands via a constructor function. The Go code is a decoy to load the malicious plugin.

The repository claims to be a PoC for CVE-2018-6574 but contains a C file with a constructor function that executes a suspicious command and a Go file that appears unrelated to the stated vulnerability. The C code is deceptive as it does not demonstrate the vulnerability but instead runs an arbitrary command.

This repository contains a minimal Go program that demonstrates a plugin-based function call, but it does not exploit CVE-2018-6574. The code lacks any offensive techniques or vulnerability exploitation logic.

The repository contains a minimal Go program that demonstrates a basic C function call via cgo, but it does not exploit CVE-2018-6574. The README references the CVE but lacks technical details or exploit logic.

The exploit leverages a constructor-based code execution in C (via `malicious()` function) and a Go-based plugin mechanism to trigger arbitrary code execution. The C code executes a system command, while the Go code demonstrates plugin-based function invocation.

The provided code is a minimal Go program demonstrating a C function bridge via cgo, unrelated to CVE-2018-6574. It lacks exploit logic or vulnerability targeting.

This PoC demonstrates a dynamic linker hijacking vulnerability (CVE-2018-6574) via a malicious shared object (attack.so) loaded as a plugin in a Go program. The attack.c file contains a constructor function that executes arbitrary commands upon loading.

This PoC demonstrates a dynamic library injection vulnerability (CVE-2018-6574) by using a malicious constructor in a shared object (attack.c) loaded via cgo in a Go program (main.go). The exploit executes arbitrary code during library initialization.

This PoC demonstrates a dynamic library injection vulnerability (CVE-2018-6574) by using a Go program to load a malicious shared object (attack.so) via cgo. The attack.c file contains a constructor function that executes arbitrary code upon library load.

This PoC exploits CVE-2018-6574 by leveraging a malicious constructor in a shared library to execute arbitrary commands. The Go program dynamically loads the library, triggering the exploit.

This PoC exploits CVE-2018-6574 by leveraging a malicious shared library (attack.so) loaded via Go's cgo, executing arbitrary code during program initialization. The attack.c file uses a constructor attribute to trigger a system command, while main.go demonstrates the exploitation vector.

This PoC demonstrates a remote code execution (RCE) vulnerability in a Go application by leveraging a malicious shared library (attack.so) loaded via cgo. The attack.c file contains a constructor function that executes arbitrary commands upon library load.

This PoC demonstrates a dynamic library injection vulnerability (CVE-2018-6574) via a Go program that loads a malicious shared object (attack.so) using a constructor function to execute arbitrary commands. The attack.c file contains a constructor-based payload that triggers a system command.

The repository contains a C file with a constructor function that executes a sleep command, and a Go file that appears to be a benign example of CGo usage. The C file's purpose is unclear and may be deceptive.

This PoC demonstrates CVE-2018-6574 by exploiting a vulnerability in Go's cgo plugin system to execute arbitrary code via a malicious shared library. The attack.c file contains a constructor function that executes a command when loaded.

This PoC demonstrates CVE-2018-6574, a Go 'go get' RCE vulnerability where malicious packages could execute arbitrary commands via cflags during compilation. The exploit uses a shared library with a constructor function to execute a command when linked.

This PoC demonstrates a dynamic library injection vulnerability (CVE-2018-6574) by using a malicious constructor in a shared object (attack.so) loaded via Go's cgo. The exploit executes arbitrary code when the library is loaded.

This PoC demonstrates a shared library exploit using a constructor function to execute arbitrary commands. The main.go file loads the shared library and triggers the exploit via a function call.

The repository contains a C-based exploit (attack.c) that leverages a constructor attribute to execute arbitrary commands via system(). The Go file (attack.go) appears to be a benign example demonstrating CGo interoperability, unrelated to the exploit.

This PoC demonstrates a dynamic library injection via a Go CGO plugin to execute arbitrary code. The `attack.c` file contains a constructor function that runs a command upon library load, while `main.go` loads the malicious plugin.

This PoC demonstrates a Go-based exploit for CVE-2018-6574, leveraging a malicious shared library (attack.so) injected via cgo to execute arbitrary commands during program initialization. The attack.c file uses a constructor attribute to trigger the payload automatically.

This PoC exploits CVE-2018-6574, a vulnerability in Go's `go get` command that allows arbitrary code execution via malicious plugins. The attack uses a shared library (`attack.so`) with a constructor function to execute arbitrary commands.

The repository contains a minimal Go program that prints a string, with no functional exploit code for CVE-2018-6574. The README lacks details, and the code does not demonstrate any vulnerability exploitation.

The repository contains a proof-of-concept exploit for CVE-2018-6574, leveraging a constructor-based code execution in C and a Go wrapper. The exploit demonstrates arbitrary command execution via a malicious constructor function.

This repository contains a minimal Go program that appears to be a placeholder or stub for CVE-2018-6574. It does not demonstrate any exploit functionality but includes a reference to an external shared object (attack.so) which is not provided.

This is a minimal Go program that prints a string via C interop, likely a placeholder or stub. It does not demonstrate any exploit logic for CVE-2018-6574.

This PoC demonstrates a Go-based RCE exploit via a malicious shared library (attack.so) loaded through cgo. The attack.c file contains a constructor function that executes arbitrary commands upon library load.

The repository claims to be a PoC for CVE-2018-6574 but contains a Go program that loads a malicious C shared library via cgo. The C code executes arbitrary commands during initialization, which is unrelated to the stated CVE.

The repository contains a minimal Go program demonstrating a C function call via cgo, but lacks any exploit logic for CVE-2018-6574. The README only references the CVE without details.

This repository contains a minimal Go program that prints a string, but it does not demonstrate any exploit for CVE-2018-6574. The code lacks any offensive techniques or vulnerability exploitation logic.

The repository claims to be a PoC for CVE-2018-6574 but contains a malicious constructor in the C code that executes an unrelated command. The Go code is a benign example and unrelated to the stated vulnerability.

The repository contains a C-based exploit leveraging a constructor attribute to execute arbitrary code via a shared object (attack.so) and a Go program that loads this object. The exploit demonstrates code execution by calling an external binary.

This repository contains a minimal Go program that demonstrates a potential RCE vulnerability (CVE-2018-6574) by loading a malicious plugin via cgo. However, the actual exploit payload (plugin.so) is missing, making it a stub rather than a working PoC.

This repository contains a proof-of-concept exploit for CVE-2018-6574, leveraging a constructor function in C to execute arbitrary commands via the `system` call. The Go file demonstrates integration with the malicious C code, though it does not directly exploit the vulnerability.