chore: ctrl port connection id validation

modules/apps/27-interchain-accounts/keeper/handshake.go

@@ -1,11 +1,15 @@
 package keeper
 
 import (
+	"strconv"
+	"strings"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
 
 	"github.com/cosmos/ibc-go/v2/modules/apps/27-interchain-accounts/types"
+	connectiontypes "github.com/cosmos/ibc-go/v2/modules/core/03-connection/types"
 	channeltypes "github.com/cosmos/ibc-go/v2/modules/core/04-channel/types"
 	porttypes "github.com/cosmos/ibc-go/v2/modules/core/05-port/types"
 	host "github.com/cosmos/ibc-go/v2/modules/core/24-host"
@@ -31,16 +35,50 @@ func (k Keeper) OnChanOpenInit(
 	version string,
 ) error {
 	if order != channeltypes.ORDERED {
-		return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "invalid channel ordering: %s, expected %s", order.String(), channeltypes.ORDERED.String())
+		return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s", channeltypes.ORDERED, order)
 	}
+
 	if counterparty.PortId != types.PortID {
-		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "counterparty port-id must be '%s', (%s != %s)", types.PortID, counterparty.PortId, types.PortID)
+		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "expected %s, got %s", types.PortID, portID)
 	}
 
 	if err := types.ValidateVersion(version); err != nil {
 		return sdkerrors.Wrap(err, "version validation failed")
 	}
 
+	s := strings.Split(portID, types.Delimiter)
+	if len(s) != 4 {
+		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "unexpected format in port ID (%s)", portID)
+	}
+
+	channel, found := k.channelKeeper.GetChannel(ctx, portID, channelID)
+	if !found {
+		return sdkerrors.Wrapf(channeltypes.ErrChannelNotFound, "port ID (%s) channel ID (%s)", portID, channelID)
+	}
+
+	counterpartyHops, found := k.channelKeeper.CounterpartyHops(ctx, channel)
+	if !found {
+		return sdkerrors.Wrap(connectiontypes.ErrConnectionNotFound, channel.ConnectionHops[0])
+	}
+
+	connSeq, err := connectiontypes.ParseConnectionSequence(connectionHops[0])
+	if err != nil {
+		return sdkerrors.Wrap(connectiontypes.ErrInvalidConnection, "failed to parse connection sequence")
+	}
+
+	counterpartyConnSeq, err := connectiontypes.ParseConnectionSequence(counterpartyHops[0])
+	if err != nil {
+		return sdkerrors.Wrap(connectiontypes.ErrInvalidConnection, "failed to parse counterparty connection sequence")
+	}
+
+	if strconv.FormatUint(connSeq, 10) != s[1] {
+		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "invalid connection sequence in port (%s)", s[1])
+	}
+
+	if strconv.FormatUint(counterpartyConnSeq, 10) != s[2] {
+		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "invalid connection sequence in port (%s)", s[2])
+	}
+
 	existingChannelID, found := k.GetActiveChannel(ctx, portID)
 	if found {
 		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "existing active channel (%s) for portID (%s)", existingChannelID, portID)
