package armor

Import Path
	golang.org/x/crypto/openpgp/armor (on go.dev)

Dependency Relation
	imports 5 packages, and imported by one package

Involved Source Files

	   d➜ armor.go
		Package armor implements OpenPGP ASCII Armor, see RFC 4880. OpenPGP Armor is
		very similar to PEM except that it has an additional CRC checksum.

	      encode.go
Package-Level Type Names (total 5, in which 1 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Block (struct)
		A Block represents an OpenPGP armored structure.

		The encoded form is:
		   -----BEGIN Type-----
		   Headers

		   base64-encoded Bytes
		   '=' base64 encoded checksum
		   -----END Type-----
		where Headers is a possibly empty sequence of Key: Value lines.

		Since the armored data can be very large, this package presents a streaming
		interface.

		Fields (total 5, in which 3 are exported)
			Body io.Reader
				// A Reader from which the contents can be read

			Header map[string]string
				// Optional headers.

			Type string
				// The type, taken from the preamble (i.e. "PGP SIGNATURE").

			/* 2 unexporteds ... *//* 2 unexporteds: */
			lReader lineReader
			oReader openpgpReader
		As Outputs Of (at least one exported)
			func Decode(in io.Reader) (p *Block, err error)

	/* 4 unexporteds ... *//* 4 unexporteds: */
	 type encoding (struct)
		encoding keeps track of a running CRC24 over the data which has been written
		to it and outputs a OpenPGP checksum when closed, followed by an armor
		trailer.

		It's built into a stack of io.Writers:
		   encoding -> base64 encoder -> lineBreaker -> out

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			b64 io.WriteCloser
			blockType []byte
			breaker *lineBreaker
			crc uint32
			out io.Writer
		Methods (total 2, both are exported)
			(*T) Close() (err error)
			(*T) Write(data []byte) (n int, err error)
		Implements (at least 5, all are exported)
			*T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			*T : github.com/jbenet/go-context/io.Writer
			*T : io.Closer
			*T : io.WriteCloser
			*T : io.Writer

	 type lineBreaker (struct)
		lineBreaker breaks data across several lines, all of the same byte length
		(except possibly the last). Lines are broken with a single '\n'.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			haveWritten bool
			line []byte
			lineLength int
			out io.Writer
			used int
		Methods (total 2, both are exported)
			(*T) Close() (err error)
			(*T) Write(b []byte) (n int, err error)
		Implements (at least 5, all are exported)
			*T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			*T : github.com/jbenet/go-context/io.Writer
			*T : io.Closer
			*T : io.WriteCloser
			*T : io.Writer
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newLineBreaker(out io.Writer, lineLength int) *lineBreaker

	 type lineReader (struct)
		lineReader wraps a line based reader. It watches for the end of an armor
		block and records the expected CRC value.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			buf []byte
			crc uint32
			crcSet bool
			eof bool
			in *bufio.Reader
		Methods (only one, which is exported)
			(*T) Read(p []byte) (n int, err error)
		Implements (at least 2, both are exported)
			*T : github.com/jbenet/go-context/io.Reader
			*T : io.Reader

	 type openpgpReader (struct)
		openpgpReader passes Read calls to the underlying base64 decoder, but keeps
		a running CRC of the resulting data and checks the CRC against the value
		found by the lineReader at EOF.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			b64Reader io.Reader
			currentCRC uint32
			lReader *lineReader
		Methods (only one, which is exported)
			(*T) Read(p []byte) (n int, err error)
		Implements (at least 2, both are exported)
			*T : github.com/jbenet/go-context/io.Reader
			*T : io.Reader


Package-Level Functions (total 5, in which 2 are exported)

	 func Decode(in io.Reader) (p *Block, err error)
		Decode reads a PGP armored block from the given Reader. It will ignore
		leading garbage. If it doesn't find a block, it will return nil, io.EOF. The
		given Reader is not usable after calling this function: an arbitrary amount
		of data may have been read past the end of the block.

	 func Encode(out io.Writer, blockType string, headers map[string]string) (w io.WriteCloser, err error)
		Encode returns a WriteCloser which will encode the data written to it in
		OpenPGP armor.

	/* 3 unexporteds ... *//* 3 unexporteds: */
	 func crc24(crc uint32, d []byte) uint32
		crc24 calculates the OpenPGP checksum as specified in RFC 4880, section 6.1

	 func newLineBreaker(out io.Writer, lineLength int) *lineBreaker
	 func writeSlices(out io.Writer, slices ...[]byte) (err error)
		writeSlices writes its arguments to the given Writer.


Package-Level Variables (total 8, in which 1 are exported)

	  var ArmorCorrupt error
	/* 7 unexporteds ... *//* 7 unexporteds: */
	  var armorEnd []byte
	  var armorEndOfLine []byte
	  var armorEndOfLineOut []byte
	  var armorHeaderSep []byte
	  var armorStart []byte
	  var blockEnd []byte
	  var newline []byte
Package-Level Constants (total 3, none are exported)

	/* 3 unexporteds ... *//* 3 unexporteds: */
	const crc24Init = 11994318
	const crc24Mask = 16777215
	const crc24Poly = 25578747

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.