filepath

Feb 1, 2023 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Changes in this version

+ var SkipAll error = fs.SkipAll

+ func IsLocal(path string) bool

Jan 12, 2023 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 4, 2023 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 7, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 10, 2023 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 6, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 1, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 4, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 6, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 2, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 12, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 6, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 9, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 10, 2023 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 6, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 1, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 4, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 6, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 1, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 12, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 1, 2022 GO-2022-0522GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 10, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 12, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 15, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 16, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 31, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 14, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 1, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 12, 2022 GO-2023-1568

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 1, 2022 GO-2022-0522GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 10, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 12, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 3, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 9, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 6, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 9, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 2, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 4, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 7, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 9, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 16, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 2, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 13, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 10, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 3, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 9, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 6, 2022 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 9, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 2, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 4, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 7, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 9, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 4, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 12, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 3, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 6, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 1, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 11, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 10, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 16, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Changes in this version

+ func WalkDir(root string, fn fs.WalkDirFunc) error

Jan 27, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 17, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 4, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 12, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 3, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 6, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 1, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 11, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 10, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 4, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 19, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 3, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 12, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 5, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 14, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 9, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 1, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 11, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 7, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 24, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 10, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 4, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 19, 2021 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 3, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 12, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 5, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 14, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 9, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 1, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 6, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 16, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 14, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 1, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 14, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 8, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 19, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 25, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 5, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 17, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 6, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 16, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 14, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 1, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 14, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 8, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 19, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 12, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 27, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 9, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 4, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 31, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 17, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 17, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 25, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 3, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 29, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 21, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 26, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 12, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 27, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 9, 2020 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 4, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 31, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 17, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 17, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 25, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 15, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 13, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 8, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 11, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 6, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 11, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 8, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 5, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 14, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 25, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 11, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 10, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 18, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 13, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 8, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 11, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 6, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 11, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 8, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 5, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 14, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 23, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 14, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 13, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 2, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 1, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 24, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Changes in this version

+ func HasPrefix(p, prefix string) bool — js/wasm

+ func IsAbs(path string) bool — js/wasm

Aug 22, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 13, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 3, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 19, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 26, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 23, 2019 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 14, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 13, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 2, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 24, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 6, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 30, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 29, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 16, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 7, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 25, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 11, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 7, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 6, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 30, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 29, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 7, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 22, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 25, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 4, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 24, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 7, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 24, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 26, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 14, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 7, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 23, 2018 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 25, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 25, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 20, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 4, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 24, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 23, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 7, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 16, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 26, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 19, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 10, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 15, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 1, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 23, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 26, 2017 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 1, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 19, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 17, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 7, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 15, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 8, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 2, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 2, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 21, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 18, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 8, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 16, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 2, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 1, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 18, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 19, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 11, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 17, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 3, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 28, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 13, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 17, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 11, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 13, 2016 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 3, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 9, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 19, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 6, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 29, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 17, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jul 7, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 23, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Feb 18, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jan 15, 2015 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 11, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Dec 2, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 17, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 30, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 1, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 25, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 13, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 19, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 13, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 2, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 21, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 22, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 5, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 3, 2014 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 28, 2013 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 18, 2013 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 13, 2013 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Nov 1, 2013 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Oct 18, 2013 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Aug 13, 2013 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 13, 2013 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 13, 2013 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Changes in this version

+ func VolumeName(path string) (v string) — js/wasm

May 8, 2013 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

May 7, 2013 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Sep 21, 2012 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Jun 14, 2012 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Apr 26, 2012 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Mar 28, 2012 GO-2022-0522GO-2022-0533GO-2023-1568

  GO-2022-0522: Calling Glob on a path which contains a large number of path separators can cause a panic due to stack exhaustion.

  GO-2022-0533: On Windows, the filepath.Clean function can convert certain invalid paths to valid, absolute paths, potentially allowing a directory traversal attack. For example, Clean(`.\c:`) returns `c:`.

  GO-2023-1568: A path traversal vulnerability exists in filepath.Clean on Windows. On Windows, the filepath.Clean function could transform an invalid path such as "a/../c:/b" into the valid path "c:\b". This transformation of a relative (if invalid) path into an absolute path could enable a directory traversal attack. After fix, the filepath.Clean function transforms this path into the relative (but still invalid) path ".\c:\b".

Changes in this version

+ const ListSeparator

+ const Separator

+ var ErrBadPattern = errors.New("syntax error in pattern")

+ var SkipDir = errors.New("skip this directory")

+ func Abs(path string) (string, error)

+ func Base(path string) string

+ func Clean(path string) string

+ func Dir(path string) string

+ func EvalSymlinks(path string) (string, error)

+ func Ext(path string) string

+ func FromSlash(path string) string

+ func Glob(pattern string) (matches []string, err error)

+ func HasPrefix(p, prefix string) bool — darwin/amd64, linux/amd64, windows/amd64

+ func IsAbs(path string) (b bool) — windows/amd64

+ func IsAbs(path string) bool — darwin/amd64, linux/amd64

+ func Join(elem ...string) string

+ func Match(pattern, name string) (matched bool, err error)

+ func Rel(basepath, targpath string) (string, error)

+ func Split(path string) (dir, file string)

+ func SplitList(path string) []string

+ func ToSlash(path string) string

+ func VolumeName(path string) (v string) — windows/amd64

+ func VolumeName(path string) string — darwin/amd64, linux/amd64

+ func Walk(root string, walkFn WalkFunc) error

+ type WalkFunc func(path string, info os.FileInfo, err error) error