Debian Codegraph @

tests/file_storage/test_generate_filename.py

raw
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)