script/strip-png-ancillary-chunks.go - external/github.com/google/wuffs - Git at Google

 // Copyright 2021 The Wuffs Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 //go:build ignore
 // +build ignore

 package main

 // strip-png-ancillary-chunks.go copies PNG data from stdin to stdout, removing
 // any ancillary chunks.
 //
 // Specification-compliant PNG decoders are required to honor critical chunks
 // but may ignore ancillary (non-critical) chunks. Stripping out ancillary
 // chunks before decoding should mean that different PNG decoders will agree on
 // the decoded output regardless of which ancillary chunk types they choose to
 // honor. Specifically, some PNG decoders may implement color and gamma
 // correction but not all do.
 //
 // This program will strip out all ancillary chunks, but it should be
 // straightforward to copy-paste-and-modify it to strip out only certain chunk
 // types (e.g. only "tRNS" transparency chunks).
 //
 // --------
 //
 // A PNG file consists of an 8-byte magic identifier and then a series of
 // chunks. Each chunk is:
 //
 //  - a 4-byte uint32 payload length N.
 //  - a 4-byte chunk type (e.g. "gAMA" for gamma correction metadata).
 //  - an N-byte payload.
 //  - a 4-byte CRC-32 checksum of the previous (N + 4) bytes, including the
 //    chunk type but excluding the payload length.
 //
 // Chunk types consist of 4 ASCII letters. The upper-case / lower-case bit of
 // the first letter denote critical or ancillary chunks: "IDAT" and "PLTE" are
 // critical, "gAMA" and "tEXt" are ancillary. See
 // https://www.w3.org/TR/2003/REC-PNG-20031110/#5Chunk-naming-conventions
 //
 // --------
 //
 // Usage:
 //  go run strip-png-ancillary-chunks.go             < in.png > out.png
 //
 // Adding a -random=123 flag should not change the output:
 //  go run strip-png-ancillary-chunks.go -random=123 < in.png > out.png

 import (
 	"encoding/binary"
 	"flag"
 	"io"
 	"math/rand"
 	"os"
 	"os/signal"
 	"syscall"
 )

 var (
 	randomFlag = flag.Int64("random", 0, "If non-zero, the seed for generating smaller reads")
 )

 // chunkTypeAncillaryBit is whether the first byte of a big-endian uint32 chunk
 // type (the first of four ASCII letters) is lower-case.
 const chunkTypeAncillaryBit = 0x20000000

 // RandomSizedReader wraps another io.Reader such that the Reader.Read []byte
 // argument has randomized lengths, up to a maximum of 9 bytes.
 //
 // This is slower but helps manually test that PNGAncillaryChunkStripper
 // produces identical output regardless of whether Read is called many times
 // (with small buffers) or few times (with large buffers). Specifically, this
 // exercises having Read boundaries straddle chunk boundaries.
 type RandomSizedReader struct {
 	// Reader is the wrapped io.Reader.
 	Reader io.Reader

 	// Rand is the random number generator.
 	Rand *rand.Rand
 }

 // Read implements io.Reader.
 func (r *RandomSizedReader) Read(p []byte) (int, error) {
 	if n := r.Rand.Intn(10); len(p) > n {
 		p = p[:n]
 	}
 	return r.Reader.Read(p)
 }

 // PNGAncillaryChunkStripper wraps another io.Reader to strip ancillary chunks,
 // if the data is in the PNG file format. If the data isn't PNG, it is passed
 // through unmodified.
 type PNGAncillaryChunkStripper struct {
 	// Reader is the wrapped io.Reader.
 	Reader io.Reader

 	// stickyErr is the first error returned from the wrapped io.Reader.
 	stickyErr error

 	// buffer[rIndex:wIndex] holds data read from the wrapped io.Reader that
 	// wasn't passed through yet.
 	buffer [8]byte
 	rIndex int
 	wIndex int

 	// pending and discard is the number of remaining bytes for (and whether to
 	// discard or pass through) the current chunk-in-progress.
 	pending int64
 	discard bool

 	// notPNG is set true if the data stream doesn't start with the 8-byte PNG
 	// magic identifier. If true, the wrapped io.Reader's data (including the
 	// first up-to-8 bytes) is passed through without modification.
 	notPNG bool

 	// seenMagic is whether we've seen the 8-byte PNG magic identifier.
 	seenMagic bool
 }

 // Read implements io.Reader.
 func (r *PNGAncillaryChunkStripper) Read(p []byte) (int, error) {
 	for {
 		// If the wrapped io.Reader returned a non-nil error, drain r.buffer
 		// (what data we have) and return that error (if fully drained).
 		if r.stickyErr != nil {
 			n := copy(p, r.buffer[r.rIndex:r.wIndex])
 			r.rIndex += n
 			if r.rIndex < r.wIndex {
 				return n, nil
 			}
 			return n, r.stickyErr
 		}

 		// Handle trivial requests, including draining our buffer.
 		if len(p) == 0 {
 			return 0, nil
 		} else if r.rIndex < r.wIndex {
 			n := copy(p, r.buffer[r.rIndex:r.wIndex])
 			r.rIndex += n
 			return n, nil
 		}

 		// From here onwards, our buffer is drained: r.rIndex == r.wIndex.

 		// Handle non-PNG input.
 		if r.notPNG {
 			return r.Reader.Read(p)
 		}

 		// Continue processing any PNG chunk that's in progress, whether
 		// discarding it or passing it through.
 		for r.pending > 0 {
 			if int64(len(p)) > r.pending {
 				p = p[:r.pending]
 			}
 			n, err := r.Reader.Read(p)
 			r.pending -= int64(n)
 			r.stickyErr = err
 			if r.discard {
 				continue
 			}
 			return n, err
 		}

 		// We're either expecting the 8-byte PNG magic identifier or the 4-byte
 		// PNG chunk length + 4-byte PNG chunk type. Either way, read 8 bytes.
 		r.rIndex = 0
 		r.wIndex, r.stickyErr = io.ReadFull(r.Reader, r.buffer[:8])
 		if r.stickyErr != nil {
 			// Undo io.ReadFull converting io.EOF to io.ErrUnexpectedEOF.
 			if r.stickyErr == io.ErrUnexpectedEOF {
 				r.stickyErr = io.EOF
 			}
 			continue
 		}

 		// Process those 8 bytes, either:
 		//  - a PNG chunk (if we've already seen the PNG magic identifier),
 		//  - the PNG magic identifier itself (if the input is a PNG) or
 		//  - something else (if it's not a PNG).
 		if r.seenMagic {
 			// The number of pending bytes is equal to (N + 4) because of the 4
 			// byte trailer, a checksum.
 			r.pending = int64(binary.BigEndian.Uint32(r.buffer[:4])) + 4
 			chunkType := binary.BigEndian.Uint32(r.buffer[4:])
 			r.discard = (chunkType & chunkTypeAncillaryBit) != 0
 			if r.discard {
 				r.rIndex = r.wIndex
 			}
 		} else if string(r.buffer[:8]) == "\x89PNG\x0D\x0A\x1A\x0A" {
 			r.seenMagic = true
 		} else {
 			r.notPNG = true
 		}
 	}
 }

 func main() {
 	// Piping to /usr/bin/head can cause SIGPIPE (in the upstream process)
 	// since head can exit early, leaving this process with pending output. The
 	// command line experience can be cleaner if this program ignores SIGPIPE.
 	signal.Ignore(syscall.SIGPIPE)

 	flag.Parse()

 	r := io.Reader(&PNGAncillaryChunkStripper{
 		Reader: os.Stdin,
 	})

 	if *randomFlag != 0 {
 		r = &RandomSizedReader{
 			Reader: r,
 			Rand:   rand.New(rand.NewSource(*randomFlag)),
 		}
 	}

 	io.Copy(os.Stdout, r)
 }
	// Copyright 2021 The Wuffs Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	//go:build ignore
	// +build ignore

	package main

	// strip-png-ancillary-chunks.go copies PNG data from stdin to stdout, removing
	// any ancillary chunks.
	//
	// Specification-compliant PNG decoders are required to honor critical chunks
	// but may ignore ancillary (non-critical) chunks. Stripping out ancillary
	// chunks before decoding should mean that different PNG decoders will agree on
	// the decoded output regardless of which ancillary chunk types they choose to
	// honor. Specifically, some PNG decoders may implement color and gamma
	// correction but not all do.
	//
	// This program will strip out all ancillary chunks, but it should be
	// straightforward to copy-paste-and-modify it to strip out only certain chunk
	// types (e.g. only "tRNS" transparency chunks).
	//
	// --------
	//
	// A PNG file consists of an 8-byte magic identifier and then a series of
	// chunks. Each chunk is:
	//
	// - a 4-byte uint32 payload length N.
	// - a 4-byte chunk type (e.g. "gAMA" for gamma correction metadata).
	// - an N-byte payload.
	// - a 4-byte CRC-32 checksum of the previous (N + 4) bytes, including the
	// chunk type but excluding the payload length.
	//
	// Chunk types consist of 4 ASCII letters. The upper-case / lower-case bit of
	// the first letter denote critical or ancillary chunks: "IDAT" and "PLTE" are
	// critical, "gAMA" and "tEXt" are ancillary. See
	// https://www.w3.org/TR/2003/REC-PNG-20031110/#5Chunk-naming-conventions
	//
	// --------
	//
	// Usage:
	// go run strip-png-ancillary-chunks.go < in.png > out.png
	//
	// Adding a -random=123 flag should not change the output:
	// go run strip-png-ancillary-chunks.go -random=123 < in.png > out.png

	import (
	"encoding/binary"
	"flag"
	"io"
	"math/rand"
	"os"
	"os/signal"
	"syscall"
	)

	var (
	randomFlag = flag.Int64("random", 0, "If non-zero, the seed for generating smaller reads")
	)

	// chunkTypeAncillaryBit is whether the first byte of a big-endian uint32 chunk
	// type (the first of four ASCII letters) is lower-case.
	const chunkTypeAncillaryBit = 0x20000000

	// RandomSizedReader wraps another io.Reader such that the Reader.Read []byte
	// argument has randomized lengths, up to a maximum of 9 bytes.
	//
	// This is slower but helps manually test that PNGAncillaryChunkStripper
	// produces identical output regardless of whether Read is called many times
	// (with small buffers) or few times (with large buffers). Specifically, this
	// exercises having Read boundaries straddle chunk boundaries.
	type RandomSizedReader struct {
	// Reader is the wrapped io.Reader.
	Reader io.Reader

	// Rand is the random number generator.
	Rand *rand.Rand
	}

	// Read implements io.Reader.
	func (r *RandomSizedReader) Read(p []byte) (int, error) {
	if n := r.Rand.Intn(10); len(p) > n {
	p = p[:n]
	}
	return r.Reader.Read(p)
	}

	// PNGAncillaryChunkStripper wraps another io.Reader to strip ancillary chunks,
	// if the data is in the PNG file format. If the data isn't PNG, it is passed
	// through unmodified.
	type PNGAncillaryChunkStripper struct {
	// Reader is the wrapped io.Reader.
	Reader io.Reader

	// stickyErr is the first error returned from the wrapped io.Reader.
	stickyErr error

	// buffer[rIndex:wIndex] holds data read from the wrapped io.Reader that
	// wasn't passed through yet.
	buffer [8]byte
	rIndex int
	wIndex int

	// pending and discard is the number of remaining bytes for (and whether to
	// discard or pass through) the current chunk-in-progress.
	pending int64
	discard bool

	// notPNG is set true if the data stream doesn't start with the 8-byte PNG
	// magic identifier. If true, the wrapped io.Reader's data (including the
	// first up-to-8 bytes) is passed through without modification.
	notPNG bool

	// seenMagic is whether we've seen the 8-byte PNG magic identifier.
	seenMagic bool
	}

	// Read implements io.Reader.
	func (r *PNGAncillaryChunkStripper) Read(p []byte) (int, error) {
	for {
	// If the wrapped io.Reader returned a non-nil error, drain r.buffer
	// (what data we have) and return that error (if fully drained).
	if r.stickyErr != nil {
	n := copy(p, r.buffer[r.rIndex:r.wIndex])
	r.rIndex += n
	if r.rIndex < r.wIndex {
	return n, nil
	}
	return n, r.stickyErr
	}

	// Handle trivial requests, including draining our buffer.
	if len(p) == 0 {
	return 0, nil
	} else if r.rIndex < r.wIndex {
	n := copy(p, r.buffer[r.rIndex:r.wIndex])
	r.rIndex += n
	return n, nil
	}

	// From here onwards, our buffer is drained: r.rIndex == r.wIndex.

	// Handle non-PNG input.
	if r.notPNG {
	return r.Reader.Read(p)
	}

	// Continue processing any PNG chunk that's in progress, whether
	// discarding it or passing it through.
	for r.pending > 0 {
	if int64(len(p)) > r.pending {
	p = p[:r.pending]
	}
	n, err := r.Reader.Read(p)
	r.pending -= int64(n)
	r.stickyErr = err
	if r.discard {
	continue
	}
	return n, err
	}

	// We're either expecting the 8-byte PNG magic identifier or the 4-byte
	// PNG chunk length + 4-byte PNG chunk type. Either way, read 8 bytes.
	r.rIndex = 0
	r.wIndex, r.stickyErr = io.ReadFull(r.Reader, r.buffer[:8])
	if r.stickyErr != nil {
	// Undo io.ReadFull converting io.EOF to io.ErrUnexpectedEOF.
	if r.stickyErr == io.ErrUnexpectedEOF {
	r.stickyErr = io.EOF
	}
	continue
	}

	// Process those 8 bytes, either:
	// - a PNG chunk (if we've already seen the PNG magic identifier),
	// - the PNG magic identifier itself (if the input is a PNG) or
	// - something else (if it's not a PNG).
	if r.seenMagic {
	// The number of pending bytes is equal to (N + 4) because of the 4
	// byte trailer, a checksum.
	r.pending = int64(binary.BigEndian.Uint32(r.buffer[:4])) + 4
	chunkType := binary.BigEndian.Uint32(r.buffer[4:])
	r.discard = (chunkType & chunkTypeAncillaryBit) != 0
	if r.discard {
	r.rIndex = r.wIndex
	}
	} else if string(r.buffer[:8]) == "\x89PNG\x0D\x0A\x1A\x0A" {
	r.seenMagic = true
	} else {
	r.notPNG = true
	}
	}
	}

	func main() {
	// Piping to /usr/bin/head can cause SIGPIPE (in the upstream process)
	// since head can exit early, leaving this process with pending output. The
	// command line experience can be cleaner if this program ignores SIGPIPE.
	signal.Ignore(syscall.SIGPIPE)

	flag.Parse()

	r := io.Reader(&PNGAncillaryChunkStripper{
	Reader: os.Stdin,
	})

	if *randomFlag != 0 {
	r = &RandomSizedReader{
	Reader: r,
	Rand: rand.New(rand.NewSource(*randomFlag)),
	}
	}

	io.Copy(os.Stdout, r)
	}