package pem

Import Path
	encoding/pem (on go.dev)

Dependency Relation
	imports 6 packages, and imported by 2 packages

Involved Source Files

	   #d pem.go
		Package pem implements the PEM data encoding, which originated in Privacy
		Enhanced Mail. The most common use of PEM encoding today is in TLS keys and
		certificates. See RFC 1421.
Code Examples

	Decode
		package main
		
		import (
			"crypto/x509"
			"encoding/pem"
			"fmt"
			"log"
		)
		
		func main() {
			var pubPEMData = []byte(`
		-----BEGIN PUBLIC KEY-----
		MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAlRuRnThUjU8/prwYxbty
		WPT9pURI3lbsKMiB6Fn/VHOKE13p4D8xgOCADpdRagdT6n4etr9atzDKUSvpMtR3
		CP5noNc97WiNCggBjVWhs7szEe8ugyqF23XwpHQ6uV1LKH50m92MbOWfCtjU9p/x
		qhNpQQ1AZhqNy5Gevap5k8XzRmjSldNAFZMY7Yv3Gi+nyCwGwpVtBUwhuLzgNFK/
		yDtw2WcWmUU7NuC8Q6MWvPebxVtCfVp/iQU6q60yyt6aGOBkhAX0LpKAEhKidixY
		nP9PNVBvxgu3XZ4P36gZV6+ummKdBVnc3NqwBLu5+CcdRdusmHPHd5pHf4/38Z3/
		6qU2a/fPvWzceVTEgZ47QjFMTCTmCwNt29cvi7zZeQzjtwQgn4ipN9NibRH/Ax/q
		TbIzHfrJ1xa2RteWSdFjwtxi9C20HUkjXSeI4YlzQMH0fPX6KCE7aVePTOnB69I/
		a9/q96DiXZajwlpq3wFctrs1oXqBp5DVrCIj8hU2wNgB7LtQ1mCtsYz//heai0K9
		PhE4X6hiE0YmeAZjR0uHl8M/5aW9xCoJ72+12kKpWAa0SFRWLy6FejNYCYpkupVJ
		yecLk/4L1W0l6jQQZnWErXZYe0PNFcmwGXy1Rep83kfBRNKRy5tvocalLlwXLdUk
		AIU+2GKjyT3iMuzZxxFxPFMCAwEAAQ==
		-----END PUBLIC KEY-----
		and some more`)
		
			block, rest := pem.Decode(pubPEMData)
			if block == nil || block.Type != "PUBLIC KEY" {
				log.Fatal("failed to decode PEM block containing public key")
			}
		
			pub, err := x509.ParsePKIXPublicKey(block.Bytes)
			if err != nil {
				log.Fatal(err)
			}
		
			fmt.Printf("Got a %T, with remaining data: %q", pub, rest)
		}

	Encode
		package main
		
		import (
			"encoding/pem"
			"log"
			"os"
		)
		
		func main() {
			block := &pem.Block{
				Type: "MESSAGE",
				Headers: map[string]string{
					"Animal": "Gopher",
				},
				Bytes: []byte("test"),
			}
		
			if err := pem.Encode(os.Stdout, block); err != nil {
				log.Fatal(err)
			}
		}


Package-Level Type Names (total 2, in which 1 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Block (struct)
		A Block represents a PEM encoded structure.

		The encoded form is:
		   -----BEGIN Type-----
		   Headers
		   base64-encoded Bytes
		   -----END Type-----
		where Headers is a possibly empty sequence of Key: Value lines.

		Fields (total 3, all are exported)
			Bytes []byte
				// The decoded bytes of the contents. Typically a DER encoded ASN.1 structure.

			Headers map[string]string
				// Optional headers.

			Type string
				// The type, taken from the preamble (i.e. "RSA PRIVATE KEY").

		As Outputs Of (at least 3, in which 2 are exported)
			func Decode(data []byte) (p *Block, rest []byte)
			func crypto/x509.EncryptPEMBlock(rand io.Reader, blockType string, data, password []byte, alg x509.PEMCipher) (*Block, error)
			/* at least one unexported ... *//* at least one unexported: */
			func decodeError(data, rest []byte) (*Block, []byte)
		As Inputs Of (at least 4, all are exported)
			func Encode(out io.Writer, b *Block) error
			func EncodeToMemory(b *Block) []byte
			func crypto/x509.DecryptPEMBlock(b *Block, password []byte) ([]byte, error)
			func crypto/x509.IsEncryptedPEMBlock(b *Block) bool

	/* one unexported ... *//* one unexported: */
	 type lineBreaker (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			line [64]byte
			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 3, all are exported)
			*T : io.Closer
			*T : io.WriteCloser
			*T : io.Writer


Package-Level Functions (total 7, in which 3 are exported)

	 func Decode(data []byte) (p *Block, rest []byte)
		Decode will find the next PEM formatted block (certificate, private key
		etc) in the input. It returns that block and the remainder of the input. If
		no PEM data is found, p is nil and the whole of the input is returned in
		rest.

	 func Encode(out io.Writer, b *Block) error
		Encode writes the PEM encoding of b to out.

	 func EncodeToMemory(b *Block) []byte
		EncodeToMemory returns the PEM encoding of b.

		If b has invalid headers and cannot be encoded,
		EncodeToMemory returns nil. If it is important to
		report details about this error case, use Encode instead.

	/* 4 unexporteds ... *//* 4 unexporteds: */
	 func decodeError(data, rest []byte) (*Block, []byte)
	 func getLine(data []byte) (line, rest []byte)
		getLine results the first \r\n or \n delineated line from the given byte
		array. The line does not include trailing whitespace or the trailing new
		line bytes. The remainder of the byte array (also not including the new line
		bytes) is also returned and this will always be smaller than the original
		argument.

	 func removeSpacesAndTabs(data []byte) []byte
		removeSpacesAndTabs returns a copy of its input with all spaces and tabs
		removed, if there were any. Otherwise, the input is returned unchanged.

		The base64 decoder already skips newline characters, so we don't need to
		filter them out here.

	 func writeHeader(out io.Writer, k, v string) error
Package-Level Variables (total 4, none are exported)

	/* 4 unexporteds ... *//* 4 unexporteds: */
	  var nl []byte
	  var pemEnd []byte
	  var pemEndOfLine []byte
	  var pemStart []byte
Package-Level Constants (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	const pemLineLength = 64

The pages are generated with Golds v0.4.2. (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.