@@ -70,7 +108,7 @@ func (k Keeper) OnChanOpenTry(
 	counterpartyVersion string,
 ) error {
 	if order != channeltypes.ORDERED {
-		return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "invalid channel ordering: %s, expected %s", order.String(), channeltypes.ORDERED.String())
+		return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s", channeltypes.ORDERED, order)
 	}
 
 	if err := types.ValidateVersion(version); err != nil {
@@ -81,6 +119,43 @@ func (k Keeper) OnChanOpenTry(
 		return sdkerrors.Wrap(err, "counterparty version validation failed")
 	}
 
+	if portID != types.PortID {
+		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "expected %s, got %s", types.PortID, portID)
+	}
+
+	s := strings.Split(counterparty.PortId, types.Delimiter)
+	if len(s) != 4 {
+		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "unexpected format in port ID (%s)", counterparty.PortId)
+	}
+
+	channel, found := k.channelKeeper.GetChannel(ctx, portID, channelID)
+	if !found {
+		return sdkerrors.Wrapf(channeltypes.ErrChannelNotFound, "port ID (%s) channel ID (%s)", portID, channelID)
+	}
+
+	counterpartyHops, found := k.channelKeeper.CounterpartyHops(ctx, channel)
+	if !found {
+		return sdkerrors.Wrap(connectiontypes.ErrConnectionNotFound, channel.ConnectionHops[0])
+	}
+
+	connSeq, err := connectiontypes.ParseConnectionSequence(connectionHops[0])
+	if err != nil {
+		return sdkerrors.Wrap(connectiontypes.ErrInvalidConnection, "failed to parse connection sequence")
+	}
+
+	counterpartyConnSeq, err := connectiontypes.ParseConnectionSequence(counterpartyHops[0])
+	if err != nil {
+		return sdkerrors.Wrap(connectiontypes.ErrInvalidConnection, "failed to parse counterparty connection sequence")
+	}
+
+	if strconv.FormatUint(connSeq, 10) != s[2] {
+		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "invalid connection sequence in port (%s)", s[2])
+	}
+
+	if strconv.FormatUint(counterpartyConnSeq, 10) != s[1] {
+		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "invalid connection sequence in port (%s)", s[1])
+	}
+
 	// On the host chain the capability may only be claimed during the OnChanOpenTry
 	// The capability being claimed in OpenInit is for a controller chain (the port is different)
 	if err := k.ClaimCapability(ctx, chanCap, host.ChannelCapabilityPath(portID, channelID)); err != nil {

modules/apps/27-interchain-accounts/keeper/handshake_test.go

@@ -23,33 +23,92 @@ func (suite *KeeperTestSuite) TestOnChanOpenInit() {
 	}{
 
 		{
-			"success", func() {}, true,
+			"success",
+			func() {
+				path.EndpointA.SetChannel(*channel)
+			},
+			true,
 		},
 		{
-			"invalid order - UNORDERED", func() {
+			"invalid order - UNORDERED",
+			func() {
 				channel.Ordering = channeltypes.UNORDERED
-			}, false,
+			},
+			false,
 		},
 		{
-			"invalid counterparty port ID", func() {
-				channel.Counterparty.PortId = ibctesting.MockPort
-			}, false,
+			"invalid port ID",
+			func() {
+				path.EndpointA.ChannelConfig.PortID = "invalid-port-id"
+			},
+			false,
 		},
 		{
-			"invalid version", func() {
+			"invalid counterparty port ID",
+			func() {
+				channel.Counterparty.PortId = "invalid-port-id"
+			},
+			false,
+		},
+		{
+			"invalid version",
+			func() {
 				channel.Version = "version"
-			}, false,
+			},
+			false,
 		},
 		{
-			"channel is already active", func() {
+			"channel not found",
+			func() {
+				path.EndpointA.ChannelID = "invalid-channel-id"
+			},
+			false,
+		},
+		{
+			"connection not found",
+			func() {
+				channel.ConnectionHops = []string{"invalid-connnection-id"}
+				path.EndpointA.SetChannel(*channel)
+			},
+			false,
+		},
+		{
+			"invalid connection sequence",
+			func() {
+				portID, err := types.GeneratePortID(TestOwnerAddress, "connection-1", "connection-0")
+				suite.Require().NoError(err)
+
+				path.EndpointA.ChannelConfig.PortID = portID
+				path.EndpointA.SetChannel(*channel)
+			},
+			false,
+		},
+		{
+			"invalid counterparty connection sequence",
+			func() {
+				portID, err := types.GeneratePortID(TestOwnerAddress, "connection-0", "connection-1")
+				suite.Require().NoError(err)
+
+				path.EndpointA.ChannelConfig.PortID = portID
+				path.EndpointA.SetChannel(*channel)
+			},
+			false,
+		},
+		{
+			"channel is already active",
+			func() {
 				suite.chainA.GetSimApp().ICAKeeper.SetActiveChannel(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
-			}, false,
+			},
+			false,
 		},
 		{
-			"capability already claimed", func() {
+			"capability already claimed",
+			func() {
+				path.EndpointA.SetChannel(*channel)
 				err := suite.chainA.GetSimApp().ScopedICAKeeper.ClaimCapability(suite.chainA.GetContext(), chanCap, host.ChannelCapabilityPath(path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID))
 				suite.Require().NoError(err)
-			}, false,
+			},
+			false,
 		},
 	}
 
@@ -97,7 +156,6 @@ func (suite *KeeperTestSuite) TestOnChanOpenInit() {
 	}
 }
 
-// ChainA is controller, ChainB is host chain
 func (suite *KeeperTestSuite) TestOnChanOpenTry() {
 	var (
 		channel             *channeltypes.Channel
@@ -113,33 +171,103 @@ func (suite *KeeperTestSuite) TestOnChanOpenTry() {
 	}{
 
 		{
-			"success", func() {}, true,
+			"success",
+			func() {
+				path.EndpointB.SetChannel(*channel)
+			},
+			true,
 		},
 		{
-			"invalid order - UNORDERED", func() {
+			"invalid order - UNORDERED",
+			func() {
 				channel.Ordering = channeltypes.UNORDERED
-			}, false,
+			},
+			false,
+		},
+		{
+			"invalid port",
+			func() {
+				path.EndpointB.ChannelConfig.PortID = "invalid-port-id"
+			},
+			false,
+		},
+		{
+			"invalid counterparty port",
+			func() {
+				channel.Counterparty.PortId = "invalid-port-id"
+			},
+			false,
 		},
 		{
-			"invalid version", func() {
+			"channel not found",
+			func() {
+				path.EndpointB.ChannelID = "invalid-channel-id"
+			},
+			false,
+		},
+		{
+			"connection not found",
+			func() {
+				channel.ConnectionHops = []string{"invalid-connnection-id"}
+				path.EndpointB.SetChannel(*channel)
+			},
+			false,
+		},
+		{
+			"invalid connection sequence",
+			func() {
+				portID, err := types.GeneratePortID(TestOwnerAddress, "connection-0", "connection-1")
+				suite.Require().NoError(err)
+
+				channel.Counterparty.PortId = portID
+				path.EndpointB.SetChannel(*channel)
+			},
+			false,
+		},
+		{
+			"invalid counterparty connection sequence",
+			func() {
+				portID, err := types.GeneratePortID(TestOwnerAddress, "connection-1", "connection-0")
+				suite.Require().NoError(err)
+
+				channel.Counterparty.PortId = portID
+				path.EndpointB.SetChannel(*channel)
+			},
+			false,
+		},
+		{
+			"invalid version",
+			func() {
 				channel.Version = "version"
-			}, false,
+			},
+			false,
 		},
 		{
-			"invalid counterparty version", func() {
+			"invalid counterparty version",
+			func() {
 				counterpartyVersion = "version"
-			}, false,
+			},
+			false,
 		},
 		{
-			"capability already claimed", func() {
+			"capability already claimed",
+			func() {
+				path.EndpointB.SetChannel(*channel)
 				err := suite.chainB.GetSimApp().ScopedICAKeeper.ClaimCapability(suite.chainB.GetContext(), chanCap, host.ChannelCapabilityPath(path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID))
 				suite.Require().NoError(err)
-			}, false,
+			},
+			false,
 		},
 		{
-			"invalid account address", func() {
-				channel.Counterparty.PortId = "invalid-port-id"
-			}, false,
+			"invalid account address",
+			func() {
+				portID, err := types.GeneratePortID("invalid-owner-addr", "connection-0", "connection-0")
+				suite.Require().NoError(err)
+
+				channel.Counterparty.PortId = portID
+				path.EndpointB.SetChannel(*channel)
+			},
+			false,
 		},
 	}
 
@@ -155,6 +283,10 @@ func (suite *KeeperTestSuite) TestOnChanOpenTry() {
 			err := InitInterchainAccount(path.EndpointA, TestOwnerAddress)
 			suite.Require().NoError(err)
 
+			// set the channel id on host
+			channelSequence := path.EndpointB.Chain.App.GetIBCKeeper().ChannelKeeper.GetNextChannelSequence(path.EndpointB.Chain.GetContext())
+			path.EndpointB.ChannelID = channeltypes.FormatChannelIdentifier(channelSequence)
+
 			// default values
 			counterparty := channeltypes.NewCounterparty(path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
 			channel = &channeltypes.Channel{

modules/apps/27-interchain-accounts/keeper/keeper_test.go

@@ -21,7 +21,7 @@ var (
 	// TestOwnerAddress defines a reusable bech32 address for testing purposes
 	TestOwnerAddress = "cosmos17dtl0mjt3t77kpuhg2edqzjpszulwhgzuj9ljs"
 	// TestPortID defines a resuable port identifier for testing purposes
-	TestPortID = fmt.Sprintf("%s-0-0-%s", types.VersionPrefix, TestOwnerAddress)
+	TestPortID = fmt.Sprintf("%s|0|0|%s", types.VersionPrefix, TestOwnerAddress)
 	// TestVersion defines a resuable interchainaccounts version string for testing purposes
 	TestVersion = types.NewAppVersion(types.VersionPrefix, TestAccAddress.String())
 )