chore: Basic UnixFS sanity checks

core/commands/files.go

@@ -94,6 +94,7 @@ cache, free memory and speed up read operations.`,
 const (
 	filesCidVersionOptionName = "cid-version"
 	filesHashOptionName       = "hash"
+	filesForceOptionName      = "force"
 )
 
 var (
@@ -440,6 +441,7 @@ being GC'ed.
 	},
 	Options: []cmds.Option{
 		cmds.BoolOption(filesParentsOptionName, "p", "Make parent directories as needed."),
+		cmds.BoolOption(filesForceOptionName, "f", "Force operation: ignore format validation errors and UnixFS safety checks."),
 	},
 	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
 		mkParents, _ := req.Options[filesParentsOptionName].(bool)
@@ -480,6 +482,19 @@ being GC'ed.
 			return fmt.Errorf("cp: cannot get node from path %s: %s", src, err)
 		}
 
+		force, _ := req.Options[filesForceOptionName].(bool)
+		if !force {
+			// Check if it's a raw node
+			if _, ok := node.(*dag.RawNode); !ok {
+				if _, ok := node.(*dag.ProtoNode); !ok {
+					return fmt.Errorf("cp: source must be a valid UnixFS (dag-pb or raw codec)")
+				}
+				if _, err = ft.FSNodeFromBytes(node.(*dag.ProtoNode).Data()); err != nil {
+					return fmt.Errorf("cp: source must be a valid UnixFS (dag-pb or raw codec): %s", err)
+				}
+			}
+		}
+
 		if mkParents {
 			err := ensureContainingDirectoryExists(nd.FilesRoot, dst, prefix)
 			if err != nil {

core/commands/files_test.go

@@ -0,0 +1,47 @@
+package commands
+
+import (
+	"context"
+	"io"
+	"testing"
+
+	dag "github.com/ipfs/boxo/ipld/merkledag"
+	cmds "github.com/ipfs/go-ipfs-cmds"
+	coremock "github.com/ipfs/kubo/core/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFilesCp_DagCborNodeFails(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	cmdCtx, err := coremock.MockCmdsCtx()
+	require.NoError(t, err)
+
+	node, err := cmdCtx.ConstructNode()
+	require.NoError(t, err)
+
+	invalidData := []byte{0x00}
+	protoNode := dag.NodeWithData(invalidData)
+	err = node.DAG.Add(ctx, protoNode)
+	require.NoError(t, err)
+
+	req := &cmds.Request{
+		Context: ctx,
+		Arguments: []string{
+			"/ipfs/" + protoNode.Cid().String(),
+			"/test-destination",
+		},
+		Options: map[string]interface{}{
+			"force": false,
+		},
+	}
+
+	_, pw := io.Pipe()
+	res, err := cmds.NewWriterResponseEmitter(pw, req)
+	require.NoError(t, err)
+
+	err = filesCpCmd.Run(req, res, &cmdCtx)
+	require.Error(t, err)
+	require.ErrorContains(t, err, "cp: source must be a UnixFS node or raw data")
+}

test/cli/files_test.go

@@ -0,0 +1,74 @@
+package cli
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/ipfs/kubo/test/cli/harness"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFilesCp(t *testing.T) {
+	t.Parallel()
+
+	t.Run("files cp with valid UnixFS", func(t *testing.T) {
+		t.Parallel()
+
+		node := harness.NewT(t).NewNode().Init().StartDaemon()
+
+		// Create simple text file
+		data := "testing files cp command"
+		cid := node.IPFSAddStr(data)
+
+		// Copy form IPFS => MFS
+		res := node.IPFS("files", "cp", fmt.Sprintf("/ipfs/%s", cid), "/valid-file")
+		assert.NoError(t, res.Err)
+
+		// verification
+		catRes := node.IPFS("files", "read", "/valid-file")
+		assert.Equal(t, data, catRes.Stdout.Trimmed())
+	})
+
+	t.Run("files cp with invalid DAG node fails without force", func(t *testing.T) {
+		t.Parallel()
+		node := harness.NewT(t).NewNode().Init().StartDaemon()
+
+		// create a dag-cbor node
+		jsonData := `{"data": "not a UnixFS node"}`
+		tempFile := filepath.Join(node.Dir, "test.json")
+		err := os.WriteFile(tempFile, []byte(jsonData), 0644)
+		require.NoError(t, err)
+		cid := node.IPFS("dag", "put", "--input-codec=json", "--store-codec=dag-cbor", tempFile).Stdout.Trimmed()
+
+		// copy without --force
+		res := node.RunIPFS("files", "cp", fmt.Sprintf("/ipfs/%s", cid), "/invalid-file")
+		assert.NotEqual(t, 0, res.ExitErr.ExitCode())
+		assert.Contains(t, res.Stderr.String(), "source must be a UnixFS")
+	})
+
+	t.Run("files cp with invalid DAG node succeeds with force", func(t *testing.T) {
+		t.Parallel()
+		node := harness.NewT(t).NewNode().Init().StartDaemon()
+
+		// create dag-bor node
+		jsonData := `{"data": "not a UnixFS node"}`
+		tempFile := filepath.Join(node.Dir, "test.json")
+		err := os.WriteFile(tempFile, []byte(jsonData), 0644)
+		require.NoError(t, err)
+		cid := node.IPFS("dag", "put", "--input-codec=json", "--store-codec=dag-cbor", tempFile).Stdout.Trimmed()
+
+		// copy with --force
+		resWithForce := node.RunIPFS("files", "cp", "--force", fmt.Sprintf("/ipfs/%s", cid), "/forced-file")
+		assert.NotEqual(t, 0, resWithForce.ExitErr.ExitCode())
+
+		// Verification
+		// Should NOT contain the validation error
+		assert.NotContains(t, resWithForce.Stderr.String(), "source must be a valid UnixFS")
+
+		// But should contain flush error instead
+		assert.Contains(t, resWithForce.Stderr.String(), "cannot flush the created file")
+	})
+}