[FAB-8333] Make peer admin API work with envelopes

The peer admin currently deviates from the spirit of fabric APIs
which involves envelopes containing marshaled payloads of proto messages
which contain marshaled payloads of other proto messages, and that
have channel headers and signature headers, etc.

Therefore we should probably standardize the un-used admin API
and this make it more robust and similar to other fabric APIs
such as the endorser API, the deliver API, etc.

Change-Id: If0ed81c6eed02457fda23e1d9359064187651d1d
Signed-off-by: yacovm <yacovm@il.ibm.com>

Author: yacovm

common/crypto/signer.go

@@ -1,28 +1,68 @@
 /*
-Copyright IBM Corp. 2016 All Rights Reserved.
+Copyright IBM Corp. All Rights Reserved.
 
-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.
+SPDX-License-Identifier: Apache-2.0
 */
 
 package crypto
 
-import cb "github.com/hyperledger/fabric/protos/common"
+import (
+	cb "github.com/hyperledger/fabric/protos/common"
+)
 
 // LocalSigner is a temporary stub interface which will be implemented by the local MSP
 type LocalSigner interface {
+	SignatureHeaderMaker
+	Signer
+}
+
+// Signer signs messages
+type Signer interface {
+	// Sign a message and return the signature over the digest, or error on failure
+	Sign(message []byte) ([]byte, error)
+}
+
+// IdentitySerializer serializes identities
+type IdentitySerializer interface {
+	// Serialize converts an identity to bytes
+	Serialize() ([]byte, error)
+}
+
+// SignatureHeaderMaker creates a new SignatureHeader
+type SignatureHeaderMaker interface {
 	// NewSignatureHeader creates a SignatureHeader with the correct signing identity and a valid nonce
 	NewSignatureHeader() (*cb.SignatureHeader, error)
+}
 
-	// Sign a message which should embed a signature header created by NewSignatureHeader
-	Sign(message []byte) ([]byte, error)
+// SignatureHeaderCreator creates signature headers
+type SignatureHeaderCreator struct {
+	SignerSupport
+}
+
+// SignerSupport implements the needed support for LocalSigner
+type SignerSupport interface {
+	Signer
+	IdentitySerializer
+}
+
+// NewSignatureHeaderCreator creates new signature headers
+func NewSignatureHeaderCreator(ss SignerSupport) *SignatureHeaderCreator {
+	return &SignatureHeaderCreator{ss}
+}
+
+// NewSignatureHeader creates a SignatureHeader with the correct signing identity and a valid nonce
+func (bs *SignatureHeaderCreator) NewSignatureHeader() (*cb.SignatureHeader, error) {
+	creator, err := bs.Serialize()
+	if err != nil {
+		return nil, err
+	}
+	nonce, err := GetRandomNonce()
+	if err != nil {
+		return nil, err
+	}
+
+	return &cb.SignatureHeader{
+		Creator: creator,
+		Nonce:   nonce,
+	}, nil
 }

common/crypto/signer_test.go

@@ -0,0 +1,85 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package crypto
+
+import (
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+func bytesFromArgs(args mock.Arguments) ([]byte, error) {
+	if args.Get(1) != nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).([]byte), nil
+}
+
+type mockSigner struct {
+	mock.Mock
+}
+
+func (s *mockSigner) Sign(message []byte) ([]byte, error) {
+	return bytesFromArgs(s.Called(message))
+}
+
+type mockIdentitySerializer struct {
+	mock.Mock
+}
+
+func (is *mockIdentitySerializer) Serialize() ([]byte, error) {
+	return bytesFromArgs(is.Called())
+}
+
+type signerSupport struct {
+	Signer
+	IdentitySerializer
+}
+
+func TestCLISignerNewSignatureHeader(t *testing.T) {
+	tests := []struct {
+		name           string
+		signError      error
+		serializeError error
+	}{
+		{
+			name:           "SerializeFailure",
+			serializeError: errors.New("failed1"),
+		},
+		{
+			name:           "SignFailure",
+			serializeError: errors.New("failed2"),
+		},
+		{
+			name: "Success",
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			s := &mockSigner{}
+			s.On("Sign", mock.Anything).Return([]byte{1, 2, 3}, test.signError)
+			is := &mockIdentitySerializer{}
+			is.On("Serialize", mock.Anything).Return([]byte{1, 2, 3}, test.serializeError)
+			signer := NewSignatureHeaderCreator(&signerSupport{
+				Signer:             s,
+				IdentitySerializer: is,
+			})
+			sh, err := signer.NewSignatureHeader()
+			if test.serializeError == nil && test.signError == nil {
+				assert.NoError(t, err)
+				assert.NotNil(t, sh)
+				return
+			}
+			assert.Error(t, err)
+			assert.Nil(t, sh)
+		})
+	}
+}

core/admin.go

