redact

type RedactableBytes ¶

type RedactableBytes []byte

RedactableBytes is like RedactableString but is a byte slice.

Instances of RedactableBytes should not be constructed directly; instead use the facilities from print.go (Sprint, Sprintf) or the methods below.

func EscapeBytes(s []byte) RedactableBytes

func (s RedactableBytes) Redact() RedactableBytes

func (s RedactableBytes) SafeFormat(sp SafePrinter, _ rune)

func (s RedactableBytes) StripMarkers() []byte

func (s RedactableBytes) ToString() RedactableString

type RedactableString ¶

type RedactableString string

RedactableString is a string that contains a mix of safe and unsafe bits of data, but where it is known that unsafe bits are enclosed by redaction markers ‹ and ›, and occurrences of the markers inside the original data items have been escaped.

Instances of RedactableString should not be constructed directly; instead use the facilities from print.go (Sprint, Sprintf) or the methods below.

func HelperForErrorf(format string, args ...interface{}) (RedactableString, error)

func Sprint(args ...interface{}) RedactableString

func Sprintf(format string, args ...interface{}) RedactableString

func Sprintfn(printer func(w SafePrinter)) RedactableString

func (s RedactableString) Redact() RedactableString

func (s RedactableString) SafeFormat(sp SafePrinter, _ rune)

func (s RedactableString) StripMarkers() string

func (s RedactableString) ToBytes() RedactableBytes

type SafeFormatter ¶

type SafeFormatter interface {
	// SafeFormat is like the Format method of fmt.Formatter, except
	// that it operates using a SafePrinter instead of a fmt.State for
	// output.
	//
	// The verb argument is the control character that defines
	// the formatting mode in the surrounding Printf call.
	// For example, if this method is called to format %03d,
	// the verb is 'd'.
	SafeFormat(s SafePrinter, verb rune)
}

SafeFormatter is implemented by object types that want to separate safe and non-safe information when printed out by a Printf-like formatter.

type SafeMessager ¶

type SafeMessager interface {
	SafeMessage() string
}

SafeMessager is an alternative to SafeFormatter used in previous versions of CockroachDB. NB: this interface is obsolete. Use SafeFormatter instead. TODO(knz): Remove this.

type SafePrinter ¶

type SafePrinter interface {
	// SafePrinter inherits fmt.State to access format flags, however
	// calls to fmt.State's underlying Write() as unsafe.
	fmt.State

	// SafePrinter provides the SafeWriter interface.
	SafeWriter
}

SafePrinter is a stateful helper that abstracts an output stream in the context of printf-like formatting, but with the ability to separate safe and unsafe bits of data.

This package provides one implementation of this using marker delimiters for unsafe data, see markers.go. We would like to aim for alternate implementations to generate more structured formats.

type SafeRune ¶

type SafeRune rune

SafeRune aliases rune. See the explanation for SafeString.

func (SafeRune) SafeValue()

type SafeString ¶

type SafeString string

SafeString aliases string. This is not meant to be used directly; the type definition ensures that SafePrinter's SafeString method can only take constant string literals as arguments. Typically, a Go linter would ensure that ConstantString is never used to cast a value.

func (SafeString) SafeValue()

type SafeValue ¶

type SafeValue interface {
	SafeValue()
}

SafeValue is a marker interface to be implemented by types that alias base Go types and whose natural representation via Printf is always safe for reporting.

This is recognized by the SafePrinter interface as an alternative to SafeFormatter.

It is provided to decorate "leaf" Go types, such as aliases to int.

Typically, a linter enforces that a type can only implement this interface if it aliases a base go type. More complex types should implement SafeFormatter instead.

It is advised to build an automatic process during builds to collect all the types that implement this interface, as well as all uses of this type, and produce a report. Changes to this report should receive maximal amount of scrutiny during code reviews.

func Safe(a interface{}) SafeValue

type SafeWriter ¶

type SafeWriter interface {
	// SafeString emits a safe string.
	SafeString(SafeString)

	// SafeRune emits a safe rune.
	SafeRune(SafeRune)

	// Print emits its arguments separated by spaces.
	// For each argument it dynamically checks for the SafeFormatter or
	// SafeValue interface and either use that, or mark the argument
	// payload as unsafe.
	Print(args ...interface{})

	// For printf, a linter checks that the format string is
	// a constant literal, so the implementation can assume it's always
	// safe.
	Printf(format string, arg ...interface{})

	// UnsafeString writes an unsafe string.
	UnsafeString(string)

	// UnsafeByte writes an unsafe byte.
	UnsafeByte(byte)

	// UnsafeBytes writes an unsafe byte slice.
	UnsafeBytes([]byte)

	// UnsafeRune writes an unsafe rune.
	UnsafeRune(rune)
}

SafeWriter provides helper functions for use in implementations of SafeFormatter, to format mixes of safe and unsafe strings.

type StringBuilder ¶ added in v1.0.3

type StringBuilder struct {
	// contains filtered or unexported fields
}

StringBuilder accumulates strings with optional redaction markers.

It implements io.Writer but marks direct writes as redactable. To distinguish safe and unsafe bits, it also implements the SafeWriter interface.

func (b *StringBuilder) Cap() int

func (b *StringBuilder) Len() int

func (b *StringBuilder) Print(args ...interface{})

func (b *StringBuilder) Printf(format string, args ...interface{})

func (b *StringBuilder) RedactableBytes() RedactableBytes

func (b *StringBuilder) RedactableString() RedactableString

func (b *StringBuilder) Reset()

func (b *StringBuilder) SafeFormat(p SafePrinter, _ rune)

func (b *StringBuilder) SafeRune(s SafeRune)

func (b *StringBuilder) SafeString(s SafeString)

func (b *StringBuilder) String() string

func (b *StringBuilder) UnsafeByte(s byte)

func (b *StringBuilder) UnsafeBytes(s []byte)

func (b *StringBuilder) UnsafeRune(s rune)

func (b *StringBuilder) UnsafeString(s string)

func (b *StringBuilder) Write(s []byte) (int, error)