Generate random kernel interface names

pkg/networkservice/common/mechanisms/kernel/client.go

@@ -2,6 +2,8 @@
 //
 // Copyright (c) 2021 Doc.ai and/or its affiliates.
 //
+// Copyright (c) 2024 Cisco and/or its affiliates.
+//
 // SPDX-License-Identifier: Apache-2.0
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,6 +24,7 @@
 	"context"
 
 	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/pkg/errors"
 	"google.golang.org/grpc"
 
 	"github.com/networkservicemesh/api/pkg/api/networkservice"
@@ -46,12 +49,20 @@
 }
 
 func (k *kernelMechanismClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) {
-	if !k.updateMechanismPreferences(request) {
+	updated, err := k.updateMechanismPreferences(request)
+	if err != nil {
+		return nil, errors.Wrap(err, "Failed to update mechanism preferences")
+	}
+	if !updated {
 		mechanism := kernelmech.ToMechanism(kernelmech.New(netNSURL))
 		if k.interfaceName != "" {
 			mechanism.SetInterfaceName(k.interfaceName)
 		} else {
-			mechanism.SetInterfaceName(getNameFromConnection(request.GetConnection()))
+			ifname, err := generateInterfaceName()
+			if err != nil {
+				return nil, errors.Wrap(err, "Failed to generate kernel interface name")
+			}
+			mechanism.SetInterfaceName(ifname)
 		}
 		request.MechanismPreferences = append(request.GetMechanismPreferences(), mechanism.Mechanism)
 	}
@@ -63,7 +74,7 @@
 }
 
 // updateMechanismPreferences returns true if MechanismPreferences has updated
-func (k *kernelMechanismClient) updateMechanismPreferences(request *networkservice.NetworkServiceRequest) bool {
+func (k *kernelMechanismClient) updateMechanismPreferences(request *networkservice.NetworkServiceRequest) (bool, error) {
 	var updated = false
 
 	for _, m := range request.GetRequestMechanismPreferences() {
@@ -72,7 +83,11 @@
 				if k.interfaceName != "" {
 					mechanism.SetInterfaceName(k.interfaceName)
 				} else {
-					mechanism.SetInterfaceName(getNameFromConnection(request.GetConnection()))
+					ifname, err := generateInterfaceName()
+					if err != nil {
+						return false, errors.Wrap(err, "Failed to generate kernel interface name")
+					}
+					mechanism.SetInterfaceName(ifname)
 				}
 			}
 			mechanism.SetNetNSURL(netNSURL)
@@ -81,5 +96,5 @@
 		}
 	}
 
-	return updated
+	return updated, nil
 }

pkg/networkservice/common/mechanisms/kernel/client_test.go

@@ -1,5 +1,7 @@
 // Copyright (c) 2021 Doc.ai and/or its affiliates.
 //
+// Copyright (c) 2024 Cisco and/or its affiliates.
+//
 // SPDX-License-Identifier: Apache-2.0
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,6 +21,7 @@ package kernel_test
 import (
 	"context"
 	"net/url"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -27,6 +30,8 @@ import (
 	kernelmech "github.com/networkservicemesh/api/pkg/api/networkservice/mechanisms/kernel"
 
 	"github.com/networkservicemesh/sdk/pkg/networkservice/common/mechanisms/kernel"
+
+	"github.com/networkservicemesh/sdk/pkg/tools/nanoid"
 )
 
 var netNSURL = (&url.URL{Scheme: "file", Path: "/proc/thread-self/ns/net"}).String()
@@ -72,3 +77,19 @@ func TestKernelMechanismClient_ShouldSetValidNetNSURL(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, netNSURL, req.MechanismPreferences[0].Parameters[kernelmech.NetNSURL])
 }
+
+func TestKernelMechanismClient_ShouldSetRandomInteraceName(t *testing.T) {
+	c := kernel.NewClient()
+	req := &networkservice.NetworkServiceRequest{}
+
+	_, err := c.Request(context.Background(), req)
+	require.NoError(t, err)
+
+	ifname := req.MechanismPreferences[0].Parameters[kernelmech.InterfaceNameKey]
+
+	require.Len(t, ifname, kernelmech.LinuxIfMaxLength)
+	require.True(t, strings.HasPrefix(ifname, "nsm"))
+	for i := 0; i < kernelmech.LinuxIfMaxLength; i++ {
+		require.Contains(t, nanoid.DefaultAlphabet, string(ifname[i]))
+	}
+}

pkg/networkservice/common/mechanisms/kernel/server.go

@@ -1,5 +1,7 @@
 // Copyright (c) 2020-2021 Doc.ai and/or its affiliates.
 //
+// Copyright (c) 2024 Cisco and/or its affiliates.
+//
 // SPDX-License-Identifier: Apache-2.0
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,6 +23,7 @@
 	"context"
 
 	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/pkg/errors"
 
 	"github.com/networkservicemesh/api/pkg/api/networkservice"
 	kernelmech "github.com/networkservicemesh/api/pkg/api/networkservice/mechanisms/kernel"
@@ -49,7 +52,11 @@
 		if m.interfaceName != "" {
 			mechanism.SetInterfaceName(m.interfaceName)
 		} else {
-			mechanism.SetInterfaceName(getNameFromConnection(request.GetConnection()))
+			ifname, err := generateInterfaceName()
+			if err != nil {
+				return nil, errors.Wrap(err, "Failed to generate kernel interface name")
+			}
+			mechanism.SetInterfaceName(ifname)
 		}
 	}
 	return next.Server(ctx).Request(ctx, request)

pkg/networkservice/common/mechanisms/kernel/utils.go

