fs_unix_test.go 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407
  1. // +build !windows
  2. // Licensed under the Apache License, Version 2.0; See LICENSE.APACHE
  3. package symlink
  4. import (
  5. "fmt"
  6. "io/ioutil"
  7. "os"
  8. "path/filepath"
  9. "testing"
  10. )
  11. // TODO Windows: This needs some serious work to port to Windows. For now,
  12. // turning off testing in this package.
  13. type dirOrLink struct {
  14. path string
  15. target string
  16. }
  17. func makeFs(tmpdir string, fs []dirOrLink) error {
  18. for _, s := range fs {
  19. s.path = filepath.Join(tmpdir, s.path)
  20. if s.target == "" {
  21. os.MkdirAll(s.path, 0755)
  22. continue
  23. }
  24. if err := os.MkdirAll(filepath.Dir(s.path), 0755); err != nil {
  25. return err
  26. }
  27. if err := os.Symlink(s.target, s.path); err != nil && !os.IsExist(err) {
  28. return err
  29. }
  30. }
  31. return nil
  32. }
  33. func testSymlink(tmpdir, path, expected, scope string) error {
  34. rewrite, err := FollowSymlinkInScope(filepath.Join(tmpdir, path), filepath.Join(tmpdir, scope))
  35. if err != nil {
  36. return err
  37. }
  38. expected, err = filepath.Abs(filepath.Join(tmpdir, expected))
  39. if err != nil {
  40. return err
  41. }
  42. if expected != rewrite {
  43. return fmt.Errorf("Expected %q got %q", expected, rewrite)
  44. }
  45. return nil
  46. }
  47. func TestFollowSymlinkAbsolute(t *testing.T) {
  48. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkAbsolute")
  49. if err != nil {
  50. t.Fatal(err)
  51. }
  52. defer os.RemoveAll(tmpdir)
  53. if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/a/d", target: "/b"}}); err != nil {
  54. t.Fatal(err)
  55. }
  56. if err := testSymlink(tmpdir, "testdata/fs/a/d/c/data", "testdata/b/c/data", "testdata"); err != nil {
  57. t.Fatal(err)
  58. }
  59. }
  60. func TestFollowSymlinkRelativePath(t *testing.T) {
  61. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkRelativePath")
  62. if err != nil {
  63. t.Fatal(err)
  64. }
  65. defer os.RemoveAll(tmpdir)
  66. if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/i", target: "a"}}); err != nil {
  67. t.Fatal(err)
  68. }
  69. if err := testSymlink(tmpdir, "testdata/fs/i", "testdata/fs/a", "testdata"); err != nil {
  70. t.Fatal(err)
  71. }
  72. }
  73. func TestFollowSymlinkSkipSymlinksOutsideScope(t *testing.T) {
  74. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkSkipSymlinksOutsideScope")
  75. if err != nil {
  76. t.Fatal(err)
  77. }
  78. defer os.RemoveAll(tmpdir)
  79. if err := makeFs(tmpdir, []dirOrLink{
  80. {path: "linkdir", target: "realdir"},
  81. {path: "linkdir/foo/bar"},
  82. }); err != nil {
  83. t.Fatal(err)
  84. }
  85. if err := testSymlink(tmpdir, "linkdir/foo/bar", "linkdir/foo/bar", "linkdir/foo"); err != nil {
  86. t.Fatal(err)
  87. }
  88. }
  89. func TestFollowSymlinkInvalidScopePathPair(t *testing.T) {
  90. if _, err := FollowSymlinkInScope("toto", "testdata"); err == nil {
  91. t.Fatal("expected an error")
  92. }
  93. }
  94. func TestFollowSymlinkLastLink(t *testing.T) {
  95. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkLastLink")
  96. if err != nil {
  97. t.Fatal(err)
  98. }
  99. defer os.RemoveAll(tmpdir)
  100. if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/a/d", target: "/b"}}); err != nil {
  101. t.Fatal(err)
  102. }
  103. if err := testSymlink(tmpdir, "testdata/fs/a/d", "testdata/b", "testdata"); err != nil {
  104. t.Fatal(err)
  105. }
  106. }
  107. func TestFollowSymlinkRelativeLinkChangeScope(t *testing.T) {
  108. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkRelativeLinkChangeScope")
  109. if err != nil {
  110. t.Fatal(err)
  111. }
  112. defer os.RemoveAll(tmpdir)
  113. if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/a/e", target: "../b"}}); err != nil {
  114. t.Fatal(err)
  115. }
  116. if err := testSymlink(tmpdir, "testdata/fs/a/e/c/data", "testdata/fs/b/c/data", "testdata"); err != nil {
  117. t.Fatal(err)
  118. }
  119. // avoid letting allowing symlink e lead us to ../b
  120. // normalize to the "testdata/fs/a"
  121. if err := testSymlink(tmpdir, "testdata/fs/a/e", "testdata/fs/a/b", "testdata/fs/a"); err != nil {
  122. t.Fatal(err)
  123. }
  124. }
  125. func TestFollowSymlinkDeepRelativeLinkChangeScope(t *testing.T) {
  126. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkDeepRelativeLinkChangeScope")
  127. if err != nil {
  128. t.Fatal(err)
  129. }
  130. defer os.RemoveAll(tmpdir)
  131. if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/a/f", target: "../../../../test"}}); err != nil {
  132. t.Fatal(err)
  133. }
  134. // avoid letting symlink f lead us out of the "testdata" scope
  135. // we don't normalize because symlink f is in scope and there is no
  136. // information leak
  137. if err := testSymlink(tmpdir, "testdata/fs/a/f", "testdata/test", "testdata"); err != nil {
  138. t.Fatal(err)
  139. }
  140. // avoid letting symlink f lead us out of the "testdata/fs" scope
  141. // we don't normalize because symlink f is in scope and there is no
  142. // information leak
  143. if err := testSymlink(tmpdir, "testdata/fs/a/f", "testdata/fs/test", "testdata/fs"); err != nil {
  144. t.Fatal(err)
  145. }
  146. }
  147. func TestFollowSymlinkRelativeLinkChain(t *testing.T) {
  148. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkRelativeLinkChain")
  149. if err != nil {
  150. t.Fatal(err)
  151. }
  152. defer os.RemoveAll(tmpdir)
  153. // avoid letting symlink g (pointed at by symlink h) take out of scope
  154. // TODO: we should probably normalize to scope here because ../[....]/root
  155. // is out of scope and we leak information
  156. if err := makeFs(tmpdir, []dirOrLink{
  157. {path: "testdata/fs/b/h", target: "../g"},
  158. {path: "testdata/fs/g", target: "../../../../../../../../../../../../root"},
  159. }); err != nil {
  160. t.Fatal(err)
  161. }
  162. if err := testSymlink(tmpdir, "testdata/fs/b/h", "testdata/root", "testdata"); err != nil {
  163. t.Fatal(err)
  164. }
  165. }
  166. func TestFollowSymlinkBreakoutPath(t *testing.T) {
  167. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkBreakoutPath")
  168. if err != nil {
  169. t.Fatal(err)
  170. }
  171. defer os.RemoveAll(tmpdir)
  172. // avoid letting symlink -> ../directory/file escape from scope
  173. // normalize to "testdata/fs/j"
  174. if err := makeFs(tmpdir, []dirOrLink{{path: "testdata/fs/j/k", target: "../i/a"}}); err != nil {
  175. t.Fatal(err)
  176. }
  177. if err := testSymlink(tmpdir, "testdata/fs/j/k", "testdata/fs/j/i/a", "testdata/fs/j"); err != nil {
  178. t.Fatal(err)
  179. }
  180. }
  181. func TestFollowSymlinkToRoot(t *testing.T) {
  182. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkToRoot")
  183. if err != nil {
  184. t.Fatal(err)
  185. }
  186. defer os.RemoveAll(tmpdir)
  187. // make sure we don't allow escaping to /
  188. // normalize to dir
  189. if err := makeFs(tmpdir, []dirOrLink{{path: "foo", target: "/"}}); err != nil {
  190. t.Fatal(err)
  191. }
  192. if err := testSymlink(tmpdir, "foo", "", ""); err != nil {
  193. t.Fatal(err)
  194. }
  195. }
  196. func TestFollowSymlinkSlashDotdot(t *testing.T) {
  197. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkSlashDotdot")
  198. if err != nil {
  199. t.Fatal(err)
  200. }
  201. defer os.RemoveAll(tmpdir)
  202. tmpdir = filepath.Join(tmpdir, "dir", "subdir")
  203. // make sure we don't allow escaping to /
  204. // normalize to dir
  205. if err := makeFs(tmpdir, []dirOrLink{{path: "foo", target: "/../../"}}); err != nil {
  206. t.Fatal(err)
  207. }
  208. if err := testSymlink(tmpdir, "foo", "", ""); err != nil {
  209. t.Fatal(err)
  210. }
  211. }
  212. func TestFollowSymlinkDotdot(t *testing.T) {
  213. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkDotdot")
  214. if err != nil {
  215. t.Fatal(err)
  216. }
  217. defer os.RemoveAll(tmpdir)
  218. tmpdir = filepath.Join(tmpdir, "dir", "subdir")
  219. // make sure we stay in scope without leaking information
  220. // this also checks for escaping to /
  221. // normalize to dir
  222. if err := makeFs(tmpdir, []dirOrLink{{path: "foo", target: "../../"}}); err != nil {
  223. t.Fatal(err)
  224. }
  225. if err := testSymlink(tmpdir, "foo", "", ""); err != nil {
  226. t.Fatal(err)
  227. }
  228. }
  229. func TestFollowSymlinkRelativePath2(t *testing.T) {
  230. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkRelativePath2")
  231. if err != nil {
  232. t.Fatal(err)
  233. }
  234. defer os.RemoveAll(tmpdir)
  235. if err := makeFs(tmpdir, []dirOrLink{{path: "bar/foo", target: "baz/target"}}); err != nil {
  236. t.Fatal(err)
  237. }
  238. if err := testSymlink(tmpdir, "bar/foo", "bar/baz/target", ""); err != nil {
  239. t.Fatal(err)
  240. }
  241. }
  242. func TestFollowSymlinkScopeLink(t *testing.T) {
  243. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkScopeLink")
  244. if err != nil {
  245. t.Fatal(err)
  246. }
  247. defer os.RemoveAll(tmpdir)
  248. if err := makeFs(tmpdir, []dirOrLink{
  249. {path: "root2"},
  250. {path: "root", target: "root2"},
  251. {path: "root2/foo", target: "../bar"},
  252. }); err != nil {
  253. t.Fatal(err)
  254. }
  255. if err := testSymlink(tmpdir, "root/foo", "root/bar", "root"); err != nil {
  256. t.Fatal(err)
  257. }
  258. }
  259. func TestFollowSymlinkRootScope(t *testing.T) {
  260. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkRootScope")
  261. if err != nil {
  262. t.Fatal(err)
  263. }
  264. defer os.RemoveAll(tmpdir)
  265. expected, err := filepath.EvalSymlinks(tmpdir)
  266. if err != nil {
  267. t.Fatal(err)
  268. }
  269. rewrite, err := FollowSymlinkInScope(tmpdir, "/")
  270. if err != nil {
  271. t.Fatal(err)
  272. }
  273. if rewrite != expected {
  274. t.Fatalf("expected %q got %q", expected, rewrite)
  275. }
  276. }
  277. func TestFollowSymlinkEmpty(t *testing.T) {
  278. res, err := FollowSymlinkInScope("", "")
  279. if err != nil {
  280. t.Fatal(err)
  281. }
  282. wd, err := os.Getwd()
  283. if err != nil {
  284. t.Fatal(err)
  285. }
  286. if res != wd {
  287. t.Fatalf("expected %q got %q", wd, res)
  288. }
  289. }
  290. func TestFollowSymlinkCircular(t *testing.T) {
  291. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkCircular")
  292. if err != nil {
  293. t.Fatal(err)
  294. }
  295. defer os.RemoveAll(tmpdir)
  296. if err := makeFs(tmpdir, []dirOrLink{{path: "root/foo", target: "foo"}}); err != nil {
  297. t.Fatal(err)
  298. }
  299. if err := testSymlink(tmpdir, "root/foo", "", "root"); err == nil {
  300. t.Fatal("expected an error for foo -> foo")
  301. }
  302. if err := makeFs(tmpdir, []dirOrLink{
  303. {path: "root/bar", target: "baz"},
  304. {path: "root/baz", target: "../bak"},
  305. {path: "root/bak", target: "/bar"},
  306. }); err != nil {
  307. t.Fatal(err)
  308. }
  309. if err := testSymlink(tmpdir, "root/foo", "", "root"); err == nil {
  310. t.Fatal("expected an error for bar -> baz -> bak -> bar")
  311. }
  312. }
  313. func TestFollowSymlinkComplexChainWithTargetPathsContainingLinks(t *testing.T) {
  314. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkComplexChainWithTargetPathsContainingLinks")
  315. if err != nil {
  316. t.Fatal(err)
  317. }
  318. defer os.RemoveAll(tmpdir)
  319. if err := makeFs(tmpdir, []dirOrLink{
  320. {path: "root2"},
  321. {path: "root", target: "root2"},
  322. {path: "root/a", target: "r/s"},
  323. {path: "root/r", target: "../root/t"},
  324. {path: "root/root/t/s/b", target: "/../u"},
  325. {path: "root/u/c", target: "."},
  326. {path: "root/u/x/y", target: "../v"},
  327. {path: "root/u/v", target: "/../w"},
  328. }); err != nil {
  329. t.Fatal(err)
  330. }
  331. if err := testSymlink(tmpdir, "root/a/b/c/x/y/z", "root/w/z", "root"); err != nil {
  332. t.Fatal(err)
  333. }
  334. }
  335. func TestFollowSymlinkBreakoutNonExistent(t *testing.T) {
  336. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkBreakoutNonExistent")
  337. if err != nil {
  338. t.Fatal(err)
  339. }
  340. defer os.RemoveAll(tmpdir)
  341. if err := makeFs(tmpdir, []dirOrLink{
  342. {path: "root/slash", target: "/"},
  343. {path: "root/sym", target: "/idontexist/../slash"},
  344. }); err != nil {
  345. t.Fatal(err)
  346. }
  347. if err := testSymlink(tmpdir, "root/sym/file", "root/file", "root"); err != nil {
  348. t.Fatal(err)
  349. }
  350. }
  351. func TestFollowSymlinkNoLexicalCleaning(t *testing.T) {
  352. tmpdir, err := ioutil.TempDir("", "TestFollowSymlinkNoLexicalCleaning")
  353. if err != nil {
  354. t.Fatal(err)
  355. }
  356. defer os.RemoveAll(tmpdir)
  357. if err := makeFs(tmpdir, []dirOrLink{
  358. {path: "root/sym", target: "/foo/bar"},
  359. {path: "root/hello", target: "/sym/../baz"},
  360. }); err != nil {
  361. t.Fatal(err)
  362. }
  363. if err := testSymlink(tmpdir, "root/hello", "root/foo/baz", "root"); err != nil {
  364. t.Fatal(err)
  365. }
  366. }