Netcat

Para los que no sepan que es netcat, es una herramienta “simple” que nos sirve para hacer conexiones tcp o udp y enviar datos por las mismas, se puede enviar por ejemplo, una petición http (o si nos vamos a algo mas malvado, una reverse Shell).
Si quieren hacer una petición http solo tienen que levantar un server, y escribir las siguientes líneas en que programa que realizamos

GET / HTTP/1.0
Host: localhost

También se ocupa la linea vacía del final

Código con comentarios que explican el flujo del código esperado. ```js package main import ( "flag" "fmt" "io" "log" "net" "os" ) var ( port = flag.Int("p", 3090, "Port to connect") host = flag.String("h", "localhost", "Host to connect") ) func main() { flag.Parse() //Parse the flags connection, err := net.Dial("tcp", fmt.Sprintf("%s:%d", *host, *port)) if err != nil { log.Fatal(err) //If there is an error, print it and exit } done := make(chan struct{}) //Channel of control, we dont care about the value, just the signal go func() { io.Copy(os.Stdout, connection) //Copy the data from the connection to the standard output. If connection hasn't data, it will block. If connection is closed, it will return. done <- struct{}{} //Send a signal to the channel }() CopyContent(connection, os.Stdin) //Copy the data from the standard input to the connection. It will block until the standard input has data. If the standard input is closed, it will return. connection.Close() //Close the connection <-done //Wait for the signal } func CopyContent(dst io.Writer, src io.Reader) { _, err := io.Copy(dst, src) if err != nil { log.Fatal(err) } } ```

```js package main import ( "flag" "fmt" "io" "log" "net" "os" "sync" ) var ( port = flag.Int("p", 3090, "port") host = flag.String("h", "localhost", "host") ) func handleServerOutput(conn net.Conn, done chan struct{}) { io.Copy(os.Stdout, conn) done <- struct{}{} } func CopyContent(dst io.Writer, src io.Reader) { _, err := io.Copy(dst, src) if err != nil { log.Println("Error copying content:", err) } } func NetCat(wg *sync.WaitGroup) { defer wg.Done() address := fmt.Sprintf("%s:%d", *host, *port) conn, err := net.Dial("tcp", address) if err != nil { log.Println("Error connecting:", err) return } defer conn.Close() done := make(chan struct{}) go handleServerOutput(conn, done) CopyContent(conn, os.Stdin) <-done } func main() { flag.Parse() var wg sync.WaitGroup wg.Add(1) go NetCat(&wg) wg.Wait() } ```

```js package main import ( "flag" "fmt" "io" "log" "net" "os" "sync" ) var ( port = flag.Int("p", 3090, "port") host = flag.String("h", "localhost", "host") ) // Esta función maneja la lectura desde la conexión y la escritura en stdout func handleServerOutput(conn net.Conn, done chan struct{}) { io.Copy(os.Stdout, conn) done <- struct{}{} } // Esta función copia el contenido desde el stdin a la conexión func CopyContent(dst io.Writer, src io.Reader) { _, err := io.Copy(dst, src) if err != nil { log.Println("Error copying content:", err) } } func NetCat(wg *sync.WaitGroup) { defer wg.Done() address := fmt.Sprintf("%s:%d", *host, *port) conn, err := net.Dial("tcp", address) if err != nil { log.Println("Error connecting:", err) return } defer conn.Close() done := make(chan struct{}) go handleServerOutput(conn, done) CopyContent(conn, os.Stdin) <-done } func main() { flag.Parse() var wg sync.WaitGroup wg.Add(1) go NetCat(&wg) wg.Wait() } ```package main import (    "flag"    "fmt"    "io"    "log"    "net"    "os"    "sync") var (    port = flag.Int("p", 3090, "port")    host = flag.String("h", "localhost", "host")) // Esta función maneja la lectura desde la conexión y la escritura en stdoutfunc handleServerOutput(conn net.Conn, done chan struct{}) {    io.Copy(os.Stdout, conn)    done <- struct{}{}} // Esta función copia el contenido desde el stdin a la conexiónfunc CopyContent(dst io.Writer, src io.Reader) {    \_, err := io.Copy(dst, src)    if err != nil {        log.Println("Error copying content:", err)    }} func NetCat(wg \*sync.WaitGroup) {    defer wg.Done()    address := fmt.Sprintf("%s:%d", \*host, \*port)    conn, err := net.Dial("tcp", address)    if err != nil {        log.Println("Error connecting:", err)        return    }    defer conn.Close()     done := make(chan struct{})    go handleServerOutput(conn, done)    CopyContent(conn, os.Stdin)    <-done} func main() {    flag.Parse()    var wg sync.WaitGroup    wg.Add(1)    go NetCat(\&wg)    wg.Wait()}

Esta es mi versión del código separando un poco la lógica para que sea mas legible. `package main` `import (    "flag"    "fmt"    "io"    "log"    "net"    "os"    "sync")` `var (    port = flag.Int("p", 3090, "port")    host = flag.String("h", "localhost", "host"))` `// Esta función maneja la lectura desde la conexión y la escritura en stdoutfunc handleServerOutput(conn net.Conn, done chan struct{}) {    io.Copy(os.Stdout, conn)    done <- struct{}{}}` `// Esta función copia el contenido desde el stdin a la conexiónfunc CopyContent(dst io.Writer, src io.Reader) {    _, err := io.Copy(dst, src)    if err != nil {        log.Println("Error copying content:", err)    }}` `func NetCat(wg *sync.WaitGroup) {    defer wg.Done()    address := fmt.Sprintf("%s:%d", *host, *port)    conn, err := net.Dial("tcp", address)    if err != nil {        log.Println("Error connecting:", err)        return    }    defer conn.Close()` `    done := make(chan struct{})    go handleServerOutput(conn, done)    CopyContent(conn, os.Stdin)    <-done}` `func main() {    flag.Parse()    var wg sync.WaitGroup    wg.Add(1)    go NetCat(&wg)    wg.Wait()}`