@@ -1,73 +1,99 @@
 /*
-Copyright IBM Corp. 2016 All Rights Reserved.
+Copyright IBM Corp. All Rights Reserved.
 
-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.
+SPDX-License-Identifier: Apache-2.0
 */
 
 package core
 
 import (
 	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/hyperledger/fabric/common/flogging"
+	"github.com/hyperledger/fabric/protos/common"
 	pb "github.com/hyperledger/fabric/protos/peer"
+	"github.com/pkg/errors"
 	"golang.org/x/net/context"
 )
 
 var logger = flogging.MustGetLogger("server")
 
+type requestValidator interface {
+	validate(ctx context.Context, env *common.Envelope) (*pb.AdminOperation, error)
+}
+
+// AccessControlEvaluator evaluates whether the creator of the given SignedData
+// is eligible of using the admin service
+type AccessControlEvaluator interface {
+	// Evaluate evaluates the eligibility of the creator of the given SignedData
+	// for being serviced by the admin service
+	Evaluate(signatureSet []*common.SignedData) error
+}
+
 // NewAdminServer creates and returns a Admin service instance.
-func NewAdminServer() *ServerAdmin {
-	s := new(ServerAdmin)
+func NewAdminServer(ace AccessControlEvaluator) *ServerAdmin {
+	s := &ServerAdmin{
+		v: &validator{
+			ace: ace,
+		},
+	}
 	return s
 }
 
 // ServerAdmin implementation of the Admin service for the Peer
 type ServerAdmin struct {
+	v requestValidator
 }
 
-// GetStatus reports the status of the server
-func (*ServerAdmin) GetStatus(context.Context, *empty.Empty) (*pb.ServerStatus, error) {
+func (s *ServerAdmin) GetStatus(ctx context.Context, env *common.Envelope) (*pb.ServerStatus, error) {
+	if _, err := s.v.validate(ctx, env); err != nil {
+		return nil, err
+	}
 	status := &pb.ServerStatus{Status: pb.ServerStatus_STARTED}
 	logger.Debugf("returning status: %s", status)
 	return status, nil
 }
 
-// StartServer starts the server
-func (*ServerAdmin) StartServer(context.Context, *empty.Empty) (*pb.ServerStatus, error) {
+func (s *ServerAdmin) StartServer(ctx context.Context, env *common.Envelope) (*pb.ServerStatus, error) {
+	if _, err := s.v.validate(ctx, env); err != nil {
+		return nil, err
+	}
 	status := &pb.ServerStatus{Status: pb.ServerStatus_STARTED}
 	logger.Debugf("returning status: %s", status)
 	return status, nil
 }
 
-// GetModuleLogLevel gets the current logging level for the specified module
-// TODO Modify the signature so as to remove the error return - it's always been nil
-func (*ServerAdmin) GetModuleLogLevel(ctx context.Context, request *pb.LogLevelRequest) (*pb.LogLevelResponse, error) {
+func (s *ServerAdmin) GetModuleLogLevel(ctx context.Context, env *common.Envelope) (*pb.LogLevelResponse, error) {
+	op, err := s.v.validate(ctx, env)
+	if err != nil {
+		return nil, err
+	}
+	request := op.GetLogReq()
+	if request == nil {
+		return nil, errors.New("request is nil")
+	}
 	logLevelString := flogging.GetModuleLevel(request.LogModule)
 	logResponse := &pb.LogLevelResponse{LogModule: request.LogModule, LogLevel: logLevelString}
 	return logResponse, nil
 }
 
-// SetModuleLogLevel sets the logging level for the specified module
-func (*ServerAdmin) SetModuleLogLevel(ctx context.Context, request *pb.LogLevelRequest) (*pb.LogLevelResponse, error) {
+func (s *ServerAdmin) SetModuleLogLevel(ctx context.Context, env *common.Envelope) (*pb.LogLevelResponse, error) {
+	op, err := s.v.validate(ctx, env)
+	if err != nil {
+		return nil, err
+	}
+	request := op.GetLogReq()
+	if request == nil {
+		return nil, errors.New("request is nil")
+	}
 	logLevelString, err := flogging.SetModuleLevel(request.LogModule, request.LogLevel)
 	logResponse := &pb.LogLevelResponse{LogModule: request.LogModule, LogLevel: logLevelString}
 	return logResponse, err
 }
 
-// RevertLogLevels reverts the logger levels for all modules to the level
-// defined at the end of peer startup.
-func (*ServerAdmin) RevertLogLevels(context.Context, *empty.Empty) (*empty.Empty, error) {
+func (s *ServerAdmin) RevertLogLevels(ctx context.Context, env *common.Envelope) (*empty.Empty, error) {
+	if _, err := s.v.validate(ctx, env); err != nil {
+		return nil, err
+	}
 	err := flogging.RevertToPeerStartupLevels()
-
 	return &empty.Empty{}, err
 }