| 1 |
import os |
| 2 |
|
| 3 |
from django.core.exceptions import SuspiciousFileOperation |
| 4 |
from django.core.files.base import ContentFile |
| 5 |
from django.core.files.storage import FileSystemStorage, Storage |
| 6 |
from django.db.models import FileField |
| 7 |
from django.test import SimpleTestCase |
| 8 |
|
| 9 |
|
| 10 |
class AWSS3Storage(Storage): |
| 11 |
""" |
| 12 |
Simulate an AWS S3 storage which uses Unix-like paths and allows any |
| 13 |
characters in file names but where there aren't actual folders but just |
| 14 |
keys. |
| 15 |
""" |
| 16 |
|
| 17 |
prefix = "mys3folder/" |
| 18 |
|
| 19 |
def _save(self, name, content): |
| 20 |
""" |
| 21 |
This method is important to test that Storage.save() doesn't replace |
| 22 |
'\' with '/' (rather FileSystemStorage.save() does). |
| 23 |
""" |
| 24 |
return name |
| 25 |
|
| 26 |
def get_valid_name(self, name): |
| 27 |
return name |
| 28 |
|
| 29 |
def get_available_name(self, name, max_length=None): |
| 30 |
return name |
| 31 |
|
| 32 |
def generate_filename(self, filename): |
| 33 |
""" |
| 34 |
This is the method that's important to override when using S3 so that |
| 35 |
os.path() isn't called, which would break S3 keys. |
| 36 |
""" |
| 37 |
return self.prefix + self.get_valid_name(filename) |
| 38 |
|
| 39 |
|
| 40 |
class StorageGenerateFilenameTests(SimpleTestCase): |
| 41 |
"""Tests for base Storage's generate_filename method.""" |
| 42 |
|
| 43 |
storage_class = Storage |
| 44 |
|
| 45 |
def test_valid_names(self): |
| 46 |
storage = self.storage_class() |
| 47 |
name = "UnTRIVĂAL @fil$ena#me!" |
| 48 |
valid_name = storage.get_valid_name(name) |
| 49 |
candidates = [ |
| 50 |
(name, valid_name), |
| 51 |
(f"././././././{name}", valid_name), |
| 52 |
(f"some/path/{name}", f"some/path/{valid_name}"), |
| 53 |
(f"some/./path/./{name}", f"some/path/{valid_name}"), |
| 54 |
(f"././some/././path/./{name}", f"some/path/{valid_name}"), |
| 55 |
(f".\\.\\.\\.\\.\\.\\{name}", valid_name), |
| 56 |
(f"some\\path\\{name}", f"some/path/{valid_name}"), |
| 57 |
(f"some\\.\\path\\.\\{name}", f"some/path/{valid_name}"), |
| 58 |
(f".\\.\\some\\.\\.\\path\\.\\{name}", f"some/path/{valid_name}"), |
| 59 |
] |
| 60 |
for name, expected in candidates: |
| 61 |
with self.subTest(name=name): |
| 62 |
result = storage.generate_filename(name) |
| 63 |
self.assertEqual(result, os.path.normpath(expected)) |
| 64 |
|
| 65 |
|
| 66 |
class FileSystemStorageGenerateFilenameTests(StorageGenerateFilenameTests): |
| 67 |
|
| 68 |
storage_class = FileSystemStorage |
| 69 |
|
| 70 |
|
| 71 |
class GenerateFilenameStorageTests(SimpleTestCase): |
| 72 |
def test_storage_dangerous_paths(self): |
| 73 |
candidates = [ |
| 74 |
("/tmp/..", ".."), |
| 75 |
("\\tmp\\..", ".."), |
| 76 |
("/tmp/.", "."), |
| 77 |
("\\tmp\\.", "."), |
| 78 |
("..", ".."), |
| 79 |
(".", "."), |
| 80 |
("", ""), |
| 81 |
] |
| 82 |
s = FileSystemStorage() |
| 83 |
s_overwrite = FileSystemStorage(allow_overwrite=True) |
| 84 |
msg = "Could not derive file name from '%s'" |
| 85 |
for file_name, base_name in candidates: |
| 86 |
with self.subTest(file_name=file_name): |
| 87 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg % base_name): |
| 88 |
s.get_available_name(file_name) |
| 89 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg % base_name): |
| 90 |
s_overwrite.get_available_name(file_name) |
| 91 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg % base_name): |
| 92 |
s.generate_filename(file_name) |
| 93 |
|
| 94 |
def test_storage_dangerous_paths_dir_name(self): |
| 95 |
candidates = [ |
| 96 |
("../path", ".."), |
| 97 |
("..\\path", ".."), |
| 98 |
("tmp/../path", "tmp/.."), |
| 99 |
("tmp\\..\\path", "tmp/.."), |
| 100 |
("/tmp/../path", "/tmp/.."), |
| 101 |
("\\tmp\\..\\path", "/tmp/.."), |
| 102 |
] |
| 103 |
s = FileSystemStorage() |
| 104 |
s_overwrite = FileSystemStorage(allow_overwrite=True) |
| 105 |
for file_name, path in candidates: |
| 106 |
msg = "Detected path traversal attempt in '%s'" % path |
| 107 |
with self.subTest(file_name=file_name): |
| 108 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg): |
| 109 |
s.get_available_name(file_name) |
| 110 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg): |
| 111 |
s_overwrite.get_available_name(file_name) |
| 112 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg): |
| 113 |
s.generate_filename(file_name) |
| 114 |
|
| 115 |
def test_filefield_dangerous_filename(self): |
| 116 |
candidates = [ |
| 117 |
("..", "some/folder/.."), |
| 118 |
(".", "some/folder/."), |
| 119 |
("", "some/folder/"), |
| 120 |
("???", "???"), |
| 121 |
("$.$.$", "$.$.$"), |
| 122 |
] |
| 123 |
f = FileField(upload_to="some/folder/") |
| 124 |
for file_name, msg_file_name in candidates: |
| 125 |
msg = f"Could not derive file name from '{msg_file_name}'" |
| 126 |
with self.subTest(file_name=file_name): |
| 127 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg): |
| 128 |
f.generate_filename(None, file_name) |
| 129 |
|
| 130 |
def test_filefield_dangerous_filename_dot_segments(self): |
| 131 |
f = FileField(upload_to="some/folder/") |
| 132 |
msg = "Detected path traversal attempt in 'some/folder/../path'" |
| 133 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg): |
| 134 |
f.generate_filename(None, "../path") |
| 135 |
|
| 136 |
def test_filefield_generate_filename_absolute_path(self): |
| 137 |
f = FileField(upload_to="some/folder/") |
| 138 |
candidates = [ |
| 139 |
"/tmp/path", |
| 140 |
"/tmp/../path", |
| 141 |
] |
| 142 |
for file_name in candidates: |
| 143 |
msg = f"Detected path traversal attempt in '{file_name}'" |
| 144 |
with self.subTest(file_name=file_name): |
| 145 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg): |
| 146 |
f.generate_filename(None, file_name) |
| 147 |
|
| 148 |
def test_filefield_generate_filename(self): |
| 149 |
f = FileField(upload_to="some/folder/") |
| 150 |
self.assertEqual( |
| 151 |
f.generate_filename(None, "test with space.txt"), |
| 152 |
os.path.normpath("some/folder/test_with_space.txt"), |
| 153 |
) |
| 154 |
|
| 155 |
def test_filefield_generate_filename_with_upload_to(self): |
| 156 |
def upload_to(instance, filename): |
| 157 |
return "some/folder/" + filename |
| 158 |
|
| 159 |
f = FileField(upload_to=upload_to) |
| 160 |
self.assertEqual( |
| 161 |
f.generate_filename(None, "test with space.txt"), |
| 162 |
os.path.normpath("some/folder/test_with_space.txt"), |
| 163 |
) |
| 164 |
|
| 165 |
def test_filefield_generate_filename_upload_to_overrides_dangerous_filename(self): |
| 166 |
def upload_to(instance, filename): |
| 167 |
return "test.txt" |
| 168 |
|
| 169 |
f = FileField(upload_to=upload_to) |
| 170 |
candidates = [ |
| 171 |
"/tmp/.", |
| 172 |
"/tmp/..", |
| 173 |
"/tmp/../path", |
| 174 |
"/tmp/path", |
| 175 |
"some/folder/", |
| 176 |
"some/folder/.", |
| 177 |
"some/folder/..", |
| 178 |
"some/folder/???", |
| 179 |
"some/folder/$.$.$", |
| 180 |
"some/../test.txt", |
| 181 |
"", |
| 182 |
] |
| 183 |
for file_name in candidates: |
| 184 |
with self.subTest(file_name=file_name): |
| 185 |
self.assertEqual(f.generate_filename(None, file_name), "test.txt") |
| 186 |
|
| 187 |
def test_filefield_generate_filename_upload_to_absolute_path(self): |
| 188 |
def upload_to(instance, filename): |
| 189 |
return "/tmp/" + filename |
| 190 |
|
| 191 |
f = FileField(upload_to=upload_to) |
| 192 |
candidates = [ |
| 193 |
"path", |
| 194 |
"../path", |
| 195 |
"???", |
| 196 |
"$.$.$", |
| 197 |
] |
| 198 |
for file_name in candidates: |
| 199 |
msg = f"Detected path traversal attempt in '/tmp/{file_name}'" |
| 200 |
with self.subTest(file_name=file_name): |
| 201 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg): |
| 202 |
f.generate_filename(None, file_name) |
| 203 |
|
| 204 |
def test_filefield_generate_filename_upload_to_dangerous_filename(self): |
| 205 |
def upload_to(instance, filename): |
| 206 |
return "/tmp/" + filename |
| 207 |
|
| 208 |
f = FileField(upload_to=upload_to) |
| 209 |
candidates = ["..", ".", ""] |
| 210 |
for file_name in candidates: |
| 211 |
msg = f"Could not derive file name from '/tmp/{file_name}'" |
| 212 |
with self.subTest(file_name=file_name): |
| 213 |
with self.assertRaisesMessage(SuspiciousFileOperation, msg): |
| 214 |
f.generate_filename(None, file_name) |
| 215 |
|
| 216 |
def test_filefield_awss3_storage(self): |
| 217 |
""" |
| 218 |
Simulate a FileField with an S3 storage which uses keys rather than |
| 219 |
folders and names. FileField and Storage shouldn't have any os.path() |
| 220 |
calls that break the key. |
| 221 |
""" |
| 222 |
storage = AWSS3Storage() |
| 223 |
folder = "not/a/folder/" |
| 224 |
|
| 225 |
f = FileField(upload_to=folder, storage=storage) |
| 226 |
key = "my-file-key\\with odd characters" |
| 227 |
data = ContentFile("test") |
| 228 |
expected_key = AWSS3Storage.prefix + folder + key |
| 229 |
|
| 230 |
# Simulate call to f.save() |
| 231 |
result_key = f.generate_filename(None, key) |
| 232 |
self.assertEqual(result_key, expected_key) |
| 233 |
|
| 234 |
result_key = storage.save(result_key, data) |
| 235 |
self.assertEqual(result_key, expected_key) |
| 236 |
|
| 237 |
# Repeat test with a callable. |
| 238 |
def upload_to(instance, filename): |
| 239 |
# Return a non-normalized path on purpose. |
| 240 |
return folder + filename |
| 241 |
|
| 242 |
f = FileField(upload_to=upload_to, storage=storage) |
| 243 |
|
| 244 |
# Simulate call to f.save() |
| 245 |
result_key = f.generate_filename(None, key) |
| 246 |
self.assertEqual(result_key, expected_key) |
| 247 |
|
| 248 |
result_key = storage.save(result_key, data) |
| 249 |
self.assertEqual(result_key, expected_key) |