code review 5448065: Add a []byte argument to hash.Hash to allow an allocati...

src/pkg/crypto/openpgp/packet/signature.go

 // Copyright 2011 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 packet
 
 import (
         "crypto"
         "crypto/dsa"
         error_ "crypto/openpgp/error"
         "crypto/openpgp/s2k"
         "crypto/rand"
         "crypto/rsa"
         "encoding/binary"
         "hash"
         "io"
         "strconv"
+        "time"
 )
 
 // Signature represents a signature. See RFC 4880, section 5.2.
 type Signature struct {
         SigType    SignatureType
         PubKeyAlgo PublicKeyAlgorithm
         Hash       crypto.Hash
 
         // HashSuffix is extra data that is hashed in after the signed data.
         HashSuffix []byte
         // HashTag contains the first two bytes of the hash for fast rejection
         // of bad signed data.
         HashTag      [2]byte
-        CreationTime uint32 // Unix epoch time
+        CreationTime time.Time
 
         RSASignature     parsedMPI
         DSASigR, DSASigS parsedMPI
 
         // rawSubpackets contains the unparsed subpackets, in order.
         rawSubpackets []outputSubpacket
 
         // The following are optional so are nil when not included in the
         // signature.
 
@@ skipping 102 matching lines @@
 // parseSignatureSubpackets parses subpackets of the main signature packet. See
 // RFC 4880, section 5.2.3.1.
 func parseSignatureSubpackets(sig *Signature, subpackets []byte, isHashed bool) (err error) {
         for len(subpackets) > 0 {
                 subpackets, err = parseSignatureSubpacket(sig, subpackets, isHashed)
                 if err != nil {
                         return
                 }
         }
 
-        if sig.CreationTime == 0 {
+        if sig.CreationTime.IsZero() {
                 err = error_.StructuralError("no creation time in signature")
         }
 
         return
 }
 
 type signatureSubpacketType uint8
 
 const (
         creationTimeSubpacket        signatureSubpacketType = 2
@@ skipping 51 matching lines @@
         switch packetType {
         case creationTimeSubpacket:
                 if !isHashed {
                         err = error_.StructuralError("signature creation time in non-hashed area")
                         return
                 }
                 if len(subpacket) != 4 {
                         err = error_.StructuralError("signature creation time not four bytes")
                         return
                 }
-                sig.CreationTime = binary.BigEndian.Uint32(subpacket)
+                t := binary.BigEndian.Uint32(subpacket)
+                if t == 0 {
+                        sig.CreationTime = time.Time{}
+                } else {
+                        sig.CreationTime = time.Unix(int64(t), 0)
+                }
         case signatureExpirationSubpacket:
                 // Signature expiration time, section 5.2.3.10
                 if !isHashed {
                         return
                 }
                 if len(subpacket) != 4 {
                         err = error_.StructuralError("expiration subpacket with bad length")
                         return
                 }
                 sig.SigLifetimeSecs = new(uint32)
@@ skipping 297 matching lines @@
 // outputSubpacket represents a subpacket to be marshaled.
 type outputSubpacket struct {
         hashed        bool // true if this subpacket is in the hashed area.
         subpacketType signatureSubpacketType
         isCritical    bool
         contents      []byte
 }
 
 func (sig *Signature) buildSubpackets() (subpackets []outputSubpacket) {
         creationTime := make([]byte, 4)
-        creationTime[0] = byte(sig.CreationTime >> 24)
-        creationTime[1] = byte(sig.CreationTime >> 16)
-        creationTime[2] = byte(sig.CreationTime >> 8)
-        creationTime[3] = byte(sig.CreationTime)
+        binary.BigEndian.PutUint32(creationTime, uint32(sig.CreationTime.Unix()))
         subpackets = append(subpackets, outputSubpacket{true, creationTimeSubpacket, false, creationTime})
 
         if sig.IssuerKeyId != nil {
                 keyId := make([]byte, 8)
                 binary.BigEndian.PutUint64(keyId, *sig.IssuerKeyId)
                 subpackets = append(subpackets, outputSubpacket{true, issuerSubpacket, false, keyId})
         }
 
         return
 }