mirror of
https://github.com/genuinetools/reg.git
synced 2024-08-21 06:10:23 -04:00
408 lines
11 KiB
Go
408 lines
11 KiB
Go
// +build !windows
|
|
|
|
// Licensed under the Apache License, Version 2.0; See LICENSE.APACHE
|
|
|
|
package symlink // import "github.com/docker/docker/pkg/symlink"
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
)
|
|
|
|
// TODO Windows: This needs some serious work to port to Windows. For now,
|
|
// turning off testing in this package.
|
|
|
|
type dirOrLink struct {
|
|
path string
|
|
target string
|
|
}
|
|
|
|
func makeFs(tmpdir string, fs []dirOrLink) error {
|
|
for _, s := range fs {
|
|
s.path = filepath.Join(tmpdir, s.path)
|
|
if s.target == "" {
|
|
os.MkdirAll(s.path, 0755)
|
|
continue
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(s.path), 0755); err != nil {
|
|
return err
|
|
}
|
|
if err := os.Symlink(s.target, s.path); err != nil && !os.IsExist(err) {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func testSymlink(tmpdir, path, expected, scope string) error {
|
|
rewrite, err := FollowSymlinkInScope(filepath.Join(tmpdir, path), filepath.Join(tmpdir, scope))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
expected, err = filepath.Abs(filepath.Join(tmpdir, expected))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if expected != rewrite {
|
|
return fmt.Errorf("Expected %q got %q", expected, rewrite)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func TestFollowSymlinkAbsolute(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkAbsolute")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/a/d", target: "/b"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "testdata/fs/a/d/c/data", "testdata/b/c/data", "testdata"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkRelativePath(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkRelativePath")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/i", target: "a"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "testdata/fs/i", "testdata/fs/a", "testdata"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkSkipSymlinksOutsideScope(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkSkipSymlinksOutsideScope")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
if err := makeFs(tmpdir, []dirOrLink{
|
|
{path: "linkdir", target: "realdir"},
|
|
{path: "linkdir/foo/bar"},
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "linkdir/foo/bar", "linkdir/foo/bar", "linkdir/foo"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkInvalidScopePathPair(t *testing.T) {
|
|
if _, err := FollowSymlinkInScope("toto", "testdata"); err == nil {
|
|
t.Fatal("expected an error")
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkLastLink(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkLastLink")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/a/d", target: "/b"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "testdata/fs/a/d", "testdata/b", "testdata"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkRelativeLinkChangeScope(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkRelativeLinkChangeScope")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/a/e", target: "../b"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "testdata/fs/a/e/c/data", "testdata/fs/b/c/data", "testdata"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// avoid letting allowing symlink e lead us to ../b
|
|
// normalize to the "testdata/fs/a"
|
|
if err := testSymlink(tmpdir, "testdata/fs/a/e", "testdata/fs/a/b", "testdata/fs/a"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkDeepRelativeLinkChangeScope(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkDeepRelativeLinkChangeScope")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/a/f", target: "../../../../test"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// avoid letting symlink f lead us out of the "testdata" scope
|
|
// we don't normalize because symlink f is in scope and there is no
|
|
// information leak
|
|
if err := testSymlink(tmpdir, "testdata/fs/a/f", "testdata/test", "testdata"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// avoid letting symlink f lead us out of the "testdata/fs" scope
|
|
// we don't normalize because symlink f is in scope and there is no
|
|
// information leak
|
|
if err := testSymlink(tmpdir, "testdata/fs/a/f", "testdata/fs/test", "testdata/fs"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkRelativeLinkChain(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkRelativeLinkChain")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
// avoid letting symlink g (pointed at by symlink h) take out of scope
|
|
// TODO: we should probably normalize to scope here because ../[....]/root
|
|
// is out of scope and we leak information
|
|
if err := makeFs(tmpdir, []dirOrLink{
|
|
{path: "testdata/fs/b/h", target: "../g"},
|
|
{path: "testdata/fs/g", target: "../../../../../../../../../../../../root"},
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "testdata/fs/b/h", "testdata/root", "testdata"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkBreakoutPath(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkBreakoutPath")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
// avoid letting symlink -> ../directory/file escape from scope
|
|
// normalize to "testdata/fs/j"
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/j/k", target: "../i/a"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "testdata/fs/j/k", "testdata/fs/j/i/a", "testdata/fs/j"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkToRoot(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkToRoot")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
// make sure we don't allow escaping to /
|
|
// normalize to dir
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "foo", target: "/"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "foo", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkSlashDotdot(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkSlashDotdot")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
tmpdir = filepath.Join(tmpdir, "dir", "subdir")
|
|
|
|
// make sure we don't allow escaping to /
|
|
// normalize to dir
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "foo", target: "/../../"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "foo", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkDotdot(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkDotdot")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
tmpdir = filepath.Join(tmpdir, "dir", "subdir")
|
|
|
|
// make sure we stay in scope without leaking information
|
|
// this also checks for escaping to /
|
|
// normalize to dir
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "foo", target: "../../"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "foo", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkRelativePath2(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkRelativePath2")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "bar/foo", target: "baz/target"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "bar/foo", "bar/baz/target", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkScopeLink(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkScopeLink")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
if err := makeFs(tmpdir, []dirOrLink{
|
|
{path: "root2"},
|
|
{path: "root", target: "root2"},
|
|
{path: "root2/foo", target: "../bar"},
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "root/foo", "root/bar", "root"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkRootScope(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkRootScope")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
expected, err := filepath.EvalSymlinks(tmpdir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
rewrite, err := FollowSymlinkInScope(tmpdir, "/")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if rewrite != expected {
|
|
t.Fatalf("expected %q got %q", expected, rewrite)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkEmpty(t *testing.T) {
|
|
res, err := FollowSymlinkInScope("", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wd, err := os.Getwd()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if res != wd {
|
|
t.Fatalf("expected %q got %q", wd, res)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkCircular(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkCircular")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
if err := makeFs(tmpdir, []dirOrLink{{path: "root/foo", target: "foo"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "root/foo", "", "root"); err == nil {
|
|
t.Fatal("expected an error for foo -> foo")
|
|
}
|
|
|
|
if err := makeFs(tmpdir, []dirOrLink{
|
|
{path: "root/bar", target: "baz"},
|
|
{path: "root/baz", target: "../bak"},
|
|
{path: "root/bak", target: "/bar"},
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "root/foo", "", "root"); err == nil {
|
|
t.Fatal("expected an error for bar -> baz -> bak -> bar")
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkComplexChainWithTargetPathsContainingLinks(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkComplexChainWithTargetPathsContainingLinks")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
if err := makeFs(tmpdir, []dirOrLink{
|
|
{path: "root2"},
|
|
{path: "root", target: "root2"},
|
|
{path: "root/a", target: "r/s"},
|
|
{path: "root/r", target: "../root/t"},
|
|
{path: "root/root/t/s/b", target: "/../u"},
|
|
{path: "root/u/c", target: "."},
|
|
{path: "root/u/x/y", target: "../v"},
|
|
{path: "root/u/v", target: "/../w"},
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "root/a/b/c/x/y/z", "root/w/z", "root"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkBreakoutNonExistent(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkBreakoutNonExistent")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
if err := makeFs(tmpdir, []dirOrLink{
|
|
{path: "root/slash", target: "/"},
|
|
{path: "root/sym", target: "/idontexist/../slash"},
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "root/sym/file", "root/file", "root"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFollowSymlinkNoLexicalCleaning(t *testing.T) {
|
|
tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkNoLexicalCleaning")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(tmpdir)
|
|
|
|
if err := makeFs(tmpdir, []dirOrLink{
|
|
{path: "root/sym", target: "/foo/bar"},
|
|
{path: "root/hello", target: "/sym/../baz"},
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := testSymlink(tmpdir, "root/hello", "root/foo/baz", "root"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|