Fresh dep ensure

vendor/google.golang.org/grpc/credentials/alts/alts.go

@@ -32,10 +32,10 @@ import (
 
 	"golang.org/x/net/context"
 	"google.golang.org/grpc/credentials"
-	"google.golang.org/grpc/credentials/alts/core"
-	"google.golang.org/grpc/credentials/alts/core/handshaker"
-	"google.golang.org/grpc/credentials/alts/core/handshaker/service"
-	altspb "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
+	core "google.golang.org/grpc/credentials/alts/internal"
+	"google.golang.org/grpc/credentials/alts/internal/handshaker"
+	"google.golang.org/grpc/credentials/alts/internal/handshaker/service"
+	altspb "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
 	"google.golang.org/grpc/grpclog"
 )
 
@@ -66,7 +66,7 @@ var (
 	// ErrUntrustedPlatform is returned from ClientHandshake and
 	// ServerHandshake is running on a platform where the trustworthiness of
 	// the handshaker service is not guaranteed.
-	ErrUntrustedPlatform = errors.New("untrusted platform")
+	ErrUntrustedPlatform = errors.New("ALTS: untrusted platform. ALTS is only supported on GCP")
 )
 
 // AuthInfo exposes security information from the ALTS handshake to the
@@ -190,6 +190,7 @@ func (g *altsTC) ClientHandshake(ctx context.Context, addr string, rawConn net.C
 	}()
 
 	opts := handshaker.DefaultClientHandshakerOptions()
