From 0181a83a4cd113bc7e0f0a03bffe4cd46d2055d3 Mon Sep 17 00:00:00 2001 From: speckij Date: Sun, 6 Jan 2019 22:00:43 +0100 Subject: [PATCH] Initial upload --- .gitignore | 73 +++++++++++++++++++++++++++ main.go | 141 +++++++++++++++++++++++++++++++++++++++++++++++++++++ writer.go | 98 +++++++++++++++++++++++++++++++++++++ 3 files changed, 312 insertions(+) create mode 100644 .gitignore create mode 100644 main.go create mode 100644 writer.go diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ae61770 --- /dev/null +++ b/.gitignore @@ -0,0 +1,73 @@ +# Created by .ignore support plugin (hsz.mobi) +### Go template +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, build with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out +*.prof + +### JetBrains template +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff +.idea/**/workspace.xml +.idea/**/tasks.xml +.idea/**/dictionaries +.idea/**/shelf + +# Sensitive or high-churn files +.idea/**/dataSources/ +.idea/**/dataSources.ids +.idea/**/dataSources.local.xml +.idea/**/sqlDataSources.xml +.idea/**/dynamic.xml +.idea/**/uiDesigner.xml +.idea/**/dbnavigator.xml + +# Gradle +.idea/**/gradle.xml +.idea/**/libraries + +# CMake +cmake-build-debug/ +cmake-build-release/ + +# Mongo Explorer plugin +.idea/**/mongoSettings.xml + +# File-based project format +*.iws + +# IntelliJ +out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Cursive Clojure plugin +.idea/replstate.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +# Editor-based Rest Client +.idea/httpRequests + +### Custom +# Additional Dev Files +/tcpDialer.go diff --git a/main.go b/main.go new file mode 100644 index 0000000..667a7d6 --- /dev/null +++ b/main.go @@ -0,0 +1,141 @@ +package main + +import ( + "flag" + "net" + "runtime/pprof" + "time" +) + +import "fmt" +import "image/png" +import "log" +import "os" +import "strconv" +import _ "net/http/pprof" + +var err error +var cpuprofile = flag.String("cpuprofile", "", "Destination file for CPU Profile") +var image = flag.String("image", "", "Absolute Path to image") +var canvas_xsize = flag.Int("xsize", 800, "Width of the canvas in px") +var canvas_ysize = flag.Int("ysize", 600, "Height of the canvas in px") +var image_offsetx = flag.Int("xoffset", 0, "Offset of posted image from left border") +var image_offsety = flag.Int("yoffset", 0, "Offset of posted image from top border") +var connections = flag.Int("connections", 10, "Number of simultaneous connections/threads. Each Thread posts a subimage") +var address = flag.String("host", "127.0.0.1:1337", "Server address") +var runtime = flag.String("runtime", "1", "Runtime in Minutes") + +func main() { + flag.Parse() + if *image == "" || *address == "" { + log.Fatal("No image or no server address provided") + } + + // Start cpu profiling if wanted + if *cpuprofile != "" { + f, err := os.Create(*cpuprofile) + if err != nil { + log.Fatal(err) + } + pprof.StartCPUProfile(f) + defer pprof.StopCPUProfile() + } + // Generate and split messages into equal chunks + msg := splitmessages(genMessages()) + for _, message := range msg { + go bomb(message) + } + + // Terminate after 1 Minute to save resources + timer, err := time.ParseDuration(*runtime + "m") + if err != nil { + log.Fatal("Invalid runtime specified: " + err.Error()) + } + time.Sleep(time.Minute * timer) +} + +func bomb(messages []byte) { + conn, err := net.Dial("tcp", *address) + + if err != nil { + log.Print("error establishing tcp connection: " + err.Error()) + } + //TODO: Actually close the connection and not just terminate main thread + defer conn.Close() + + // Start bombardement + for { + _, err := conn.Write(messages) + if err != nil { + log.Println(err.Error()) + } + } +} + +// Creates message based on given image +func genMessages() (output []byte) { + reader, err := os.Open(*image) + if err != nil { + log.Fatal(err) + } + + img, err2 := png.Decode(reader) + if err2 != nil { + log.Fatal(err2) + } + + for x := img.Bounds().Max.X; x != 0; x-- { + for y := img.Bounds().Max.Y; y != 0; y-- { + col := img.At(x, y) + r, g, b, _ := col.RGBA() + + rStr := strconv.FormatInt(int64(r), 16) + if len(rStr) == 1 { + rStr = "0" + rStr + } + + gStr := strconv.FormatInt(int64(g), 16) + if len(gStr) == 1 { + gStr = "0" + gStr + } + + bStr := strconv.FormatInt(int64(b), 16) + if len(bStr) == 1 { + bStr = "0" + bStr + } + + colStr := rStr[0:2] + colStr += gStr[0:2] + colStr += bStr[0:2] + + //Do not draw transparent pixels + if colStr == "000000" { + continue + } + pxStr := fmt.Sprintf("PX %d %d %s\n", x+*image_offsetx, y+*image_offsety, colStr) + output = append(output, []byte(pxStr)...) + } + } + return output +} + +// Splits messages into chunks, splitting on complete commands only +func splitmessages(in []byte) [][]byte { + index := 0 + equalsplit := len(in) / *connections + output := make([][]byte, *connections) + for i := 0; i < *connections; i++ { + if index+equalsplit > len(in) { + output[i] = in[index:] + break + } + + tmp := index + for in[index+equalsplit] != 80 { + index++ + } + output[i] = in[tmp : index+equalsplit] + index += equalsplit + } + return output +} diff --git a/writer.go b/writer.go new file mode 100644 index 0000000..68e1fc8 --- /dev/null +++ b/writer.go @@ -0,0 +1,98 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Modified 2018 by Jan Speckamp. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// This implements buffered I/O. It wraps an io.Reader or io.Writer +// object, creating another object (Reader or Writer) that also implements +// the interface but provides buffering and some help for textual I/O. +package main + +import ( + "io" +) + +const ( + defaultBufSize = 4096 +) + +// Writer implements buffering for an io.Writer object. +// If an error occurs writing to a Writer, no more data will be +// accepted and all subsequent writes, and Flush, will return the error. +// After all data has been written, the client should call the +// Flush method to guarantee all data has been forwarded to +// the underlying io.Writer. +type Writer struct { + err error + buf []byte + n int + wr io.Writer +} + +// NewWriterSize returns a new Writer whose buffer has at least the specified +// size. If the argument io.Writer is already a Writer with large enough +// size, it returns the underlying Writer. +func NewWriterSize(w io.Writer, size int) *Writer { + // Is it already a Writer? + b, ok := w.(*Writer) + if ok && len(b.buf) >= size { + return b + } + if size <= 0 { + size = defaultBufSize + } + return &Writer{ + buf: make([]byte, size), + wr: w, + } +} + +// Flush writes any buffered data to the underlying io.Writer. +func (b *Writer) Flush() error { + if b.err != nil { + return b.err + } + if b.n == 0 { + return nil + } + n, err := b.wr.Write(b.buf[0:b.n]) + if n < b.n && err == nil { + err = io.ErrShortWrite + } + if err != nil { + if n > 0 && n < b.n { + copy(b.buf[0:b.n-n], b.buf[n:b.n]) + } + b.n -= n + b.err = err + return err + } + return nil +} + +// Write writes the contents of p into the buffer. +// It returns the number of bytes written. +// If nn < len(p), it also returns an error explaining +// why the write is short. +func (b *Writer) Write(p []byte) (nn int, err error) { + for len(p) > (len(b.buf)-b.n) && b.err == nil { + var n int + if b.n == 0 { + // Large write, empty buffer. + // Write directly from p to avoid copy. + n, b.err = b.wr.Write(p) + } else { + n = copy(b.buf[b.n:], p) + b.n += n + } + nn += n + p = p[n:] + } + if b.err != nil { + return nn, b.err + } + n := copy(b.buf[b.n:], p) + b.n += n + nn += n + return nn, nil +}