code review 14540051: go.crypto/ssh: Add certificate verification, step up su...

ssh/certs.go

 // Copyright 2012 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 ssh
 
 import (
         "time"
 )
 
@@ skipping 34 matching lines @@
         KeyId                   string
         ValidPrincipals         []string
         ValidAfter, ValidBefore time.Time
         CriticalOptions         []tuple
         Extensions              []tuple
         Reserved                []byte
         SignatureKey            PublicKey
         Signature               *signature
 }
 
-// validateOpenSSHCertV01Signature uses the cert's SignatureKey to verify that the
-// cert's Signature.Blob is the result of signing the cert bytes starting from
-// the algorithm string and going up to and including the SignatureKey.
+// validateOpenSSHCertV01Signature uses the cert's SignatureKey to verify that
+// the cert's Signature.Blob is the result of signing the cert bytes starting
+// from the algorithm string and going up to and including the SignatureKey.
 func validateOpenSSHCertV01Signature(cert *OpenSSHCertV01) bool {
         return cert.SignatureKey.Verify(cert.BytesForSigning(), cert.Signature.Blob)
 }
 
 var certAlgoNames = map[string]string{
         KeyAlgoRSA:      CertAlgoRSAv01,
         KeyAlgoDSA:      CertAlgoDSAv01,
         KeyAlgoECDSA256: CertAlgoECDSA256v01,
         KeyAlgoECDSA384: CertAlgoECDSA384v01,
         KeyAlgoECDSA521: CertAlgoECDSA521v01,
 }
 
 // certToPrivAlgo returns the underlying algorithm for a certificate algorithm.
 // Panics if a non-certificate algorithm is passed.
 func certToPrivAlgo(algo string) string {
         for privAlgo, pubAlgo := range certAlgoNames {
                 if pubAlgo == algo {
                         return privAlgo
                 }
         }
         panic("unknown cert algorithm")
 }
 
-func (cert *OpenSSHCertV01) BytesForSigning() []byte {
+func (cert *OpenSSHCertV01) marshal(includeAlgo, includeSig bool) []byte {
         algoName := cert.PublicKeyAlgo()
         pubKey := cert.Key.Marshal()
         sigKey := MarshalPublicKey(cert.SignatureKey)
 
-        length := stringLength(len(algoName))
+        var length int
+        if includeAlgo {
+                length += stringLength(len(algoName))
+        }
         length += stringLength(len(cert.Nonce))
         length += len(pubKey)
         length += 8 // Length of Serial
         length += 4 // Length of Type
         length += stringLength(len(cert.KeyId))
         length += lengthPrefixedNameListLength(cert.ValidPrincipals)
         length += 8 // Length of ValidAfter
         length += 8 // Length of ValidBefore
         length += tupleListLength(cert.CriticalOptions)
         length += tupleListLength(cert.Extensions)
         length += stringLength(len(cert.Reserved))
         length += stringLength(len(sigKey))
+        if includeSig {
+                length += signatureLength(cert.Signature)
+        }
 
         ret := make([]byte, length)
-        r := marshalString(ret, []byte(algoName))
+        r := ret
+        if includeAlgo {
+                r = marshalString(r, []byte(algoName))
+        }
         r = marshalString(r, cert.Nonce)
         copy(r, pubKey)
         r = r[len(pubKey):]
         r = marshalUint64(r, cert.Serial)
         r = marshalUint32(r, cert.Type)
         r = marshalString(r, []byte(cert.KeyId))
         r = marshalLengthPrefixedNameList(r, cert.ValidPrincipals)
         r = marshalUint64(r, uint64(cert.ValidAfter.Unix()))
         r = marshalUint64(r, uint64(cert.ValidBefore.Unix()))
         r = marshalTupleList(r, cert.CriticalOptions)
         r = marshalTupleList(r, cert.Extensions)
         r = marshalString(r, cert.Reserved)
         r = marshalString(r, sigKey)
+        if includeSig {
+                r = marshalSignature(r, cert.Signature)
+        }
         if len(r) > 0 {
                 panic("ssh: internal error, marshaling certificate did not fill the entire buffer")
         }
         return ret
+}
+
+func (cert *OpenSSHCertV01) BytesForSigning() []byte {
+        return cert.marshal(true, false)
+}
+
+func (cert *OpenSSHCertV01) Marshal() []byte {
+        return cert.marshal(false, true)
 }
 
 func (c *OpenSSHCertV01) PublicKeyAlgo() string {
         algo, ok := certAlgoNames[c.Key.PublicKeyAlgo()]
         if !ok {
                 panic("unknown cert key type")
         }
         return algo
 }
 
@@ skipping 73 matching lines @@
         if cert.SignatureKey, _, ok = ParsePublicKey(sigKey); !ok {
                 return
         }
 
         if cert.Signature, in, ok = parseSignature(in); !ok {
                 return
         }
 
         ok = true
         return cert, in, ok
-}
-
-func (cert *OpenSSHCertV01) Marshal() []byte {
-        pubKey := cert.Key.Marshal()
-        sigKey := MarshalPublicKey(cert.SignatureKey)
-
-        length := stringLength(len(cert.Nonce))
-        length += len(pubKey)
-        length += 8 // Length of Serial
-        length += 4 // Length of Type
-        length += stringLength(len(cert.KeyId))
-        length += lengthPrefixedNameListLength(cert.ValidPrincipals)
-        length += 8 // Length of ValidAfter
-        length += 8 // Length of ValidBefore
-        length += tupleListLength(cert.CriticalOptions)
-        length += tupleListLength(cert.Extensions)
-        length += stringLength(len(cert.Reserved))
-        length += stringLength(len(sigKey))
-        length += signatureLength(cert.Signature)
-
-        ret := make([]byte, length)
-        r := marshalString(ret, cert.Nonce)
-        copy(r, pubKey)
-        r = r[len(pubKey):]
-        r = marshalUint64(r, cert.Serial)
-        r = marshalUint32(r, cert.Type)
-        r = marshalString(r, []byte(cert.KeyId))
-        r = marshalLengthPrefixedNameList(r, cert.ValidPrincipals)
-        r = marshalUint64(r, uint64(cert.ValidAfter.Unix()))
-        r = marshalUint64(r, uint64(cert.ValidBefore.Unix()))
-        r = marshalTupleList(r, cert.CriticalOptions)
-        r = marshalTupleList(r, cert.Extensions)
-        r = marshalString(r, cert.Reserved)
-        r = marshalString(r, sigKey)
-        r = marshalSignature(r, cert.Signature)
-        if len(r) > 0 {
-                panic("ssh: internal error, marshaling certificate did not fill the entire buffer")
-        }
-        return ret
 }
 
 func lengthPrefixedNameListLength(namelist []string) int {
         length := 4 // length prefix for list
         for _, name := range namelist {
                 length += 4 // length prefix for name
                 length += len(name)
         }
         return length
 }
@@ skipping 105 matching lines @@
         if sigBytes, rest, ok = parseString(in); !ok {
                 return
         }
 
         out, sigBytes, ok = parseSignatureBody(sigBytes)
         if !ok || len(sigBytes) > 0 {
                 return nil, nil, false
         }
         return
 }