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()

}