Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// 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.
package pem

import (
        "bytes"
        "encoding/base64"
        "io"
)

// 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.
type Block struct {
        Type    string            // The type, taken from the preamble (i.e. "RSA PRIVATE KEY").
        Headers map[string]string // Optional headers.
        Bytes   []byte            // The decoded bytes of the contents. Typically a DER encoded ASN.1 structure.
}

// getLine results the first \r\n or \n delineated line from the given byte
// array. The line does not include the \r\n or \n. 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 getLine(data []byte) (line, rest []byte) {
        i := bytes.Index(data, []byte{'\n'})
        var j int
        if i < 0 {
                i = len(data)
                j = i
        } else {
                j = i + 1
                if i > 0 && data[i-1] == '\r' {
                        i--
                }
        }
        return data[0:i], data[j:]
}

// removeWhitespace returns a copy of its input with all spaces, tab and
// newline characters removed.
func removeWhitespace(data []byte) []byte {
        result := make([]byte, len(data))
        n := 0

        for _, b := range data {
                if b == ' ' || b == '\t' || b == '\r' || b == '\n' {
                        continue
                }
                result[n] = b
                n++
        }

        return result[0:n]
}

var pemStart = []byte("\n-----BEGIN ")
var pemEnd = []byte("\n-----END ")
var pemEndOfLine = []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 Decode(data []byte) (p *Block, rest []byte) {
        // pemStart begins with a newline. However, at the very beginning of
        // the byte array, we'll accept the start string without it.
        rest = data
        if bytes.HasPrefix(data, pemStart[1:]) {
                rest = rest[len(pemStart)-1 : len(data)]
        } else if i := bytes.Index(data, pemStart); i >= 0 {
                rest = rest[i+len(pemStart) : len(data)]
        } else {
                return nil, data
        }

        typeLine, rest := getLine(rest)
        if !bytes.HasSuffix(typeLine, pemEndOfLine) {
                return decodeError(data, rest)
        }
        typeLine = typeLine[0 : len(typeLine)-len(pemEndOfLine)]

        p = &Block{
                Headers: make(map[string]string),
                Type:    string(typeLine),
        }

        for {
                // This loop terminates because getLine's second result is
                // always smaller than its argument.
                if len(rest) == 0 {
                        return nil, data
                }
                line, next := getLine(rest)

                i := bytes.Index(line, []byte{':'})
                if i == -1 {
                        break
                }

                // TODO(agl): need to cope with values that spread across lines.
                key, val := line[0:i], line[i+1:]
                key = bytes.TrimSpace(key)
                val = bytes.TrimSpace(val)
                p.Headers[string(key)] = string(val)
                rest = next
        }

        i := bytes.Index(rest, pemEnd)
        if i < 0 {
                return decodeError(data, rest)
        }
        base64Data := removeWhitespace(rest[0:i])

        p.Bytes = make([]byte, base64.StdEncoding.DecodedLen(len(base64Data)))
        n, err := base64.StdEncoding.Decode(p.Bytes, base64Data)
        if err != nil {
                return decodeError(data, rest)
        }
        p.Bytes = p.Bytes[0:n]

        _, rest = getLine(rest[i+len(pemEnd):])

        return
}

func decodeError(data, rest []byte) (*Block, []byte) {
        // If we get here then we have rejected a likely looking, but
        // ultimately invalid PEM block. We need to start over from a new
        // position.  We have consumed the preamble line and will have consumed
        // any lines which could be header lines. However, a valid preamble
        // line is not a valid header line, therefore we cannot have consumed
        // the preamble line for the any subsequent block. Thus, we will always
        // find any valid block, no matter what bytes precede it.
        //
        // For example, if the input is
        //
        //    -----BEGIN MALFORMED BLOCK-----
        //    junk that may look like header lines
        //   or data lines, but no END line
        //
        //    -----BEGIN ACTUAL BLOCK-----
        //    realdata
        //    -----END ACTUAL BLOCK-----
        //
        // we've failed to parse using the first BEGIN line
        // and now will try again, using the second BEGIN line.
        p, rest := Decode(rest)
        if p == nil {
                rest = data
        }
        return p, rest
}

const pemLineLength = 64

type lineBreaker struct {
        line [pemLineLength]byte
        used int
        out  io.Writer
}

func (l *lineBreaker) Write(b []byte) (n int, err error) {
        if l.used+len(b) < pemLineLength {
                copy(l.line[l.used:], b)
                l.used += len(b)
                return len(b), nil
        }

        n, err = l.out.Write(l.line[0:l.used])
        if err != nil {
                return
        }
        excess := pemLineLength - l.used
        l.used = 0

        n, err = l.out.Write(b[0:excess])
        if err != nil {
                return
        }

        n, err = l.out.Write([]byte{'\n'})
        if err != nil {
                return
        }

        return l.Write(b[excess:])
}

func (l *lineBreaker) Close() (err error) {
        if l.used > 0 {
                _, err = l.out.Write(l.line[0:l.used])
                if err != nil {
                        return
                }
                _, err = l.out.Write([]byte{'\n'})
        }

        return
}

func Encode(out io.Writer, b *Block) (err error) {
        _, err = out.Write(pemStart[1:])
        if err != nil {
                return
        }
        _, err = out.Write([]byte(b.Type + "-----\n"))
        if err != nil {
                return
        }

        if len(b.Headers) > 0 {
                for k, v := range b.Headers {
                        _, err = out.Write([]byte(k + ": " + v + "\n"))
                        if err != nil {
                                return
                        }
                }
                _, err = out.Write([]byte{'\n'})
                if err != nil {
                        return
                }
        }

        var breaker lineBreaker
        breaker.out = out

        b64 := base64.NewEncoder(base64.StdEncoding, &breaker)
        _, err = b64.Write(b.Bytes)
        if err != nil {
                return
        }
        b64.Close()
        breaker.Close()

        _, err = out.Write(pemEnd[1:])
        if err != nil {
                return
        }
        _, err = out.Write([]byte(b.Type + "-----\n"))
        return
}

func EncodeToMemory(b *Block) []byte {
        var buf bytes.Buffer
        Encode(&buf, b)
        return buf.Bytes()
}