@@ -1,5 +1,7 @@
 // Copyright (c) 2021 Doc.ai and/or its affiliates.
 //
+// Copyright (c) 2024 Cisco and/or its affiliates.
+//
 // SPDX-License-Identifier: Apache-2.0
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,21 +22,27 @@
 	"fmt"
 	"net/url"
 
-	"github.com/networkservicemesh/api/pkg/api/networkservice"
 	kernelmech "github.com/networkservicemesh/api/pkg/api/networkservice/mechanisms/kernel"
+
+	"github.com/networkservicemesh/sdk/pkg/tools/nanoid"
+)
+
+const (
+	ifPrefix = "nsm"
 )
 
 var netNSURL = (&url.URL{Scheme: "file", Path: "/proc/thread-self/ns/net"}).String()
 
-// getNameFromConnection - returns a name computed from networkservice.Connection 'conn'
-func getNameFromConnection(conn *networkservice.Connection) string {
-	ns := conn.GetNetworkService()
-	nsMaxLength := kernelmech.LinuxIfMaxLength - 5
-	if len(ns) > nsMaxLength {
-		ns = ns[:nsMaxLength]
+// generateInterfaceName - returns a random interface name with "nsm" prefix
+func generateInterfaceName() (string, error) {
+	ifIDLen := kernelmech.LinuxIfMaxLength - len(ifPrefix)
+	id, err := nanoid.RandomString(ifIDLen)
+	if err != nil {
+		return "", err
 	}
-	name := fmt.Sprintf("%s-%s", ns, conn.GetId())
-	return limitName(name)
+	name := fmt.Sprintf("%s%s", ifPrefix, id)
+
+	return limitName(name), nil
 }
 
 func limitName(name string) string {

pkg/networkservice/common/mechanismtranslation/client_test.go

@@ -1,5 +1,7 @@
 // Copyright (c) 2020-2021 Doc.ai and/or its affiliates.
 //
+// Copyright (c) 2024 Cisco and/or its affiliates.
+//
 // SPDX-License-Identifier: Apache-2.0
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -41,13 +43,17 @@ import (
 	"github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata"
 )
 
+const (
+	clientIfName = "nsm1"
+)
+
 func kernelMechanism() *networkservice.Mechanism {
 	request := &networkservice.NetworkServiceRequest{
 		Connection: &networkservice.Connection{
 			Id: "id",
 		},
 	}
-	_, _ = kernel.NewClient().Request(context.Background(), request)
+	_, _ = kernel.NewClient(kernel.WithInterfaceName(clientIfName)).Request(context.Background(), request)
 	return request.MechanismPreferences[0]
 }
 
@@ -58,7 +64,7 @@ func TestMechanismTranslationClient(t *testing.T) {
 		metadata.NewClient(),
 		mechanismtranslation.NewClient(),
 		capture,
-		kernel.NewClient(),
+		kernel.NewClient(kernel.WithInterfaceName(clientIfName)),
 		adapters.NewServerToClient(
 			mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{
 				kernelmech.MECHANISM: null.NewServer(),
@@ -130,7 +136,7 @@ func TestMechanismTranslationClient_CloseOnError(t *testing.T) {
 			}
 			count++
 		}),
-		kernel.NewClient(),
+		kernel.NewClient(kernel.WithInterfaceName(clientIfName)),
 		adapters.NewServerToClient(
 			mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{
 				kernelmech.MECHANISM: null.NewServer(),

pkg/tools/nanoid/generator.go

@@ -0,0 +1,88 @@
+// Copyright (c) 2024 Cisco and/or its affiliates.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// 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 nanoid is a tiny, unique string ID generator
+package nanoid
+
+import (
+	"crypto/rand"
+	"math"
+	"math/bits"
+)
+
+const (
+	// DefaultAlphabet is the default alphabet for the generator which can be used to generate kernel interface names
+	DefaultAlphabet = "!\"#$&'()*+,-.012456789;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+)
+
+type generatorOpts struct {
+	alphabet string
+}
+
+// Option represents options for the string generator
+type Option func(o *generatorOpts)
+
+// WithAlphabet sets a custom alphabet for the  generator
+func WithAlphabet(alphabet string) Option {
+	return func(o *generatorOpts) {
+		o.alphabet = alphabet
+	}
+}
+
+func generateRandomBuffer(step int) ([]byte, error) {
+	buffer := make([]byte, step)
+	if _, err := rand.Read(buffer); err != nil {
+		return nil, err
+	}
+	return buffer, nil
+}
+
+// RandomString generates a random string based on size.
+// Original JavaScript implementation: https://github.com/ai/nanoid/blob/main/README.md
+func RandomString(size int, opt ...Option) (string, error) {
+	opts := &generatorOpts{
+		alphabet: DefaultAlphabet,
+	}
+
+	for _, o := range opt {
+		o(opts)
+	}
+
+	mask := 2<<uint32(31-bits.LeadingZeros32(uint32(len(opts.alphabet)-1|1))) - 1
+	step := int(math.Ceil(1.6 * float64(mask*size) / float64(len(opts.alphabet))))
+
+	id := make([]byte, size)
+
+	for {
+		randomBuffer, err := generateRandomBuffer(step)
+		if err != nil {
+			return "", err
+		}
+
+		j := 0
+		for i := 0; i < step; i++ {
+			currentIndex := int(randomBuffer[i]) & mask
+
+			if currentIndex < len(opts.alphabet) {
+				id[j] = opts.alphabet[currentIndex]
+				j++
+				if j == size {
+					return string(id), nil
+				}
+			}
+		}
+	}
+}