+	opts.TargetName = addr
 	opts.TargetServiceAccounts = g.accounts
 	opts.RPCVersions = &altspb.RpcProtocolVersions{
 		MaxRpcVersion: maxRPCVersion,

vendor/google.golang.org/grpc/credentials/alts/alts_test.go

@@ -23,7 +23,7 @@ import (
 	"testing"
 
 	"github.com/golang/protobuf/proto"
-	altspb "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
+	altspb "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
 )
 
 func TestInfoServerName(t *testing.T) {

vendor/google.golang.org/grpc/credentials/alts/internal/authinfo/authinfo.go

@@ -21,7 +21,7 @@ package authinfo
 
 import (
 	"google.golang.org/grpc/credentials"
-	altspb "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
+	altspb "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
 )
 
 var _ credentials.AuthInfo = (*altsAuthInfo)(nil)

vendor/google.golang.org/grpc/credentials/alts/internal/authinfo/authinfo_test.go

@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"testing"
 
-	altspb "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
+	altspb "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
 )
 
 const (

vendor/google.golang.org/grpc/credentials/alts/internal/common.go

@@ -18,9 +18,8 @@
 
 //go:generate ./regenerate.sh
 
-// Package core contains common core functionality for ALTS.
-// Disclaimer: users should NEVER reference this package directly.
-package core
+// Package internal contains common core functionality for ALTS.
+package internal
 
 import (
 	"net"

vendor/google.golang.org/grpc/credentials/alts/internal/conn/aes128gcm.go

@@ -22,7 +22,7 @@ import (
 	"crypto/aes"
 	"crypto/cipher"
 
-	"google.golang.org/grpc/credentials/alts/core"
+	core "google.golang.org/grpc/credentials/alts/internal"
 )
 
 const (
@@ -38,8 +38,8 @@ type aes128gcm struct {
 	// inCounter is used in ALTS record to check that incoming counters are
 	// as expected, since ALTS record guarantees that messages are unwrapped
 	// in the same order that the peer wrapped them.
-	inCounter  counter
-	outCounter counter
+	inCounter  Counter
+	outCounter Counter
 	aead       cipher.AEAD
 }
 
@@ -54,8 +54,8 @@ func NewAES128GCM(side core.Side, key []byte) (ALTSRecordCrypto, error) {
 		return nil, err
 	}
 	return &aes128gcm{
-		inCounter:  newInCounter(side, overflowLenAES128GCM),
-		outCounter: newOutCounter(side, overflowLenAES128GCM),
+		inCounter:  NewInCounter(side, overflowLenAES128GCM),
+		outCounter: NewOutCounter(side, overflowLenAES128GCM),
 		aead:       a,
 	}, nil
 }

vendor/google.golang.org/grpc/credentials/alts/internal/conn/aes128gcm_test.go

@@ -22,7 +22,7 @@ import (
 	"bytes"
 	"testing"
 
-	"google.golang.org/grpc/credentials/alts/core"
+	core "google.golang.org/grpc/credentials/alts/internal"
 )
 
 // cryptoTestVector is struct for a GCM test vector
@@ -43,12 +43,12 @@ func getGCMCryptoPair(key []byte, counter []byte, t *testing.T) (ALTSRecordCrypt
 	}
 	// set counter if provided.
 	if counter != nil {
-		if counterSide(counter) == core.ClientSide {
-			client.(*aes128gcm).outCounter = counterFromValue(counter, overflowLenAES128GCM)
-			server.(*aes128gcm).inCounter = counterFromValue(counter, overflowLenAES128GCM)
+		if CounterSide(counter) == core.ClientSide {
+			client.(*aes128gcm).outCounter = CounterFromValue(counter, overflowLenAES128GCM)
+			server.(*aes128gcm).inCounter = CounterFromValue(counter, overflowLenAES128GCM)
 		} else {
-			server.(*aes128gcm).outCounter = counterFromValue(counter, overflowLenAES128GCM)
-			client.(*aes128gcm).inCounter = counterFromValue(counter, overflowLenAES128GCM)
+			server.(*aes128gcm).outCounter = CounterFromValue(counter, overflowLenAES128GCM)
+			client.(*aes128gcm).inCounter = CounterFromValue(counter, overflowLenAES128GCM)
 		}
 	}
 	return client, server
@@ -150,7 +150,7 @@ func TestAES128GCMEncrypt(t *testing.T) {
 	} {
 		// Test encryption and decryption for aes128gcm.
 		client, server := getGCMCryptoPair(test.key, test.counter, t)
-		if counterSide(test.counter) == core.ClientSide {
+		if CounterSide(test.counter) == core.ClientSide {
 			testGCMEncryptionDecryption(client, server, &test, false, t)
 		} else {
 			testGCMEncryptionDecryption(server, client, &test, false, t)

vendor/google.golang.org/grpc/credentials/alts/internal/conn/aes128gcmrekey.go

@@ -21,7 +21,7 @@ package conn
 import (
 	"crypto/cipher"
 
-	"google.golang.org/grpc/credentials/alts/core"
+	core "google.golang.org/grpc/credentials/alts/internal"
 )
 
 const (
@@ -43,8 +43,8 @@ type aes128gcmRekey struct {
 	// inCounter is used in ALTS record to check that incoming counters are
 	// as expected, since ALTS record guarantees that messages are unwrapped
 	// in the same order that the peer wrapped them.
-	inCounter  counter
-	outCounter counter
+	inCounter  Counter
+	outCounter Counter
 	inAEAD     cipher.AEAD
 	outAEAD    cipher.AEAD
 }
@@ -54,8 +54,8 @@ type aes128gcmRekey struct {
 // are used as a key for HKDF-expand and the remainining 12 bytes are used
 // as a random mask for the counter.
 func NewAES128GCMRekey(side core.Side, key []byte) (ALTSRecordCrypto, error) {
-	inCounter := newInCounter(side, overflowLenAES128GCMRekey)
-	outCounter := newOutCounter(side, overflowLenAES128GCMRekey)
+	inCounter := NewInCounter(side, overflowLenAES128GCMRekey)
+	outCounter := NewOutCounter(side, overflowLenAES128GCMRekey)
 	inAEAD, err := newRekeyAEAD(key)
 	if err != nil {
 		return nil, err

vendor/google.golang.org/grpc/credentials/alts/internal/conn/aes128gcmrekey_test.go

@@ -21,7 +21,7 @@ package conn
 import (
 	"testing"
 
-	"google.golang.org/grpc/credentials/alts/core"
+	core "google.golang.org/grpc/credentials/alts/internal"
 )
 
 // cryptoTestVector is struct for a rekey test vector
@@ -41,12 +41,12 @@ func getRekeyCryptoPair(key []byte, counter []byte, t *testing.T) (ALTSRecordCry
 	}
 	// set counter if provided.
 	if counter != nil {
-		if counterSide(counter) == core.ClientSide {
-			client.(*aes128gcmRekey).outCounter = counterFromValue(counter, overflowLenAES128GCMRekey)
-			server.(*aes128gcmRekey).inCounter = counterFromValue(counter, overflowLenAES128GCMRekey)
+		if CounterSide(counter) == core.ClientSide {
+			client.(*aes128gcmRekey).outCounter = CounterFromValue(counter, overflowLenAES128GCMRekey)
+			server.(*aes128gcmRekey).inCounter = CounterFromValue(counter, overflowLenAES128GCMRekey)
 		} else {
-			server.(*aes128gcmRekey).outCounter = counterFromValue(counter, overflowLenAES128GCMRekey)
-			client.(*aes128gcmRekey).inCounter = counterFromValue(counter, overflowLenAES128GCMRekey)
+			server.(*aes128gcmRekey).outCounter = CounterFromValue(counter, overflowLenAES128GCMRekey)
+			client.(*aes128gcmRekey).inCounter = CounterFromValue(counter, overflowLenAES128GCMRekey)
 		}
 	}
 	return client, server

vendor/google.golang.org/grpc/credentials/alts/internal/conn/counter.go

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package conn
+
+import (
+	"errors"
+)
+
+const counterLen = 12
+
+var (
+	errInvalidCounter = errors.New("invalid counter")
+)
+
+// Counter is a 96-bit, little-endian counter.
+type Counter struct {
+	value       [counterLen]byte
+	invalid     bool
+	overflowLen int
+}
+
+// Value returns the current value of the counter as a byte slice.
+func (c *Counter) Value() ([]byte, error) {
+	if c.invalid {
+		return nil, errInvalidCounter
+	}
+	return c.value[:], nil
+}
+
+// Inc increments the counter and checks for overflow.
+func (c *Counter) Inc() {
+	// If the counter is already invalid, there is no need to increase it.
+	if c.invalid {
+		return
+	}
+	i := 0
+	for ; i < c.overflowLen; i++ {
+		c.value[i]++
+		if c.value[i] != 0 {
+			break
+		}
+	}
+	if i == c.overflowLen {
+		c.invalid = true
+	}
+}

vendor/google.golang.org/grpc/credentials/alts/internal/conn/counter_test.go

@@ -22,7 +22,7 @@ import (
 	"bytes"
 	"testing"
 
-	"google.golang.org/grpc/credentials/alts/core"
+	core "google.golang.org/grpc/credentials/alts/internal"
 )
 
 const (
@@ -31,17 +31,17 @@ const (
 
 func TestCounterSides(t *testing.T) {
 	for _, side := range []core.Side{core.ClientSide, core.ServerSide} {
-		outCounter := newOutCounter(side, testOverflowLen)
-		inCounter := newInCounter(side, testOverflowLen)
+		outCounter := NewOutCounter(side, testOverflowLen)
+		inCounter := NewInCounter(side, testOverflowLen)
 		for i := 0; i < 1024; i++ {
 			value, _ := outCounter.Value()
-			if g, w := counterSide(value), side; g != w {
-				t.Errorf("after %d iterations, counterSide(outCounter.Value()) = %v, want %v", i, g, w)
+			if g, w := CounterSide(value), side; g != w {
+				t.Errorf("after %d iterations, CounterSide(outCounter.Value()) = %v, want %v", i, g, w)
 				break
 			}
 			value, _ = inCounter.Value()
-			if g, w := counterSide(value), side; g == w {
-				t.Errorf("after %d iterations, counterSide(inCounter.Value()) = %v, want %v", i, g, w)
+			if g, w := CounterSide(value), side; g == w {
+				t.Errorf("after %d iterations, CounterSide(inCounter.Value()) = %v, want %v", i, g, w)
 				break
 			}
 			outCounter.Inc()
@@ -80,7 +80,7 @@ func TestCounterInc(t *testing.T) {
 			want:    []byte{0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80},
 		},
 	} {
-		c := counterFromValue(test.counter, overflowLenAES128GCM)
+		c := CounterFromValue(test.counter, overflowLenAES128GCM)
 		c.Inc()
 		value, _ := c.Value()
 		if g, w := value, test.want; !bytes.Equal(g, w) || c.invalid {
@@ -116,7 +116,7 @@ func TestRolloverCounter(t *testing.T) {
 			overflowLen: 8,
 		},
 	} {
-		c := counterFromValue(test.value, overflowLenAES128GCM)
+		c := CounterFromValue(test.value, overflowLenAES128GCM)
 
 		// First Inc() + Value() should work.
 		c.Inc()

vendor/google.golang.org/grpc/credentials/alts/internal/conn/record.go

@@ -26,7 +26,7 @@ import (
 	"math"
 	"net"
 
-	"google.golang.org/grpc/credentials/alts/core"
+	core "google.golang.org/grpc/credentials/alts/internal"
 )
 
 // ALTSRecordCrypto is the interface for gRPC ALTS record protocol.

vendor/google.golang.org/grpc/credentials/alts/internal/conn/record_test.go

@@ -28,7 +28,7 @@ import (
 	"reflect"
 	"testing"
 
-	"google.golang.org/grpc/credentials/alts/core"
+	core "google.golang.org/grpc/credentials/alts/internal"
 )
 
 var (

vendor/google.golang.org/grpc/credentials/alts/internal/conn/utils.go

@@ -18,28 +18,11 @@
 
 package conn
 
-import (
-	"errors"
+import core "google.golang.org/grpc/credentials/alts/internal"
 
-	"google.golang.org/grpc/credentials/alts/core"
-)
-
-const counterLen = 12
-
-var (
-	errInvalidCounter = errors.New("invalid counter")
-)
-
-// counter is a 96-bit, little-endian counter.
-type counter struct {
-	value       [counterLen]byte
-	invalid     bool
-	overflowLen int
-}
-
-// newOutCounter returns an outgoing counter initialized to the starting sequence
+// NewOutCounter returns an outgoing counter initialized to the starting sequence
 // number for the client/server side of a connection.
-func newOutCounter(s core.Side, overflowLen int) (c counter) {
+func NewOutCounter(s core.Side, overflowLen int) (c Counter) {
 	c.overflowLen = overflowLen
 	if s == core.ServerSide {
 		// Server counters in ALTS record have the little-endian high bit
@@ -49,11 +32,11 @@ func newOutCounter(s core.Side, overflowLen int) (c counter) {
 	return
 }
 
-// newInCounter returns an incoming counter initialized to the starting sequence
+// NewInCounter returns an incoming counter initialized to the starting sequence
 // number for the client/server side of a connection. This is used in ALTS record
 // to check that incoming counters are as expected, since ALTS record guarantees
 // that messages are unwrapped in the same order that the peer wrapped them.
-func newInCounter(s core.Side, overflowLen int) (c counter) {
+func NewInCounter(s core.Side, overflowLen int) (c Counter) {
 	c.overflowLen = overflowLen
 	if s == core.ClientSide {
 		// Server counters in ALTS record have the little-endian high bit
@@ -63,42 +46,16 @@ func newInCounter(s core.Side, overflowLen int) (c counter) {
 	return
 }
 
-// counterFromValue creates a new counter given an initial value.
-func counterFromValue(value []byte, overflowLen int) (c counter) {
+// CounterFromValue creates a new counter given an initial value.
+func CounterFromValue(value []byte, overflowLen int) (c Counter) {
 	c.overflowLen = overflowLen
 	copy(c.value[:], value)
 	return
 }
 
-// Value returns the current value of the counter as a byte slice.
-func (c *counter) Value() ([]byte, error) {
-	if c.invalid {
-		return nil, errInvalidCounter
-	}
-	return c.value[:], nil
-}
-
-// Inc increments the counter and checks for overflow.
-func (c *counter) Inc() {
-	// If the counter is already invalid, there is not need to increase it.
-	if c.invalid {
-		return
-	}
-	i := 0
-	for ; i < c.overflowLen; i++ {
-		c.value[i]++
-		if c.value[i] != 0 {
-			break
-		}
-	}
-	if i == c.overflowLen {
-		c.invalid = true
-	}
-}
-
-// counterSide returns the connection side (client/server) a sequence counter is
+// CounterSide returns the connection side (client/server) a sequence counter is
 // associated with.
-func counterSide(c []byte) core.Side {
+func CounterSide(c []byte) core.Side {
 	if c[counterLen-1]&0x80 == 0x80 {
 		return core.ServerSide
 	}

vendor/google.golang.org/grpc/credentials/alts/internal/handshaker/handshaker.go

@@ -30,11 +30,11 @@ import (
 	grpc "google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials"
-	"google.golang.org/grpc/credentials/alts/core"
-	"google.golang.org/grpc/credentials/alts/core/authinfo"
-	"google.golang.org/grpc/credentials/alts/core/conn"
-	altsgrpc "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
-	altspb "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
+	core "google.golang.org/grpc/credentials/alts/internal"
+	"google.golang.org/grpc/credentials/alts/internal/authinfo"
+	"google.golang.org/grpc/credentials/alts/internal/conn"
+	altsgrpc "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
+	altspb "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
 )
 
 const (

vendor/google.golang.org/grpc/credentials/alts/internal/handshaker/handshaker_test.go

@@ -25,9 +25,9 @@ import (
 
 	"golang.org/x/net/context"
 	grpc "google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/alts/core"
-	altspb "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
-	"google.golang.org/grpc/credentials/alts/core/testutil"
+	core "google.golang.org/grpc/credentials/alts/internal"
+	altspb "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
+	"google.golang.org/grpc/credentials/alts/internal/testutil"
 )
 
 var (
@@ -89,8 +89,8 @@ func (t *testRPCStream) Send(req *altspb.HandshakerReq) error {
 		}
 	} else {
 		// Add delay to test concurrent calls.
-		close := stat.Update()
-		defer close()
+		cleanup := stat.Update()
+		defer cleanup()
 		time.Sleep(t.delay)
 
 		// Generate the response to be returned by Recv() for the

vendor/google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp/altscontext.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: grpc/gcp/altscontext.proto
 
-package grpc_gcp // import "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
+package grpc_gcp // import "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -30,17 +30,19 @@ type AltsContext struct {
 	// The local service account.
 	LocalServiceAccount string `protobuf:"bytes,5,opt,name=local_service_account,json=localServiceAccount,proto3" json:"local_service_account,omitempty"`
 	// The RPC protocol versions supported by the peer.
-	PeerRpcVersions      *RpcProtocolVersions `protobuf:"bytes,6,opt,name=peer_rpc_versions,json=peerRpcVersions,proto3" json:"peer_rpc_versions,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
-	XXX_unrecognized     []byte               `json:"-"`
-	XXX_sizecache        int32                `json:"-"`
+	PeerRpcVersions *RpcProtocolVersions `protobuf:"bytes,6,opt,name=peer_rpc_versions,json=peerRpcVersions,proto3" json:"peer_rpc_versions,omitempty"`
+	// Additional attributes of the peer.
+	PeerAttributes       map[string]string `protobuf:"bytes,7,rep,name=peer_attributes,json=peerAttributes,proto3" json:"peer_attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
 }
 
 func (m *AltsContext) Reset()         { *m = AltsContext{} }
 func (m *AltsContext) String() string { return proto.CompactTextString(m) }
 func (*AltsContext) ProtoMessage()    {}
 func (*AltsContext) Descriptor() ([]byte, []int) {
-	return fileDescriptor_altscontext_2f63c0ac7e856743, []int{0}
+	return fileDescriptor_altscontext_f6b7868f9a30497f, []int{0}
 }
 func (m *AltsContext) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AltsContext.Unmarshal(m, b)
@@ -102,36 +104,48 @@ func (m *AltsContext) GetPeerRpcVersions() *RpcProtocolVersions {
 	return nil
 }
 
+func (m *AltsContext) GetPeerAttributes() map[string]string {
+	if m != nil {
+		return m.PeerAttributes
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*AltsContext)(nil), "grpc.gcp.AltsContext")
+	proto.RegisterMapType((map[string]string)(nil), "grpc.gcp.AltsContext.PeerAttributesEntry")
 }
 
 func init() {
-	proto.RegisterFile("grpc/gcp/altscontext.proto", fileDescriptor_altscontext_2f63c0ac7e856743)
+	proto.RegisterFile("grpc/gcp/altscontext.proto", fileDescriptor_altscontext_f6b7868f9a30497f)
 }
 
-var fileDescriptor_altscontext_2f63c0ac7e856743 = []byte{
-	// 338 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x91, 0x4d, 0x4b, 0x23, 0x41,
-	0x10, 0x86, 0x99, 0xec, 0x6e, 0xd8, 0xed, 0xb0, 0xc9, 0xee, 0x6c, 0xc2, 0x0e, 0x01, 0x21, 0x78,
-	0x71, 0x4e, 0x33, 0x1a, 0x8f, 0x82, 0x90, 0x78, 0x12, 0x3c, 0x84, 0x09, 0x78, 0xf0, 0x32, 0xb4,
-	0x95, 0xa2, 0x6d, 0xe8, 0x74, 0x35, 0xd5, 0x9d, 0xa0, 0x7f, 0xd5, 0x5f, 0x23, 0xd3, 0x93, 0x2f,
-	0xf4, 0x58, 0xf5, 0xbc, 0x6f, 0x7d, 0x8a, 0xb1, 0x62, 0x07, 0xa5, 0x02, 0x57, 0x4a, 0x13, 0x3c,
-	0x90, 0x0d, 0xf8, 0x1a, 0x0a, 0xc7, 0x14, 0x28, 0xfd, 0xd9, 0xb0, 0x42, 0x81, 0x1b, 0xe7, 0x07,
-	0x55, 0x60, 0x69, 0xbd, 0x23, 0x0e, 0xb5, 0x47, 0xd8, 0xb0, 0x0e, 0x6f, 0x35, 0xd0, 0x7a, 0x4d,
-	0xb6, 0xf5, 0x9c, 0xbf, 0x77, 0x44, 0x6f, 0x66, 0x82, 0xbf, 0x6b, 0x2b, 0xa5, 0x57, 0x62, 0x28,
-	0x9d, 0x33, 0x1a, 0x64, 0xd0, 0x64, 0xeb, 0x28, 0x02, 0x32, 0x59, 0x32, 0x49, 0xf2, 0x5f, 0xd5,
-	0xbf, 0x13, 0xb6, 0xd8, 0xa1, 0xf4, 0x42, 0x0c, 0x18, 0x81, 0x78, 0x75, 0x54, 0x77, 0xa2, 0xba,
-	0xdf, 0xa6, 0x0f, 0xc2, 0x5b, 0xd1, 0x3f, 0x0c, 0x61, 0x70, 0x8b, 0x26, 0xfb, 0x36, 0x49, 0xf2,
-	0xfe, 0xf4, 0x7f, 0xb1, 0x1f, 0xbc, 0x58, 0xee, 0xf8, 0x43, 0x83, 0xab, 0xdf, 0xfe, 0x34, 0x4c,
-	0x2f, 0xc5, 0xd0, 0x21, 0x72, 0xed, 0x91, 0xb7, 0x1a, 0xb0, 0x96, 0x00, 0xb4, 0xb1, 0x21, 0xfb,
-	0x1e, 0xbb, 0xa5, 0x0d, 0x5b, 0xb6, 0x68, 0xd6, 0x92, 0x74, 0x2a, 0x46, 0x86, 0x40, 0x9a, 0x2f,
-	0x96, 0x1f, 0xed, 0x3a, 0x11, 0x7e, 0xf2, 0xdc, 0x8b, 0xbf, 0xb1, 0x0b, 0x3b, 0xa8, 0xb7, 0xc8,
-	0x5e, 0x93, 0xf5, 0x59, 0x77, 0x92, 0xe4, 0xbd, 0xe9, 0xd9, 0x71, 0xd0, 0xca, 0xc1, 0x7e, 0xaf,
-	0xc7, 0x9d, 0xa8, 0x1a, 0x34, 0xbe, 0xca, 0xc1, 0x3e, 0x31, 0x7f, 0x11, 0x23, 0x4d, 0xad, 0xa7,
-	0xf9, 0x56, 0xa1, 0x6d, 0x40, 0xb6, 0xd2, 0xcc, 0xff, 0x9c, 0x9c, 0x3c, 0x96, 0x59, 0x24, 0x4f,
-	0x37, 0x8a, 0x48, 0x19, 0x2c, 0x14, 0x19, 0x69, 0x55, 0x41, 0xac, 0xca, 0xf8, 0x45, 0x60, 0x5c,
-	0xa1, 0x0d, 0x5a, 0x1a, 0x1f, 0x7f, 0x5e, 0x02, 0x31, 0x96, 0xf1, 0xd4, 0x51, 0x50, 0x2b, 0x70,
-	0xcf, 0xdd, 0x18, 0x5f, 0x7f, 0x04, 0x00, 0x00, 0xff, 0xff, 0xe8, 0x41, 0xe3, 0x52, 0x1f, 0x02,
-	0x00, 0x00,
+var fileDescriptor_altscontext_f6b7868f9a30497f = []byte{
+	// 411 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x4d, 0x6f, 0x13, 0x31,
+	0x10, 0x86, 0xb5, 0x0d, 0x2d, 0xe0, 0x88, 0xb4, 0xb8, 0xa9, 0x58, 0x45, 0x42, 0x8a, 0xb8, 0xb0,
+	0x5c, 0x76, 0x21, 0x5c, 0x10, 0x07, 0x50, 0x8a, 0x38, 0x20, 0x71, 0x88, 0xb6, 0x12, 0x07, 0x2e,
+	0x2b, 0x77, 0x3a, 0xb2, 0x2c, 0x5c, 0x8f, 0x35, 0x76, 0x22, 0xf2, 0xb3, 0xf9, 0x07, 0x68, 0xed,
+	0xcd, 0x07, 0x1f, 0xb7, 0x9d, 0x79, 0x9f, 0x19, 0xbf, 0xb3, 0x33, 0x62, 0xa6, 0xd9, 0x43, 0xa3,
+	0xc1, 0x37, 0xca, 0xc6, 0x00, 0xe4, 0x22, 0xfe, 0x8c, 0xb5, 0x67, 0x8a, 0x24, 0x1f, 0xf5, 0x5a,
+	0xad, 0xc1, 0xcf, 0xaa, 0x3d, 0x15, 0x59, 0xb9, 0xe0, 0x89, 0x63, 0x17, 0x10, 0xd6, 0x6c, 0xe2,
+	0xb6, 0x03, 0xba, 0xbf, 0x27, 0x97, 0x6b, 0x5e, 0xfc, 0x1a, 0x89, 0xf1, 0xd2, 0xc6, 0xf0, 0x29,
+	0x77, 0x92, 0x6f, 0xc4, 0x54, 0x79, 0x6f, 0x0d, 0xa8, 0x68, 0xc8, 0x75, 0x09, 0x02, 0xb2, 0x65,
+	0x31, 0x2f, 0xaa, 0xc7, 0xed, 0xe5, 0x91, 0xb6, 0x1a, 0x24, 0xf9, 0x52, 0x9c, 0x33, 0x02, 0xf1,
+	0xdd, 0x81, 0x3e, 0x49, 0xf4, 0x24, 0xa7, 0xf7, 0xe0, 0x07, 0x31, 0xd9, 0x9b, 0xb0, 0xb8, 0x41,
+	0x5b, 0x8e, 0xe6, 0x45, 0x35, 0x59, 0x3c, 0xab, 0x77, 0xc6, 0xeb, 0x9b, 0x41, 0xff, 0xda, 0xcb,
+	0xed, 0x93, 0x70, 0x1c, 0xca, 0xd7, 0x62, 0xea, 0x11, 0xb9, 0x0b, 0xc8, 0x1b, 0x03, 0xd8, 0x29,
+	0x00, 0x5a, 0xbb, 0x58, 0x3e, 0x48, 0xaf, 0xc9, 0x5e, 0xbb, 0xc9, 0xd2, 0x32, 0x2b, 0x72, 0x21,
+	0xae, 0x2c, 0x81, 0xb2, 0xff, 0x94, 0x9c, 0xe6, 0x71, 0x92, 0xf8, 0x57, 0xcd, 0x17, 0xf1, 0x34,
+	0xbd, 0xc2, 0x1e, 0xba, 0x0d, 0x72, 0x30, 0xe4, 0x42, 0x79, 0x36, 0x2f, 0xaa, 0xf1, 0xe2, 0xf9,
+	0xc1, 0x68, 0xeb, 0x61, 0x37, 0xd7, 0xb7, 0x01, 0x6a, 0xcf, 0xfb, 0xba, 0xd6, 0xc3, 0x2e, 0x21,
+	0x5b, 0x91, 0x52, 0x9d, 0x8a, 0x91, 0xcd, 0xed, 0x3a, 0x62, 0x28, 0x1f, 0xce, 0x47, 0xd5, 0x78,
+	0xf1, 0xea, 0xd0, 0xe8, 0xe8, 0xe7, 0xd7, 0x2b, 0x44, 0x5e, 0xee, 0xd9, 0xcf, 0x2e, 0xf2, 0xb6,
+	0x9d, 0xf8, 0x3f, 0x92, 0xb3, 0xa5, 0xb8, 0xfc, 0x0f, 0x26, 0x2f, 0xc4, 0xe8, 0x07, 0x6e, 0x87,
+	0x35, 0xf5, 0x9f, 0x72, 0x2a, 0x4e, 0x37, 0xca, 0xae, 0x71, 0x58, 0x46, 0x0e, 0xde, 0x9f, 0xbc,
+	0x2b, 0xae, 0xad, 0xb8, 0x32, 0x94, 0x1d, 0xf4, 0x47, 0x54, 0x1b, 0x17, 0x91, 0x9d, 0xb2, 0xd7,
+	0x17, 0x47, 0x66, 0xd2, 0x74, 0xab, 0xe2, 0xfb, 0x47, 0x4d, 0xa4, 0x2d, 0xd6, 0x9a, 0xac, 0x72,
+	0xba, 0x26, 0xd6, 0x4d, 0x3a, 0x2e, 0x60, 0xbc, 0x43, 0x17, 0x8d, 0xb2, 0x21, 0x9d, 0x62, 0xb3,
+	0xeb, 0xd2, 0xa4, 0x2b, 0x48, 0x50, 0xa7, 0xc1, 0xdf, 0x9e, 0xa5, 0xf8, 0xed, 0xef, 0x00, 0x00,
+	0x00, 0xff, 0xff, 0x9b, 0x8c, 0xe4, 0x6a, 0xba, 0x02, 0x00, 0x00,
 }

vendor/google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp/handshaker.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: grpc/gcp/handshaker.proto
 
-package grpc_gcp // import "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
+package grpc_gcp // import "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -41,15 +41,15 @@ var HandshakeProtocol_name = map[int32]string{
 }
 var HandshakeProtocol_value = map[string]int32{
 	"HANDSHAKE_PROTOCOL_UNSPECIFIED": 0,
-	"TLS":  1,
-	"ALTS": 2,
+	"TLS":                            1,
+	"ALTS":                           2,
 }
 
 func (x HandshakeProtocol) String() string {
 	return proto.EnumName(HandshakeProtocol_name, int32(x))
 }
 func (HandshakeProtocol) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{0}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{0}
 }
 
 type NetworkProtocol int32
@@ -67,15 +67,15 @@ var NetworkProtocol_name = map[int32]string{
 }
 var NetworkProtocol_value = map[string]int32{
 	"NETWORK_PROTOCOL_UNSPECIFIED": 0,
-	"TCP": 1,
-	"UDP": 2,
+	"TCP":                          1,
+	"UDP":                          2,
 }
 
 func (x NetworkProtocol) String() string {
 	return proto.EnumName(NetworkProtocol_name, int32(x))
 }
 func (NetworkProtocol) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{1}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{1}
 }
 
 type Endpoint struct {
@@ -95,7 +95,7 @@ func (m *Endpoint) Reset()         { *m = Endpoint{} }
 func (m *Endpoint) String() string { return proto.CompactTextString(m) }
 func (*Endpoint) ProtoMessage()    {}
 func (*Endpoint) Descriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{0}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{0}
 }
 func (m *Endpoint) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Endpoint.Unmarshal(m, b)
@@ -140,17 +140,19 @@ type Identity struct {
 	// Types that are valid to be assigned to IdentityOneof:
 	//	*Identity_ServiceAccount
 	//	*Identity_Hostname
-	IdentityOneof        isIdentity_IdentityOneof `protobuf_oneof:"identity_oneof"`
-	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
-	XXX_unrecognized     []byte                   `json:"-"`
-	XXX_sizecache        int32                    `json:"-"`
+	IdentityOneof isIdentity_IdentityOneof `protobuf_oneof:"identity_oneof"`
+	// Additional attributes of the identity.
+	Attributes           map[string]string `protobuf:"bytes,3,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
 }
 
 func (m *Identity) Reset()         { *m = Identity{} }
 func (m *Identity) String() string { return proto.CompactTextString(m) }
 func (*Identity) ProtoMessage()    {}
 func (*Identity) Descriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{1}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{1}
 }
 func (m *Identity) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Identity.Unmarshal(m, b)
@@ -177,12 +179,14 @@ type isIdentity_IdentityOneof interface {
 type Identity_ServiceAccount struct {
 	ServiceAccount string `protobuf:"bytes,1,opt,name=service_account,json=serviceAccount,proto3,oneof"`
 }
+
 type Identity_Hostname struct {
 	Hostname string `protobuf:"bytes,2,opt,name=hostname,proto3,oneof"`
 }
 
 func (*Identity_ServiceAccount) isIdentity_IdentityOneof() {}
-func (*Identity_Hostname) isIdentity_IdentityOneof()       {}
+
+func (*Identity_Hostname) isIdentity_IdentityOneof() {}
 
 func (m *Identity) GetIdentityOneof() isIdentity_IdentityOneof {
 	if m != nil {
@@ -205,6 +209,13 @@ func (m *Identity) GetHostname() string {
 	return ""
 }
 
+func (m *Identity) GetAttributes() map[string]string {
+	if m != nil {
+		return m.Attributes
+	}
+	return nil
+}
+
 // XXX_OneofFuncs is for the internal use of the proto package.
 func (*Identity) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 	return _Identity_OneofMarshaler, _Identity_OneofUnmarshaler, _Identity_OneofSizer, []interface{}{
@@ -308,7 +319,7 @@ func (m *StartClientHandshakeReq) Reset()         { *m = StartClientHandshakeReq
 func (m *StartClientHandshakeReq) String() string { return proto.CompactTextString(m) }
 func (*StartClientHandshakeReq) ProtoMessage()    {}
 func (*StartClientHandshakeReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{2}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{2}
 }
 func (m *StartClientHandshakeReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StartClientHandshakeReq.Unmarshal(m, b)
@@ -407,7 +418,7 @@ func (m *ServerHandshakeParameters) Reset()         { *m = ServerHandshakeParame
 func (m *ServerHandshakeParameters) String() string { return proto.CompactTextString(m) }
 func (*ServerHandshakeParameters) ProtoMessage()    {}
 func (*ServerHandshakeParameters) Descriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{3}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{3}
 }
 func (m *ServerHandshakeParameters) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ServerHandshakeParameters.Unmarshal(m, b)
@@ -471,7 +482,7 @@ func (m *StartServerHandshakeReq) Reset()         { *m = StartServerHandshakeReq
 func (m *StartServerHandshakeReq) String() string { return proto.CompactTextString(m) }
 func (*StartServerHandshakeReq) ProtoMessage()    {}
 func (*StartServerHandshakeReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{4}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{4}
 }
 func (m *StartServerHandshakeReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StartServerHandshakeReq.Unmarshal(m, b)
@@ -547,7 +558,7 @@ func (m *NextHandshakeMessageReq) Reset()         { *m = NextHandshakeMessageReq
 func (m *NextHandshakeMessageReq) String() string { return proto.CompactTextString(m) }
 func (*NextHandshakeMessageReq) ProtoMessage()    {}
 func (*NextHandshakeMessageReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{5}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{5}
 }
 func (m *NextHandshakeMessageReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_NextHandshakeMessageReq.Unmarshal(m, b)
@@ -589,7 +600,7 @@ func (m *HandshakerReq) Reset()         { *m = HandshakerReq{} }
 func (m *HandshakerReq) String() string { return proto.CompactTextString(m) }
 func (*HandshakerReq) ProtoMessage()    {}
 func (*HandshakerReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{6}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{6}
 }
 func (m *HandshakerReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_HandshakerReq.Unmarshal(m, b)
@@ -616,16 +627,20 @@ type isHandshakerReq_ReqOneof interface {
 type HandshakerReq_ClientStart struct {
 	ClientStart *StartClientHandshakeReq `protobuf:"bytes,1,opt,name=client_start,json=clientStart,proto3,oneof"`
 }
+
 type HandshakerReq_ServerStart struct {
 	ServerStart *StartServerHandshakeReq `protobuf:"bytes,2,opt,name=server_start,json=serverStart,proto3,oneof"`
 }
+
 type HandshakerReq_Next struct {
 	Next *NextHandshakeMessageReq `protobuf:"bytes,3,opt,name=next,proto3,oneof"`
 }
 
 func (*HandshakerReq_ClientStart) isHandshakerReq_ReqOneof() {}
+
 func (*HandshakerReq_ServerStart) isHandshakerReq_ReqOneof() {}
-func (*HandshakerReq_Next) isHandshakerReq_ReqOneof()        {}
+
+func (*HandshakerReq_Next) isHandshakerReq_ReqOneof() {}
 
 func (m *HandshakerReq) GetReqOneof() isHandshakerReq_ReqOneof {
 	if m != nil {
@@ -776,7 +791,7 @@ func (m *HandshakerResult) Reset()         { *m = HandshakerResult{} }
 func (m *HandshakerResult) String() string { return proto.CompactTextString(m) }
 func (*HandshakerResult) ProtoMessage()    {}
 func (*HandshakerResult) Descriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{7}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{7}
 }
 func (m *HandshakerResult) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_HandshakerResult.Unmarshal(m, b)
@@ -859,7 +874,7 @@ func (m *HandshakerStatus) Reset()         { *m = HandshakerStatus{} }
 func (m *HandshakerStatus) String() string { return proto.CompactTextString(m) }
 func (*HandshakerStatus) ProtoMessage()    {}
 func (*HandshakerStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{8}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{8}
 }
 func (m *HandshakerStatus) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_HandshakerStatus.Unmarshal(m, b)
@@ -918,7 +933,7 @@ func (m *HandshakerResp) Reset()         { *m = HandshakerResp{} }
 func (m *HandshakerResp) String() string { return proto.CompactTextString(m) }
 func (*HandshakerResp) ProtoMessage()    {}
 func (*HandshakerResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_handshaker_b28e45bdd1661054, []int{9}
+	return fileDescriptor_handshaker_1dfe659b12ea825e, []int{9}
 }
 func (m *HandshakerResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_HandshakerResp.Unmarshal(m, b)
@@ -969,6 +984,7 @@ func (m *HandshakerResp) GetStatus() *HandshakerStatus {
 func init() {
 	proto.RegisterType((*Endpoint)(nil), "grpc.gcp.Endpoint")
 	proto.RegisterType((*Identity)(nil), "grpc.gcp.Identity")
+	proto.RegisterMapType((map[string]string)(nil), "grpc.gcp.Identity.AttributesEntry")
 	proto.RegisterType((*StartClientHandshakeReq)(nil), "grpc.gcp.StartClientHandshakeReq")
 	proto.RegisterType((*ServerHandshakeParameters)(nil), "grpc.gcp.ServerHandshakeParameters")
 	proto.RegisterType((*StartServerHandshakeReq)(nil), "grpc.gcp.StartServerHandshakeReq")
@@ -1099,80 +1115,82 @@ var _HandshakerService_serviceDesc = grpc.ServiceDesc{
 }
 
 func init() {
-	proto.RegisterFile("grpc/gcp/handshaker.proto", fileDescriptor_handshaker_b28e45bdd1661054)
+	proto.RegisterFile("grpc/gcp/handshaker.proto", fileDescriptor_handshaker_1dfe659b12ea825e)
 }
 
-var fileDescriptor_handshaker_b28e45bdd1661054 = []byte{
-	// 1128 bytes of a gzipped FileDescriptorProto
+var fileDescriptor_handshaker_1dfe659b12ea825e = []byte{
+	// 1168 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xdf, 0x6e, 0x1a, 0xc7,
-	0x17, 0xf6, 0x02, 0xb6, 0xe1, 0x60, 0xfe, 0x78, 0x92, 0x28, 0xd8, 0x49, 0x7e, 0x3f, 0x4a, 0x55,
-	0x95, 0xf8, 0x02, 0x5a, 0xd2, 0x2a, 0x4d, 0xa2, 0xaa, 0xb1, 0x31, 0x16, 0x6e, 0x5c, 0x8c, 0x16,
-	0xa7, 0x95, 0x9a, 0x8b, 0xd5, 0x64, 0x39, 0x59, 0xaf, 0x58, 0x66, 0xd6, 0x33, 0x83, 0x1b, 0x1e,
-	0xa0, 0x8f, 0xd3, 0x57, 0xe8, 0xdb, 0xf4, 0x0d, 0x7a, 0xdf, 0x6a, 0x67, 0xff, 0x61, 0x0c, 0x51,
-	0xa2, 0xde, 0xed, 0xce, 0x7c, 0xdf, 0xd9, 0x73, 0xbe, 0xf3, 0xcd, 0xd9, 0x81, 0x3d, 0x47, 0xf8,
-	0x76, 0xdb, 0xb1, 0xfd, 0xf6, 0x25, 0x65, 0x63, 0x79, 0x49, 0x27, 0x28, 0x5a, 0xbe, 0xe0, 0x8a,
-	0x93, 0x7c, 0xb0, 0xd5, 0x72, 0x6c, 0x7f, 0xbf, 0x99, 0x80, 0x94, 0xa0, 0x4c, 0xfa, 0x5c, 0x28,
-	0x4b, 0xa2, 0x3d, 0x13, 0xae, 0x9a, 0x5b, 0x36, 0x9f, 0x4e, 0x39, 0x0b, 0x39, 0x0d, 0x05, 0xf9,
-	0x1e, 0x1b, 0xfb, 0xdc, 0x65, 0x8a, 0x3c, 0x02, 0x70, 0x7d, 0x8b, 0x8e, 0xc7, 0x02, 0xa5, 0xac,
-	0x19, 0x75, 0xa3, 0x59, 0x30, 0x0b, 0xae, 0x7f, 0x18, 0x2e, 0x10, 0x02, 0xb9, 0x20, 0x50, 0x2d,
-	0x53, 0x37, 0x9a, 0x9b, 0xa6, 0x7e, 0x26, 0xdf, 0x42, 0x5e, 0xc7, 0xb1, 0xb9, 0x57, 0xcb, 0xd6,
-	0x8d, 0x66, 0xb9, 0xb3, 0xd7, 0x8a, 0xb3, 0x68, 0x0d, 0x50, 0xfd, 0xc6, 0xc5, 0x64, 0x18, 0x01,
-	0xcc, 0x04, 0xda, 0x40, 0xc8, 0x9f, 0x8e, 0x91, 0x29, 0x57, 0xcd, 0xc9, 0x63, 0xa8, 0x48, 0x14,
-	0xd7, 0xae, 0x8d, 0x16, 0xb5, 0x6d, 0x3e, 0x63, 0x2a, 0xfc, 0x74, 0x7f, 0xc3, 0x2c, 0x47, 0x1b,
-	0x87, 0xe1, 0x3a, 0x79, 0x08, 0xf9, 0x4b, 0x2e, 0x15, 0xa3, 0x53, 0xd4, 0x59, 0x04, 0x98, 0x64,
-	0xe5, 0xa8, 0x0a, 0x65, 0x37, 0x0a, 0x6a, 0x71, 0x86, 0xfc, 0x5d, 0xe3, 0x8f, 0x1c, 0xdc, 0x1f,
-	0x29, 0x2a, 0x54, 0xd7, 0x73, 0x91, 0xa9, 0x7e, 0x2c, 0x98, 0x89, 0x57, 0xe4, 0x0d, 0x3c, 0x48,
-	0x04, 0x4c, 0xb5, 0x49, 0x8a, 0x31, 0x74, 0x31, 0x0f, 0xd2, 0x62, 0x12, 0x72, 0x52, 0xce, 0x5e,
-	0xc2, 0x1f, 0x45, 0xf4, 0x78, 0x8b, 0x3c, 0x81, 0x7b, 0xd4, 0xf7, 0x3d, 0xd7, 0xa6, 0xca, 0xe5,
-	0x2c, 0x89, 0x2a, 0x6b, 0x99, 0x7a, 0xb6, 0x59, 0x30, 0xef, 0x2e, 0x6c, 0xc6, 0x1c, 0x49, 0x1e,
-	0x43, 0x55, 0xa0, 0xcd, 0xc5, 0x78, 0x01, 0x9f, 0xd5, 0xf8, 0x4a, 0xb8, 0x9e, 0x42, 0x7f, 0x80,
-	0x5d, 0x45, 0x85, 0x83, 0xca, 0x8a, 0x2a, 0x76, 0x51, 0xd6, 0x72, 0xf5, 0x6c, 0xb3, 0xd8, 0x21,
-	0x69, 0xca, 0xb1, 0xc4, 0x66, 0x35, 0x04, 0x9f, 0x26, 0x58, 0xf2, 0x0c, 0xca, 0x1e, 0xb7, 0xa9,
-	0x17, 0xf3, 0xe7, 0xb5, 0xcd, 0xba, 0xb1, 0x86, 0x5d, 0xd2, 0xc8, 0xa4, 0x5f, 0x09, 0x15, 0x23,
-	0xdf, 0xd4, 0xb6, 0x96, 0xa9, 0xb1, 0xa3, 0x22, 0x6a, 0x62, 0xb0, 0x17, 0x50, 0x11, 0x38, 0xe5,
-	0x0a, 0x53, 0xee, 0xf6, 0x5a, 0x6e, 0x39, 0x84, 0x26, 0xe4, 0xff, 0x43, 0x31, 0xaa, 0x59, 0xf7,
-	0x3f, 0xaf, 0xed, 0x09, 0xe1, 0xd2, 0x80, 0x4e, 0x91, 0xbc, 0x84, 0x1d, 0xe1, 0xdb, 0xd6, 0x35,
-	0x0a, 0xe9, 0x72, 0x26, 0x6b, 0x05, 0x1d, 0xfa, 0x51, 0x1a, 0xda, 0xf4, 0xed, 0x58, 0xc2, 0x9f,
-	0x23, 0x90, 0x59, 0x14, 0xbe, 0x1d, 0xbf, 0x34, 0x7e, 0x37, 0x60, 0x6f, 0x84, 0xe2, 0x1a, 0x45,
-	0xda, 0x6d, 0x2a, 0xe8, 0x14, 0x15, 0x8a, 0xd5, 0xfd, 0x31, 0x56, 0xf7, 0xe7, 0x7b, 0xa8, 0xde,
-	0x90, 0x37, 0x68, 0x4f, 0x66, 0x6d, 0x7b, 0x2a, 0x8b, 0x02, 0xbb, 0x28, 0x1b, 0xff, 0x64, 0x23,
-	0xdf, 0x2e, 0x25, 0x13, 0xf8, 0x76, 0xad, 0xb5, 0x8c, 0x0f, 0x58, 0x6b, 0x0a, 0x77, 0x53, 0xb3,
-	0xfb, 0x49, 0x49, 0x51, 0x4e, 0xcf, 0xd3, 0x9c, 0xd6, 0x7c, 0xb5, 0xb5, 0x42, 0x8f, 0x1e, 0x53,
-	0x62, 0x6e, 0xde, 0xb9, 0x5c, 0xa1, 0xd4, 0x1e, 0xe4, 0x5d, 0x66, 0xbd, 0x9d, 0x2b, 0x94, 0x7a,
-	0x2a, 0xec, 0x98, 0xdb, 0x2e, 0x3b, 0x0a, 0x5e, 0x57, 0xb8, 0x27, 0xf7, 0x1f, 0xdc, 0xb3, 0xf9,
-	0xd1, 0xee, 0x59, 0x36, 0xc7, 0xd6, 0xa7, 0x9a, 0x63, 0x7f, 0x02, 0xb5, 0x75, 0x2a, 0x90, 0x2a,
-	0x64, 0x27, 0x38, 0xd7, 0x43, 0x63, 0xd3, 0x0c, 0x1e, 0xc9, 0x33, 0xd8, 0xbc, 0xa6, 0xde, 0x2c,
-	0x9c, 0x53, 0xc5, 0xce, 0xe7, 0x0b, 0x12, 0xaf, 0x33, 0x98, 0x19, 0x32, 0x9e, 0x67, 0xbe, 0x33,
-	0x1a, 0xdf, 0xc0, 0xfd, 0x01, 0xbe, 0x4f, 0x27, 0xd6, 0x4f, 0x28, 0x25, 0x75, 0xb4, 0x01, 0x16,
-	0xc5, 0x35, 0x6e, 0x88, 0xdb, 0xf8, 0xcb, 0x80, 0x52, 0x42, 0x11, 0x01, 0xf8, 0x04, 0x76, 0x6c,
-	0x3d, 0xfb, 0x2c, 0x19, 0x74, 0x56, 0x13, 0x8a, 0x9d, 0xcf, 0x96, 0x1a, 0x7e, 0x7b, 0x3c, 0xf6,
-	0x37, 0xcc, 0x62, 0x48, 0xd4, 0x80, 0x20, 0x8e, 0xd4, 0x79, 0x47, 0x71, 0x32, 0x2b, 0xe3, 0xdc,
-	0x36, 0x4e, 0x10, 0x27, 0x24, 0x86, 0x71, 0x9e, 0x42, 0x8e, 0xe1, 0x7b, 0xa5, 0x5d, 0x71, 0x83,
-	0xbf, 0xa6, 0xda, 0xfe, 0x86, 0xa9, 0x09, 0x47, 0x45, 0x28, 0x08, 0xbc, 0x8a, 0xe6, 0xfa, 0xdf,
-	0x19, 0xa8, 0x2e, 0xd6, 0x29, 0x67, 0x9e, 0x22, 0x5f, 0xc3, 0xdd, 0x55, 0x07, 0x23, 0xfa, 0x8f,
-	0xdd, 0x59, 0x71, 0x2e, 0xc8, 0x97, 0x50, 0x59, 0x3a, 0xd1, 0xe1, 0x6f, 0x25, 0x70, 0xcf, 0xe2,
-	0x81, 0x0e, 0x34, 0x9f, 0xe0, 0xdc, 0x1a, 0x53, 0x45, 0x63, 0x43, 0x4f, 0x70, 0x7e, 0x4c, 0x15,
-	0x25, 0x4f, 0xa1, 0xe4, 0x23, 0x8a, 0x74, 0x90, 0xe6, 0xd6, 0x0e, 0xd2, 0x9d, 0x00, 0x78, 0x7b,
-	0x8e, 0x7e, 0xfa, 0x08, 0x3e, 0x80, 0xdd, 0x09, 0xa2, 0x6f, 0xd9, 0x97, 0x94, 0x31, 0xf4, 0x2c,
-	0xee, 0x23, 0xd3, 0x8e, 0xce, 0x9b, 0x95, 0x60, 0xa3, 0x1b, 0xae, 0x9f, 0xfb, 0xc8, 0xc8, 0x29,
-	0xec, 0xea, 0xfc, 0x6e, 0xb8, 0x7f, 0xfb, 0x63, 0xdc, 0x5f, 0x09, 0x78, 0xe6, 0xc2, 0x78, 0x7c,
-	0xb9, 0xa8, 0xfa, 0x48, 0x51, 0x35, 0xd3, 0x97, 0x02, 0x9b, 0x8f, 0x51, 0xab, 0x5c, 0x32, 0xf5,
-	0x33, 0xa9, 0xc1, 0xf6, 0x18, 0x15, 0x75, 0xf5, 0xff, 0x2e, 0x90, 0x33, 0x7e, 0x6d, 0xfc, 0x69,
-	0x40, 0xf9, 0x46, 0xe3, 0xfc, 0xe0, 0xd2, 0xc1, 0x67, 0xca, 0x7a, 0x17, 0x9c, 0x82, 0xd8, 0xd0,
-	0x05, 0x3e, 0x53, 0x27, 0x7a, 0x81, 0x7c, 0x01, 0x65, 0x6d, 0x75, 0xcb, 0xe6, 0x4c, 0xce, 0xa6,
-	0x38, 0xd6, 0x21, 0x4b, 0x66, 0x49, 0xaf, 0x76, 0xa3, 0x45, 0xd2, 0x81, 0x2d, 0xa1, 0x6d, 0x10,
-	0x39, 0x6b, 0x7f, 0xc5, 0x8f, 0x3b, 0x32, 0x8a, 0x19, 0x21, 0x03, 0x8e, 0xd4, 0x45, 0x44, 0x2d,
-	0x5b, 0xc9, 0x09, 0xcb, 0x34, 0x23, 0xe4, 0xc1, 0x8f, 0xb0, 0x7b, 0xeb, 0x22, 0x40, 0x1a, 0xf0,
-	0xbf, 0xfe, 0xe1, 0xe0, 0x78, 0xd4, 0x3f, 0x7c, 0xd5, 0xb3, 0x86, 0xe6, 0xf9, 0xc5, 0x79, 0xf7,
-	0xfc, 0xcc, 0x7a, 0x3d, 0x18, 0x0d, 0x7b, 0xdd, 0xd3, 0x93, 0xd3, 0xde, 0x71, 0x75, 0x83, 0x6c,
-	0x43, 0xf6, 0xe2, 0x6c, 0x54, 0x35, 0x48, 0x1e, 0x72, 0x87, 0x67, 0x17, 0xa3, 0x6a, 0xe6, 0xa0,
-	0x07, 0x95, 0xa5, 0x1b, 0x12, 0xa9, 0xc3, 0xc3, 0x41, 0xef, 0xe2, 0x97, 0x73, 0xf3, 0xd5, 0x87,
-	0xe2, 0x74, 0x87, 0x55, 0x23, 0x78, 0x78, 0x7d, 0x3c, 0xac, 0x66, 0x3a, 0x6f, 0x16, 0x52, 0x12,
-	0xa3, 0xf0, 0xc2, 0x44, 0x4e, 0xa0, 0x78, 0xcc, 0x93, 0x65, 0x72, 0x7f, 0xb5, 0x1c, 0x57, 0xfb,
-	0xb5, 0x35, 0x3a, 0xf9, 0x8d, 0x8d, 0xa6, 0xf1, 0x95, 0x71, 0xe4, 0xc0, 0x3d, 0x97, 0x87, 0x18,
-	0xea, 0x29, 0xd9, 0x72, 0x99, 0x42, 0xc1, 0xa8, 0x77, 0x54, 0x49, 0xe1, 0x3a, 0xfb, 0xa1, 0xf1,
-	0xeb, 0x0b, 0x87, 0x73, 0xc7, 0xc3, 0x96, 0xc3, 0x3d, 0xca, 0x9c, 0x16, 0x17, 0x4e, 0x5b, 0x5f,
-	0x43, 0x6d, 0x81, 0xda, 0xb8, 0xd4, 0x93, 0xed, 0x20, 0x48, 0xdb, 0xe6, 0x02, 0xdb, 0xfa, 0xc4,
-	0x69, 0x80, 0xe5, 0xd8, 0xfe, 0xdb, 0x2d, 0xfd, 0xfe, 0xe4, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0xfa, 0xd2, 0x42, 0x7f, 0xdf, 0x0a, 0x00, 0x00,
+	0x17, 0xf6, 0x02, 0xb6, 0xf1, 0xc1, 0xfc, 0xf1, 0xc4, 0x51, 0xd6, 0x4e, 0xf2, 0xfb, 0x51, 0xaa,
+	0xaa, 0x24, 0x17, 0xd0, 0x92, 0x56, 0x69, 0x52, 0x45, 0x09, 0x60, 0x2c, 0xdc, 0xa4, 0x18, 0x2d,
+	0x4e, 0x2b, 0x35, 0x17, 0xab, 0xc9, 0x32, 0xc1, 0x2b, 0x96, 0x99, 0xf5, 0xcc, 0xe0, 0x86, 0x07,
+	0xe8, 0xe3, 0xf4, 0x15, 0xfa, 0x36, 0x95, 0xfa, 0x00, 0xbd, 0x6f, 0xb5, 0xb3, 0xb3, 0x7f, 0xc0,
+	0x10, 0x25, 0xea, 0xdd, 0xee, 0x99, 0xef, 0x3b, 0x7b, 0xe6, 0x3b, 0xdf, 0x9c, 0x1d, 0x38, 0x9a,
+	0x70, 0xdf, 0x69, 0x4e, 0x1c, 0xbf, 0x79, 0x89, 0xe9, 0x58, 0x5c, 0xe2, 0x29, 0xe1, 0x0d, 0x9f,
+	0x33, 0xc9, 0x50, 0x3e, 0x58, 0x6a, 0x4c, 0x1c, 0xff, 0xb8, 0x1e, 0x83, 0x24, 0xc7, 0x54, 0xf8,
+	0x8c, 0x4b, 0x5b, 0x10, 0x67, 0xce, 0x5d, 0xb9, 0xb0, 0x1d, 0x36, 0x9b, 0x31, 0x1a, 0x72, 0x6a,
+	0x12, 0xf2, 0x3d, 0x3a, 0xf6, 0x99, 0x4b, 0x25, 0xba, 0x0f, 0xe0, 0xfa, 0x36, 0x1e, 0x8f, 0x39,
+	0x11, 0xc2, 0x34, 0xaa, 0x46, 0x7d, 0xcf, 0xda, 0x73, 0xfd, 0x76, 0x18, 0x40, 0x08, 0x72, 0x41,
+	0x22, 0x33, 0x53, 0x35, 0xea, 0xdb, 0x96, 0x7a, 0x46, 0xdf, 0x42, 0x5e, 0xe5, 0x71, 0x98, 0x67,
+	0x66, 0xab, 0x46, 0xbd, 0xd4, 0x3a, 0x6a, 0x44, 0x55, 0x34, 0x06, 0x44, 0xfe, 0xca, 0xf8, 0x74,
+	0xa8, 0x01, 0x56, 0x0c, 0xad, 0xfd, 0x65, 0x40, 0xfe, 0x6c, 0x4c, 0xa8, 0x74, 0xe5, 0x02, 0x3d,
+	0x80, 0xb2, 0x20, 0xfc, 0xda, 0x75, 0x88, 0x8d, 0x1d, 0x87, 0xcd, 0xa9, 0x0c, 0xbf, 0xdd, 0xdf,
+	0xb2, 0x4a, 0x7a, 0xa1, 0x1d, 0xc6, 0xd1, 0x3d, 0xc8, 0x5f, 0x32, 0x21, 0x29, 0x9e, 0x11, 0x55,
+	0x46, 0x80, 0x89, 0x23, 0xa8, 0x03, 0x80, 0xa5, 0xe4, 0xee, 0xdb, 0xb9, 0x24, 0xc2, 0xcc, 0x56,
+	0xb3, 0xf5, 0x42, 0xab, 0x96, 0x94, 0x13, 0x7d, 0xb0, 0xd1, 0x8e, 0x41, 0x3d, 0x2a, 0xf9, 0xc2,
+	0x4a, 0xb1, 0x8e, 0x9f, 0x41, 0x79, 0x65, 0x19, 0x55, 0x20, 0x3b, 0x25, 0x0b, 0xad, 0x47, 0xf0,
+	0x88, 0x0e, 0x61, 0xfb, 0x1a, 0x7b, 0x73, 0x5d, 0x83, 0x15, 0xbe, 0x3c, 0xcd, 0x7c, 0x67, 0x74,
+	0x2a, 0x50, 0x72, 0xf5, 0x67, 0x6c, 0x46, 0x09, 0x7b, 0x57, 0xfb, 0x3d, 0x07, 0x77, 0x46, 0x12,
+	0x73, 0xd9, 0xf5, 0x5c, 0x42, 0x65, 0x3f, 0x6a, 0x9a, 0x45, 0xae, 0xd0, 0x1b, 0xb8, 0x1b, 0x37,
+	0x31, 0xe9, 0x4f, 0x2c, 0xa8, 0xa1, 0x04, 0xbd, 0x9b, 0xec, 0x20, 0x26, 0xc7, 0x92, 0x1e, 0xc5,
+	0xfc, 0x91, 0xa6, 0x47, 0x4b, 0xe8, 0x11, 0xdc, 0xc6, 0xbe, 0xef, 0xb9, 0x0e, 0x96, 0x2e, 0xa3,
+	0x71, 0x56, 0x61, 0x66, 0xaa, 0xd9, 0xfa, 0x9e, 0x75, 0x98, 0x5a, 0x8c, 0x38, 0x02, 0x3d, 0x80,
+	0x0a, 0x27, 0x0e, 0xe3, 0xe3, 0x14, 0x3e, 0xab, 0xf0, 0xe5, 0x30, 0x9e, 0x40, 0x9f, 0xc3, 0x81,
+	0xc4, 0x7c, 0x42, 0xa4, 0xad, 0x77, 0xec, 0x12, 0x61, 0xe6, 0x94, 0xe8, 0xe8, 0xa6, 0xe8, 0x56,
+	0x25, 0x04, 0x9f, 0xc5, 0x58, 0xf4, 0x04, 0x4a, 0x1e, 0x73, 0xb0, 0x17, 0xf1, 0x17, 0xe6, 0x76,
+	0xd5, 0xd8, 0xc0, 0x2e, 0x2a, 0x64, 0x6c, 0x99, 0x98, 0x4a, 0xb4, 0x77, 0xcd, 0x9d, 0x55, 0x6a,
+	0xe4, 0x6a, 0x4d, 0x8d, 0x4d, 0xfe, 0x3d, 0x94, 0x39, 0x99, 0x31, 0x49, 0x12, 0xee, 0xee, 0x46,
+	0x6e, 0x29, 0x84, 0xc6, 0xe4, 0xff, 0x43, 0x41, 0xef, 0x59, 0x59, 0x30, 0xaf, 0xda, 0x0f, 0x61,
+	0x68, 0x10, 0x58, 0xf0, 0x05, 0xec, 0x73, 0xdf, 0xb1, 0xaf, 0x09, 0x17, 0x2e, 0xa3, 0xc2, 0xdc,
+	0x53, 0xa9, 0xef, 0x27, 0xa9, 0x2d, 0xdf, 0x89, 0x24, 0xfc, 0x49, 0x83, 0xac, 0x02, 0xf7, 0x9d,
+	0xe8, 0xa5, 0xf6, 0x9b, 0x01, 0x47, 0x23, 0xc2, 0xaf, 0x09, 0x4f, 0xba, 0x8d, 0x39, 0x9e, 0x11,
+	0x49, 0xf8, 0xfa, 0xfe, 0x18, 0xeb, 0xfb, 0xf3, 0x0c, 0x2a, 0x4b, 0xf2, 0x06, 0xed, 0xc9, 0x6c,
+	0x6c, 0x4f, 0x39, 0x2d, 0xb0, 0x4b, 0x44, 0xed, 0x9f, 0xac, 0xf6, 0xed, 0x4a, 0x31, 0x81, 0x6f,
+	0x37, 0x5a, 0xcb, 0xf8, 0x80, 0xb5, 0x66, 0x70, 0x98, 0x98, 0xdd, 0x8f, 0xb7, 0xa4, 0x6b, 0x7a,
+	0x9a, 0xd4, 0xb4, 0xe1, 0xab, 0x8d, 0x35, 0x7a, 0x84, 0xe7, 0xf7, 0xd6, 0xe5, 0x1a, 0xa5, 0x8e,
+	0x20, 0xef, 0x52, 0xfb, 0xed, 0x22, 0x1c, 0x05, 0x46, 0x7d, 0xdf, 0xda, 0x75, 0x69, 0x27, 0x78,
+	0x5d, 0xe3, 0x9e, 0xdc, 0x7f, 0x70, 0xcf, 0xf6, 0x47, 0xbb, 0x67, 0xd5, 0x1c, 0x3b, 0x9f, 0x6a,
+	0x8e, 0xe3, 0x29, 0x98, 0x9b, 0x54, 0x48, 0x8f, 0xa9, 0xed, 0x70, 0x4c, 0x3d, 0x49, 0x8f, 0xa9,
+	0x42, 0xeb, 0xf3, 0x94, 0xc4, 0x9b, 0x0c, 0x96, 0x9a, 0x65, 0xb5, 0x6f, 0xe0, 0xce, 0x80, 0xbc,
+	0x4f, 0x26, 0xd6, 0x8f, 0x44, 0x08, 0x3c, 0x51, 0x06, 0x48, 0x8b, 0x6b, 0x2c, 0x89, 0x5b, 0xfb,
+	0xd3, 0x80, 0x62, 0x4c, 0xe1, 0x01, 0xf8, 0x14, 0xf6, 0x1d, 0x35, 0xfb, 0x6c, 0x11, 0x74, 0x56,
+	0x11, 0x0a, 0xad, 0xcf, 0x56, 0x1a, 0x7e, 0x73, 0x3c, 0xf6, 0xb7, 0xac, 0x42, 0x48, 0x54, 0x80,
+	0x20, 0x8f, 0x50, 0x75, 0xeb, 0x3c, 0x99, 0xb5, 0x79, 0x6e, 0x1a, 0x27, 0xc8, 0x13, 0x12, 0xc3,
+	0x3c, 0x8f, 0x21, 0x47, 0xc9, 0x7b, 0xa9, 0x5c, 0xb1, 0xc4, 0xdf, 0xb0, 0xdb, 0xfe, 0x96, 0xa5,
+	0x08, 0x9d, 0x02, 0xec, 0x71, 0x72, 0xa5, 0xe7, 0xfa, 0xdf, 0x19, 0xa8, 0xa4, 0xf7, 0x29, 0xe6,
+	0x9e, 0x44, 0x5f, 0xc3, 0xe1, 0xba, 0x83, 0xa1, 0xff, 0x1d, 0xb7, 0xd6, 0x9c, 0x0b, 0xf4, 0x25,
+	0x94, 0x57, 0x4e, 0xb4, 0xfe, 0xab, 0x94, 0x96, 0x0f, 0x74, 0xa0, 0xf9, 0x94, 0x2c, 0xec, 0x31,
+	0x96, 0x38, 0x32, 0xf4, 0x94, 0x2c, 0x4e, 0xb0, 0xc4, 0xe8, 0x31, 0x14, 0x7d, 0x42, 0x78, 0x32,
+	0x48, 0x73, 0x1b, 0x07, 0xe9, 0x7e, 0x00, 0xbc, 0x39, 0x47, 0x3f, 0x7d, 0x04, 0x3f, 0x84, 0x83,
+	0x29, 0x21, 0xbe, 0xed, 0x5c, 0x62, 0x4a, 0x89, 0x67, 0x33, 0x9f, 0x50, 0xe5, 0xe8, 0xbc, 0x55,
+	0x0e, 0x16, 0xba, 0x61, 0xfc, 0xdc, 0x27, 0x14, 0x9d, 0xc1, 0x81, 0xaa, 0x6f, 0xc9, 0xfd, 0xbb,
+	0x1f, 0xe3, 0xfe, 0x72, 0xc0, 0xb3, 0x52, 0xe3, 0xf1, 0x45, 0x5a, 0xf5, 0x91, 0xc4, 0x72, 0xae,
+	0x2e, 0x26, 0x0e, 0x1b, 0x13, 0xa5, 0x72, 0xd1, 0x52, 0xcf, 0xc8, 0x84, 0xdd, 0x31, 0x91, 0xd8,
+	0x55, 0xff, 0xbb, 0x40, 0xce, 0xe8, 0xb5, 0xf6, 0x87, 0x01, 0xa5, 0xa5, 0xc6, 0xf9, 0xc1, 0xc5,
+	0x87, 0xcd, 0xa5, 0xfd, 0x2e, 0x38, 0x05, 0x91, 0xa1, 0xf7, 0xd8, 0x5c, 0x9e, 0xaa, 0x00, 0xfa,
+	0x02, 0x4a, 0xca, 0xea, 0xb6, 0xc3, 0xa8, 0x98, 0xcf, 0xc8, 0x58, 0xa5, 0x2c, 0x5a, 0x45, 0x15,
+	0xed, 0xea, 0x20, 0x6a, 0xc1, 0x0e, 0x57, 0x36, 0xd0, 0xce, 0x3a, 0x5e, 0xf3, 0xe3, 0xd6, 0x46,
+	0xb1, 0x34, 0x32, 0xe0, 0x08, 0xb5, 0x09, 0xdd, 0xb2, 0xb5, 0x9c, 0x70, 0x9b, 0x96, 0x46, 0x3e,
+	0xfc, 0x01, 0x0e, 0x6e, 0x5c, 0x04, 0x50, 0x0d, 0xfe, 0xd7, 0x6f, 0x0f, 0x4e, 0x46, 0xfd, 0xf6,
+	0xcb, 0x9e, 0x3d, 0xb4, 0xce, 0x2f, 0xce, 0xbb, 0xe7, 0xaf, 0xec, 0xd7, 0x83, 0xd1, 0xb0, 0xd7,
+	0x3d, 0x3b, 0x3d, 0xeb, 0x9d, 0x54, 0xb6, 0xd0, 0x2e, 0x64, 0x2f, 0x5e, 0x8d, 0x2a, 0x06, 0xca,
+	0x43, 0xae, 0xfd, 0xea, 0x62, 0x54, 0xc9, 0x3c, 0xec, 0x41, 0x79, 0xe5, 0x96, 0x86, 0xaa, 0x70,
+	0x6f, 0xd0, 0xbb, 0xf8, 0xf9, 0xdc, 0x7a, 0xf9, 0xa1, 0x3c, 0xdd, 0x61, 0xc5, 0x08, 0x1e, 0x5e,
+	0x9f, 0x0c, 0x2b, 0x99, 0xd6, 0x9b, 0x54, 0x49, 0x7c, 0x14, 0xde, 0xd9, 0xd0, 0x29, 0x14, 0x4e,
+	0x58, 0x1c, 0x46, 0x77, 0xd6, 0xcb, 0x71, 0x75, 0x6c, 0x6e, 0xd0, 0xc9, 0xaf, 0x6d, 0xd5, 0x8d,
+	0xaf, 0x8c, 0xce, 0x14, 0x6e, 0xbb, 0x2c, 0xc4, 0x60, 0x4f, 0x8a, 0x86, 0x4b, 0x25, 0xe1, 0x14,
+	0x7b, 0x9d, 0x72, 0x02, 0x57, 0xd5, 0x0f, 0x8d, 0x5f, 0x9e, 0x4f, 0x18, 0x9b, 0x78, 0xa4, 0x31,
+	0x61, 0x1e, 0xa6, 0x93, 0x06, 0xe3, 0x93, 0xa6, 0xba, 0x0a, 0x3b, 0x9c, 0x28, 0xe3, 0x62, 0x4f,
+	0x34, 0x83, 0x24, 0xcd, 0x28, 0x49, 0x53, 0x9d, 0x3a, 0x05, 0xb2, 0x27, 0x8e, 0xff, 0x76, 0x47,
+	0xbd, 0x3f, 0xfa, 0x37, 0x00, 0x00, 0xff, 0xff, 0x6e, 0x37, 0x34, 0x9b, 0x67, 0x0b, 0x00, 0x00,
 }

vendor/google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp/transport_security_common.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: grpc/gcp/transport_security_common.proto
 
-package grpc_gcp // import "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
+package grpc_gcp // import "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -43,7 +43,7 @@ func (x SecurityLevel) String() string {
 	return proto.EnumName(SecurityLevel_name, int32(x))
 }
 func (SecurityLevel) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_transport_security_common_6489ab913bf26255, []int{0}
+	return fileDescriptor_transport_security_common_71945991f2c3b4a6, []int{0}
 }
 
 // Max and min supported RPC protocol versions.
@@ -61,7 +61,7 @@ func (m *RpcProtocolVersions) Reset()         { *m = RpcProtocolVersions{} }
 func (m *RpcProtocolVersions) String() string { return proto.CompactTextString(m) }
 func (*RpcProtocolVersions) ProtoMessage()    {}
 func (*RpcProtocolVersions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_transport_security_common_6489ab913bf26255, []int{0}
+	return fileDescriptor_transport_security_common_71945991f2c3b4a6, []int{0}
 }
 func (m *RpcProtocolVersions) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RpcProtocolVersions.Unmarshal(m, b)
@@ -108,7 +108,7 @@ func (m *RpcProtocolVersions_Version) Reset()         { *m = RpcProtocolVersions
 func (m *RpcProtocolVersions_Version) String() string { return proto.CompactTextString(m) }
 func (*RpcProtocolVersions_Version) ProtoMessage()    {}
 func (*RpcProtocolVersions_Version) Descriptor() ([]byte, []int) {
-	return fileDescriptor_transport_security_common_6489ab913bf26255, []int{0, 0}
+	return fileDescriptor_transport_security_common_71945991f2c3b4a6, []int{0, 0}
 }
 func (m *RpcProtocolVersions_Version) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RpcProtocolVersions_Version.Unmarshal(m, b)
@@ -149,30 +149,30 @@ func init() {
 }
 
 func init() {
-	proto.RegisterFile("grpc/gcp/transport_security_common.proto", fileDescriptor_transport_security_common_6489ab913bf26255)
+	proto.RegisterFile("grpc/gcp/transport_security_common.proto", fileDescriptor_transport_security_common_71945991f2c3b4a6)
 }
 
-var fileDescriptor_transport_security_common_6489ab913bf26255 = []byte{
-	// 324 bytes of a gzipped FileDescriptorProto
+var fileDescriptor_transport_security_common_71945991f2c3b4a6 = []byte{
+	// 323 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x91, 0x41, 0x4b, 0x3b, 0x31,
 	0x10, 0xc5, 0xff, 0x5b, 0xf8, 0xab, 0x44, 0x56, 0xeb, 0x6a, 0x41, 0xc5, 0x83, 0x08, 0x42, 0xf1,
-	0x90, 0x05, 0xc5, 0x93, 0xa7, 0xb6, 0x16, 0x29, 0xd4, 0x6d, 0xdd, 0xd6, 0x42, 0xbd, 0x84, 0x18,
-	0x43, 0x88, 0x64, 0x33, 0x61, 0x36, 0x96, 0xfa, 0x95, 0xfd, 0x14, 0xb2, 0x69, 0x97, 0x22, 0x78,
-	0xf1, 0x96, 0xf7, 0x98, 0xf9, 0x4d, 0x66, 0x1e, 0x69, 0x2b, 0x74, 0x22, 0x55, 0xc2, 0xa5, 0x1e,
-	0xb9, 0x2d, 0x1d, 0xa0, 0x67, 0xa5, 0x14, 0x1f, 0xa8, 0xfd, 0x27, 0x13, 0x50, 0x14, 0x60, 0xa9,
-	0x43, 0xf0, 0x90, 0xec, 0x54, 0x95, 0x54, 0x09, 0x77, 0xf1, 0x15, 0x91, 0xc3, 0xdc, 0x89, 0x71,
-	0x65, 0x0b, 0x30, 0x33, 0x89, 0xa5, 0x06, 0x5b, 0x26, 0x8f, 0x64, 0xbf, 0xe0, 0x4b, 0x86, 0x4e,
-	0xb0, 0xc5, 0xca, 0x3b, 0x8e, 0xce, 0xa3, 0xf6, 0xee, 0xf5, 0x25, 0xad, 0x7b, 0xe9, 0x2f, 0x7d,
-	0x74, 0xfd, 0xc8, 0xe3, 0x82, 0x2f, 0x73, 0x27, 0xd6, 0x32, 0xe0, 0xb4, 0xfd, 0x81, 0x6b, 0xfc,
-	0x0d, 0xa7, 0xed, 0x06, 0x77, 0x7a, 0x4b, 0xb6, 0x6b, 0xf2, 0x11, 0xf9, 0x5f, 0xf0, 0x77, 0xc0,
-	0xf0, 0xbd, 0x38, 0x5f, 0x89, 0xe0, 0x6a, 0x0b, 0x18, 0xa6, 0x54, 0x6e, 0x25, 0xae, 0x9e, 0x48,
-	0x3c, 0x59, 0xdf, 0x63, 0x28, 0x17, 0xd2, 0x24, 0x07, 0x24, 0x9e, 0xf4, 0x7b, 0xcf, 0xf9, 0x60,
-	0x3a, 0x67, 0xd9, 0x28, 0xeb, 0x37, 0xff, 0x25, 0x09, 0xd9, 0x1b, 0x64, 0xd3, 0xfe, 0x43, 0xf0,
-	0x46, 0xd9, 0x70, 0xde, 0x8c, 0x92, 0x13, 0xd2, 0xda, 0x78, 0x9d, 0xec, 0x9e, 0x8d, 0xf3, 0xc1,
-	0xac, 0xd3, 0x9b, 0x37, 0x1b, 0x5d, 0x4f, 0x5a, 0x1a, 0x56, 0x3b, 0x70, 0xe3, 0x4b, 0xaa, 0xad,
-	0x97, 0x68, 0xb9, 0xe9, 0x9e, 0x4d, 0xeb, 0x0c, 0xea, 0x91, 0xbd, 0x90, 0x40, 0x58, 0x71, 0x1c,
-	0xbd, 0xdc, 0x29, 0x00, 0x65, 0x24, 0x55, 0x60, 0xb8, 0x55, 0x14, 0x50, 0xa5, 0x21, 0x3e, 0x81,
-	0xf2, 0x4d, 0x5a, 0xaf, 0xb9, 0x29, 0xd3, 0x8a, 0x98, 0x0a, 0x40, 0x99, 0x86, 0xd8, 0x42, 0x01,
-	0x53, 0xc2, 0xbd, 0x6e, 0x05, 0x7d, 0xf3, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xa8, 0xc8, 0x38, 0x9d,
-	0xf2, 0x01, 0x00, 0x00,
+	0x90, 0x05, 0xc5, 0xb3, 0xb4, 0xb5, 0x48, 0xa1, 0x6e, 0xeb, 0xb6, 0x16, 0xea, 0x25, 0xc4, 0x18,
+	0x42, 0x24, 0x9b, 0x09, 0xb3, 0xb1, 0xd4, 0xaf, 0xec, 0xa7, 0x90, 0x4d, 0xbb, 0x14, 0xc1, 0x8b,
+	0xb7, 0xbc, 0xc7, 0xcc, 0x6f, 0x32, 0xf3, 0x48, 0x5b, 0xa1, 0x13, 0xa9, 0x12, 0x2e, 0xf5, 0xc8,
+	0x6d, 0xe9, 0x00, 0x3d, 0x2b, 0xa5, 0xf8, 0x40, 0xed, 0x3f, 0x99, 0x80, 0xa2, 0x00, 0x4b, 0x1d,
+	0x82, 0x87, 0x64, 0xa7, 0xaa, 0xa4, 0x4a, 0xb8, 0x8b, 0xaf, 0x88, 0x1c, 0xe6, 0x4e, 0x8c, 0x2b,
+	0x5b, 0x80, 0x99, 0x49, 0x2c, 0x35, 0xd8, 0x32, 0x79, 0x24, 0xfb, 0x05, 0x5f, 0x32, 0x74, 0x82,
+	0x2d, 0x56, 0xde, 0x71, 0x74, 0x1e, 0xb5, 0x77, 0xaf, 0x2f, 0x69, 0xdd, 0x4b, 0x7f, 0xe9, 0xa3,
+	0xeb, 0x47, 0x1e, 0x17, 0x7c, 0x99, 0x3b, 0xb1, 0x96, 0x01, 0xa7, 0xed, 0x0f, 0x5c, 0xe3, 0x6f,
+	0x38, 0x6d, 0x37, 0xb8, 0xd3, 0x5b, 0xb2, 0x5d, 0x93, 0x8f, 0xc8, 0xff, 0x82, 0xbf, 0x03, 0x86,
+	0xef, 0xc5, 0xf9, 0x4a, 0x04, 0x57, 0x5b, 0xc0, 0x30, 0xa5, 0x72, 0x2b, 0x71, 0xf5, 0x44, 0xe2,
+	0xc9, 0xfa, 0x1e, 0x43, 0xb9, 0x90, 0x26, 0x39, 0x20, 0xf1, 0xa4, 0xdf, 0x7b, 0xce, 0x07, 0xd3,
+	0x39, 0xcb, 0x46, 0x59, 0xbf, 0xf9, 0x2f, 0x49, 0xc8, 0xde, 0x20, 0x9b, 0xf6, 0x1f, 0x82, 0x37,
+	0xca, 0x86, 0xf3, 0x66, 0x94, 0x9c, 0x90, 0xd6, 0xc6, 0xeb, 0x64, 0xf7, 0x6c, 0x9c, 0x0f, 0x66,
+	0x9d, 0xde, 0xbc, 0xd9, 0xe8, 0x2e, 0x49, 0x4b, 0xc3, 0x6a, 0x07, 0x6e, 0x7c, 0x49, 0xb5, 0xf5,
+	0x12, 0x2d, 0x37, 0xdd, 0xb3, 0x69, 0x9d, 0x41, 0x3d, 0xb2, 0x17, 0x12, 0x08, 0x2b, 0x8e, 0xa3,
+	0x97, 0x3b, 0x05, 0xa0, 0x8c, 0xa4, 0x0a, 0x0c, 0xb7, 0x8a, 0x02, 0xaa, 0x34, 0xc4, 0x27, 0x50,
+	0xbe, 0x49, 0xeb, 0x35, 0x37, 0x65, 0x5a, 0x11, 0xd3, 0x9a, 0x98, 0x86, 0xe8, 0x42, 0x11, 0x53,
+	0xc2, 0xbd, 0x6e, 0x05, 0x7d, 0xf3, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x31, 0x14, 0xb4, 0x11, 0xf6,
+	0x01, 0x00, 0x00,
 }

vendor/google.golang.org/grpc/credentials/alts/internal/testutil/testutil.go

@@ -26,7 +26,7 @@ import (
 	"net"
 	"sync"
 
-	"google.golang.org/grpc/credentials/alts/core/conn"
+	"google.golang.org/grpc/credentials/alts/internal/conn"
 )
 
 // Stats is used to collect statistics about concurrent handshake calls.

vendor/google.golang.org/grpc/credentials/alts/utils.go

@@ -29,7 +29,6 @@ import (
 	"regexp"
 	"runtime"
 	"strings"
-	"time"
 
 	"golang.org/x/net/context"
 	"google.golang.org/grpc/peer"
@@ -41,7 +40,6 @@ const (
 	windowsCheckCommandArgs  = "Get-WmiObject -Class Win32_BIOS"
 	powershellOutputFilter   = "Manufacturer"
 	windowsManufacturerRegex = ":(.*)"
-	windowsCheckTimeout      = 30 * time.Second
 )
 
 type platformError string
@@ -124,13 +122,20 @@ func readManufacturer() ([]byte, error) {
 // information about the communicating peer. For client-side, use grpc.Peer()
 // CallOption.
 func AuthInfoFromContext(ctx context.Context) (AuthInfo, error) {
-	peer, ok := peer.FromContext(ctx)
+	p, ok := peer.FromContext(ctx)
 	if !ok {
 		return nil, errors.New("no Peer found in Context")
 	}
-	altsAuthInfo, ok := peer.AuthInfo.(AuthInfo)
+	return AuthInfoFromPeer(p)
+}
+
+// AuthInfoFromPeer extracts the alts.AuthInfo object from the given peer, if it
+// exists. This API should be used by gRPC clients after obtaining a peer object
+// using the grpc.Peer() CallOption.
+func AuthInfoFromPeer(p *peer.Peer) (AuthInfo, error) {
+	altsAuthInfo, ok := p.AuthInfo.(AuthInfo)
 	if !ok {
-		return nil, errors.New("no alts.AuthInfo found in Context")
+		return nil, errors.New("no alts.AuthInfo found in Peer")
 	}
 	return altsAuthInfo, nil
 }

vendor/google.golang.org/grpc/credentials/alts/utils_test.go

@@ -24,7 +24,7 @@ import (
 	"testing"
 
 	"golang.org/x/net/context"
-	altspb "google.golang.org/grpc/credentials/alts/core/proto/grpc_gcp"
+	altspb "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp"
 	"google.golang.org/grpc/peer"
 )
 
@@ -98,6 +98,34 @@ func TestAuthInfoFromContext(t *testing.T) {
 	}
 }
 
+func TestAuthInfoFromPeer(t *testing.T) {
+	altsAuthInfo := &fakeALTSAuthInfo{}
+	p := &peer.Peer{
+		AuthInfo: altsAuthInfo,
+	}
+	for _, tc := range []struct {
+		desc    string
+		p       *peer.Peer
+		success bool
+		out     AuthInfo
+	}{
+		{
+			"working case",
+			p,
+			true,
+			altsAuthInfo,
+		},
+	} {
+		authInfo, err := AuthInfoFromPeer(tc.p)
+		if got, want := (err == nil), tc.success; got != want {
+			t.Errorf("%v: AuthInfoFromPeer(_)=(err=nil)=%v, want %v", tc.desc, got, want)
+		}
+		if got, want := authInfo, tc.out; got != want {
+			t.Errorf("%v:, AuthInfoFromPeer(_)=(%v, _), want (%v, _)", tc.desc, got, want)
+		}
+	}
+}
+
 type fakeALTSAuthInfo struct{}
 
 func (*fakeALTSAuthInfo) AuthType() string            { return "" }