func main() { if len(os.Args) < 2 { log.Fatal("No filename given.") } file, err := os.Open(os.Args[1]) if err != nil { log.Fatal(err) } decoder := tp4.NewDecoder() img, err := decoder.DecodeFile(file) if err != nil { log.Fatal(err) } out, err := os.Create("test.png") if err != nil { log.Fatal(err) } encoder := png.Encoder{png.BestCompression} err = encoder.Encode(out, img) if err != nil { log.Fatal(err) } }
// Encodes data to monochromatic-scale PNG file func EncodeColor(file []byte, secDat [][]int) (png.Encoder, *image.RGBA) { fSize := len(file) min := 0 max := int(math.Sqrt(float64(fSize))) binIndex := 0 fmt.Printf("[+] File size: %d\n", fSize) fmt.Printf("[+] Max vector size: %d\n", max) fmt.Printf("[+] Total vectors: %d\n", fSize/max) binImage := image.NewRGBA( image.Rect(min, min, max, max), ) var c color.Color sectionNumber := 0 // Fill the image with the file bytes for y := min; y < max; y++ { for x := min; x < max; x++ { // Set section color delimiters idxA := binIndex > secDat[sectionNumber][0] idxB := binIndex < secDat[sectionNumber][1] lim := sectionNumber < len(secDat)-1 // Increase section number if binIndex > secDat[sectionNumber][1] && lim { sectionNumber++ } // If the same section map with color if idxA && idxB && lim { // Get a color for every different section // NOTE: "sectionNumber%12" is for color table security, only 12 colors // available at the moment. c = GetColor(sectionNumber%12, file[binIndex]) } else { c = color.RGBA{ uint8(file[binIndex]), uint8(file[binIndex]), uint8(file[binIndex]), uint8(255), } } binIndex++ binImage.Set(x, y, c) } } var enc png.Encoder enc.CompressionLevel = 0 return enc, binImage }
func (b basicController) Encode(target io.Writer) error { switch b.imageFormat { case "jpeg": jpeg.Encode(target, b.data, &jpeg.Options{jpeg.DefaultQuality}) case "png": encoder := png.Encoder{CompressionLevel: png.BestCompression} encoder.Encode(target, b.data) case "gif": gif.Encode(target, b.data, &gif.Options{256, nil, nil}) default: return fmt.Errorf("invalid imageFormat given") } return nil }
func writeMandelbrotImageToFile() { m := image.NewRGBA(image.Rect(0, 0, int(w), int(h))) for i := 0; i < int(w); i += 1 { for j := 0; j < int(h); j += 1 { c := colorOf(i, j) m.Set(i, j, color.RGBA{c, c, c, 255}) } } file, err := os.Create("pure-go.png") if err != nil { fmt.Printf("%v\n", err) } defer file.Close() enc := png.Encoder{CompressionLevel: -1} enc.Encode(file, m) }
// Calculate the DiffMetrics for the provided digests. func (fs *FileDiffStore) diff(d1, d2 string) (*diff.DiffMetrics, error) { img1, err := fs.getDigestImage(d1) if err != nil { return nil, err } img2, err := fs.getDigestImage(d2) if err != nil { return nil, err } dm, resultImg := diff.Diff(img1, img2) baseName := getDiffBasename(d1, d2) // Write the diff image to a temporary file. tempOut, err := ioutil.TempFile(fs.localTempFileDir, fmt.Sprintf("tempfile-%s", baseName)) if err != nil { return nil, fmt.Errorf("Unable to create temp file: %s", err) } encoder := png.Encoder{CompressionLevel: png.BestSpeed} if err := encoder.Encode(tempOut, resultImg); err != nil { return nil, err } err = tempOut.Close() if err != nil { return nil, fmt.Errorf("Error closing temp file: %s", err) } diffImageFilename := fmt.Sprintf("%s.%s", baseName, IMG_EXTENSION) outputFileName, err := fs.createRadixPath(fs.localDiffDir, diffImageFilename) if err != nil { return nil, err } fs.diffDirLock.Lock() defer fs.diffDirLock.Unlock() if err := os.Rename(tempOut.Name(), outputFileName); err != nil { return nil, fmt.Errorf("Unable to move file: %s", err) } // This sets a logical path for this file. dm.PixelDiffFilePath = diffImageFilename return dm, nil }
// Encodes data to black and white PNG file func EncodeBW(file []byte) (png.Encoder, *image.RGBA) { fSize := len(file) min := 0 max := int(math.Sqrt(float64(fSize))) binIndex := 0 fmt.Printf("[+] File size: %d\n", fSize) fmt.Printf("[+] Max vector size: %d\n", max) fmt.Printf("[+] Total vectors: %d\n", fSize/max) binImage := image.NewRGBA( image.Rect(min, min, max, max), ) var c color.Color // Fill the image with the file bytes for y := min; y < max; y++ { for x := min; x < max; x++ { c = color.RGBA{ uint8(file[binIndex]), uint8(file[binIndex]), uint8(file[binIndex]), uint8(255), } binIndex++ binImage.Set(x, y, c) } } var enc png.Encoder enc.CompressionLevel = 0 return enc, binImage }
// Process はリサイズ処理を行い、エンコードしたデータを返します。 func (self *Processor) Process(i image.Image, w io.Writer, f storage.Image) (*image.Point, error) { var ir image.Image switch f.ValidatedMethod { default: return nil, fmt.Errorf("Unsupported method: %s", f.ValidatedMethod) case storage.MethodNormal: ir = resize.Resize(uint(f.DestWidth), uint(f.DestHeight), i, resize.Lanczos3) case storage.MethodThumbnail: cr := image.Rect(0, 0, f.CanvasWidth, f.CanvasHeight) src := resize.Resize(uint(f.DestWidth), uint(f.DestHeight), i, resize.Lanczos3) dst := image.NewRGBA(cr) draw.Draw(dst, cr, src, image.Point{int((f.DestWidth - f.CanvasWidth) / 2), int((f.DestHeight - f.CanvasHeight) / 2)}, draw.Src) ir = dst } switch f.ValidatedFormat { default: return nil, fmt.Errorf("Unsupported format: %s", f.ValidatedFormat) case storage.FormatJpeg: if err := jpeg.Encode(w, ir, &jpeg.Options{int(f.ValidatedQuality)}); err != nil { return nil, err } case storage.FormatPng: e := png.Encoder{CompressionLevel: png.DefaultCompression} if err := e.Encode(w, ir); err != nil { return nil, err } case storage.FormatGif: if err := gif.Encode(w, ir, &gif.Options{NumColors: 256}); err != nil { return nil, err } } size := ir.Bounds().Size() return &size, nil }
func Render(letter string, bgColor color.Color, width int, out io.Writer) error { fg := pickForegroundColor(bgColor) rgba := image.NewRGBA(image.Rect(0, 0, width, width)) draw.Draw(rgba, rgba.Bounds(), &image.Uniform{bgColor}, image.ZP, draw.Src) fontSize := fontSizeFactor * float64(width) d := &font.Drawer{ Dst: rgba, Src: &image.Uniform{fg}, Face: truetype.NewFace(fnt, &truetype.Options{ Size: fontSize, DPI: dpi, Hinting: font.HintingNone, }), } y := int(yOffsetFactor*float64(width)) + int(math.Ceil(fontSize*dpi/72)) d.Dot = fixed.Point26_6{ X: (fixed.I(width) - d.MeasureString(letter)) / 2, Y: fixed.I(y), } d.DrawString(letter) b := bufio.NewWriter(out) encoder := png.Encoder{CompressionLevel: png.DefaultCompression} err := encoder.Encode(b, rgba) if err != nil { return err } err = b.Flush() if err != nil { return err } return nil }
func main() { const charFullWidth = 12 const charHalfWidth = 6 const charHeight = 16 files := []string{ "latin.png", "bmp-0.png", "bmp-2.png", "bmp-3.png", "bmp-4.png", "bmp-5.png", "bmp-6.png", "bmp-7.png", "bmp-8.png", "bmp-9.png", "bmp-15.png", } palette := color.Palette([]color.Color{ color.Transparent, color.Opaque, }) result := image.NewPaletted(image.Rect(0, 0, 256*charFullWidth, 256*charHeight), palette) for _, file := range files { f, err := os.Open(file) if err != nil { panic(err) } defer f.Close() img, _, err := image.Decode(f) if err != nil { panic(err) } if file == "latin.png" { for i := 0; i < 256; i++ { dx := i * charFullWidth dy := 0 dr := image.Rect(dx, dy, dx+charHalfWidth, dy+charHeight) sp := image.Point{ (i % 32) * charHalfWidth, (i / 32) * charHeight, } draw.Draw(result, dr, img, sp, draw.Src) } continue } id, err := strconv.Atoi(regexp.MustCompile(`\d+`).FindString(file)) if err != nil { panic(err) } for i := 0; i < 4096; i++ { if id == 0 && i < 256 { continue } dx := (i % 256) * charFullWidth dy := id*256 + (i/256)*charHeight dr := image.Rect(dx, dy, dx+charFullWidth, dy+charHeight) sp := image.Point{ (i % 64) * charFullWidth, (i / 64) * charHeight, } draw.Draw(result, dr, img, sp, draw.Src) } } e := png.Encoder{CompressionLevel: png.BestCompression} if err := e.Encode(os.Stdout, result); err != nil { panic(err) } }
func main() { flag.Parse() if infoFlag { fmt.Println("") fmt.Println("malPic " + VERSION) fmt.Println("\t Malware visual analysis tool") fmt.Println("\t Licensed under GPLv2 – 2015") fmt.Println("\t https://github.com/hcninja/malpic/LICENSE") fmt.Println("\t By @bitsniper") fmt.Println("") os.Exit(0) } // Flag sanity checks if inputFlag == "" || outputFlag == "" && !noPictFlag { fmt.Println("[!] Please give me an input and output, try with -h") os.Exit(1) } if colorizeFlag && !execInfoFlag { fmt.Println("[!] Colorized output needs -execinfo") os.Exit(1) } if noPictFlag && !execInfoFlag { fmt.Println("[!] Setting -execinfo flag") execInfoFlag = true } if noPictFlag && inputFlag != "" { fmt.Println("[!] Ignoring -out flag") } if symbolsDumpFlag && !execInfoFlag { fmt.Println("[!] For symbols dump the -execinfo is needed") fmt.Println("[!] Symbols will not be dumped") } // Open file file, err := ioutil.ReadFile(inputFlag) if err != nil { fmt.Printf("[!] %s\n", err) os.Exit(1) } var sectionData [][]int // Extract executable info if execInfoFlag { if err := bin.IsPE(inputFlag); err == nil { fmt.Println("[+] File is PE") sectionData, err = bin.PEAnal(inputFlag, symbolsDumpFlag) if err != nil { fmt.Println(err) os.Exit(1) } } else if err := bin.IsELF(inputFlag); err == nil { fmt.Println("[+] File is ELF") sectionData, err = bin.ELFAnal(inputFlag, symbolsDumpFlag) if err != nil { fmt.Println(err) os.Exit(1) } } else if err := bin.IsMACHO(inputFlag); err == nil { fmt.Println("[+] File is MACH-O") sectionData, err = bin.MACHOAnal(inputFlag, symbolsDumpFlag) if err != nil { fmt.Println(err) os.Exit(1) } } else { fmt.Println("[+] File is not an executable") } } var encoder png.Encoder var binImage *image.RGBA // Encode binary to colorized image or B/W if !noPictFlag { if colorizeFlag { encoder, binImage = img.EncodeColor(file, sectionData) } else { encoder, binImage = img.EncodeBW(file) } // Write image to file malPict, _ := os.Create(outputFlag) encoder.Encode(malPict, binImage) fmt.Println("[+] Picture saved as: " + outputFlag) } }
return image.Decode(fp) } saveImage := func(path string, format string, i image.Image) error { fp, err := os.Create(path) if err != nil { return err } defer fp.Close() switch format { case "jpeg": jpeg.Encode(fp, i, &jpeg.Options{jpeg.DefaultQuality}) case "png": encoder := png.Encoder{CompressionLevel: png.BestCompression} encoder.Encode(fp, i) case "gif": gif.Encode(fp, i, &gif.Options{256, nil, nil}) default: return fmt.Errorf("invalid imageFormat given") } return nil } formats := []format{ {Width: 220, Height: 480}, {Width: 500, Height: 500}, {Width: 400, Height: 200}, {Width: 50, Height: 50},
func (img *Img) Save() error { encoder := png.Encoder{png.DefaultCompression} err := encoder.Encode(img.f, img.i) img.f.Close() return err }