1import unittest 2import subprocess 3import logging 4import inspect 5import sys 6import os 7import collections 8import shutil 9import random 10import re 11import errno 12from fnmatch import fnmatchcase as matches 13 14try: 15 from cStringIO import StringIO 16except ImportError: 17 from io import StringIO 18 19try: 20 from urllib import quote_plus, urlretrieve 21except ImportError: 22 from urllib.parse import quote_plus 23 from urllib.request import urlretrieve 24 25if sys.version[0] == '3': 26 basestring = str 27 28logg = logging.getLogger("test") 29 30topsrcdir = "../.." 31testdatadir = "testdata.d" 32readme = "README" 33mkzip = "zip" 34unzip = "unzip" 35unzip_skip = False 36exeext = "" 37bindir = os.path.join("..", "bins") 38downloaddir = "tmp.download" 39downloadonly = False 40nodownloads = False 41 42def yesno(text): 43 if not text: return False 44 if text.lower() in ["y", "yes", "t", "true", "on", "ok"]: 45 return True 46 return False 47 48def decodes(text): 49 if text is None: return None 50 if isinstance(text, bytes): 51 encoded = sys.getdefaultencoding() 52 if encoded in ["ascii"]: 53 encoded = "utf-8" 54 try: 55 return text.decode(encoded) 56 except: 57 return text.decode("latin-1") 58 59def shell_string(command): 60 return " ".join(["'%s'" % arg.replace("'","\\'") for arg in command]) 61 62def shell(command, shell=True, calls=False, cwd=None, env=None, lang=None, returncodes=None): 63 returncodes = returncodes or [ None, 0 ] 64 Shell = collections.namedtuple("Shell",["returncode", "output", "errors", "shell"]) 65 if isinstance(command, basestring): 66 sh_command = command 67 command = [ command ] 68 else: 69 sh_command = shell_string(command) 70 if not env: 71 env = os.environ.copy() 72 if lang: 73 for name, value in env.items(): 74 if name.startswith("LC_"): 75 env[name] = lang 76 env["LANG"] = lang # defines message format 77 env["LC_ALL"] = lang # other locale formats 78 zzip_libs = "/zzip/.libs" 79 zzip_cmds = command[0].split(" ")[0] 80 build_lib1 = os.path.dirname(os.path.realpath(zzip_cmds)) 81 build_lib2 = os.path.dirname(build_lib1) 82 build_lib3 = os.path.dirname(build_lib2) 83 if os.path.isdir(build_lib1 + zzip_libs): 84 env["LD_LIBRARY_PATH"] = build_lib1 + zzip_libs 85 elif os.path.isdir(build_lib2 + zzip_libs): 86 env["LD_LIBRARY_PATH"] = build_lib2 + zzip_libs 87 elif os.path.isdir(build_lib3 + zzip_libs): 88 env["LD_LIBRARY_PATH"] = build_lib3 + zzip_libs 89 try: 90 output, errors = "", "" 91 if calls: 92 logg.debug("result from %s: %s", cwd and cwd+"/" or "shell", sh_command) 93 run = subprocess.Popen(command, shell=shell, cwd=cwd, env=env) 94 if run.returncode: 95 logg.warning("EXIT %s: %s", run.returncode, command) 96 run.wait() 97 else: 98 logg.debug("output from %s: %s", cwd and cwd+"/" or "shell", sh_command) 99 run = subprocess.Popen(command, shell=shell, cwd=cwd, 100 stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=None, env=env) 101 if run.returncode: 102 logg.warning("EXIT %s: %s", run.returncode, command) 103 out, err = run.communicate() 104 output = decodes(out) 105 errors = decodes(err) 106 except: 107 logg.error("*E*: %s", sh_command) 108 for line in output.split("\n"): 109 if line: 110 logg.error("OUT: %s", line) 111 for line in errors.split("\n"): 112 if line: 113 logg.error("ERR: %s", line) 114 raise 115 if run.returncode not in returncodes: 116 logg.warning("*%02i: %s", run.returncode, sh_command) 117 for line in output.split("\n"): 118 if line: 119 logg.warning("OUT: %s", line) 120 for line in errors.split("\n"): 121 if line: 122 logg.warning("ERR: %s", line) 123 raise subprocess.CalledProcessError(run.returncode, sh_command, output) 124 else: 125 for line in output.split("\n"): 126 if line: 127 logg.debug("OUT: %s", line) 128 for line in errors.split("\n"): 129 if line: 130 logg.debug("ERR: %s", line) 131 return Shell(run.returncode, output, errors, sh_command) 132 133def get_caller_name(): 134 frame = inspect.currentframe().f_back.f_back 135 return frame.f_code.co_name 136def get_caller_caller_name(): 137 frame = inspect.currentframe().f_back.f_back.f_back 138 return frame.f_code.co_name 139 140def download_raw(base_url, filename, into, style = "?raw=true"): 141 return download(base_url, filename, into, style) 142def download(base_url, filename, into = None, style = ""): 143 if nodownloads: 144 return False 145 data = downloaddir 146 if not os.path.isdir(data): 147 os.makedirs(data) 148 subname = quote_plus(base_url) 149 subdir = os.path.join(data, subname) 150 if not os.path.isdir(subdir): 151 os.makedirs(subdir) 152 subfile = os.path.join(subdir, filename) 153 if not os.path.exists(subfile) and "---" in base_url: 154 my_downloads = os.path.expanduser("~/Downloads") 155 srcfile = os.path.join(my_downloads, filename) 156 if os.path.exists(srcfile): 157 shutil.copy(srcfile, subfile) 158 if not os.path.exists(subfile): 159 logg.info("need %s", subfile) 160 try: 161 url = base_url + "/" + filename + style 162 url = url.replace("/blob/", "/raw/") 163 logg.info("curl %s", url) 164 urlretrieve(url, subfile) 165 except: 166 # Ensure zero-length file exists in case we couldn't 167 # download the file so that we won't try to 168 # re-download it. 169 open(subfile, 'a').close() 170 if not os.path.exists(subfile): 171 return None 172 if os.path.getsize(subfile) < 5: 173 return None 174 # 175 if into: 176 if not os.path.isdir(into): 177 os.makedirs(into) 178 intofile = os.path.join(into, filename) 179 shutil.copy(subfile, intofile) 180 logg.debug("copied %s -> %s", subfile, intofile) 181 return filename 182 183def output(cmd, shell=True): 184 run = subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE) 185 out, err = run.communicate() 186 return out.decode('utf-8') 187def grep(pattern, lines): 188 if isinstance(lines, basestring): 189 lines = lines.split("\n") 190 for line in lines: 191 if re.search(pattern, line.rstrip()): 192 yield line.rstrip() 193def greps(lines, pattern): 194 return list(grep(pattern, lines)) 195def all_errors(lines): 196 if isinstance(lines, basestring): 197 lines = lines.split("\n") 198 for line in lines: 199 if not line.strip(): 200 continue 201 if "DEBUG:" in line: 202 continue 203 if "HINT:" in line: 204 continue 205 yield line.rstrip() 206def errors(lines): 207 return list(all_errors(lines)) 208 209class ZZipTest(unittest.TestCase): 210 @property 211 def t(self): 212 if not os.path.isdir(testdatadir): 213 os.makedirs(testdatadir) 214 return testdatdir 215 @property 216 def s(self): 217 return topsrcdir 218 def src(self, name): 219 return os.path.join(self.s, name) 220 def assertErrorMessage(self, errors, errno): 221 self.assertIn(': ' + os.strerror(errno), errors) 222 def readme(self): 223 f = open(self.src(readme)) 224 text = f.read() 225 f.close() 226 return text 227 def mkfile(self, name, content): 228 b = os.path.dirname(name) 229 if not os.path.isdir(b): 230 os.makedirs(b) 231 f = open(name, "w") 232 f.write(content) 233 f.close() 234 def bins(self, name): 235 if name == "unzip": return unzip 236 if name == "mkzip": return mkzip 237 exe = os.path.join(bindir, name) 238 if exeext: exe += exeext 239 return exe 240 def gdb_bins(self, name): 241 if name == "unzip": return unzip 242 if name == "mkzip": return mkzip 243 exe = os.path.join(bindir, ".libs", name) 244 if exeext: exe += exeext 245 return exe 246 def gentext(self, size): 247 random.seed(1234567891234567890) 248 result = StringIO() 249 old1 = '' 250 old2 = '' 251 for i in range(size): 252 while True: 253 x = random.choice(" abcdefghijklmnopqrstuvwxyz\n") 254 if x == old1 or x == old2: continue 255 old1 = old2 256 old2 = x 257 break 258 result.write(x) 259 return result.getvalue() 260 def caller_testname(self): 261 name = get_caller_caller_name() 262 x1 = name.find("_") 263 if x1 < 0: return name 264 x2 = name.find("_", x1+1) 265 if x2 < 0: return name 266 return name[:x2] 267 def testname(self, suffix = None): 268 name = self.caller_testname() 269 if suffix: 270 return name + "_" + suffix 271 return name 272 def testzip(self, testname = None): 273 testname = testname or self.caller_testname() 274 zipname = testname + ".zip" 275 return zipname 276 def testdir(self, testname = None): 277 testname = testname or self.caller_testname() 278 newdir = "tmp."+testname 279 if os.path.isdir(newdir): 280 shutil.rmtree(newdir) 281 os.makedirs(newdir) 282 return newdir 283 def rm_testdir(self, testname = None): 284 testname = testname or self.caller_testname() 285 newdir = "tmp."+testname 286 if os.path.isdir(newdir): 287 shutil.rmtree(newdir) 288 return newdir 289 def rm_testzip(self, testname = None): 290 testname = testname or self.caller_testname() 291 zipname = testname + ".zip" 292 if os.path.exists(zipname): 293 os.remove(zipname) 294 return True 295 ################################################################ 296 def test_1000_make_test0_zip(self): 297 """ create a test.zip for later tests using standard 'zip' 298 It will fall back to a variant in the source code if 'zip' 299 is not installed on the build host. The content is just 300 the README file that we can check for equality later on. """ 301 zipfile="test0.zip" 302 tmpdir="test0.tmp" 303 exe=self.bins("mkzip") 304 filename = os.path.join(tmpdir,"README") 305 filetext = self.readme() 306 self.mkfile(filename, filetext) 307 shell("{exe} ../{zipfile} README".format(**locals()), cwd=tmpdir) 308 self.assertGreater(os.path.getsize(zipfile), 10) 309 def test_10001_make_test1_zip(self): 310 """ create a test1.zip for later tests using standard 'zip' 311 It will fall back to a variant in the source code if 'zip' 312 is not installed on the build host. The archive has 10 313 generic files that we can check for their content later. """ 314 zipfile="test1.zip" 315 tmpdir="test1.tmp" 316 exe=self.bins("mkzip") 317 for i in [1,2,3,4,5,6,7,8,9]: 318 filename = os.path.join(tmpdir,"file.%i" % i) 319 filetext = "file-%i\n" % i 320 self.mkfile(filename, filetext) 321 filename = os.path.join(tmpdir,"README") 322 filetext = self.readme() 323 self.mkfile(filename, filetext) 324 shell("{exe} ../{zipfile} ??*.* README".format(**locals()), cwd=tmpdir) 325 self.assertGreater(os.path.getsize(zipfile), 10) 326 def test_10002_make_test2_zip(self): 327 """ create a test2.zip for later tests using standard 'zip' 328 It will NOT fall back to a variant in the source code. 329 The archive has 100 generic files with known content. """ 330 zipfile="test2.zip" 331 tmpdir="test2.tmp" 332 exe=self.bins("mkzip") 333 for i in range(100): 334 filename = os.path.join(tmpdir,"file.%02i" % i) 335 filetext = "file-%02i\n" % i 336 self.mkfile(filename, filetext) 337 filename = os.path.join(tmpdir,"README") 338 filetext = self.readme() 339 self.mkfile(filename, filetext) 340 shell("{exe} ../{zipfile} ??*.* README".format(**locals()), cwd=tmpdir) 341 self.assertGreater(os.path.getsize(zipfile), 10) 342 def test_10003_make_test3_zip(self): 343 """ create a test3.zip for later tests using standard 'zip' 344 It will NOT fall back to a variant in the source code. 345 The archive has 1000 generic files with known content. """ 346 zipfile="test3.zip" 347 tmpdir="test3.tmp" 348 exe=self.bins("mkzip") 349 for i in range(1000): 350 filename = os.path.join(tmpdir,"file.%03i" % i) 351 filetext = "file-%03i\n" % i 352 self.mkfile(filename, filetext) 353 filename = os.path.join(tmpdir,"README") 354 filetext = self.readme() 355 self.mkfile(filename, filetext) 356 shell("{exe} ../{zipfile} ??*.* README".format(**locals()), cwd=tmpdir) 357 self.assertGreater(os.path.getsize(zipfile), 10) 358 def test_10004_make_test4_zip(self): 359 """ create a test4.zip for later tests using standard 'zip' 360 It will NOT fall back to a variant in the source code. 361 The archive has 10000 generic files with known content 362 and they are stored (NOT compressed) in the archive. """ 363 zipfile="test4.zip" 364 tmpdir="test4.tmp" 365 exe=self.bins("mkzip") 366 for i in range(10000): 367 filename = os.path.join(tmpdir,"file%04i.txt" % i) 368 filetext = "file-%04i\n" % i 369 self.mkfile(filename, filetext) 370 filename = os.path.join(tmpdir,"README") 371 filetext = self.readme() 372 self.mkfile(filename, filetext) 373 shell("{exe} -n README ../{zipfile} ??*.* README".format(**locals()), cwd=tmpdir) 374 self.assertGreater(os.path.getsize(zipfile), 1000000) 375 def test_10005_make_test5_zip(self): 376 """ create a test5.zip for later tests using standard 'zip' 377 It will NOT fall back to a variant in the source code. 378 The archive has files at multiple subdirectories depth 379 and of varying sizes each. """ 380 zipfile="test5.zip" 381 tmpdir="test5.tmp" 382 exe=self.bins("mkzip") 383 for depth in range(20): 384 dirpath = "" 385 for i in range(depth): 386 if i: 387 dirpath += "subdir%i/" % i 388 for size in range(18): 389 size = 2 ** size 390 filetext = self.gentext(size) 391 filepart = "file%i-%i.txt" % (depth, size) 392 filename = os.path.join(tmpdir, dirpath + filepart ) 393 self.mkfile(filename, filetext) 394 filename = os.path.join(tmpdir,"README") 395 filetext = self.readme() 396 self.mkfile(filename, filetext) 397 shell("{exe} ../{zipfile} -r file* subdir* README".format(**locals()), cwd=tmpdir) 398 self.assertGreater(os.path.getsize(zipfile), 1000000) 399 def test_10010_make_test0_dat(self): 400 """ create test.dat from test.zip with xorcopy """ 401 zipfile = "test0.zip" 402 datfile = "test0x.dat" 403 exe = self.bins("zzxorcopy") 404 shell("{exe} {zipfile} {datfile}".format(**locals())) 405 self.assertGreater(os.path.getsize(datfile), 10) 406 self.assertEqual(os.path.getsize(datfile), os.path.getsize(zipfile)) 407 def test_10011_make_test1_dat(self): 408 """ create test.dat from test.zip with xorcopy """ 409 zipfile = "test1.zip" 410 datfile = "test1x.dat" 411 exe = self.bins("zzxorcopy") 412 shell("{exe} {zipfile} {datfile}".format(**locals())) 413 self.assertGreater(os.path.getsize(datfile), 10) 414 self.assertEqual(os.path.getsize(datfile), os.path.getsize(zipfile)) 415 def test_10012_make_test2_dat(self): 416 """ create test.dat from test.zip with xorcopy """ 417 zipfile = "test2.zip" 418 datfile = "test2x.dat" 419 exe = self.bins("zzxorcopy") 420 shell("{exe} {zipfile} {datfile}".format(**locals())) 421 self.assertGreater(os.path.getsize(datfile), 10) 422 self.assertEqual(os.path.getsize(datfile), os.path.getsize(zipfile)) 423 def test_10013_make_test3_dat(self): 424 """ create test.dat from test.zip with xorcopy """ 425 zipfile = "test3.zip" 426 datfile = "test3x.dat" 427 exe = self.bins("zzxorcopy") 428 shell("{exe} {zipfile} {datfile}".format(**locals())) 429 self.assertGreater(os.path.getsize(datfile), 10) 430 self.assertEqual(os.path.getsize(datfile), os.path.getsize(zipfile)) 431 def test_10014_make_test4_dat(self): 432 """ create test.dat from test.zip with xorcopy """ 433 zipfile = "test4.zip" 434 datfile = "test4x.dat" 435 exe = self.bins("zzxorcopy") 436 shell("{exe} {zipfile} {datfile}".format(**locals())) 437 self.assertGreater(os.path.getsize(datfile), 10) 438 self.assertEqual(os.path.getsize(datfile), os.path.getsize(zipfile)) 439 def test_20000_zziptest_test0_zip(self): 440 """ run zziptest on test.zip """ 441 zipfile = "test0.zip" 442 logfile = "test0.log" 443 exe = self.bins("zziptest") 444 shell("{exe} --quick {zipfile} | tee {logfile}".format(**locals())) 445 self.assertGreater(os.path.getsize(logfile), 10) 446 def test_20001_zziptest_test1_zip(self): 447 """ run zziptest on test.zip """ 448 zipfile = "test1.zip" 449 logfile = "test1.log" 450 exe = self.bins("zziptest") 451 shell("{exe} --quick {zipfile} | tee {logfile}".format(**locals())) 452 self.assertGreater(os.path.getsize(logfile), 10) 453 def test_20002_zziptest_test2_zip(self): 454 """ run zziptest on test.zip """ 455 zipfile = "test2.zip" 456 logfile = "test2.log" 457 exe = self.bins("zziptest") 458 shell("{exe} --quick {zipfile} | tee {logfile}".format(**locals())) 459 self.assertGreater(os.path.getsize(logfile), 10) 460 def test_20003_zziptest_test3_zip(self): 461 """ run zziptest on test.zip """ 462 zipfile = "test3.zip" 463 logfile = "test3.log" 464 exe = self.bins("zziptest") 465 shell("{exe} --quick {zipfile} | tee {logfile}".format(**locals())) 466 self.assertGreater(os.path.getsize(logfile), 10) 467 def test_20004_zziptest_test4_zip(self): 468 """ run zziptest on test.zip """ 469 zipfile = "test4.zip" 470 logfile = "test4.log" 471 exe = self.bins("zziptest") 472 shell("{exe} --quick {zipfile} | tee {logfile}".format(**locals())) 473 self.assertGreater(os.path.getsize(logfile), 10) 474 def test_20010_zzcat_test0_zip(self): 475 """ run zzcat on test.zip using just test/README """ 476 zipfile = "test0.zip" 477 getfile = "test0/README" 478 logfile = "test0.readme.txt" 479 exe = self.bins("zzcat") 480 run = shell("{exe} {getfile} | tee {logfile}".format(**locals())) 481 self.assertGreater(os.path.getsize(logfile), 10) 482 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 483 def test_20011_zzcat_test1_zip(self): 484 """ run zzcat on test.zip using just test/README """ 485 zipfile = "test1.zip" 486 getfile = "test1/README" 487 logfile = "test1.readme.txt" 488 exe = self.bins("zzcat") 489 run = shell("{exe} {getfile} | tee {logfile}".format(**locals())) 490 self.assertGreater(os.path.getsize(logfile), 10) 491 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 492 getfile = "test1/file.1" 493 run = shell("{exe} {getfile}".format(**locals())) 494 self.assertEqual("file-1\n", run.output) 495 def test_20012_zzcat_test2_zip(self): 496 """ run zzcat on test.zip using just test/README """ 497 zipfile = "test2.zip" 498 getfile = "test2/README" 499 logfile = "test2.readme.txt" 500 exe = self.bins("zzcat") 501 run = shell("{exe} {getfile} | tee {logfile}".format(**locals())) 502 self.assertGreater(os.path.getsize(logfile), 10) 503 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 504 getfile = "test2/file.22" 505 run = shell("{exe} {getfile}".format(**locals())) 506 self.assertEqual("file-22\n", run.output) 507 def test_20013_zzcat_test3_zip(self): 508 """ run zzcat on test.zip using just test/README """ 509 zipfile = "test3.zip" 510 getfile = "test3/README" 511 logfile = "test3.readme.txt" 512 exe = self.bins("zzcat") 513 run = shell("{exe} {getfile} | tee {logfile}".format(**locals())) 514 self.assertGreater(os.path.getsize(logfile), 10) 515 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 516 getfile = "test3/file.999" 517 run = shell("{exe} {getfile}".format(**locals())) 518 self.assertEqual("file-999\n", run.output) 519 def test_20014_zzcat_test4_zip(self): 520 """ run zzcat on test.zip using just test/README """ 521 zipfile = "test4.zip" 522 getfile = "test4/README" 523 logfile = "test4.readme.txt" 524 exe = self.bins("zzcat") 525 run = shell("{exe} {getfile} | tee {logfile}".format(**locals())) 526 self.assertGreater(os.path.getsize(logfile), 10) 527 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 528 getfile = "test4/file9999.txt" 529 run = shell("{exe} {getfile}".format(**locals())) 530 self.assertEqual("file-9999\n", run.output) 531 def test_20020_zzdir_test0_zip(self): 532 """ run zzdir on test0.zip using just 'test0' """ 533 zipfile = "test0.zip" 534 getfile = "test0" 535 exe = self.bins("zzdir") 536 run = shell("{exe} {getfile} ".format(**locals())) 537 self.assertIn(' README\n', run.output) 538 self.assertIn(' defl:N ', run.output) 539 self.assertLess(len(run.output), 30) 540 def test_20021_zzdir_test1_zip(self): 541 """ run zzdir on test1.zip using just 'test1' """ 542 zipfile = "test1.zip" 543 getfile = "test1" 544 exe = self.bins("zzdir") 545 run = shell("{exe} {getfile} ".format(**locals())) 546 self.assertIn(' file.1\n', run.output) 547 self.assertIn(' file.2\n', run.output) 548 self.assertIn(' file.9\n', run.output) 549 self.assertIn(' README\n', run.output) 550 self.assertIn(' defl:N ', run.output) 551 self.assertIn(' stored ', run.output) 552 def test_20022_zzdir_test2_zip(self): 553 """ run zzdir on test2.zip using just 'test2' """ 554 zipfile = "test2.zip" 555 getfile = "test2" 556 exe = self.bins("zzdir") 557 run = shell("{exe} {getfile} ".format(**locals())) 558 self.assertIn(' file.01\n', run.output) 559 self.assertIn(' file.22\n', run.output) 560 self.assertIn(' file.99\n', run.output) 561 self.assertIn(' defl:N ', run.output) 562 self.assertIn(' stored ', run.output) 563 def test_20023_zzdir_test3_zip(self): 564 """ run zzdir on test3.zip using just 'test3' """ 565 zipfile = "test3.zip" 566 getfile = "test3" 567 exe = self.bins("zzdir") 568 run = shell("{exe} {getfile} ".format(**locals())) 569 self.assertIn(' file.001\n', run.output) 570 self.assertIn(' file.222\n', run.output) 571 self.assertIn(' file.999\n', run.output) 572 self.assertIn(' defl:N ', run.output) 573 self.assertIn(' stored ', run.output) 574 def test_20024_zzdir_test4_zip(self): 575 """ run zzdir on test4.zip using just 'test4' """ 576 zipfile = "test4.zip" 577 getfile = "test4" 578 exe = self.bins("zzdir") 579 run = shell("{exe} {getfile} ".format(**locals())) 580 self.assertIn(' file0001.txt\n', run.output) 581 self.assertIn(' file2222.txt\n', run.output) 582 self.assertIn(' file9999.txt\n', run.output) 583 self.assertNotIn(' defl:N ', run.output) 584 self.assertIn(' stored ', run.output) 585 def test_20320_zzxordir_test0_dat(self): 586 """ run zzxordir on test0x.dat """ 587 zipfile = "test0x.dat" 588 getfile = "test0x.dat" 589 exe = self.bins("zzdir") 590 run = shell("{exe} {getfile} ".format(**locals()), returncodes = [0,1]) 591 self.assertEqual(run.returncode, 1) 592 self.assertEqual("", run.output) 593 self.assertIn("did not open test", run.errors) 594 exe = self.bins("zzxordir") 595 run = shell("{exe} {getfile} ".format(**locals())) 596 self.assertIn(' README\n', run.output) 597 self.assertIn(' defl:N ', run.output) 598 self.assertLess(len(run.output), 30) 599 def test_20321_zzxordir_test1_dat(self): 600 """ run zzxordir on test1x.dat using just 'test1x' """ 601 zipfile = "test1x.dat" 602 getfile = "test1x.dat" 603 exe = self.bins("zzdir") 604 run = shell("{exe} {getfile} ".format(**locals()), returncodes = [0,1]) 605 self.assertEqual(run.returncode, 1) 606 self.assertEqual("", run.output) 607 self.assertIn("did not open test", run.errors) 608 exe = self.bins("zzxordir") 609 run = shell("{exe} {getfile} ".format(**locals())) 610 self.assertIn(' file.1\n', run.output) 611 self.assertIn(' file.2\n', run.output) 612 self.assertIn(' file.9\n', run.output) 613 self.assertIn(' README\n', run.output) 614 self.assertIn(' defl:N ', run.output) 615 self.assertIn(' stored ', run.output) 616 def test_20322_zzxordir_test2_dat(self): 617 """ run zzxordir on test2x.dat using just 'test2x' """ 618 zipfile = "test2x.dat" 619 getfile = "test2x" 620 exe = self.bins("zzdir") 621 run = shell("{exe} {getfile} ".format(**locals()), returncodes = [0,1]) 622 self.assertEqual(run.returncode, 1) 623 self.assertEqual("", run.output) 624 self.assertIn("did not open test", run.errors) 625 exe = self.bins("zzxordir") 626 run = shell("{exe} {getfile} ".format(**locals())) 627 self.assertIn(' file.01\n', run.output) 628 self.assertIn(' file.22\n', run.output) 629 self.assertIn(' file.99\n', run.output) 630 self.assertIn(' defl:N ', run.output) 631 self.assertIn(' stored ', run.output) 632 def test_20323_zzxordir_test3_dat(self): 633 """ run zzxordir on test3x.dat using just 'test3x' """ 634 zipfile = "test3x.dat" 635 getfile = "test3x" 636 exe = self.bins("zzdir") 637 run = shell("{exe} {getfile} ".format(**locals()), returncodes = [0,1]) 638 self.assertEqual(run.returncode, 1) 639 self.assertEqual("", run.output) 640 self.assertIn("did not open test", run.errors) 641 exe = self.bins("zzxordir") 642 run = shell("{exe} {getfile} ".format(**locals())) 643 self.assertIn(' file.001\n', run.output) 644 self.assertIn(' file.222\n', run.output) 645 self.assertIn(' file.999\n', run.output) 646 self.assertIn(' defl:N ', run.output) 647 self.assertIn(' stored ', run.output) 648 def test_20324_zzxordir_test4_zip(self): 649 """ run zzxordir on test4x.dat using just 'test4x' """ 650 zipfile = "test4x.dat" 651 getfile = "test4x" 652 exe = self.bins("zzdir") 653 run = shell("{exe} {getfile} ".format(**locals()), returncodes = [0,1]) 654 self.assertEqual(run.returncode, 1) 655 self.assertEqual("", run.output) 656 self.assertIn("did not open test", run.errors) 657 exe = self.bins("zzxordir") 658 run = shell("{exe} {getfile} ".format(**locals())) 659 self.assertIn(' file0001.txt\n', run.output) 660 self.assertIn(' file2222.txt\n', run.output) 661 self.assertIn(' file9999.txt\n', run.output) 662 self.assertNotIn(' defl:N ', run.output) 663 self.assertIn(' stored ', run.output) 664 def test_20340_zzxorcat_test0_zip(self): 665 """ run zzxorcat on testx.zip using just testx/README """ 666 getfile = "test0x/README" 667 logfile = "test0x.readme.txt" 668 exe = self.bins("zzcat") 669 run = shell("{exe} {getfile} ".format(**locals()), lang="C") 670 self.assertEqual("", run.output) 671 self.assertIn("No such file or directory", run.errors) 672 exe = self.bins("zzxorcat") 673 run = shell("{exe} {getfile} | tee {logfile}".format(**locals())) 674 self.assertGreater(os.path.getsize(logfile), 10) 675 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 676 def test_20341_zzxorcat_test1_zip(self): 677 """ run zzxorcat on testx.zip using just testx/README """ 678 getfile = "test1x/README" 679 logfile = "test1x.readme.txt" 680 exe = self.bins("zzcat") 681 run = shell("{exe} {getfile} ".format(**locals()), lang="C") 682 self.assertEqual("", run.output) 683 self.assertIn("No such file or directory", run.errors) 684 exe = self.bins("zzxorcat") 685 run = shell("{exe} {getfile} | tee {logfile}".format(**locals())) 686 self.assertGreater(os.path.getsize(logfile), 10) 687 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 688 getfile = "test1x/file.1" 689 run = shell("{exe} {getfile}".format(**locals())) 690 self.assertEqual("file-1\n", run.output) 691 def test_20342_zzxorcat_test2_zip(self): 692 """ run zzxorcat on testx.zip using just testx/README """ 693 getfile = "test2x/README" 694 logfile = "test2x.readme.txt" 695 exe = self.bins("zzcat") 696 run = shell("{exe} {getfile} ".format(**locals()), lang="C") 697 self.assertEqual("", run.output) 698 self.assertIn("No such file or directory", run.errors) 699 exe = self.bins("zzxorcat") 700 run = shell("{exe} {getfile} | tee {logfile}".format(**locals())) 701 self.assertGreater(os.path.getsize(logfile), 10) 702 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 703 getfile = "test2x/file.22" 704 run = shell("{exe} {getfile}".format(**locals())) 705 self.assertEqual("file-22\n", run.output) 706 def test_20343_zzxorcat_test3_zip(self): 707 """ run zzxorcat on testx.zip using just testx/README """ 708 getfile = "test3x/README" 709 logfile = "test3x.readme.txt" 710 exe = self.bins("zzcat") 711 run = shell("{exe} {getfile} ".format(**locals()), lang="C") 712 self.assertEqual("", run.output) 713 self.assertIn("No such file or directory", run.errors) 714 exe = self.bins("zzxorcat") 715 run = shell("{exe} {getfile} | tee {logfile}".format(**locals())) 716 self.assertGreater(os.path.getsize(logfile), 10) 717 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 718 getfile = "test3x/file.999" 719 run = shell("{exe} {getfile}".format(**locals())) 720 self.assertEqual("file-999\n", run.output) 721 def test_20344_zzxorcat_test4_zip(self): 722 """ run zzxorcat on testx.zip using just testx/README """ 723 getfile = "test4x/README" 724 logfile = "test4x.readme.txt" 725 exe = self.bins("zzxorcat") 726 run = shell("{exe} {getfile} | tee {logfile}".format(**locals())) 727 self.assertGreater(os.path.getsize(logfile), 10) 728 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 729 getfile = "test4x/file9999.txt" 730 run = shell("{exe} {getfile}".format(**locals())) 731 self.assertEqual("file-9999\n", run.output) 732 ##################################################################### 733 # check unzzip 734 ##################################################################### 735 def test_20400_infozip_cat_test0_zip(self): 736 """ run inzo-zip cat test.zip using just archive README """ 737 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 738 zipfile = "test0.zip" 739 getfile = "README" 740 logfile = "test0.readme.pk.txt" 741 exe = self.bins("unzip") 742 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 743 self.assertGreater(os.path.getsize(logfile), 10) 744 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 745 def test_20401_infozip_cat_test1_zip(self): 746 """ run info-zip cat test.zip using just archive README """ 747 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 748 zipfile = "test1.zip" 749 getfile = "README" 750 logfile = "test1.readme.pk.txt" 751 exe = self.bins("unzip") 752 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 753 self.assertGreater(os.path.getsize(logfile), 10) 754 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 755 getfile = "file.1" 756 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 757 self.assertEqual("file-1\n", run.output) 758 def test_20402_infozip_cat_test2_zip(self): 759 """ run info-zip cat test.zip using just archive README """ 760 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 761 zipfile = "test2.zip" 762 getfile = "README" 763 logfile = "test2.readme.pk.txt" 764 exe = self.bins("unzip") 765 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 766 self.assertGreater(os.path.getsize(logfile), 10) 767 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 768 getfile = "file.22" 769 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 770 self.assertEqual("file-22\n", run.output) 771 def test_20405_zzcat_big_test5_zip(self): 772 """ run info-zip cat test.zip using archive README """ 773 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 774 zipfile = "test5.zip" 775 getfile = "README" 776 logfile = "test5.readme.pk.txt" 777 exe = self.bins("unzip") 778 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 779 self.assertGreater(os.path.getsize(logfile), 10) 780 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 781 getfile = "subdir1/subdir2/subdir3/subdir4/subdir5/subdir6/file7-1024.txt" 782 compare = self.gentext(1024) 783 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 784 self.assertEqual(compare, run.output) 785 def test_20410_zzcat_big_test0_zip(self): 786 """ run zzcat-big on test.zip using just archive README """ 787 zipfile = "test0.zip" 788 getfile = "README" 789 logfile = "test0.readme.big.txt" 790 exe = self.bins("unzzip-big") 791 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 792 self.assertGreater(os.path.getsize(logfile), 10) 793 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 794 def test_20411_zzcat_big_test1_zip(self): 795 """ run zzcat-big on test.zip using just archive README """ 796 zipfile = "test1.zip" 797 getfile = "README" 798 logfile = "test1.readme.big.txt" 799 exe = self.bins("unzzip-big") 800 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 801 self.assertGreater(os.path.getsize(logfile), 10) 802 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 803 getfile = "file.1" 804 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 805 self.assertEqual("file-1\n", run.output) 806 def test_20412_zzcat_big_test2_zip(self): 807 """ run zzcat-seeke on test.zip using just archive README """ 808 zipfile = "test2.zip" 809 getfile = "README" 810 logfile = "test2.readme.big.txt" 811 exe = self.bins("unzzip-big") 812 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 813 self.assertGreater(os.path.getsize(logfile), 10) 814 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 815 getfile = "file.22" 816 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 817 self.assertEqual("file-22\n", run.output) 818 def test_20415_zzcat_big_test5_zip(self): 819 """ run zzcat-big on test.zip using archive README """ 820 zipfile = "test5.zip" 821 getfile = "README" 822 logfile = "test5.readme.zap.txt" 823 exe = self.bins("unzzip-big") 824 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 825 self.assertGreater(os.path.getsize(logfile), 10) 826 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 827 getfile = "subdir1/subdir2/subdir3/subdir4/subdir5/subdir6/file7-1024.txt" 828 compare = self.gentext(1024) 829 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 830 self.assertEqual(compare, run.output) 831 def test_20420_zzcat_mem_test0_zip(self): 832 """ run zzcat-mem on test.zip using just archive README """ 833 zipfile = "test0.zip" 834 getfile = "README" 835 logfile = "test0.readme.mem.txt" 836 exe = self.bins("unzzip-mem") 837 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 838 self.assertGreater(os.path.getsize(logfile), 10) 839 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 840 def test_20421_zzcat_mem_test1_zip(self): 841 """ run zzcat-mem on test.zip using archive README """ 842 zipfile = "test1.zip" 843 getfile = "README" 844 logfile = "test1.readme.mem.txt" 845 exe = self.bins("unzzip-mem") 846 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 847 self.assertGreater(os.path.getsize(logfile), 10) 848 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 849 getfile = "file.1" 850 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 851 self.assertEqual("file-1\n", run.output) 852 def test_20422_zzcat_mem_test2_zip(self): 853 """ run zzcat-mem on test.zip using archive README """ 854 zipfile = "test2.zip" 855 getfile = "README" 856 logfile = "test2.readme.mem.txt" 857 exe = self.bins("unzzip-mem") 858 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 859 self.assertGreater(os.path.getsize(logfile), 10) 860 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 861 getfile = "file.22" 862 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 863 self.assertEqual("file-22\n", run.output) 864 def test_20423_zzcat_mem_test3_zip(self): 865 """ run zzcat-mem on test.zip using archive README """ 866 zipfile = "test3.zip" 867 getfile = "README" 868 logfile = "test3.readme.mem.txt" 869 exe = self.bins("unzzip-mem") 870 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 871 self.assertGreater(os.path.getsize(logfile), 10) 872 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 873 getfile = "file.999" 874 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 875 self.assertEqual("file-999\n", run.output) 876 def test_20424_zzcat_mem_test4_zip(self): 877 """ run zzcat-mem on test.zip using archive README """ 878 zipfile = "test4.zip" 879 getfile = "README" 880 logfile = "test4.readme.mem.txt" 881 exe = self.bins("unzzip-mem") 882 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 883 self.assertGreater(os.path.getsize(logfile), 10) 884 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 885 getfile = "file9999.txt" 886 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 887 self.assertEqual("file-9999\n", run.output) 888 def test_20425_zzcat_mem_test5_zip(self): 889 """ run zzcat-mem on test.zip using archive README """ 890 zipfile = "test5.zip" 891 getfile = "README" 892 logfile = "test5.readme.zap.txt" 893 exe = self.bins("unzzip-mem") 894 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 895 self.assertGreater(os.path.getsize(logfile), 10) 896 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 897 getfile = "subdir1/subdir2/subdir3/subdir4/subdir5/subdir6/file7-1024.txt" 898 compare = self.gentext(1024) 899 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 900 self.assertEqual(compare, run.output) 901 def test_20430_zzcat_mix_test0_zip(self): 902 """ run zzcat-mix on test.zip using just archive README """ 903 zipfile = "test0.zip" 904 getfile = "README" 905 logfile = "test0.readme.mix.txt" 906 exe = self.bins("unzzip-mix") 907 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 908 self.assertGreater(os.path.getsize(logfile), 10) 909 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 910 def test_20431_zzcat_mix_test1_zip(self): 911 """ run zzcat-mix on test.zip using archive README """ 912 zipfile = "test1.zip" 913 getfile = "README" 914 logfile = "test1.readme.mix.txt" 915 exe = self.bins("unzzip-mix") 916 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 917 self.assertGreater(os.path.getsize(logfile), 10) 918 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 919 getfile = "file.1" 920 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 921 self.assertEqual("file-1\n", run.output) 922 def test_20432_zzcat_mix_test2_zip(self): 923 """ run zzcat-mix on test.zip using archive README """ 924 zipfile = "test2.zip" 925 getfile = "README" 926 logfile = "test2.readme.mix.txt" 927 exe = self.bins("unzzip-mix") 928 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 929 self.assertGreater(os.path.getsize(logfile), 10) 930 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 931 getfile = "file.22" 932 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 933 self.assertEqual("file-22\n", run.output) 934 def test_20433_zzcat_mix_test3_zip(self): 935 """ run zzcat-mix on test.zip using archive README """ 936 zipfile = "test3.zip" 937 getfile = "README" 938 logfile = "test3.readme.mix.txt" 939 exe = self.bins("unzzip-mix") 940 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 941 self.assertGreater(os.path.getsize(logfile), 10) 942 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 943 getfile = "file.999" 944 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 945 self.assertEqual("file-999\n", run.output) 946 def test_20434_zzcat_mix_test4_zip(self): 947 """ run zzcat-mix on test.zip using archive README """ 948 zipfile = "test4.zip" 949 getfile = "README" 950 logfile = "test4.readme.mix.txt" 951 exe = self.bins("unzzip-mix") 952 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 953 self.assertGreater(os.path.getsize(logfile), 10) 954 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 955 getfile = "file9999.txt" 956 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 957 self.assertEqual("file-9999\n", run.output) 958 def test_20435_zzcat_mix_test5_zip(self): 959 """ run zzcat-mix on test.zip using archive README """ 960 zipfile = "test5.zip" 961 getfile = "README" 962 logfile = "test5.readme.zap.txt" 963 exe = self.bins("unzzip-mix") 964 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 965 self.assertGreater(os.path.getsize(logfile), 10) 966 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 967 getfile = "subdir1/subdir2/subdir3/subdir4/subdir5/subdir6/file7-1024.txt" 968 compare = self.gentext(1024) 969 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 970 self.assertEqual(compare, run.output) 971 def test_20440_zzcat_zap_test0_zip(self): 972 """ run zzcat-zap on test.zip using just archive README """ 973 zipfile = "test0.zip" 974 getfile = "README" 975 logfile = "test0.readme.txt" 976 exe = self.bins("unzzip") 977 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 978 self.assertGreater(os.path.getsize(logfile), 10) 979 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 980 def test_20441_zzcat_zap_test1_zip(self): 981 """ run zzcat-zap on test.zip using archive README """ 982 zipfile = "test1.zip" 983 getfile = "README" 984 logfile = "test1.readme.zap.txt" 985 exe = self.bins("unzzip") 986 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 987 self.assertGreater(os.path.getsize(logfile), 10) 988 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 989 getfile = "file.1" 990 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 991 self.assertEqual("file-1\n", run.output) 992 def test_20442_zzcat_zap_test2_zip(self): 993 """ run zzcat-zap on test.zip using archive README """ 994 zipfile = "test2.zip" 995 getfile = "README" 996 logfile = "test2.readme.zap.txt" 997 exe = self.bins("unzzip") 998 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 999 self.assertGreater(os.path.getsize(logfile), 10) 1000 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 1001 getfile = "file.22" 1002 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 1003 self.assertEqual("file-22\n", run.output) 1004 def test_20443_zzcat_zap_test3_zip(self): 1005 """ run zzcat-zap on test.zip using archive README """ 1006 zipfile = "test3.zip" 1007 getfile = "README" 1008 logfile = "test3.readme.zap.txt" 1009 exe = self.bins("unzzip") 1010 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 1011 self.assertGreater(os.path.getsize(logfile), 10) 1012 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 1013 getfile = "file.999" 1014 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 1015 self.assertEqual("file-999\n", run.output) 1016 def test_20444_zzcat_zap_test4_zip(self): 1017 """ run zzcat-zap on test.zip using archive README """ 1018 zipfile = "test4.zip" 1019 getfile = "README" 1020 logfile = "test4.readme.zap.txt" 1021 exe = self.bins("unzzip") 1022 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 1023 self.assertGreater(os.path.getsize(logfile), 10) 1024 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 1025 getfile = "file9999.txt" 1026 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 1027 self.assertEqual("file-9999\n", run.output) 1028 def test_20445_zzcat_zap_test5_zip(self): 1029 """ run zzcat-zap on test.zip using archive README """ 1030 zipfile = "test5.zip" 1031 getfile = "README" 1032 logfile = "test5.readme.zap.txt" 1033 exe = self.bins("unzzip") 1034 run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals())) 1035 self.assertGreater(os.path.getsize(logfile), 10) 1036 self.assertEqual(run.output.split("\n"), self.readme().split("\n")) 1037 getfile = "subdir1/subdir2/subdir3/subdir4/subdir5/subdir6/file7-1024.txt" 1038 compare = self.gentext(1024) 1039 run = shell("{exe} -p {zipfile} {getfile}".format(**locals())) 1040 self.assertEqual(compare, run.output) 1041 1042 def test_20500_infozipdir_test0_zip(self): 1043 """ run info-zip dir test0.zip """ 1044 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1045 zipfile = "test0.zip" 1046 getfile = "test0.zip" 1047 exe = self.bins("unzip") 1048 run = shell("{exe} -l {getfile} ".format(**locals())) 1049 self.assertIn(' README\n', run.output) 1050 self.assertLess(len(run.output), 230) 1051 def test_20501_infozipdir_test1_zip(self): 1052 """ run info-zip dir test1.zip """ 1053 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1054 zipfile = "test1.zip" 1055 getfile = "test1.zip" 1056 exe = self.bins("unzip") 1057 run = shell("{exe} -l {getfile} ".format(**locals())) 1058 self.assertIn(' file.1\n', run.output) 1059 self.assertIn(' file.2\n', run.output) 1060 self.assertIn(' file.9\n', run.output) 1061 self.assertIn(' README\n', run.output) 1062 def test_20502_infozipdir_big_test2_zip(self): 1063 """ run info-zip dir test2.zip """ 1064 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1065 zipfile = "test2.zip" 1066 getfile = "test2.zip" 1067 exe = self.bins("unzip") 1068 run = shell("{exe} -l {getfile} ".format(**locals())) 1069 self.assertIn(' file.01\n', run.output) 1070 self.assertIn(' file.22\n', run.output) 1071 self.assertIn(' file.99\n', run.output) 1072 def test_20503_infozipdir_big_test3_zip(self): 1073 """ run info-zip dir test3.zip """ 1074 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1075 zipfile = "test3.zip" 1076 getfile = "test3.zip" 1077 exe = self.bins("unzip") 1078 run = shell("{exe} -l {getfile} ".format(**locals())) 1079 self.assertIn(' file.001\n', run.output) 1080 self.assertIn(' file.222\n', run.output) 1081 self.assertIn(' file.999\n', run.output) 1082 def test_20504_infozipdir_big_test4_zip(self): 1083 """ run info-zip dir test4.zip """ 1084 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1085 zipfile = "test4.zip" 1086 getfile = "test4.zip" 1087 exe = self.bins("unzip") 1088 run = shell("{exe} -l {getfile} ".format(**locals())) 1089 self.assertIn(' file0001.txt\n', run.output) 1090 self.assertIn(' file2222.txt\n', run.output) 1091 self.assertIn(' file9999.txt\n', run.output) 1092 def test_20505_infozipdir_big_test5_zip(self): 1093 """ run info-zip dir on test5.zip """ 1094 zipfile = "test5.zip" 1095 getfile = "test5.zip" 1096 exe = self.bins("unzzip-mix") 1097 run = shell("{exe} -v {getfile} ".format(**locals())) 1098 self.assertIn('/subdir14/file15-128.txt\n', run.output) 1099 self.assertIn('/subdir5/subdir6/', run.output) 1100 self.assertIn(' defl:N ', run.output) 1101 self.assertIn(' stored ', run.output) 1102 def test_20510_zzdir_big_test0_zip(self): 1103 """ run zzdir-big on test0.zip """ 1104 zipfile = "test0.zip" 1105 getfile = "test0.zip" 1106 exe = self.bins("unzzip-big") 1107 run = shell("{exe} -l {getfile} ".format(**locals())) 1108 self.assertIn(' README\n', run.output) 1109 self.assertLess(len(run.output), 30) 1110 def test_20511_zzdir_big_test1_zip(self): 1111 """ run zzdir-big on test1.zip """ 1112 zipfile = "test1.zip" 1113 getfile = "test1.zip" 1114 exe = self.bins("unzzip-big") 1115 run = shell("{exe} -l {getfile} ".format(**locals())) 1116 self.assertIn(' file.1\n', run.output) 1117 self.assertIn(' file.2\n', run.output) 1118 self.assertIn(' file.9\n', run.output) 1119 self.assertIn(' README\n', run.output) 1120 def test_20512_zzdir_big_test2_zip(self): 1121 """ run zzdir-big on test2.zip """ 1122 zipfile = "test2.zip" 1123 getfile = "test2.zip" 1124 exe = self.bins("unzzip-big") 1125 run = shell("{exe} -l {getfile} ".format(**locals())) 1126 self.assertIn(' file.01\n', run.output) 1127 self.assertIn(' file.22\n', run.output) 1128 self.assertIn(' file.99\n', run.output) 1129 def test_20513_zzdir_big_test3_zip(self): 1130 """ run zzdir-big on test3.zip """ 1131 zipfile = "test3.zip" 1132 getfile = "test3.zip" 1133 exe = self.bins("unzzip-big") 1134 run = shell("{exe} -l {getfile} ".format(**locals())) 1135 self.assertIn(' file.001\n', run.output) 1136 self.assertIn(' file.222\n', run.output) 1137 self.assertIn(' file.999\n', run.output) 1138 def test_20514_zzdir_big_test4_zip(self): 1139 """ run zzdir-big on test4.zip """ 1140 zipfile = "test4.zip" 1141 getfile = "test4.zip" 1142 exe = self.bins("unzzip-big") 1143 run = shell("{exe} -l {getfile} ".format(**locals())) 1144 self.assertIn(' file0001.txt\n', run.output) 1145 self.assertIn(' file2222.txt\n', run.output) 1146 self.assertIn(' file9999.txt\n', run.output) 1147 def test_20515_zzdir_big_test5_zip(self): 1148 """ run zzdir-big on test5.zip """ 1149 zipfile = "test5.zip" 1150 getfile = "test5.zip" 1151 exe = self.bins("unzzip-mix") 1152 run = shell("{exe} -v {getfile} ".format(**locals())) 1153 self.assertIn('/subdir14/file15-128.txt\n', run.output) 1154 self.assertIn('/subdir5/subdir6/', run.output) 1155 self.assertIn(' defl:N ', run.output) 1156 self.assertIn(' stored ', run.output) 1157 def test_20520_zzdir_mem_test0_zip(self): 1158 """ run zzdir-mem on test0.zip """ 1159 zipfile = "test0.zip" 1160 getfile = "test0.zip" 1161 exe = self.bins("unzzip-mem") 1162 run = shell("{exe} -v {getfile} ".format(**locals())) 1163 self.assertIn(' README\n', run.output) 1164 self.assertIn(' defl:N ', run.output) 1165 self.assertLess(len(run.output), 30) 1166 def test_20521_zzdir_mem_test1_zip(self): 1167 """ run zzdir-mem on test1.zip """ 1168 zipfile = "test1.zip" 1169 getfile = "test1.zip" 1170 exe = self.bins("unzzip-mem") 1171 run = shell("{exe} -v {getfile} ".format(**locals())) 1172 self.assertIn(' file.1\n', run.output) 1173 self.assertIn(' file.2\n', run.output) 1174 self.assertIn(' file.9\n', run.output) 1175 self.assertIn(' README\n', run.output) 1176 self.assertIn(' defl:N ', run.output) 1177 self.assertIn(' stored ', run.output) 1178 def test_20522_zzdir_mem_test2_zip(self): 1179 """ run zzdir-mem on test2.zip """ 1180 zipfile = "test2.zip" 1181 getfile = "test2.zip" 1182 exe = self.bins("unzzip-mem") 1183 run = shell("{exe} -v {getfile} ".format(**locals())) 1184 self.assertIn(' file.01\n', run.output) 1185 self.assertIn(' file.22\n', run.output) 1186 self.assertIn(' file.99\n', run.output) 1187 self.assertIn(' defl:N ', run.output) 1188 self.assertIn(' stored ', run.output) 1189 def test_20523_zzdir_mem_test3_zip(self): 1190 """ run zzdir-mem on test3.zip """ 1191 zipfile = "test3.zip" 1192 getfile = "test3.zip" 1193 exe = self.bins("unzzip-mem") 1194 run = shell("{exe} -v {getfile} ".format(**locals())) 1195 self.assertIn(' file.001\n', run.output) 1196 self.assertIn(' file.222\n', run.output) 1197 self.assertIn(' file.999\n', run.output) 1198 self.assertIn(' defl:N ', run.output) 1199 self.assertIn(' stored ', run.output) 1200 def test_20524_zzdir_mem_test4_zip(self): 1201 """ run zzdir-mem on test4.zip """ 1202 zipfile = "test4.zip" 1203 getfile = "test4.zip" 1204 exe = self.bins("unzzip-mem") 1205 run = shell("{exe} -v {getfile} ".format(**locals())) 1206 self.assertIn(' file0001.txt\n', run.output) 1207 self.assertIn(' file2222.txt\n', run.output) 1208 self.assertIn(' file9999.txt\n', run.output) 1209 self.assertNotIn(' defl:N ', run.output) 1210 self.assertIn(' stored ', run.output) 1211 def test_20525_zzdir_mem_test5_zip(self): 1212 """ run zzdir-mem on test5.zip """ 1213 zipfile = "test5.zip" 1214 getfile = "test5.zip" 1215 exe = self.bins("unzzip-mix") 1216 run = shell("{exe} -v {getfile} ".format(**locals())) 1217 self.assertIn('/subdir14/file15-128.txt\n', run.output) 1218 self.assertIn('/subdir5/subdir6/', run.output) 1219 self.assertIn(' defl:N ', run.output) 1220 self.assertIn(' stored ', run.output) 1221 def test_20530_zzdir_mix_test0_zip(self): 1222 """ run zzdir-mix on test0.zip """ 1223 # self.skipTest("todo") 1224 zipfile = "test0.zip" 1225 getfile = "test0.zip" 1226 exe = self.bins("unzzip-mix") 1227 run = shell("{exe} -v {getfile} ".format(**locals())) 1228 self.assertIn(' README\n', run.output) 1229 self.assertIn(' defl:N ', run.output) 1230 self.assertLess(len(run.output), 30) 1231 def test_20531_zzdir_mix_test1_zip(self): 1232 """ run zzdir-mix on test1.zip """ 1233 zipfile = "test1.zip" 1234 getfile = "test1.zip" 1235 exe = self.bins("unzzip-mix") 1236 run = shell("{exe} -v {getfile} ".format(**locals())) 1237 self.assertIn(' file.1\n', run.output) 1238 self.assertIn(' file.2\n', run.output) 1239 self.assertIn(' file.9\n', run.output) 1240 self.assertIn(' README\n', run.output) 1241 self.assertIn(' defl:N ', run.output) 1242 self.assertIn(' stored ', run.output) 1243 def test_20532_zzdir_mix_test2_zip(self): 1244 """ run zzdir-mix on test2.zip """ 1245 zipfile = "test2.zip" 1246 getfile = "test2.zip" 1247 exe = self.bins("unzzip-mix") 1248 run = shell("{exe} -v {getfile} ".format(**locals())) 1249 self.assertIn(' file.01\n', run.output) 1250 self.assertIn(' file.22\n', run.output) 1251 self.assertIn(' file.99\n', run.output) 1252 self.assertIn(' defl:N ', run.output) 1253 self.assertIn(' stored ', run.output) 1254 def test_20533_zzdir_mix_test3_zip(self): 1255 """ run zzdir-mix on test3.zip """ 1256 zipfile = "test3.zip" 1257 getfile = "test3.zip" 1258 exe = self.bins("unzzip-mix") 1259 run = shell("{exe} -v {getfile} ".format(**locals())) 1260 self.assertIn(' file.001\n', run.output) 1261 self.assertIn(' file.222\n', run.output) 1262 self.assertIn(' file.999\n', run.output) 1263 self.assertIn(' defl:N ', run.output) 1264 self.assertIn(' stored ', run.output) 1265 def test_20534_zzdir_mix_test4_zip(self): 1266 """ run zzdir-mix on test4.zip """ 1267 zipfile = "test4.zip" 1268 getfile = "test4.zip" 1269 exe = self.bins("unzzip-mix") 1270 run = shell("{exe} -v {getfile} ".format(**locals())) 1271 self.assertIn(' file0001.txt\n', run.output) 1272 self.assertIn(' file2222.txt\n', run.output) 1273 self.assertIn(' file9999.txt\n', run.output) 1274 self.assertNotIn(' defl:N ', run.output) 1275 self.assertIn(' stored ', run.output) 1276 def test_20535_zzdir_mix_test5_zip(self): 1277 """ run zzdir-mix on test5.zip """ 1278 zipfile = "test5.zip" 1279 getfile = "test5.zip" 1280 exe = self.bins("unzzip-mix") 1281 run = shell("{exe} -v {getfile} ".format(**locals())) 1282 self.assertIn('/subdir14/file15-128.txt\n', run.output) 1283 self.assertIn('/subdir5/subdir6/', run.output) 1284 self.assertIn(' defl:N ', run.output) 1285 self.assertIn(' stored ', run.output) 1286 def test_20540_zzdir_zap_test0_zip(self): 1287 """ run zzdir-zap on test0.zip """ 1288 zipfile = "test0.zip" 1289 getfile = "test0.zip" 1290 exe = self.bins("unzzip") 1291 run = shell("{exe} -v {getfile} ".format(**locals())) 1292 self.assertIn(' README\n', run.output) 1293 self.assertIn(' defl:N ', run.output) 1294 self.assertLess(len(run.output), 30) 1295 def test_20541_zzdir_zap_test1_zip(self): 1296 """ run zzdir-zap on test1.zip """ 1297 zipfile = "test1.zip" 1298 getfile = "test1.zip" 1299 exe = self.bins("unzzip") 1300 run = shell("{exe} -v {getfile} ".format(**locals())) 1301 self.assertIn(' file.1\n', run.output) 1302 self.assertIn(' file.2\n', run.output) 1303 self.assertIn(' file.9\n', run.output) 1304 self.assertIn(' README\n', run.output) 1305 self.assertIn(' defl:N ', run.output) 1306 self.assertIn(' stored ', run.output) 1307 def test_20542_zzdir_zap_test2_zip(self): 1308 """ run zzdir-zap on test2.zip """ 1309 zipfile = "test2.zip" 1310 getfile = "test2.zip" 1311 exe = self.bins("unzzip") 1312 run = shell("{exe} -v {getfile} ".format(**locals())) 1313 self.assertIn(' file.01\n', run.output) 1314 self.assertIn(' file.22\n', run.output) 1315 self.assertIn(' file.99\n', run.output) 1316 self.assertIn(' defl:N ', run.output) 1317 self.assertIn(' stored ', run.output) 1318 def test_20543_zzdir_zap_test3_zip(self): 1319 """ run zzdir-zap on test3.zip """ 1320 zipfile = "test3.zip" 1321 getfile = "test3.zip" 1322 exe = self.bins("unzzip") 1323 run = shell("{exe} -v {getfile} ".format(**locals())) 1324 self.assertIn(' file.001\n', run.output) 1325 self.assertIn(' file.222\n', run.output) 1326 self.assertIn(' file.999\n', run.output) 1327 self.assertIn(' defl:N ', run.output) 1328 self.assertIn(' stored ', run.output) 1329 def test_20544_zzdir_zap_test4_zip(self): 1330 """ run zzdir-zap on test4.zip """ 1331 zipfile = "test4.zip" 1332 getfile = "test4.zip" 1333 exe = self.bins("unzzip") 1334 run = shell("{exe} -v {getfile} ".format(**locals())) 1335 self.assertIn(' file0001.txt\n', run.output) 1336 self.assertIn(' file2222.txt\n', run.output) 1337 self.assertIn(' file9999.txt\n', run.output) 1338 self.assertNotIn(' defl:N ', run.output) 1339 self.assertIn(' stored ', run.output) 1340 def test_20545_zzdir_zap_test5_zip(self): 1341 """ run zzdir-zap on test5.zip """ 1342 zipfile = "test5.zip" 1343 getfile = "test5.zip" 1344 exe = self.bins("unzzip") 1345 run = shell("{exe} -v {getfile} ".format(**locals())) 1346 self.assertIn('/subdir14/file15-128.txt\n', run.output) 1347 self.assertIn('/subdir5/subdir6/', run.output) 1348 self.assertIn(' defl:N ', run.output) 1349 self.assertIn(' stored ', run.output) 1350 def test_20595_zzextract_zap_test5_zip(self): 1351 """ run zzextract-zap on test5.zip 1352 => coughs up a SEGFAULT in zzip_dir_close() ?!?""" 1353 self.rm_testdir() 1354 zipfile = "test5.zip" 1355 getfile = "test5.zip" 1356 tmpdir = self.testdir() 1357 exe = self.bins("unzzip") 1358 run = shell("cd {tmpdir} && ../{exe} ../{getfile} ".format(**locals())); 1359 self.assertTrue(tmpdir+'/subdir1/subdir2/file3-1024.txt') 1360 # self.rm_testdir() 1361 1362 url_CVE_2017_5977 = "https://github.com/asarubbo/poc/blob/master" 1363 zip_CVE_2017_5977 = "00153-zziplib-invalidread-zzip_mem_entry_extra_block" 1364 def test_59770_infozipdir_CVE_2017_5977(self): 1365 """ run info-zip dir test0.zip """ 1366 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1367 tmpdir = self.testdir() 1368 filename = self.zip_CVE_2017_5977 1369 file_url = self.url_CVE_2017_5977 1370 if not download_raw(file_url, filename, tmpdir): 1371 self.skipTest("no zip_CVE_2017_5977 available: " + filename) 1372 exe = self.bins("unzip") 1373 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1374 returncodes = [0, 2]) 1375 self.assertIn(" didn't find end-of-central-dir signature at end of central dir", run.errors) 1376 self.assertIn(" 2 extra bytes at beginning or within zipfile", run.errors) 1377 self.assertLess(len(run.output), 280) 1378 # 1379 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 1380 returncodes = [2]) 1381 self.assertLess(len(run.output), 101) 1382 self.assertLess(len(errors(run.errors)), 900) 1383 self.assertIn('test: mismatching "local" filename', run.errors) 1384 self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) 1385 self.rm_testdir() 1386 def test_59771_zzipdir_big_CVE_2017_5977(self): 1387 """ run info-zip -l $(CVE_2017_5977).zip """ 1388 tmpdir = self.testdir() 1389 filename = self.zip_CVE_2017_5977 1390 file_url = self.url_CVE_2017_5977 1391 if not download_raw(file_url, filename, tmpdir): 1392 self.skipTest("no zip_CVE_2017_5977 available: " + filename) 1393 exe = self.bins("unzzip-big") 1394 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1395 returncodes = [0]) 1396 self.assertLess(len(run.output), 30) 1397 self.assertLess(len(errors(run.errors)), 1) 1398 self.assertIn(" stored test", run.output) 1399 # 1400 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1401 returncodes = [0]) 1402 self.assertLess(len(run.output), 30) 1403 self.assertLess(len(errors(run.errors)), 1) 1404 self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) 1405 self.rm_testdir() 1406 def test_59772_zzipdir_mem_CVE_2017_5977(self): 1407 """ run unzzip-mem -l $(CVE_2017_5977).zip """ 1408 tmpdir = self.testdir() 1409 filename = self.zip_CVE_2017_5977 1410 file_url = self.url_CVE_2017_5977 1411 if not download_raw(file_url, filename, tmpdir): 1412 self.skipTest("no zip_CVE_2017_5977 available: " + filename) 1413 exe = self.bins("unzzip-mem") 1414 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1415 returncodes = [0]) 1416 self.assertLess(len(run.output), 30) 1417 self.assertLess(len(errors(run.errors)), 1) 1418 self.assertIn(" 3 test", run.output) 1419 # 1420 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1421 returncodes = [0]) 1422 self.assertLess(len(run.output), 30) 1423 self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 1424 self.rm_testdir() 1425 def test_59773_zzipdir_mix_CVE_2017_5977(self): 1426 """ run unzzip-mix -l $(CVE_2017_5977).zip """ 1427 tmpdir = self.testdir() 1428 filename = self.zip_CVE_2017_5977 1429 file_url = self.url_CVE_2017_5977 1430 if not download_raw(file_url, filename, tmpdir): 1431 self.skipTest("no zip_CVE_2017_5977 available: " + filename) 1432 exe = self.bins("unzzip-mix") 1433 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1434 returncodes = [0]) 1435 self.assertLess(len(run.output), 30) 1436 self.assertLess(len(errors(run.errors)), 1) 1437 self.assertIn(" 3 test", run.output) 1438 # 1439 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1440 returncodes = [0]) 1441 self.assertLess(len(run.output), 30) 1442 self.assertLess(len(errors(run.errors)), 1) 1443 self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) 1444 self.rm_testdir() 1445 def test_59774_zzipdir_zap_CVE_2017_5977(self): 1446 """ run unzzip -l $(CVE_2017_5977).zip """ 1447 tmpdir = self.testdir() 1448 filename = self.zip_CVE_2017_5977 1449 file_url = self.url_CVE_2017_5977 1450 if not download_raw(file_url, filename, tmpdir): 1451 self.skipTest("no zip_CVE_2017_5977 available: " + filename) 1452 exe = self.bins("unzzip") 1453 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1454 returncodes = [0, 255]) 1455 self.assertLess(len(run.output), 30) 1456 self.assertLess(len(errors(run.errors)), 1) 1457 self.assertIn(" 3 test", run.output) 1458 # 1459 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1460 returncodes = [0]) 1461 self.assertLess(len(run.output), 30) 1462 self.assertLess(len(errors(run.errors)), 1) 1463 self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) # TODO 1464 self.rm_testdir() 1465 def test_59779(self): 1466 """ check $(CVE).zip """ 1467 tmpdir = self.testdir() 1468 filename = self.zip_CVE_2017_5977 1469 file_url = self.url_CVE_2017_5977 1470 if not download_raw(file_url, filename, tmpdir): 1471 self.skipTest("no zip_CVE_2017_5977 available: " + filename) 1472 shell("ls -l {tmpdir}/{filename}".format(**locals())) 1473 size = os.path.getsize(os.path.join(tmpdir, filename)) 1474 self.assertEqual(size, 163) 1475 1476 url_CVE_2017_5978 = "https://github.com/asarubbo/poc/blob/master" 1477 zip_CVE_2017_5978 = "00156-zziplib-oobread-zzip_mem_entry_new" 1478 def test_59780_infozipdir_CVE_2017_5978(self): 1479 """ run info-zip dir test0.zip """ 1480 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1481 tmpdir = self.testdir() 1482 filename = self.zip_CVE_2017_5978 1483 file_url = self.url_CVE_2017_5978 1484 if not download_raw(file_url, filename, tmpdir): 1485 self.skipTest("no zip_CVE_2017_5978 available: " + filename) 1486 exe = self.bins("unzip") 1487 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1488 returncodes = [0, 3]) 1489 self.assertIn(' missing 4608 bytes in zipfile', run.errors) 1490 self.assertIn(' attempt to seek before beginning of zipfile', run.errors) 1491 self.assertLess(len(run.output), 80) 1492 self.assertLess(len(errors(run.errors)), 430) 1493 # 1494 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 1495 returncodes = [3]) 1496 self.assertLess(len(run.output), 90) 1497 self.assertLess(len(errors(run.errors)), 900) 1498 self.assertIn('attempt to seek before beginning of zipfile', run.errors) 1499 self.assertFalse(os.path.exists(tmpdir+"/test")) 1500 self.rm_testdir() 1501 def test_59781_zzipdir_big_CVE_2017_5978(self): 1502 """ run info-zip -l $(CVE_2017_5978).zip """ 1503 tmpdir = self.testdir() 1504 filename = self.zip_CVE_2017_5978 1505 file_url = self.url_CVE_2017_5978 1506 if not download_raw(file_url, filename, tmpdir): 1507 self.skipTest("no zip_CVE_2017_5978 available: " + filename) 1508 exe = self.bins("unzzip-big") 1509 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1510 returncodes = [0]) 1511 self.assertLess(len(run.output), 30) 1512 self.assertLess(len(errors(run.errors)), 1) 1513 self.assertIn(" stored (null)", run.output) 1514 # 1515 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1516 returncodes = [0,1]) 1517 self.assertLess(len(run.output), 30) 1518 self.assertLess(len(errors(run.errors)), 1) 1519 self.assertFalse(os.path.exists(tmpdir+"/test")) 1520 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) 1521 self.rm_testdir() 1522 def test_59782_zzipdir_mem_CVE_2017_5978(self): 1523 """ run unzzip-mem -l $(CVE_2017_5978).zip """ 1524 tmpdir = self.testdir() 1525 filename = self.zip_CVE_2017_5978 1526 file_url = self.url_CVE_2017_5978 1527 if not download_raw(file_url, filename, tmpdir): 1528 self.skipTest("no zip_CVE_2017_5978 available: " + filename) 1529 exe = self.bins("unzzip-mem") 1530 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1531 returncodes = [0]) 1532 self.assertLess(len(run.output), 1) 1533 self.assertLess(len(errors(run.errors)), 180) 1534 # self.assertIn("zzip_mem_disk_load : unable to load entry", run.errors) 1535 self.assertIn("zzip_mem_disk_open : unable to load disk", run.errors) 1536 # 1537 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1538 returncodes = [0]) 1539 self.assertLess(len(run.output), 30) 1540 self.assertLess(len(errors(run.errors)), 300) 1541 if grep("DEBUG:", run.errors): 1542 self.assertIn("zzip_mem_disk_open : unable to load disk", run.errors) 1543 self.assertFalse(os.path.exists(tmpdir+"/test")) 1544 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) 1545 self.rm_testdir() 1546 def test_59783_zzipdir_mix_CVE_2017_5978(self): 1547 """ run unzzip-mix -l $(CVE_2017_5978).zip """ 1548 tmpdir = self.testdir() 1549 filename = self.zip_CVE_2017_5978 1550 file_url = self.url_CVE_2017_5978 1551 if not download_raw(file_url, filename, tmpdir): 1552 self.skipTest("no zip_CVE_2017_5978 available: " + filename) 1553 exe = self.bins("unzzip-mix") 1554 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1555 returncodes = [0,2]) 1556 self.assertLess(len(run.output), 1) 1557 self.assertLess(len(errors(run.errors)), 180) 1558 self.assertErrorMessage(run.errors, errno.EILSEQ) 1559 # 1560 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1561 returncodes = [0,2]) 1562 self.assertLess(len(run.output), 30) 1563 self.assertLess(len(errors(run.errors)), 300) 1564 self.assertErrorMessage(run.errors, errno.EILSEQ) 1565 self.assertFalse(os.path.exists(tmpdir+"/test")) 1566 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) 1567 self.rm_testdir() 1568 def test_59784_zzipdir_zap_CVE_2017_5978(self): 1569 """ run unzzip -l $(CVE_2017_5978).zip """ 1570 tmpdir = self.testdir() 1571 filename = self.zip_CVE_2017_5978 1572 file_url = self.url_CVE_2017_5978 1573 if not download_raw(file_url, filename, tmpdir): 1574 self.skipTest("no zip_CVE_2017_5978 available: " + filename) 1575 exe = self.bins("unzzip") 1576 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1577 returncodes = [3]) 1578 self.assertLess(len(run.output), 1) 1579 self.assertLess(len(errors(run.errors)), 180) 1580 # 1581 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1582 returncodes = [0,3]) 1583 self.assertLess(len(run.output), 30) 1584 self.assertLess(len(errors(run.errors)), 300) 1585 self.assertTrue(greps(run.errors, "Zipfile corrupted")) 1586 self.assertFalse(os.path.exists(tmpdir+"/test")) 1587 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) 1588 self.rm_testdir() 1589 def test_59789(self): 1590 """ check $(CVE).zip """ 1591 tmpdir = self.testdir() 1592 filename = self.zip_CVE_2017_5978 1593 file_url = self.url_CVE_2017_5978 1594 if not download_raw(file_url, filename, tmpdir): 1595 self.skipTest("no zip_CVE_2017_5978 available: " + filename) 1596 shell("ls -l {tmpdir}/{filename}".format(**locals())) 1597 size = os.path.getsize(os.path.join(tmpdir, filename)) 1598 self.assertEqual(size, 161) 1599 1600 url_CVE_2017_5979 = "https://github.com/asarubbo/poc/blob/master" 1601 zip_CVE_2017_5979 = "00157-zziplib-nullptr-prescan_entry" 1602 def test_59790_infozipdir_CVE_2017_5979(self): 1603 """ run info-zip dir test0.zip """ 1604 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1605 tmpdir = self.testdir() 1606 filename = self.zip_CVE_2017_5979 1607 file_url = self.url_CVE_2017_5979 1608 if not download_raw(file_url, filename, tmpdir): 1609 self.skipTest("no zip_CVE_2017_5979 available: " + filename) 1610 exe = self.bins("unzip") 1611 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1612 returncodes = [0]) 1613 self.assertIn(' 1 file', run.output) 1614 self.assertLess(len(run.output), 330) 1615 self.assertLess(len(errors(run.errors)), 1) 1616 # 1617 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 1618 returncodes = [0]) 1619 self.assertLess(len(run.output), 90) 1620 self.assertLess(len(errors(run.errors)), 1) 1621 self.assertIn('extracting: a', run.output) 1622 self.assertEqual(os.path.getsize(tmpdir+"/a"), 3) 1623 self.rm_testdir() 1624 def test_59791_zzipdir_big_CVE_2017_5979(self): 1625 """ run info-zip -l $(CVE_2017_5979).zip """ 1626 tmpdir = self.testdir() 1627 filename = self.zip_CVE_2017_5979 1628 file_url = self.url_CVE_2017_5979 1629 if not download_raw(file_url, filename, tmpdir): 1630 self.skipTest("no zip_CVE_2017_5979 available: " + filename) 1631 exe = self.bins("unzzip-big") 1632 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1633 returncodes = [0]) 1634 self.assertLess(len(run.output), 30) 1635 self.assertLess(len(errors(run.errors)), 1) 1636 self.assertIn(" stored a", run.output) 1637 # 1638 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1639 returncodes = [0]) 1640 self.assertLess(len(run.output), 30) 1641 self.assertLess(len(errors(run.errors)), 1) 1642 self.assertEqual(os.path.getsize(tmpdir+"/a"), 3) 1643 self.rm_testdir() 1644 def test_59792_zzipdir_mem_CVE_2017_5979(self): 1645 """ run unzzip-mem -l $(CVE_2017_5979).zip """ 1646 tmpdir = self.testdir() 1647 filename = self.zip_CVE_2017_5979 1648 file_url = self.url_CVE_2017_5979 1649 if not download_raw(file_url, filename, tmpdir): 1650 self.skipTest("no zip_CVE_2017_5979 available: " + filename) 1651 exe = self.bins("unzzip-mem") 1652 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1653 returncodes = [0]) 1654 self.assertLess(len(run.output), 30) 1655 self.assertLess(len(errors(run.errors)), 1) 1656 self.assertIn(" 3 a", run.output) 1657 # 1658 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1659 returncodes = [0]) 1660 self.assertLess(len(run.output), 30) 1661 self.assertEqual(os.path.getsize(tmpdir+"/a"), 3) 1662 self.rm_testdir() 1663 def test_59793_zzipdir_mix_CVE_2017_5979(self): 1664 """ run unzzip-mix -l $(CVE_2017_5979).zip """ 1665 tmpdir = self.testdir() 1666 filename = self.zip_CVE_2017_5979 1667 file_url = self.url_CVE_2017_5979 1668 if not download_raw(file_url, filename, tmpdir): 1669 self.skipTest("no zip_CVE_2017_5979 available: " + filename) 1670 exe = self.bins("unzzip-mix") 1671 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1672 returncodes = [0]) 1673 self.assertLess(len(run.output), 30) 1674 self.assertLess(len(errors(run.errors)), 1) 1675 self.assertIn(" 3 a", run.output) 1676 # 1677 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1678 returncodes = [0]) 1679 self.assertLess(len(run.output), 30) 1680 self.assertLess(len(errors(run.errors)), 20) 1681 self.assertEqual(os.path.getsize(tmpdir+"/a"), 0) # FIXME 1682 # self.assertEqual(os.path.getsize(tmpdir+"/a"), 3) # FIXME 1683 self.rm_testdir() 1684 def test_59794_zzipdir_zap_CVE_2017_5979(self): 1685 """ run unzzip -l $(CVE_2017_5979).zip """ 1686 tmpdir = self.testdir() 1687 filename = self.zip_CVE_2017_5979 1688 file_url = self.url_CVE_2017_5979 1689 if not download_raw(file_url, filename, tmpdir): 1690 self.skipTest("no zip_CVE_2017_5979 available: " + filename) 1691 exe = self.bins("unzzip") 1692 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1693 returncodes = [0, 255]) 1694 self.assertLess(len(run.output), 30) 1695 self.assertLess(len(errors(run.errors)), 1) 1696 self.assertIn(" 3 a", run.output) 1697 # 1698 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1699 returncodes = [0]) 1700 self.assertLess(len(run.output), 30) 1701 self.assertLess(len(errors(run.errors)), 20) 1702 self.assertEqual(os.path.getsize(tmpdir+"/a"), 3) 1703 self.rm_testdir() 1704 def test_59799(self): 1705 """ check $(CVE).zip """ 1706 tmpdir = self.testdir() 1707 filename = self.zip_CVE_2017_5979 1708 file_url = self.url_CVE_2017_5979 1709 if not download_raw(file_url, filename, tmpdir): 1710 self.skipTest("no zip_CVE_2017_5979 available: " + filename) 1711 shell("ls -l {tmpdir}/{filename}".format(**locals())) 1712 size = os.path.getsize(os.path.join(tmpdir, filename)) 1713 self.assertEqual(size, 155) 1714 1715 1716 url_CVE_2017_5974 = "https://github.com/asarubbo/poc/blob/master" 1717 zip_CVE_2017_5974 = "00150-zziplib-heapoverflow-__zzip_get32" 1718 def test_59740_infozipdir_CVE_2017_5974(self): 1719 """ run info-zip dir test0.zip """ 1720 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1721 tmpdir = self.testdir() 1722 filename = self.zip_CVE_2017_5974 1723 file_url = self.url_CVE_2017_5974 1724 if not download_raw(file_url, filename, tmpdir): 1725 self.skipTest("no zip_CVE_2017_5974 available: " + filename) 1726 exe = self.bins("unzip") 1727 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1728 returncodes = [0, 9]) 1729 self.assertIn(' 1 file', run.output) 1730 self.assertLess(len(run.output), 330) 1731 self.assertLess(len(errors(run.errors)), 1) 1732 # 1733 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 1734 returncodes = [0]) 1735 self.assertLess(len(run.output), 90) 1736 self.assertLess(len(errors(run.errors)), 1) 1737 self.assertIn(" extracting: test", run.output) 1738 self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 1739 self.rm_testdir() 1740 def test_59741_zzipdir_big_CVE_2017_5974(self): 1741 """ run unzzip-big -l $(CVE_2017_5974).zip """ 1742 tmpdir = self.testdir() 1743 filename = self.zip_CVE_2017_5974 1744 file_url = self.url_CVE_2017_5974 1745 if not download_raw(file_url, filename, tmpdir): 1746 self.skipTest("no zip_CVE_2017_5974 available: " + filename) 1747 exe = self.bins("unzzip-big") 1748 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1749 returncodes = [0]) 1750 self.assertLess(len(run.output), 30) 1751 self.assertLess(len(errors(run.errors)), 1) 1752 self.assertIn(" stored test", run.output) 1753 # 1754 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1755 returncodes = [0]) 1756 self.assertLess(len(run.output), 30) 1757 self.assertLess(len(errors(run.errors)), 1) 1758 self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 1759 self.rm_testdir() 1760 def test_59742_zzipdir_mem_CVE_2017_5974(self): 1761 """ run unzzip-mem -l $(CVE_2017_5974).zip """ 1762 tmpdir = self.testdir() 1763 filename = self.zip_CVE_2017_5974 1764 file_url = self.url_CVE_2017_5974 1765 if not download_raw(file_url, filename, tmpdir): 1766 self.skipTest("no zip_CVE_2017_5974 available: " + filename) 1767 exe = self.bins("unzzip-mem") 1768 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1769 returncodes = [0]) 1770 self.assertLess(len(run.output), 30) 1771 self.assertLess(len(errors(run.errors)), 1) 1772 self.assertIn(" 3 test", run.output) 1773 # 1774 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1775 returncodes = [0]) 1776 self.assertLess(len(run.output), 30) 1777 self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 1778 self.rm_testdir() 1779 def test_59743_zzipdir_mix_CVE_2017_5974(self): 1780 """ run unzzip-mix -l $(CVE_2017_5974).zip """ 1781 tmpdir = self.testdir() 1782 filename = self.zip_CVE_2017_5974 1783 file_url = self.url_CVE_2017_5974 1784 if not download_raw(file_url, filename, tmpdir): 1785 self.skipTest("no zip_CVE_2017_5974 available: " + filename) 1786 exe = self.bins("unzzip-mix") 1787 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1788 returncodes = [0]) 1789 self.assertLess(len(run.output), 30) 1790 self.assertLess(len(errors(run.errors)), 1) 1791 self.assertIn(" 3 test", run.output) 1792 # 1793 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1794 returncodes = [0]) 1795 self.assertLess(len(run.output), 30) 1796 self.assertLess(len(errors(run.errors)), 1) 1797 self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) # FIXME 1798 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) # FIXME 1799 self.rm_testdir() 1800 def test_59744_zzipdir_zap_CVE_2017_5974(self): 1801 """ run unzzip -l $(CVE_2017_5974).zip """ 1802 tmpdir = self.testdir() 1803 filename = self.zip_CVE_2017_5974 1804 file_url = self.url_CVE_2017_5974 1805 if not download_raw(file_url, filename, tmpdir): 1806 self.skipTest("no zip_CVE_2017_5974 available: " + filename) 1807 exe = self.bins("unzzip") 1808 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1809 returncodes = [0, 255]) 1810 self.assertLess(len(run.output), 30) 1811 self.assertLess(len(errors(run.errors)), 1) 1812 self.assertIn(" 3 test", run.output) 1813 # 1814 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1815 returncodes = [0]) 1816 self.assertLess(len(run.output), 30) 1817 self.assertLess(len(errors(run.errors)), 1) 1818 self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 1819 self.rm_testdir() 1820 def test_59749(self): 1821 """ check $(CVE).zip """ 1822 tmpdir = self.testdir() 1823 filename = self.zip_CVE_2017_5974 1824 file_url = self.url_CVE_2017_5974 1825 if not download_raw(file_url, filename, tmpdir): 1826 self.skipTest("no zip_CVE_2017_5974 available: " + filename) 1827 shell("ls -l {tmpdir}/{filename}".format(**locals())) 1828 size = os.path.getsize(os.path.join(tmpdir, filename)) 1829 self.assertEqual(size, 161) 1830 1831 url_CVE_2017_5975 = "https://github.com/asarubbo/poc/blob/master" 1832 zip_CVE_2017_5975 = "00151-zziplib-heapoverflow-__zzip_get64" 1833 def test_59750_infozipdir_CVE_2017_5975(self): 1834 """ run info-zip dir test0.zip """ 1835 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1836 tmpdir = self.testdir() 1837 filename = self.zip_CVE_2017_5975 1838 file_url = self.url_CVE_2017_5975 1839 if not download_raw(file_url, filename, tmpdir): 1840 self.skipTest("no zip_CVE_2017_5975 available: " + filename) 1841 exe = self.bins("unzip") 1842 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1843 returncodes = [0, 2]) 1844 self.assertIn(' missing 10 bytes in zipfile', run.errors) 1845 self.assertIn("didn't find end-of-central-dir signature at end of central dir", run.errors) 1846 self.assertIn(' 1 file', run.output) 1847 self.assertLess(len(run.output), 330) 1848 self.assertLess(len(errors(run.errors)), 430) 1849 # 1850 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 1851 returncodes = [2]) 1852 self.assertLess(len(run.output), 90) 1853 self.assertLess(len(errors(run.errors)), 900) 1854 self.assertIn('file #1: bad zipfile offset (local header sig): 127', run.errors) 1855 #self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 1856 self.assertFalse(os.path.exists(tmpdir+"/test")) 1857 self.rm_testdir() 1858 def test_59751_zzipdir_big_CVE_2017_5975(self): 1859 """ run info-zip -l $(CVE_2017_5975).zip """ 1860 tmpdir = self.testdir() 1861 filename = self.zip_CVE_2017_5975 1862 file_url = self.url_CVE_2017_5975 1863 if not download_raw(file_url, filename, tmpdir): 1864 self.skipTest("no zip_CVE_2017_5975 available: " + filename) 1865 exe = self.bins("unzzip-big") 1866 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1867 returncodes = [0]) 1868 self.assertLess(len(run.output), 30) 1869 self.assertLess(len(errors(run.errors)), 1) 1870 self.assertIn(" stored test", run.output) 1871 # 1872 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1873 returncodes = [0]) 1874 self.assertLess(len(run.output), 30) 1875 self.assertLess(len(errors(run.errors)), 1) 1876 self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) # TODO 1877 self.rm_testdir() 1878 def test_59752_zzipdir_mem_CVE_2017_5975(self): 1879 """ run unzzip-mem -l $(CVE_2017_5975).zip """ 1880 tmpdir = self.testdir() 1881 filename = self.zip_CVE_2017_5975 1882 file_url = self.url_CVE_2017_5975 1883 if not download_raw(file_url, filename, tmpdir): 1884 self.skipTest("no zip_CVE_2017_5975 available: " + filename) 1885 exe = self.bins("unzzip-mem") 1886 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1887 returncodes = [0]) 1888 self.assertLess(len(run.output), 1) 1889 self.assertLess(len(errors(run.errors)), 180) 1890 self.assertIn("zzip_mem_disk_load : unable to load entry", run.errors) 1891 self.assertIn("zzip_mem_disk_open : unable to load disk", run.errors) 1892 # 1893 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1894 returncodes = [0]) 1895 self.assertLess(len(run.output), 30) 1896 self.assertLess(len(errors(run.errors)), 200) 1897 if grep("DEBUG:", run.errors): 1898 self.assertIn("no header in entry", run.errors) 1899 self.assertFalse(os.path.exists(tmpdir+"/test")) 1900 self.rm_testdir() 1901 def test_59753_zzipdir_mix_CVE_2017_5975(self): 1902 """ run unzzip-mix -l $(CVE_2017_5975).zip """ 1903 tmpdir = self.testdir() 1904 filename = self.zip_CVE_2017_5975 1905 file_url = self.url_CVE_2017_5975 1906 if not download_raw(file_url, filename, tmpdir): 1907 self.skipTest("no zip_CVE_2017_5975 available: " + filename) 1908 exe = self.bins("unzzip-mix") 1909 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1910 returncodes = [0,2]) 1911 self.assertLess(len(run.output), 1) 1912 self.assertLess(len(errors(run.errors)), 180) 1913 self.assertErrorMessage(run.errors, errno.EILSEQ) 1914 # 1915 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1916 returncodes = [0,2]) 1917 self.assertLess(len(run.output), 30) 1918 self.assertLess(len(errors(run.errors)), 200) 1919 self.assertErrorMessage(run.errors, errno.EILSEQ) 1920 self.assertFalse(os.path.exists(tmpdir+"/test")) 1921 self.rm_testdir() 1922 def test_59754_zzipdir_zap_CVE_2017_5975(self): 1923 """ run unzzip -l $(CVE_2017_5975).zip """ 1924 tmpdir = self.testdir() 1925 filename = self.zip_CVE_2017_5975 1926 file_url = self.url_CVE_2017_5975 1927 if not download_raw(file_url, filename, tmpdir): 1928 self.skipTest("no zip_CVE_2017_5975 available: " + filename) 1929 exe = self.bins("unzzip") 1930 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1931 returncodes = [0,3]) 1932 self.assertLess(len(run.output), 1) 1933 self.assertLess(len(errors(run.errors)), 180) 1934 self.assertErrorMessage(run.errors, 0) 1935 # 1936 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1937 returncodes = [0,3]) 1938 self.assertLess(len(run.output), 30) 1939 self.assertLess(len(errors(run.errors)), 200) 1940 self.assertTrue(greps(run.errors, "Zipfile corrupted")) 1941 self.assertFalse(os.path.exists(tmpdir+"/test")) 1942 self.rm_testdir() 1943 def test_59759(self): 1944 """ check $(CVE).zip """ 1945 tmpdir = self.testdir() 1946 filename = self.zip_CVE_2017_5975 1947 file_url = self.url_CVE_2017_5975 1948 if not download_raw(file_url, filename, tmpdir): 1949 self.skipTest("no zip_CVE_2017_5975 available: " + filename) 1950 shell("ls -l {tmpdir}/{filename}".format(**locals())) 1951 size = os.path.getsize(os.path.join(tmpdir, filename)) 1952 self.assertEqual(size, 151) 1953 1954 1955 url_CVE_2017_5976 = "https://github.com/asarubbo/poc/blob/master" 1956 zip_CVE_2017_5976 = "00152-zziplib-heapoverflow-zzip_mem_entry_extra_block" 1957 def test_59760_infozipdir_CVE_2017_5976(self): 1958 """ run info-zip dir test0.zip """ 1959 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 1960 tmpdir = self.testdir() 1961 filename = self.zip_CVE_2017_5976 1962 file_url = self.url_CVE_2017_5976 1963 if not download_raw(file_url, filename, tmpdir): 1964 self.skipTest("no zip_CVE_2017_5976 available: " + filename) 1965 exe = self.bins("unzip") 1966 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1967 returncodes = [0, 2]) 1968 self.assertIn(' 27 extra bytes at beginning or within zipfile', run.errors) 1969 self.assertIn("didn't find end-of-central-dir signature at end of central dir", run.errors) 1970 self.assertIn(' 1 file', run.output) 1971 self.assertLess(len(run.output), 330) 1972 self.assertLess(len(errors(run.errors)), 500) 1973 # 1974 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 1975 returncodes = [2]) 1976 self.assertLess(len(run.output), 190) 1977 self.assertLess(len(errors(run.errors)), 900) 1978 self.assertIn("extracting: test", run.output) 1979 self.assertIn('-27 bytes too long', run.errors) 1980 self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 1981 # self.assertFalse(os.path.exists(tmpdir+"/test")) 1982 self.rm_testdir() 1983 def test_59761_zzipdir_big_CVE_2017_5976(self): 1984 """ run info-zip -l $(CVE_2017_5976).zip """ 1985 tmpdir = self.testdir() 1986 filename = self.zip_CVE_2017_5976 1987 file_url = self.url_CVE_2017_5976 1988 if not download_raw(file_url, filename, tmpdir): 1989 self.skipTest("no zip_CVE_2017_5976 available: " + filename) 1990 exe = self.bins("unzzip-big") 1991 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 1992 returncodes = [0]) 1993 self.assertLess(len(run.output), 30) 1994 self.assertLess(len(errors(run.errors)), 1) 1995 self.assertIn(" stored test", run.output) 1996 # 1997 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 1998 returncodes = [0]) 1999 self.assertLess(len(run.output), 30) 2000 self.assertLess(len(errors(run.errors)), 1) 2001 self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2002 self.rm_testdir() 2003 def test_59762_zzipdir_mem_CVE_2017_5976(self): 2004 """ run unzzip-mem -l $(CVE_2017_5976).zip """ 2005 tmpdir = self.testdir() 2006 filename = self.zip_CVE_2017_5976 2007 file_url = self.url_CVE_2017_5976 2008 if not download_raw(file_url, filename, tmpdir): 2009 self.skipTest("no zip_CVE_2017_5976 available: " + filename) 2010 exe = self.bins("unzzip-mem") 2011 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2012 returncodes = [0]) 2013 self.assertLess(len(run.output), 30) 2014 self.assertLess(len(errors(run.errors)), 1) 2015 self.assertIn("3 test", run.output) 2016 # 2017 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2018 returncodes = [0]) 2019 self.assertLess(len(run.output), 30) 2020 self.assertLess(len(errors(run.errors)), 30) # TODO 2021 self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2022 self.rm_testdir() 2023 def test_59763_zzipdir_mix_CVE_2017_5976(self): 2024 """ run unzzip-mix -l $(CVE_2017_5976).zip """ 2025 tmpdir = self.testdir() 2026 filename = self.zip_CVE_2017_5976 2027 file_url = self.url_CVE_2017_5976 2028 if not download_raw(file_url, filename, tmpdir): 2029 self.skipTest("no zip_CVE_2017_5976 available: " + filename) 2030 exe = self.bins("unzzip-mix") 2031 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2032 returncodes = [0]) 2033 self.assertLess(len(run.output), 30) 2034 self.assertLess(len(errors(run.errors)), 1) 2035 self.assertIn("3 test", run.output) 2036 # 2037 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2038 returncodes = [0]) 2039 self.assertLess(len(run.output), 30) 2040 self.assertLess(len(errors(run.errors)), 30) 2041 self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) # FIXME 2042 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) # FIXME 2043 self.rm_testdir() 2044 def test_59764_zzipdir_zap_CVE_2017_5976(self): 2045 """ run unzzip -l $(CVE_2017_5976).zip """ 2046 tmpdir = self.testdir() 2047 filename = self.zip_CVE_2017_5976 2048 file_url = self.url_CVE_2017_5976 2049 if not download_raw(file_url, filename, tmpdir): 2050 self.skipTest("no zip_CVE_2017_5976 available: " + filename) 2051 exe = self.bins("unzzip") 2052 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2053 returncodes = [0, 255]) 2054 self.assertLess(len(run.output), 30) 2055 self.assertLess(len(errors(run.errors)), 1) 2056 self.assertIn("3 test", run.output) 2057 # 2058 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2059 returncodes = [0]) 2060 self.assertLess(len(run.output), 30) 2061 self.assertLess(len(errors(run.errors)), 30) 2062 self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2063 self.rm_testdir() 2064 def test_59769(self): 2065 """ check $(CVE).zip """ 2066 tmpdir = self.testdir() 2067 filename = self.zip_CVE_2017_5976 2068 file_url = self.url_CVE_2017_5976 2069 if not download_raw(file_url, filename, tmpdir): 2070 self.skipTest("no zip_CVE_2017_5976 available: " + filename) 2071 shell("ls -l {tmpdir}/{filename}".format(**locals())) 2072 size = os.path.getsize(os.path.join(tmpdir, filename)) 2073 self.assertEqual(size, 188) 2074 2075 url_CVE_2017_5980 = "https://github.com/asarubbo/poc/blob/master" 2076 zip_CVE_2017_5980 = "00154-zziplib-nullptr-zzip_mem_entry_new" 2077 def test_59800_infozipdir_CVE_2017_5980(self): 2078 """ run info-zip dir test0.zip """ 2079 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 2080 tmpdir = self.testdir() 2081 filename = self.zip_CVE_2017_5980 2082 file_url = self.url_CVE_2017_5980 2083 if not download_raw(file_url, filename, tmpdir): 2084 self.skipTest("no zip_CVE_2017_5980 available: " + filename) 2085 exe = self.bins("unzip") 2086 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2087 returncodes = [0, 2]) 2088 self.assertIn(' missing 6 bytes in zipfile', run.errors) 2089 self.assertIn("didn't find end-of-central-dir signature at end of central dir", run.errors) 2090 self.assertIn(' 1 file', run.output) 2091 self.assertLess(len(run.output), 330) 2092 self.assertLess(len(errors(run.errors)), 500) 2093 # 2094 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 2095 returncodes = [3]) 2096 self.assertLess(len(run.output), 90) 2097 self.assertLess(len(errors(run.errors)), 900) 2098 self.assertIn('file #1: bad zipfile offset (lseek)', run.errors) 2099 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2100 self.assertFalse(os.path.exists(tmpdir+"/test")) 2101 self.rm_testdir() 2102 def test_59801_zzipdir_big_CVE_2017_5980(self): 2103 """ run info-zip -l $(CVE_2017_5980).zip """ 2104 tmpdir = self.testdir() 2105 filename = self.zip_CVE_2017_5980 2106 file_url = self.url_CVE_2017_5980 2107 if not download_raw(file_url, filename, tmpdir): 2108 self.skipTest("no zip_CVE_2017_5980 available: " + filename) 2109 exe = self.bins("unzzip-big") 2110 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2111 returncodes = [0]) 2112 self.assertLess(len(run.output), 30) 2113 self.assertLess(len(errors(run.errors)), 1) 2114 self.assertIn(" stored (null)", run.output) 2115 # 2116 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2117 returncodes = [0,1]) 2118 self.assertLess(len(run.output), 30) 2119 self.assertLess(len(errors(run.errors)), 1) 2120 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2121 self.assertFalse(os.path.exists(tmpdir+"/test")) 2122 self.rm_testdir() 2123 def test_59802_zzipdir_mem_CVE_2017_5980(self): 2124 """ run unzzip-mem -l $(CVE_2017_5980).zip """ 2125 tmpdir = self.testdir() 2126 filename = self.zip_CVE_2017_5980 2127 file_url = self.url_CVE_2017_5980 2128 if not download_raw(file_url, filename, tmpdir): 2129 self.skipTest("no zip_CVE_2017_5980 available: " + filename) 2130 exe = self.bins("unzzip-mem") 2131 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2132 returncodes = [0]) 2133 self.assertLess(len(run.output), 1) 2134 self.assertLess(len(errors(run.errors)), 180) 2135 self.assertTrue(greps(run.errors, "unable to load disk")) 2136 # 2137 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2138 returncodes = [0]) 2139 self.assertLess(len(run.output), 30) 2140 self.assertLess(len(errors(run.errors)), 200) 2141 self.assertFalse(os.path.exists(tmpdir+"/test")) 2142 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2143 self.rm_testdir() 2144 def test_59803_zzipdir_mix_CVE_2017_5980(self): 2145 """ run unzzip-mix -l $(CVE_2017_5980).zip """ 2146 tmpdir = self.testdir() 2147 filename = self.zip_CVE_2017_5980 2148 file_url = self.url_CVE_2017_5980 2149 if not download_raw(file_url, filename, tmpdir): 2150 self.skipTest("no zip_CVE_2017_5980 available: " + filename) 2151 exe = self.bins("unzzip-mix") 2152 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2153 returncodes = [2]) 2154 self.assertLess(len(run.output), 1) 2155 self.assertLess(len(errors(run.errors)), 180) 2156 self.assertErrorMessage(run.errors, errno.EILSEQ) 2157 # 2158 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2159 returncodes = [2]) 2160 self.assertLess(len(run.output), 30) 2161 self.assertLess(len(errors(run.errors)), 200) 2162 self.assertFalse(os.path.exists(tmpdir+"/test")) 2163 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2164 self.rm_testdir() 2165 def test_59804_zzipdir_zap_CVE_2017_5980(self): 2166 """ run unzzip -l $(CVE_2017_5980).zip """ 2167 tmpdir = self.testdir() 2168 filename = self.zip_CVE_2017_5980 2169 file_url = self.url_CVE_2017_5980 2170 if not download_raw(file_url, filename, tmpdir): 2171 self.skipTest("no zip_CVE_2017_5980 available: " + filename) 2172 exe = self.bins("unzzip") 2173 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2174 returncodes = [3]) 2175 self.assertLess(len(run.output), 1) 2176 self.assertLess(len(errors(run.errors)), 180) 2177 self.assertErrorMessage(run.errors, 0) 2178 # 2179 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2180 returncodes = [3]) # TODO 2181 self.assertLess(len(run.output), 30) 2182 self.assertLess(len(errors(run.errors)), 200) 2183 self.assertFalse(os.path.exists(tmpdir+"/test")) 2184 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2185 self.rm_testdir() 2186 def test_59809(self): 2187 """ check $(CVE).zip """ 2188 tmpdir = self.testdir() 2189 filename = self.zip_CVE_2017_5980 2190 file_url = self.url_CVE_2017_5980 2191 if not download_raw(file_url, filename, tmpdir): 2192 self.skipTest("no zip_CVE_2017_5980 available: " + filename) 2193 shell("ls -l {tmpdir}/{filename}".format(**locals())) 2194 size = os.path.getsize(os.path.join(tmpdir, filename)) 2195 self.assertEqual(size, 155) 2196 2197 2198 url_CVE_2017_5981 = "https://github.com/asarubbo/poc/blob/master" 2199 zip_CVE_2017_5981 = "00161-zziplib-assertionfailure-seeko_C" 2200 def test_59810_infozipdir_CVE_2017_5981(self): 2201 """ run info-zip dir test0.zip """ 2202 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 2203 tmpdir = self.testdir() 2204 filename = self.zip_CVE_2017_5981 2205 file_url = self.url_CVE_2017_5981 2206 if not download_raw(file_url, filename, tmpdir): 2207 self.skipTest("no zip_CVE_2017_5981 available: " + filename) 2208 exe = self.bins("unzip") 2209 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2210 returncodes = [0, 3]) 2211 self.assertIn(' missing 4 bytes in zipfile', run.errors) 2212 self.assertIn("zipfile corrupt", run.errors) 2213 self.assertLess(len(run.output), 80) 2214 self.assertLess(len(errors(run.errors)), 500) 2215 # 2216 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 2217 returncodes = [3]) 2218 self.assertLess(len(run.output), 90) 2219 self.assertLess(len(errors(run.errors)), 500) 2220 self.assertIn('zipfile corrupt.', run.errors) 2221 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2222 self.assertFalse(os.path.exists(tmpdir+"/test")) 2223 self.rm_testdir() 2224 def test_59811_zzipdir_big_CVE_2017_5981(self): 2225 """ run info-zip -l $(CVE_2017_5981).zip """ 2226 tmpdir = self.testdir() 2227 filename = self.zip_CVE_2017_5981 2228 file_url = self.url_CVE_2017_5981 2229 if not download_raw(file_url, filename, tmpdir): 2230 self.skipTest("no zip_CVE_2017_5981 available: " + filename) 2231 exe = self.bins("unzzip-big") 2232 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2233 returncodes = [0]) 2234 self.assertLess(len(run.output), 1) 2235 self.assertLess(len(errors(run.errors)), 1) 2236 # 2237 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2238 returncodes = [0]) 2239 self.assertLess(len(run.output), 30) 2240 self.assertLess(len(errors(run.errors)), 1) 2241 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2242 self.assertFalse(os.path.exists(tmpdir+"/test")) 2243 self.rm_testdir() 2244 def test_59812_zzipdir_mem_CVE_2017_5981(self): 2245 """ run unzzip-mem -l $(CVE_2017_5981).zip """ 2246 tmpdir = self.testdir() 2247 filename = self.zip_CVE_2017_5981 2248 file_url = self.url_CVE_2017_5981 2249 if not download_raw(file_url, filename, tmpdir): 2250 self.skipTest("no zip_CVE_2017_5981 available: " + filename) 2251 exe = self.bins("unzzip-mem") 2252 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2253 returncodes = [0]) 2254 self.assertLess(len(run.output), 1) 2255 self.assertLess(len(errors(run.errors)), 1) 2256 # 2257 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2258 returncodes = [0]) 2259 self.assertLess(len(run.output), 30) 2260 self.assertLess(len(errors(run.errors)), 10) 2261 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2262 self.assertFalse(os.path.exists(tmpdir+"/test")) 2263 self.rm_testdir() 2264 def test_59813_zzipdir_mix_CVE_2017_5981(self): 2265 """ run unzzip-mix -l $(CVE_2017_5981).zip """ 2266 tmpdir = self.testdir() 2267 filename = self.zip_CVE_2017_5981 2268 file_url = self.url_CVE_2017_5981 2269 if not download_raw(file_url, filename, tmpdir): 2270 self.skipTest("no zip_CVE_2017_5981 available: " + filename) 2271 exe = self.bins("unzzip-mix") 2272 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2273 returncodes = [0,2]) 2274 self.assertLess(len(run.output), 1) 2275 self.assertErrorMessage(run.errors, errno.EILSEQ) 2276 # 2277 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2278 returncodes = [0,2]) 2279 self.assertLess(len(run.output), 30) 2280 self.assertLess(len(errors(run.errors)), 10) 2281 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2282 self.assertFalse(os.path.exists(tmpdir+"/test")) 2283 self.rm_testdir() 2284 def test_59814_zzipdir_zap_CVE_2017_5981(self): 2285 """ run unzzip-zap -l $(CVE_2017_5981).zip """ 2286 tmpdir = self.testdir() 2287 filename = self.zip_CVE_2017_5981 2288 file_url = self.url_CVE_2017_5981 2289 if not download_raw(file_url, filename, tmpdir): 2290 self.skipTest("no zip_CVE_2017_5981 available: " + filename) 2291 exe = self.bins("unzzip") 2292 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2293 returncodes = [0,3]) 2294 self.assertLess(len(run.output), 1) 2295 self.assertLess(len(errors(run.errors)), 80) 2296 self.assertErrorMessage(run.errors, 0) 2297 # 2298 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2299 returncodes = [0,3]) 2300 self.assertLess(len(run.output), 30) 2301 self.assertLess(len(errors(run.errors)), 10) 2302 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2303 self.assertFalse(os.path.exists(tmpdir+"/test")) 2304 self.rm_testdir() 2305 def test_59819(self): 2306 """ check $(CVE).zip """ 2307 tmpdir = self.testdir() 2308 filename = self.zip_CVE_2017_5981 2309 file_url = self.url_CVE_2017_5981 2310 if not download_raw(file_url, filename, tmpdir): 2311 self.skipTest("no zip_CVE_2017_5981 available: " + filename) 2312 shell("ls -l {tmpdir}/{filename}".format(**locals())) 2313 size = os.path.getsize(os.path.join(tmpdir, filename)) 2314 self.assertEqual(size, 157) 2315 2316 url_CVE_2018_10 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib" 2317 zip_CVE_2018_10 = "zziplib_0-13-67_zzdir_invalid-memory-access_main.zip" 2318 def test_63010(self): 2319 """ info unzip -l $(CVE).zip """ 2320 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 2321 tmpdir = self.testdir() 2322 filename = self.zip_CVE_2018_10 2323 file_url = self.url_CVE_2018_10 2324 if not download_raw(file_url, filename, tmpdir): 2325 self.skipTest("no zip_CVE_2018_10 available: " + filename) 2326 exe = self.bins("unzip") 2327 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2328 returncodes = [0, 9]) 2329 self.assertIn("End-of-central-directory signature not found", run.errors) 2330 self.assertLess(len(run.output), 80) 2331 self.assertLess(len(errors(run.errors)), 600) 2332 # 2333 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 2334 returncodes = [9]) 2335 self.assertLess(len(run.output), 90) 2336 self.assertLess(len(errors(run.errors)), 600) 2337 self.assertIn('End-of-central-directory signature not found', run.errors) 2338 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2339 self.assertFalse(os.path.exists(tmpdir+"/test")) 2340 self.rm_testdir() 2341 def test_63011(self): 2342 """ unzzip-big -l $(CVE).zip """ 2343 tmpdir = self.testdir() 2344 filename = self.zip_CVE_2018_10 2345 file_url = self.url_CVE_2018_10 2346 if not download_raw(file_url, filename, tmpdir): 2347 self.skipTest("no zip_CVE_2018_10 available: " + filename) 2348 exe = self.bins("unzzip-big") 2349 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2350 returncodes = [0]) 2351 self.assertLess(len(run.output), 1) 2352 self.assertLess(len(errors(run.errors)), 1) 2353 # 2354 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2355 returncodes = [0]) 2356 self.assertLess(len(run.output), 30) 2357 self.assertLess(len(errors(run.errors)), 1) 2358 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2359 self.assertFalse(os.path.exists(tmpdir+"/test")) 2360 self.rm_testdir() 2361 def test_63012(self): 2362 """ unzzip-mem -l $(CVE).zip """ 2363 tmpdir = self.testdir() 2364 filename = self.zip_CVE_2018_10 2365 file_url = self.url_CVE_2018_10 2366 if not download_raw(file_url, filename, tmpdir): 2367 self.skipTest("no zip_CVE_2018_10 available: " + filename) 2368 exe = self.bins("unzzip-mem") 2369 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2370 returncodes = [0]) 2371 self.assertLess(len(run.output), 1) 2372 self.assertLess(len(errors(run.errors)), 1) 2373 # 2374 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2375 returncodes = [0]) 2376 self.assertLess(len(run.output), 30) 2377 self.assertLess(len(errors(run.errors)), 10) 2378 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2379 self.assertFalse(os.path.exists(tmpdir+"/test")) 2380 self.rm_testdir() 2381 def test_63013(self): 2382 """ unzzip-mix -l $(CVE).zip """ 2383 tmpdir = self.testdir() 2384 filename = self.zip_CVE_2018_10 2385 file_url = self.url_CVE_2018_10 2386 if not download_raw(file_url, filename, tmpdir): 2387 self.skipTest("no zip_CVE_2018_10 available: " + filename) 2388 exe = self.bins("unzzip-mix") 2389 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2390 returncodes = [0,2]) 2391 self.assertLess(len(run.output), 1) 2392 self.assertErrorMessage(run.errors, errno.EILSEQ) 2393 # 2394 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2395 returncodes = [0,2]) 2396 self.assertLess(len(run.output), 30) 2397 self.assertLess(len(errors(run.errors)), 10) 2398 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2399 self.assertFalse(os.path.exists(tmpdir+"/test")) 2400 self.rm_testdir() 2401 def test_63014(self): 2402 """ unzzip-zap -l $(CVE).zip """ 2403 tmpdir = self.testdir() 2404 filename = self.zip_CVE_2018_10 2405 file_url = self.url_CVE_2018_10 2406 if not download_raw(file_url, filename, tmpdir): 2407 self.skipTest("no zip_CVE_2018_10 available: " + filename) 2408 exe = self.bins("unzzip") 2409 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2410 returncodes = [0,3]) 2411 self.assertLess(len(run.output), 1) 2412 self.assertLess(len(errors(run.errors)), 80) 2413 self.assertErrorMessage(run.errors, 0) 2414 # 2415 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2416 returncodes = [0,3]) 2417 self.assertLess(len(run.output), 30) 2418 self.assertLess(len(errors(run.errors)), 10) 2419 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2420 self.assertFalse(os.path.exists(tmpdir+"/test")) 2421 self.rm_testdir() 2422 def test_63018(self): 2423 """ zzdir on $(CVE).zip """ 2424 tmpdir = self.testdir() 2425 filename = self.zip_CVE_2018_10 2426 file_url = self.url_CVE_2018_10 2427 if not download_raw(file_url, filename, tmpdir): 2428 self.skipTest("no zip_CVE_2018_10 available: " + filename) 2429 exe = self.bins("zzdir") 2430 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2431 returncodes = [1]) 2432 self.assertLess(len(run.output), 1) 2433 self.assertLess(len(errors(run.errors)), 80) 2434 self.assertErrorMessage(run.errors, errno.EILSEQ) 2435 def test_63019(self): 2436 """ check $(CVE).zip """ 2437 tmpdir = self.testdir() 2438 filename = self.zip_CVE_2018_10 2439 file_url = self.url_CVE_2018_10 2440 if not download_raw(file_url, filename, tmpdir): 2441 self.skipTest("no zip_CVE_2018_10 available: " + filename) 2442 shell("ls -l {tmpdir}/{filename}".format(**locals())) 2443 size = os.path.getsize(os.path.join(tmpdir, filename)) 2444 self.assertEqual(size, 188) 2445 2446 url_CVE_2018_11 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib" 2447 zip_CVE_2018_11 = "zziplib_0-13-67_unzzip_infinite-loop_unzzip_cat_file.zip" 2448 def test_63110(self): 2449 """ info unzip -l $(CVE).zip """ 2450 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 2451 tmpdir = self.testdir() 2452 filename = self.zip_CVE_2018_11 2453 file_url = self.url_CVE_2018_11 2454 if not download_raw(file_url, filename, tmpdir): 2455 self.skipTest("no zip_CVE_2018_11 available: " + filename) 2456 exe = self.bins("unzip") 2457 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2458 returncodes = [0, 9]) 2459 self.assertIn("End-of-central-directory signature not found", run.errors) 2460 self.assertLess(len(run.output), 90) 2461 self.assertLess(len(errors(run.errors)), 600) 2462 # 2463 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 2464 returncodes = [9]) 2465 self.assertLess(len(run.output), 90) 2466 self.assertLess(len(errors(run.errors)), 600) 2467 self.assertIn('End-of-central-directory signature not found', run.errors) 2468 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2469 self.assertFalse(os.path.exists(tmpdir+"/test")) 2470 self.rm_testdir() 2471 def test_63111(self): 2472 """ unzzip-big -l $(CVE).zip """ 2473 tmpdir = self.testdir() 2474 filename = self.zip_CVE_2018_11 2475 file_url = self.url_CVE_2018_11 2476 if not download_raw(file_url, filename, tmpdir): 2477 self.skipTest("no zip_CVE_2018_11 available: " + filename) 2478 exe = self.bins("unzzip-big") 2479 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2480 returncodes = [0]) 2481 self.assertLess(len(run.output), 1) 2482 self.assertLess(len(errors(run.errors)), 1) 2483 # 2484 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2485 returncodes = [0]) 2486 self.assertLess(len(run.output), 30) 2487 self.assertLess(len(errors(run.errors)), 1) 2488 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2489 self.assertFalse(os.path.exists(tmpdir+"/test")) 2490 self.rm_testdir() 2491 def test_63112(self): 2492 """ unzzip-mem -l $(CVE).zip """ 2493 tmpdir = self.testdir() 2494 filename = self.zip_CVE_2018_11 2495 file_url = self.url_CVE_2018_11 2496 if not download_raw(file_url, filename, tmpdir): 2497 self.skipTest("no zip_CVE_2018_11 available: " + filename) 2498 exe = self.bins("unzzip-mem") 2499 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2500 returncodes = [0]) 2501 self.assertLess(len(run.output), 1) 2502 self.assertLess(len(errors(run.errors)), 1) 2503 # 2504 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2505 returncodes = [0]) 2506 self.assertLess(len(run.output), 30) 2507 self.assertLess(len(errors(run.errors)), 10) 2508 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2509 self.assertFalse(os.path.exists(tmpdir+"/test")) 2510 self.rm_testdir() 2511 def test_63113(self): 2512 """ unzzip-mix -l $(CVE).zip """ 2513 tmpdir = self.testdir() 2514 filename = self.zip_CVE_2018_11 2515 file_url = self.url_CVE_2018_11 2516 if not download_raw(file_url, filename, tmpdir): 2517 self.skipTest("no zip_CVE_2018_11 available: " + filename) 2518 exe = self.bins("unzzip-mix") 2519 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2520 returncodes = [0,2]) 2521 self.assertLess(len(run.output), 1) 2522 self.assertErrorMessage(run.errors, errno.EILSEQ) 2523 # 2524 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2525 returncodes = [0,2]) 2526 self.assertLess(len(run.output), 30) 2527 self.assertLess(len(errors(run.errors)), 10) 2528 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2529 self.assertFalse(os.path.exists(tmpdir+"/test")) 2530 self.rm_testdir() 2531 def test_63114(self): 2532 """ unzzip-zap -l $(CVE).zip """ 2533 tmpdir = self.testdir() 2534 filename = self.zip_CVE_2018_11 2535 file_url = self.url_CVE_2018_11 2536 if not download_raw(file_url, filename, tmpdir): 2537 self.skipTest("no zip_CVE_2018_11 available: " + filename) 2538 exe = self.bins("unzzip") 2539 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2540 returncodes = [0,3]) 2541 self.assertLess(len(run.output), 1) 2542 self.assertLess(len(errors(run.errors)), 90) 2543 self.assertErrorMessage(run.errors, 0) 2544 # 2545 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2546 returncodes = [0,3]) 2547 self.assertLess(len(run.output), 30) 2548 self.assertLess(len(errors(run.errors)), 10) 2549 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2550 self.assertFalse(os.path.exists(tmpdir+"/test")) 2551 # 2552 run = shell("cd {tmpdir} && ../{exe} -p {filename} ".format(**locals()), 2553 returncodes = [0,3]) 2554 self.rm_testdir() 2555 def test_63119(self): 2556 """ check $(CVE).zip """ 2557 tmpdir = self.testdir() 2558 filename = self.zip_CVE_2018_11 2559 file_url = self.url_CVE_2018_11 2560 if not download_raw(file_url, filename, tmpdir): 2561 self.skipTest("no zip_CVE_2018_11 available: " + filename) 2562 shell("ls -l {tmpdir}/{filename}".format(**locals())) 2563 size = os.path.getsize(os.path.join(tmpdir, filename)) 2564 self.assertEqual(size, 280) 2565 2566 url_CVE_2018_12 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib" 2567 zip_CVE_2018_12 = "zziplib_0-13-67_unzip-mem_buffer-access-with-incorrect-length-value_zzip_disk_fread.zip" 2568 def test_63810(self): 2569 """ info unzip -l $(CVE).zip """ 2570 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 2571 tmpdir = self.testdir() 2572 filename = self.zip_CVE_2018_12 2573 file_url = self.url_CVE_2018_12 2574 if not download_raw(file_url, filename, tmpdir): 2575 self.skipTest("no zip_CVE_2018_12 available: " + filename) 2576 exe = self.bins("unzip") 2577 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2578 returncodes = [2]) 2579 self.assertIn('reported length of central directory', run.errors) 2580 self.assertLess(len(run.output), 300) 2581 self.assertLess(len(errors(run.errors)), 800) 2582 # 2583 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 2584 returncodes = [2]) 2585 self.assertLess(len(run.output), 300) 2586 self.assertLess(len(errors(run.errors)), 800) 2587 self.assertIn('reported length of central directory', run.errors) 2588 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2589 self.assertFalse(os.path.exists(tmpdir+"/test")) 2590 self.rm_testdir() 2591 def test_63811(self): 2592 """ unzzip-big -l $(CVE).zip """ 2593 tmpdir = self.testdir() 2594 filename = self.zip_CVE_2018_12 2595 file_url = self.url_CVE_2018_12 2596 if not download_raw(file_url, filename, tmpdir): 2597 self.skipTest("no zip_CVE_2018_12 available: " + filename) 2598 exe = self.bins("unzzip-big") 2599 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2600 returncodes = [0]) 2601 self.assertLess(len(run.output), 20) 2602 self.assertLess(len(errors(run.errors)), 1) 2603 # 2604 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2605 returncodes = [0]) 2606 self.assertLess(len(run.output), 30) 2607 self.assertLess(len(errors(run.errors)), 1) 2608 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2609 self.assertFalse(os.path.exists(tmpdir+"/test")) 2610 self.rm_testdir() 2611 def test_63812(self): 2612 """ unzzip-mem -l $(CVE).zip """ 2613 tmpdir = self.testdir() 2614 filename = self.zip_CVE_2018_12 2615 file_url = self.url_CVE_2018_12 2616 if not download_raw(file_url, filename, tmpdir): 2617 self.skipTest("no zip_CVE_2018_12 available: " + filename) 2618 exe = self.bins("unzzip-mem") 2619 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2620 returncodes = [0]) 2621 self.assertIn("2 aUT", run.output) # filename contains a control-character 2622 self.assertGreater(len(run.output), 20) 2623 self.assertLess(len(errors(run.errors)), 1) 2624 # 2625 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2626 returncodes = [0]) 2627 self.assertLess(len(run.output), 30) 2628 self.assertLess(len(errors(run.errors)), 10) 2629 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2630 self.assertFalse(os.path.exists(tmpdir+"/test")) 2631 self.rm_testdir() 2632 def test_63813(self): 2633 """ unzzip-mix -l $(CVE).zip """ 2634 tmpdir = self.testdir() 2635 filename = self.zip_CVE_2018_12 2636 file_url = self.url_CVE_2018_12 2637 if not download_raw(file_url, filename, tmpdir): 2638 self.skipTest("no zip_CVE_2018_12 available: " + filename) 2639 exe = self.bins("unzzip-mix") 2640 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2641 returncodes = [0,2]) 2642 self.assertLess(len(run.output), 1) 2643 self.assertTrue(grep(run.errors, "central directory not found")) 2644 # 2645 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2646 returncodes = [0,2]) 2647 self.assertLess(len(run.output), 30) 2648 self.assertLess(len(errors(run.errors)), 10) 2649 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2650 self.assertFalse(os.path.exists(tmpdir+"/test")) 2651 self.rm_testdir() 2652 def test_63814(self): 2653 """ unzzip-zap -l $(CVE).zip """ 2654 tmpdir = self.testdir() 2655 filename = self.zip_CVE_2018_12 2656 file_url = self.url_CVE_2018_12 2657 if not download_raw(file_url, filename, tmpdir): 2658 self.skipTest("no zip_CVE_2018_12 available: " + filename) 2659 exe = self.bins("unzzip") 2660 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2661 returncodes = [0,3]) 2662 self.assertLess(len(run.output), 1) 2663 self.assertLess(len(errors(run.errors)), 200) 2664 self.assertErrorMessage(run.errors, 0) 2665 # 2666 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2667 returncodes = [0,3]) 2668 self.assertLess(len(run.output), 30) 2669 self.assertLess(len(errors(run.errors)), 10) 2670 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2671 self.assertFalse(os.path.exists(tmpdir+"/test")) 2672 self.rm_testdir() 2673 def test_63819(self): 2674 """ check $(CVE).zip """ 2675 tmpdir = self.testdir() 2676 filename = self.zip_CVE_2018_12 2677 file_url = self.url_CVE_2018_12 2678 if not download_raw(file_url, filename, tmpdir): 2679 self.skipTest("no zip_CVE_2018_12 available: " + filename) 2680 shell("ls -l {tmpdir}/{filename}".format(**locals())) 2681 size = os.path.getsize(os.path.join(tmpdir, filename)) 2682 self.assertEqual(size, 141) 2683 2684 url_CVE_2018_14 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib" 2685 zip_CVE_2018_14 = "zziplib_0-13-67_zzdir_memory-alignment-errors___zzip_fetch_disk_trailer.zip" 2686 def test_64840(self): 2687 """ info unzip -l $(CVE).zip """ 2688 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 2689 tmpdir = self.testdir() 2690 filename = self.zip_CVE_2018_14 2691 file_url = self.url_CVE_2018_14 2692 if not download_raw(file_url, filename, tmpdir): 2693 self.skipTest("no zip_CVE_2018_14 available: " + filename) 2694 exe = self.bins("unzip") 2695 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2696 returncodes = [3]) 2697 self.assertIn("attempt to seek before beginning of zipfile", run.errors) 2698 self.assertLess(len(run.output), 200) 2699 self.assertLess(len(errors(run.errors)), 800) 2700 # 2701 exe = self.bins("unzip") 2702 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 2703 returncodes = [3]) 2704 self.assertLess(len(run.output), 200) 2705 self.assertLess(len(errors(run.errors)), 800) 2706 self.assertIn('attempt to seek before beginning of zipfile', run.errors) 2707 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2708 self.assertFalse(os.path.exists(tmpdir+"/test")) 2709 self.rm_testdir() 2710 def test_64841(self): 2711 """ unzzip-big -l $(CVE).zip """ 2712 tmpdir = self.testdir() 2713 filename = self.zip_CVE_2018_14 2714 file_url = self.url_CVE_2018_14 2715 if not download_raw(file_url, filename, tmpdir): 2716 self.skipTest("no zip_CVE_2018_14 available: " + filename) 2717 exe = self.bins("unzzip-big") 2718 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2719 returncodes = [0]) 2720 self.assertLess(len(run.output), 1) 2721 self.assertLess(len(errors(run.errors)), 1) 2722 # 2723 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2724 returncodes = [0]) 2725 self.assertLess(len(run.output), 30) 2726 self.assertLess(len(errors(run.errors)), 1) 2727 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2728 self.assertFalse(os.path.exists(tmpdir+"/test")) 2729 self.rm_testdir() 2730 def test_64842(self): 2731 """ unzzip-mem -l $(CVE).zip """ 2732 tmpdir = self.testdir() 2733 filename = self.zip_CVE_2018_14 2734 file_url = self.url_CVE_2018_14 2735 if not download_raw(file_url, filename, tmpdir): 2736 self.skipTest("no zip_CVE_2018_14 available: " + filename) 2737 exe = self.bins("unzzip-mem") 2738 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2739 returncodes = [0]) 2740 self.assertLess(len(run.output), 1) 2741 # 2742 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2743 returncodes = [0]) 2744 self.assertLess(len(run.output), 30) 2745 self.assertLess(len(errors(run.errors)), 10) 2746 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2747 self.assertFalse(os.path.exists(tmpdir+"/test")) 2748 self.rm_testdir() 2749 def test_64843(self): 2750 """ unzzip-mix -l $(CVE).zip """ 2751 tmpdir = self.testdir() 2752 filename = self.zip_CVE_2018_14 2753 file_url = self.url_CVE_2018_14 2754 if not download_raw(file_url, filename, tmpdir): 2755 self.skipTest("no zip_CVE_2018_14 available: " + filename) 2756 exe = self.bins("unzzip-mix") 2757 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2758 returncodes = [0, 2]) 2759 self.assertLess(len(run.output), 1) 2760 self.assertErrorMessage(run.errors, errno.EILSEQ) 2761 # 2762 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2763 returncodes = [0,2]) 2764 self.assertLess(len(run.output), 30) 2765 self.assertLess(len(errors(run.errors)), 10) 2766 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2767 self.assertFalse(os.path.exists(tmpdir+"/test")) 2768 self.rm_testdir() 2769 def test_64844(self): 2770 """ unzzip-zap -l $(CVE).zip """ 2771 tmpdir = self.testdir() 2772 filename = self.zip_CVE_2018_14 2773 file_url = self.url_CVE_2018_14 2774 if not download_raw(file_url, filename, tmpdir): 2775 self.skipTest("no zip_CVE_2018_14 available: " + filename) 2776 exe = self.bins("unzzip") 2777 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2778 returncodes = [0, 3]) 2779 self.assertLess(len(run.output), 1) 2780 self.assertLess(len(errors(run.errors)), 200) 2781 self.assertErrorMessage(run.errors, 0) 2782 # 2783 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2784 returncodes = [0,3]) 2785 self.assertLess(len(run.output), 30) 2786 self.assertLess(len(errors(run.errors)), 10) 2787 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2788 self.assertFalse(os.path.exists(tmpdir+"/test")) 2789 self.rm_testdir() 2790 def test_64848(self): 2791 """ zzdir $(CVE).zip """ 2792 tmpdir = self.testdir() 2793 filename = self.zip_CVE_2018_14 2794 file_url = self.url_CVE_2018_14 2795 if not download_raw(file_url, filename, tmpdir): 2796 self.skipTest("no zip_CVE_2018_14 available: " + filename) 2797 exe = self.bins("zzdir") 2798 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2799 returncodes = [1]) 2800 self.assertLess(len(run.output), 1) 2801 self.assertLess(len(errors(run.errors)), 200) 2802 self.assertErrorMessage(run.errors, errno.EILSEQ) 2803 self.rm_testdir() 2804 def test_64849(self): 2805 """ check $(CVE).zip """ 2806 tmpdir = self.testdir() 2807 filename = self.zip_CVE_2018_14 2808 file_url = self.url_CVE_2018_14 2809 if not download_raw(file_url, filename, tmpdir): 2810 self.skipTest("no zip_CVE_2018_14 available: " + filename) 2811 shell("ls -l {tmpdir}/{filename}".format(**locals())) 2812 size = os.path.getsize(os.path.join(tmpdir, filename)) 2813 self.assertEqual(size, 56) 2814 2815 url_CVE_2018_15 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib" 2816 zip_CVE_2018_15 = "zziplib_0-13-67_unzip-mem_memory-alignment-errors_zzip_disk_findfirst.zip" 2817 def test_65400(self): 2818 """ info unzip -l $(CVE).zip """ 2819 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 2820 tmpdir = self.testdir() 2821 filename = self.zip_CVE_2018_15 2822 file_url = self.url_CVE_2018_15 2823 if not download_raw(file_url, filename, tmpdir): 2824 self.skipTest("no zip_CVE_2018_15 available: " + filename) 2825 exe = self.bins("unzip") 2826 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2827 returncodes = [2]) 2828 self.assertIn("reported length of central directory", run.errors) 2829 self.assertLess(len(run.output), 300) 2830 self.assertLess(len(errors(run.errors)), 800) 2831 # 2832 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 2833 returncodes = [2]) 2834 self.assertLess(len(run.output), 300) 2835 self.assertLess(len(errors(run.errors)), 800) 2836 self.assertIn('reported length of central directory', run.errors) 2837 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2838 self.assertFalse(os.path.exists(tmpdir+"/test")) 2839 self.rm_testdir() 2840 def test_65401(self): 2841 """ unzzip-big -l $(CVE).zip """ 2842 tmpdir = self.testdir() 2843 filename = self.zip_CVE_2018_15 2844 file_url = self.url_CVE_2018_15 2845 if not download_raw(file_url, filename, tmpdir): 2846 self.skipTest("no zip_CVE_2018_15 available: " + filename) 2847 exe = self.bins("unzzip-big") 2848 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2849 returncodes = [0]) 2850 self.assertLess(len(run.output), 15) 2851 self.assertLess(len(errors(run.errors)), 1) 2852 # 2853 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2854 returncodes = [0]) 2855 self.assertLess(len(run.output), 30) 2856 self.assertLess(len(errors(run.errors)), 1) 2857 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2858 self.assertFalse(os.path.exists(tmpdir+"/test")) 2859 self.rm_testdir() 2860 def test_65402(self): 2861 """ unzzip-mem -l $(CVE).zip """ 2862 tmpdir = self.testdir() 2863 filename = self.zip_CVE_2018_15 2864 file_url = self.url_CVE_2018_15 2865 if not download_raw(file_url, filename, tmpdir): 2866 self.skipTest("no zip_CVE_2018_15 available: " + filename) 2867 exe = self.bins("unzzip-mem") 2868 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2869 returncodes = [0]) 2870 self.assertLess(len(run.output), 30) 2871 self.assertLess(len(errors(run.errors)), 1) 2872 # 2873 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2874 returncodes = [0]) 2875 self.assertLess(len(run.output), 30) 2876 self.assertLess(len(errors(run.errors)), 10) 2877 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2878 self.assertFalse(os.path.exists(tmpdir+"/test")) 2879 self.rm_testdir() 2880 def test_65403(self): 2881 """ unzzip-mix -l $(CVE).zip """ 2882 tmpdir = self.testdir() 2883 filename = self.zip_CVE_2018_15 2884 file_url = self.url_CVE_2018_15 2885 if not download_raw(file_url, filename, tmpdir): 2886 self.skipTest("no zip_CVE_2018_15 available: " + filename) 2887 exe = self.bins("unzzip-mix") 2888 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2889 returncodes = [0,2]) 2890 self.assertLess(len(run.output), 1) 2891 self.assertErrorMessage(run.errors, errno.EILSEQ) 2892 # 2893 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2894 returncodes = [0,2]) 2895 self.assertLess(len(run.output), 30) 2896 self.assertLess(len(errors(run.errors)), 10) 2897 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2898 self.assertFalse(os.path.exists(tmpdir+"/test")) 2899 self.rm_testdir() 2900 def test_65404(self): 2901 """ unzzip-zap -l $(CVE).zip """ 2902 tmpdir = self.testdir() 2903 filename = self.zip_CVE_2018_15 2904 file_url = self.url_CVE_2018_15 2905 if not download_raw(file_url, filename, tmpdir): 2906 self.skipTest("no zip_CVE_2018_15 available: " + filename) 2907 exe = self.bins("unzzip") 2908 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2909 returncodes = [0, 3]) 2910 self.assertLess(len(run.output), 1) 2911 self.assertLess(len(errors(run.errors)), 200) 2912 self.assertErrorMessage(run.errors, 0) 2913 # 2914 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2915 returncodes = [0,3]) 2916 self.assertLess(len(run.output), 30) 2917 self.assertLess(len(errors(run.errors)), 10) 2918 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2919 self.assertFalse(os.path.exists(tmpdir+"/test")) 2920 self.rm_testdir() 2921 def test_65409(self): 2922 """ check $(CVE).zip """ 2923 tmpdir = self.testdir() 2924 filename = self.zip_CVE_2018_15 2925 file_url = self.url_CVE_2018_15 2926 if not download_raw(file_url, filename, tmpdir): 2927 self.skipTest("no zip_CVE_2018_15 available: " + filename) 2928 shell("ls -l {tmpdir}/{filename}".format(**locals())) 2929 size = os.path.getsize(os.path.join(tmpdir, filename)) 2930 self.assertEqual(size, 141) 2931 2932 url_CVE_2018_16 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib" 2933 zip_CVE_2018_16 = "zziplib_0-13-67_unzzip_memory-aligment-errors___zzip_fetch_disk_trailer.zip" 2934 def test_65410(self): 2935 """ info unzip -l $(CVE).zip """ 2936 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 2937 tmpdir = self.testdir() 2938 filename = self.zip_CVE_2018_16 2939 file_url = self.url_CVE_2018_16 2940 if not download_raw(file_url, filename, tmpdir): 2941 self.skipTest("no zip_CVE_2018_16 available: " + filename) 2942 exe = self.bins("unzip") 2943 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2944 returncodes = [0, 9]) 2945 self.assertIn("End-of-central-directory signature not found", run.errors) 2946 self.assertLess(len(run.output), 200) 2947 self.assertLess(len(errors(run.errors)), 800) 2948 # 2949 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 2950 returncodes = [9]) 2951 self.assertLess(len(run.output), 200) 2952 self.assertLess(len(errors(run.errors)), 800) 2953 self.assertIn('End-of-central-directory signature not found', run.errors) 2954 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2955 self.assertFalse(os.path.exists(tmpdir+"/test")) 2956 self.rm_testdir() 2957 def test_65411(self): 2958 """ unzzip-big -l $(CVE).zip """ 2959 tmpdir = self.testdir() 2960 filename = self.zip_CVE_2018_16 2961 file_url = self.url_CVE_2018_16 2962 if not download_raw(file_url, filename, tmpdir): 2963 self.skipTest("no zip_CVE_2018_16 available: " + filename) 2964 exe = self.bins("unzzip-big") 2965 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2966 returncodes = [0]) 2967 self.assertLess(len(run.output), 1) 2968 self.assertLess(len(errors(run.errors)), 1) 2969 # 2970 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2971 returncodes = [0]) 2972 self.assertLess(len(run.output), 30) 2973 self.assertLess(len(errors(run.errors)), 1) 2974 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2975 self.assertFalse(os.path.exists(tmpdir+"/test")) 2976 self.rm_testdir() 2977 def test_65412(self): 2978 """ unzzip-mem -l $(CVE).zip """ 2979 tmpdir = self.testdir() 2980 filename = self.zip_CVE_2018_16 2981 file_url = self.url_CVE_2018_16 2982 if not download_raw(file_url, filename, tmpdir): 2983 self.skipTest("no zip_CVE_2018_16 available: " + filename) 2984 exe = self.bins("unzzip-mem") 2985 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 2986 returncodes = [0]) 2987 self.assertLess(len(run.output), 1) 2988 self.assertLess(len(errors(run.errors)), 1) 2989 # 2990 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 2991 returncodes = [0]) 2992 self.assertLess(len(run.output), 30) 2993 self.assertLess(len(errors(run.errors)), 10) 2994 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 2995 self.assertFalse(os.path.exists(tmpdir+"/test")) 2996 self.rm_testdir() 2997 def test_65413(self): 2998 """ unzzip-mix -l $(CVE).zip """ 2999 tmpdir = self.testdir() 3000 filename = self.zip_CVE_2018_16 3001 file_url = self.url_CVE_2018_16 3002 if not download_raw(file_url, filename, tmpdir): 3003 self.skipTest("no zip_CVE_2018_16 available: " + filename) 3004 exe = self.bins("unzzip-mix") 3005 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3006 returncodes = [0,2]) 3007 self.assertLess(len(run.output), 1) 3008 self.assertErrorMessage(run.errors, errno.EILSEQ) 3009 # 3010 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3011 returncodes = [0,2]) 3012 self.assertLess(len(run.output), 30) 3013 self.assertLess(len(errors(run.errors)), 10) 3014 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3015 self.assertFalse(os.path.exists(tmpdir+"/test")) 3016 self.rm_testdir() 3017 def test_65414(self): 3018 """ unzzip-zap -l $(CVE).zip """ 3019 tmpdir = self.testdir() 3020 filename = self.zip_CVE_2018_16 3021 file_url = self.url_CVE_2018_16 3022 if not download_raw(file_url, filename, tmpdir): 3023 self.skipTest("no zip_CVE_2018_16 available: " + filename) 3024 exe = self.bins("unzzip") 3025 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3026 returncodes = [0, 3]) 3027 self.assertLess(len(run.output), 1) 3028 self.assertLess(len(errors(run.errors)), 200) 3029 self.assertErrorMessage(run.errors, 0) 3030 # 3031 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3032 returncodes = [0,3]) 3033 self.assertLess(len(run.output), 30) 3034 self.assertLess(len(errors(run.errors)), 10) 3035 self.assertTrue(greps(run.errors, "Zipfile corrupted")) 3036 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3037 self.assertFalse(os.path.exists(tmpdir+"/test")) 3038 # 3039 run = shell("cd {tmpdir} && ../{exe} -p {filename} ".format(**locals()), 3040 returncodes = [0,3]) 3041 self.assertTrue(greps(run.errors, "Zipfile corrupted")) 3042 self.rm_testdir() 3043 def test_65419(self): 3044 """ check $(CVE).zip """ 3045 tmpdir = self.testdir() 3046 filename = self.zip_CVE_2018_16 3047 file_url = self.url_CVE_2018_16 3048 if not download_raw(file_url, filename, tmpdir): 3049 self.skipTest("no zip_CVE_2018_16 available: " + filename) 3050 shell("ls -l {tmpdir}/{filename}".format(**locals())) 3051 size = os.path.getsize(os.path.join(tmpdir, filename)) 3052 self.assertEqual(size, 124) 3053 3054 url_CVE_2018_17 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib" 3055 zip_CVE_2018_17 = "zziplib_0-13-67_unzip-mem_memory-alignment-errors_zzip_disk_findfirst_64.zip" 3056 def test_65420(self): 3057 """ info unzip -l $(CVE).zip """ 3058 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 3059 tmpdir = self.testdir() 3060 filename = self.zip_CVE_2018_17 3061 file_url = self.url_CVE_2018_17 3062 if not download_raw(file_url, filename, tmpdir): 3063 self.skipTest("no zip_CVE_2018_17 available: " + filename) 3064 exe = self.bins("unzip") 3065 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3066 returncodes = [0, 9]) 3067 self.assertIn("End-of-central-directory signature not found", run.errors) 3068 self.assertLess(len(run.output), 200) 3069 self.assertLess(len(errors(run.errors)), 800) 3070 # 3071 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 3072 returncodes = [9]) 3073 self.assertLess(len(run.output), 200) 3074 self.assertLess(len(errors(run.errors)), 800) 3075 self.assertIn('End-of-central-directory signature not found', run.errors) 3076 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3077 self.assertFalse(os.path.exists(tmpdir+"/test")) 3078 self.rm_testdir() 3079 def test_65421(self): 3080 """ unzzip-big -l $(CVE).zip """ 3081 tmpdir = self.testdir() 3082 filename = self.zip_CVE_2018_17 3083 file_url = self.url_CVE_2018_17 3084 if not download_raw(file_url, filename, tmpdir): 3085 self.skipTest("no zip_CVE_2018_17 available: " + filename) 3086 exe = self.bins("unzzip-big") 3087 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3088 returncodes = [0]) 3089 self.assertLess(len(run.output), 1) 3090 # 3091 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3092 returncodes = [0]) 3093 self.assertLess(len(run.output), 30) 3094 self.assertLess(len(errors(run.errors)), 1) 3095 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3096 self.assertFalse(os.path.exists(tmpdir+"/test")) 3097 self.rm_testdir() 3098 def test_65422(self): 3099 """ unzzip-mem -l $(CVE).zip """ 3100 tmpdir = self.testdir() 3101 filename = self.zip_CVE_2018_17 3102 file_url = self.url_CVE_2018_17 3103 if not download_raw(file_url, filename, tmpdir): 3104 self.skipTest("no zip_CVE_2018_17 available: " + filename) 3105 exe = self.bins("unzzip-mem") 3106 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3107 returncodes = [0]) 3108 self.assertLess(len(run.output), 50) 3109 self.assertLess(len(errors(run.errors)), 1) 3110 # 3111 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3112 returncodes = [0]) 3113 self.assertLess(len(run.output), 30) 3114 self.assertLess(len(errors(run.errors)), 10) 3115 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3116 self.assertFalse(os.path.exists(tmpdir+"/test")) 3117 # 3118 run = shell("cd {tmpdir} && ../{exe} -p {filename} ".format(**locals()), 3119 returncodes = [0]) 3120 # self.rm_testdir() 3121 def test_65423(self): 3122 """ unzzip-mix -l $(CVE).zip """ 3123 tmpdir = self.testdir() 3124 filename = self.zip_CVE_2018_17 3125 file_url = self.url_CVE_2018_17 3126 if not download_raw(file_url, filename, tmpdir): 3127 self.skipTest("no zip_CVE_2018_17 available: " + filename) 3128 exe = self.bins("unzzip-mix") 3129 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3130 returncodes = [0,2]) 3131 self.assertLess(len(run.output), 1) 3132 self.assertErrorMessage(run.errors, errno.EILSEQ) 3133 # 3134 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3135 returncodes = [0,2]) 3136 self.assertLess(len(run.output), 30) 3137 self.assertErrorMessage(run.errors, errno.EILSEQ) 3138 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3139 self.assertFalse(os.path.exists(tmpdir+"/test")) 3140 self.rm_testdir() 3141 def test_65424(self): 3142 """ unzzip-zap -l $(CVE).zip """ 3143 tmpdir = self.testdir() 3144 filename = self.zip_CVE_2018_17 3145 file_url = self.url_CVE_2018_17 3146 if not download_raw(file_url, filename, tmpdir): 3147 self.skipTest("no zip_CVE_2018_17 available: " + filename) 3148 exe = self.bins("unzzip") 3149 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3150 returncodes = [0, 3]) 3151 self.assertLess(len(run.output), 1) 3152 self.assertLess(len(errors(run.errors)), 200) 3153 self.assertErrorMessage(run.errors, 0) 3154 # 3155 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3156 returncodes = [0,3]) 3157 self.assertLess(len(run.output), 30) 3158 self.assertTrue(greps(run.errors, "Zipfile corrupted")) 3159 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3160 self.assertFalse(os.path.exists(tmpdir+"/test")) 3161 self.rm_testdir() 3162 def test_65429(self): 3163 """ check $(CVE).zip """ 3164 tmpdir = self.testdir() 3165 filename = self.zip_CVE_2018_17 3166 file_url = self.url_CVE_2018_17 3167 if not download_raw(file_url, filename, tmpdir): 3168 self.skipTest("no zip_CVE_2018_17 available: " + filename) 3169 shell("ls -l {tmpdir}/{filename}".format(**locals())) 3170 size = os.path.getsize(os.path.join(tmpdir, filename)) 3171 self.assertEqual(size, 360) 3172 3173 3174 url_CVE_2018_42 = "https://github.com/fantasy7082/image_test/blob/master" 3175 zip_CVE_2018_42 = "c006-unknown-add-main" 3176 def test_65430(self): 3177 """ info unzip -l $(CVE).zip """ 3178 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 3179 tmpdir = self.testdir() 3180 filename = self.zip_CVE_2018_42 3181 file_url = self.url_CVE_2018_42 3182 if not download_raw(file_url, filename, tmpdir): 3183 self.skipTest("no zip_CVE_2018_42 available: " + filename) 3184 exe = self.bins("unzip") 3185 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3186 returncodes = [3]) 3187 self.assertIn("missing 18 bytes in zipfile", run.errors) 3188 self.assertLess(len(run.output), 200) 3189 self.assertLess(len(errors(run.errors)), 800) 3190 # 3191 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 3192 returncodes = [3]) 3193 self.assertLess(len(run.output), 200) 3194 self.assertLess(len(errors(run.errors)), 800) 3195 self.assertIn("missing 18 bytes in zipfile", run.errors) 3196 self.assertIn('expected central file header signature not found', run.errors) 3197 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3198 self.assertFalse(os.path.exists(tmpdir+"/test")) 3199 self.rm_testdir() 3200 def test_65431(self): 3201 """ zzdir $(CVE).zip """ 3202 tmpdir = self.testdir() 3203 filename = self.zip_CVE_2018_42 3204 file_url = self.url_CVE_2018_42 3205 if not download_raw(file_url, filename, tmpdir): 3206 self.skipTest("no zip_CVE_2018_42 available: " + filename) 3207 exe = self.bins("zzdir") 3208 run = shell("{exe} {tmpdir}/{filename} ".format(**locals()), 3209 returncodes = [0]) 3210 logg.info("OUT %s", run.output) 3211 logg.info("ERR %s", run.errors) 3212 self.assertIn(" zipped ", run.output) 3213 self.rm_testdir() 3214 3215 url_CVE_2018_43 = "https://github.com/fantasy7082/image_test/blob/master" 3216 zip_CVE_2018_43 = "c008-main-unknown-de" 3217 def test_65440(self): 3218 """ info unzip -l $(CVE).zip """ 3219 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 3220 tmpdir = self.testdir() 3221 filename = self.zip_CVE_2018_43 3222 file_url = self.url_CVE_2018_43 3223 if not download_raw(file_url, filename, tmpdir): 3224 self.skipTest("no zip_CVE_2018_43 available: " + filename) 3225 exe = self.bins("unzip") 3226 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3227 returncodes = [3]) 3228 self.assertIn("missing 18 bytes in zipfile", run.errors) 3229 self.assertGreater(len(run.output), 30) 3230 self.assertGreater(len(errors(run.errors)), 1) 3231 self.assertLess(len(run.output), 500) 3232 self.assertLess(len(errors(run.errors)), 800) 3233 # 3234 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 3235 returncodes = [3]) 3236 self.assertGreater(len(run.output), 30) 3237 self.assertGreater(len(errors(run.errors)), 1) 3238 self.assertLess(len(run.output), 400) 3239 self.assertLess(len(errors(run.errors)), 800) 3240 self.assertIn("missing 18 bytes in zipfile", run.errors) 3241 self.assertIn('expected central file header signature not found', run.errors) 3242 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3243 self.assertFalse(os.path.exists(tmpdir+"/test")) 3244 self.rm_testdir() 3245 def test_65441(self): 3246 """ zzdir $(CVE).zip """ 3247 tmpdir = self.testdir() 3248 filename = self.zip_CVE_2018_43 3249 file_url = self.url_CVE_2018_43 3250 if not download_raw(file_url, filename, tmpdir): 3251 self.skipTest("no zip_CVE_2018_43 available: " + filename) 3252 exe = self.bins("zzdir") 3253 run = shell("{exe} {tmpdir}/{filename} ".format(**locals()), 3254 returncodes = [0]) 3255 logg.info("OUT %s", run.output) 3256 logg.info("ERR %s", run.errors) 3257 self.assertIn(" zipped ", run.output) 3258 self.rm_testdir() 3259 3260 url_CVE_2018_27 = "https://github.com/ret2libc/---provided-by-email---" 3261 zip_CVE_2018_27 = "poc_bypass_fix2.zip" 3262 zip_CVE_2018_27_size = 56 3263 def test_65450(self): 3264 """ info unzip -l $(CVE).zip """ 3265 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 3266 tmpdir = self.testdir() 3267 filename = self.zip_CVE_2018_27 3268 file_url = self.url_CVE_2018_27 3269 filesize = self.zip_CVE_2018_27_size 3270 if not download_raw(file_url, filename, tmpdir): 3271 self.skipTest("no zip_CVE_2018_27 available: " + filename) 3272 if ((os.path.getsize(os.path.join(tmpdir, filename)) != filesize)): 3273 self.skipTest("zip for CVE_2018_27 is confidential: " + filename) 3274 exe = self.bins("unzip") 3275 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3276 returncodes = [0, 9]) 3277 self.assertIn("End-of-central-directory signature not found", run.errors) 3278 self.assertLess(len(run.output), 200) 3279 self.assertLess(len(errors(run.errors)), 800) 3280 # 3281 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 3282 returncodes = [9]) 3283 self.assertLess(len(run.output), 200) 3284 self.assertLess(len(errors(run.errors)), 800) 3285 self.assertIn('End-of-central-directory signature not found', run.errors) 3286 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3287 self.assertFalse(os.path.exists(tmpdir+"/test")) 3288 self.rm_testdir() 3289 def test_65451(self): 3290 """ unzzip-big -l $(CVE).zip """ 3291 tmpdir = self.testdir() 3292 filename = self.zip_CVE_2018_27 3293 file_url = self.url_CVE_2018_27 3294 filesize = self.zip_CVE_2018_27_size 3295 if not download_raw(file_url, filename, tmpdir): 3296 self.skipTest("no zip_CVE_2018_27 available: " + filename) 3297 if ((os.path.getsize(os.path.join(tmpdir, filename)) != filesize)): 3298 self.skipTest("zip for CVE_2018_27 is confidential: " + filename) 3299 exe = self.bins("unzzip-big") 3300 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3301 returncodes = [0]) 3302 self.assertLess(len(run.output), 1) 3303 # 3304 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3305 returncodes = [0]) 3306 self.assertLess(len(run.output), 30) 3307 self.assertLess(len(errors(run.errors)), 1) 3308 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3309 self.assertFalse(os.path.exists(tmpdir+"/test")) 3310 self.rm_testdir() 3311 def test_65452(self): 3312 """ unzzip-mem -l $(CVE).zip """ 3313 tmpdir = self.testdir() 3314 filename = self.zip_CVE_2018_27 3315 file_url = self.url_CVE_2018_27 3316 filesize = self.zip_CVE_2018_27_size 3317 if not download_raw(file_url, filename, tmpdir): 3318 self.skipTest("no zip_CVE_2018_27 available: " + filename) 3319 if ((os.path.getsize(os.path.join(tmpdir, filename)) != filesize)): 3320 self.skipTest("zip for CVE_2018_27 is confidential: " + filename) 3321 exe = self.bins("unzzip-mem") 3322 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3323 returncodes = [0]) 3324 self.assertLess(len(run.output), 50) 3325 self.assertLess(len(errors(run.errors)), 1) 3326 # 3327 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3328 returncodes = [0]) 3329 self.assertLess(len(run.output), 30) 3330 self.assertLess(len(errors(run.errors)), 10) 3331 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3332 self.assertFalse(os.path.exists(tmpdir+"/test")) 3333 # 3334 run = shell("cd {tmpdir} && ../{exe} -p {filename} ".format(**locals()), 3335 returncodes = [0]) 3336 # self.rm_testdir() 3337 def test_65453(self): 3338 """ unzzip-mix -l $(CVE).zip """ 3339 tmpdir = self.testdir() 3340 filename = self.zip_CVE_2018_27 3341 file_url = self.url_CVE_2018_27 3342 filesize = self.zip_CVE_2018_27_size 3343 if not download_raw(file_url, filename, tmpdir): 3344 self.skipTest("no zip_CVE_2018_27 available: " + filename) 3345 if ((os.path.getsize(os.path.join(tmpdir, filename)) != filesize)): 3346 self.skipTest("zip for CVE_2018_27 is confidential: " + filename) 3347 exe = self.bins("unzzip-mix") 3348 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3349 returncodes = [0,2]) 3350 self.assertLess(len(run.output), 1) 3351 self.assertErrorMessage(run.errors, errno.EILSEQ) 3352 # 3353 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3354 returncodes = [0,2]) 3355 self.assertLess(len(run.output), 30) 3356 self.assertErrorMessage(run.errors, errno.EILSEQ) 3357 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3358 self.assertFalse(os.path.exists(tmpdir+"/test")) 3359 self.rm_testdir() 3360 def test_65454(self): 3361 """ unzzip-zap -l $(CVE).zip """ 3362 tmpdir = self.testdir() 3363 filename = self.zip_CVE_2018_27 3364 file_url = self.url_CVE_2018_27 3365 filesize = self.zip_CVE_2018_27_size 3366 if not download_raw(file_url, filename, tmpdir): 3367 self.skipTest("no zip_CVE_2018_27 available: " + filename) 3368 if ((os.path.getsize(os.path.join(tmpdir, filename)) != filesize)): 3369 self.skipTest("zip for CVE_2018_27 is confidential: " + filename) 3370 exe = self.bins("unzzip") 3371 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3372 returncodes = [0, 3]) 3373 self.assertLess(len(run.output), 1) 3374 self.assertLess(len(errors(run.errors)), 200) 3375 self.assertErrorMessage(run.errors, 0) 3376 # 3377 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3378 returncodes = [0,3]) 3379 self.assertLess(len(run.output), 30) 3380 self.assertTrue(greps(run.errors, "Zipfile corrupted")) 3381 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3382 self.assertFalse(os.path.exists(tmpdir+"/test")) 3383 self.rm_testdir() 3384 def test_65459(self): 3385 """ check $(CVE).zip """ 3386 tmpdir = self.testdir() 3387 filename = self.zip_CVE_2018_27 3388 file_url = self.url_CVE_2018_27 3389 filesize = self.zip_CVE_2018_27_size 3390 if not download_raw(file_url, filename, tmpdir): 3391 self.skipTest("no zip_CVE_2018_27 available: " + filename) 3392 if ((os.path.getsize(os.path.join(tmpdir, filename)) != filesize)): 3393 self.skipTest("zip for CVE_2018_27 is confidential: " + filename) 3394 shell("ls -l {tmpdir}/{filename}".format(**locals())) 3395 size = os.path.getsize(os.path.join(tmpdir, filename)) 3396 self.assertEqual(size, filesize) # 56 3397 3398 url_CVE_2018_41 = "https://github.com/fantasy7082/image_test/blob/master" 3399 zip_CVE_2018_41 = "c005-bus-zzip_parse_root_directory" # CVE-2018-7726. 3400 def test_65460(self): 3401 """ info unzip -l $(CVE).zip """ 3402 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 3403 tmpdir = self.testdir() 3404 filename = self.zip_CVE_2018_41 3405 file_url = self.url_CVE_2018_41 3406 if not download_raw(file_url, filename, tmpdir): 3407 self.skipTest("no zip_CVE_2018_41 available: " + filename) 3408 exe = self.bins("unzip") 3409 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3410 returncodes = [0, 3]) 3411 self.assertIn("missing 20 bytes in zipfile", run.errors) 3412 self.assertLess(len(run.output), 200) 3413 self.assertLess(len(errors(run.errors)), 800) 3414 # 3415 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 3416 returncodes = [3]) 3417 self.assertLess(len(run.output), 200) 3418 self.assertLess(len(errors(run.errors)), 800) 3419 self.assertIn("missing 20 bytes in zipfile", run.errors) 3420 self.assertIn('attempt to seek before beginning of zipfile', run.errors) 3421 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3422 self.assertFalse(os.path.exists(tmpdir+"/test")) 3423 self.rm_testdir() 3424 def test_65461(self): 3425 """ zzdir $(CVE).zip """ 3426 tmpdir = self.testdir() 3427 filename = self.zip_CVE_2018_41 3428 file_url = self.url_CVE_2018_41 3429 if not download_raw(file_url, filename, tmpdir): 3430 self.skipTest("no zip_CVE_2018_41 available: " + filename) 3431 exe = self.bins("zzdir") 3432 run = shell("{exe} {tmpdir}/{filename} ".format(**locals()), 3433 returncodes = [1]) 3434 logg.info("OUT %s", run.output) 3435 logg.info("ERR %s", run.errors) 3436 ####### self.assertIn(" zipped ", run.output) 3437 self.rm_testdir() 3438 3439 url_CVE_2018_39 = "https://github.com/fantasy7082/image_test/blob/master" 3440 zip_CVE_2018_39 = "003-unknow-def-zip" 3441 def test_65470(self): 3442 """ info unzip -l $(CVE).zip """ 3443 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 3444 tmpdir = self.testdir() 3445 filename = self.zip_CVE_2018_39 3446 file_url = self.url_CVE_2018_39 3447 if not download_raw(file_url, filename, tmpdir): 3448 self.skipTest("no zip_CVE_2018_39 available: " + filename) 3449 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3450 exe = self.bins("unzip") 3451 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3452 returncodes = [3]) 3453 self.assertIn("missing 5123 bytes in zipfile", run.errors) 3454 self.assertIn("expected central file header signature not found", run.errors) 3455 self.assertLess(len(run.output), 400) 3456 self.assertLess(len(errors(run.errors)), 800) 3457 # 3458 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 3459 returncodes = [3]) 3460 self.assertLess(len(run.output), 400) 3461 self.assertLess(len(errors(run.errors)), 800) 3462 self.assertIn("missing 5123 bytes in zipfile", run.errors) 3463 self.assertIn("expected central file header signature not found", run.errors) 3464 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3465 self.assertFalse(os.path.exists(tmpdir+"/test")) 3466 self.rm_testdir() 3467 def test_65471(self): 3468 """ unzzip-big -l $(CVE).zip """ 3469 tmpdir = self.testdir() 3470 filename = self.zip_CVE_2018_39 3471 file_url = self.url_CVE_2018_39 3472 if not download_raw(file_url, filename, tmpdir): 3473 self.skipTest("no zip_CVE_2018_39 available: " + filename) 3474 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3475 exe = self.bins("unzzip-big") 3476 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3477 returncodes = [0]) 3478 self.assertLess(len(run.output), 1) 3479 # 3480 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3481 returncodes = [0]) 3482 self.assertLess(len(run.output), 30) 3483 self.assertLess(len(errors(run.errors)), 1) 3484 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3485 self.assertFalse(os.path.exists(tmpdir+"/test")) 3486 self.rm_testdir() 3487 def test_65472(self): 3488 """ unzzip-mem -l $(CVE).zip """ 3489 tmpdir = self.testdir() 3490 filename = self.zip_CVE_2018_39 3491 file_url = self.url_CVE_2018_39 3492 if not download_raw(file_url, filename, tmpdir): 3493 self.skipTest("no zip_CVE_2018_39 available: " + filename) 3494 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3495 exe = self.bins("unzzip-mem") 3496 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3497 returncodes = [0]) 3498 self.assertLess(len(run.output), 200) 3499 self.assertLess(len(errors(run.errors)), 1) 3500 # 3501 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3502 returncodes = [0]) 3503 self.assertLess(len(run.output), 200) 3504 self.assertLess(len(errors(run.errors)), 10) 3505 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3506 self.assertFalse(os.path.exists(tmpdir+"/test")) 3507 # 3508 run = shell("cd {tmpdir} && ../{exe} -p {filename} ".format(**locals()), 3509 returncodes = [0]) 3510 # self.rm_testdir() 3511 def test_65473(self): 3512 """ unzzip-mix -l $(CVE).zip """ 3513 tmpdir = self.testdir() 3514 filename = self.zip_CVE_2018_39 3515 file_url = self.url_CVE_2018_39 3516 if not download_raw(file_url, filename, tmpdir): 3517 self.skipTest("no zip_CVE_2018_39 available: " + filename) 3518 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3519 exe = self.bins("unzzip-mix") 3520 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3521 returncodes = [0,2]) 3522 self.assertLess(len(run.output), 1) 3523 self.assertErrorMessage(run.errors, errno.EILSEQ) 3524 # 3525 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3526 returncodes = [0,2]) 3527 self.assertLess(len(run.output), 30) 3528 self.assertErrorMessage(run.errors, errno.EILSEQ) 3529 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3530 self.assertFalse(os.path.exists(tmpdir+"/test")) 3531 self.rm_testdir() 3532 def test_65474(self): 3533 """ unzzip-zap -l $(CVE).zip """ 3534 tmpdir = self.testdir() 3535 filename = self.zip_CVE_2018_39 3536 file_url = self.url_CVE_2018_39 3537 if not download_raw(file_url, filename, tmpdir): 3538 self.skipTest("no zip_CVE_2018_39 available: " + filename) 3539 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3540 exe = self.bins("unzzip") 3541 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3542 returncodes = [0, 3]) 3543 self.assertLess(len(run.output), 1) 3544 self.assertLess(len(errors(run.errors)), 200) 3545 self.assertErrorMessage(run.errors, 0) 3546 # 3547 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3548 returncodes = [0,3]) 3549 self.assertLess(len(run.output), 30) 3550 self.assertTrue(greps(run.errors, "Zipfile corrupted")) 3551 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3552 self.assertFalse(os.path.exists(tmpdir+"/test")) 3553 self.rm_testdir() 3554 def test_65479(self): 3555 """ check $(CVE).zip """ 3556 tmpdir = self.testdir() 3557 filename = self.zip_CVE_2018_39 3558 file_url = self.url_CVE_2018_39 3559 if not download_raw(file_url, filename, tmpdir): 3560 self.skipTest("no zip_CVE_2018_39 available: " + filename) 3561 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3562 shell("ls -l {tmpdir}/{filename}".format(**locals())) 3563 size = os.path.getsize(os.path.join(tmpdir, filename)) 3564 self.assertEqual(size, 82347) 3565 3566 url_CVE_2018_40 = "https://github.com/fantasy7082/image_test/blob/master" 3567 zip_CVE_2018_40 = "002-mem-leaks-zip" 3568 def test_65480(self): 3569 """ info unzip -l $(CVE).zip """ 3570 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 3571 tmpdir = self.testdir() 3572 filename = self.zip_CVE_2018_40 3573 file_url = self.url_CVE_2018_40 3574 if not download_raw(file_url, filename, tmpdir): 3575 self.skipTest("no zip_CVE_2018_40 available: " + filename) 3576 exe = self.bins("unzip") 3577 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3578 returncodes = [3]) 3579 self.assertIn("missing 21 bytes in zipfile", run.errors) 3580 self.assertGreater(len(run.output), 20) 3581 self.assertGreater(len(errors(run.errors)), 1) 3582 self.assertLess(len(run.output), 2500) 3583 self.assertLess(len(errors(run.errors)), 800) 3584 # 3585 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 3586 returncodes = [3]) 3587 self.assertGreater(len(run.output), 20) 3588 self.assertGreater(len(errors(run.errors)), 1) 3589 self.assertLess(len(run.output), 2500) 3590 self.assertLess(len(errors(run.errors)), 800) 3591 self.assertIn("missing 21 bytes in zipfile", run.errors) 3592 self.assertIn('expected central file header signature not found', run.errors) 3593 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3594 self.assertFalse(os.path.exists(tmpdir+"/test")) 3595 self.rm_testdir() 3596 def test_65482(self): 3597 """ unzzip-mem -l $(CVE).zip """ 3598 tmpdir = self.testdir() 3599 filename = self.zip_CVE_2018_40 3600 file_url = self.url_CVE_2018_40 3601 if not download_raw(file_url, filename, tmpdir): 3602 self.skipTest("no zip_CVE_2018_40 available: " + filename) 3603 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3604 exe = self.bins("unzzip-mem") 3605 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3606 returncodes = [0]) 3607 self.assertLess(len(run.output), 1500) 3608 self.assertLess(len(errors(run.errors)), 1) 3609 # 3610 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3611 returncodes = [0]) 3612 self.assertLess(len(run.output), 1500) 3613 self.assertLess(len(errors(run.errors)), 10) 3614 # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) 3615 self.assertFalse(os.path.exists(tmpdir+"/test")) 3616 # 3617 run = shell("cd {tmpdir} && ../{exe} -p {filename} ".format(**locals()), 3618 returncodes = [0]) 3619 self.rm_testdir() 3620 3621 url_CVE_2018_17828 = "https://github.com/gdraheim/zziplib/files/2415382" 3622 zip_CVE_2018_17828 = "evil.zip" 3623 def test_65484(self): 3624 """ extract file with "../" in the pathname [CVE-2018-17828] """ 3625 tmpdir = self.testdir() 3626 filename = self.zip_CVE_2018_17828 3627 file_url = self.url_CVE_2018_17828 3628 if not download_raw(file_url, filename, tmpdir): 3629 self.skipTest("no zip_CVE_2018_40 available: " + filename) 3630 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3631 exe = self.bins("unzzip-mem") 3632 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3633 returncodes = [0, 80]) 3634 self.assertLess(len(run.output), 500) 3635 self.assertLess(len(errors(run.errors)), 1) 3636 # 3637 workdir = tmpdir + "/d1/d2" 3638 os.makedirs(workdir) 3639 run = shell("cd {workdir} && ../../../{exe} ../../{filename} ".format(**locals()), 3640 returncodes = [0]) 3641 self.assertLess(len(run.output), 500) 3642 self.assertEqual(len(errors(run.errors)), 1) 3643 self.assertFalse(os.path.exists(tmpdir+"/test/evil.conf")) 3644 self.assertTrue(os.path.exists(workdir+"/test/evil.conf")) 3645 self.rm_testdir() 3646 3647 def test_65485_list_verbose_compressed_with_directory(self): 3648 """ verbously list a zipfile containing directories """ 3649 chdir = "chdir" 3650 if not exeext: chdir = "cd" 3651 tmpdir = self.testdir() 3652 workdir = tmpdir + "/d" 3653 zipname = "ZIPfile" 3654 os.makedirs(workdir) 3655 f= open(tmpdir + "/d/file","w+") 3656 for i in range(10): 3657 f.write("This is line %d\r\n" % (i+1)) 3658 f.close() 3659 # create the ZIPfile 3660 mkzip=self.bins("mkzip") 3661 run = shell("{chdir} {tmpdir} && {mkzip} -9 {zipname}.zip d".format(**locals())) 3662 self.assertFalse(run.returncode) 3663 # list the ZIPfile 3664 exe=self.bins("unzip-mem"); 3665 run = shell("{chdir} {tmpdir} && ../{exe} -v {zipname}.zip".format(**locals()), returncodes = [0,-8]) 3666 logg.error("FIXME: unzip-mem test_65485 is not solved") 3667 self.skipTest("FIXME: not solved") 3668 self.assertFalse(run.returncode) 3669 self.rm_testdir() 3670 3671 url_CVE_2020_04 = "https://github.com/gdraheim/zziplib/files/5340201" 3672 zip_CVE_2020_04 = "2020_10_OutagesPUReasons.zip" 3673 def test_65570(self): 3674 """ info unzip -l $(CVE).zip """ 3675 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 3676 tmpdir = self.testdir() 3677 filename = self.zip_CVE_2020_04 3678 file_url = self.url_CVE_2020_04 3679 if not download_raw(file_url, filename, tmpdir): 3680 self.skipTest("no zip_CVE_2018_39 available: " + filename) 3681 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3682 exe = self.bins("unzip") 3683 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3684 returncodes = [0]) 3685 # 3686 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 3687 returncodes = [0]) 3688 self.assertEqual(os.path.getsize(tmpdir+"/2020_10_OutagesPUReasons.csv"), 2590160) 3689 self.rm_testdir() 3690 @unittest.expectedFailure 3691 def test_65571(self): 3692 """ unzzip-big -l $(CVE).zip """ 3693 tmpdir = self.testdir() 3694 filename = self.zip_CVE_2020_04 3695 file_url = self.url_CVE_2020_04 3696 if not download_raw(file_url, filename, tmpdir): 3697 self.skipTest("no zip_CVE_2020_04 available: " + filename) 3698 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3699 exe = self.bins("unzzip-big") 3700 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3701 returncodes = [0]) 3702 # 3703 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3704 returncodes = [0]) 3705 self.assertEqual(os.path.getsize(tmpdir+"/2020_10_OutagesPUReasons.csv"), 2590160) 3706 self.rm_testdir() 3707 @unittest.expectedFailure 3708 def test_65572(self): 3709 """ unzzip-mem -l $(CVE).zip """ 3710 tmpdir = self.testdir() 3711 filename = self.zip_CVE_2020_04 3712 file_url = self.url_CVE_2020_04 3713 if not download_raw(file_url, filename, tmpdir): 3714 self.skipTest("no zip_CVE_2020_04 available: " + filename) 3715 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3716 exe = self.bins("unzzip-mem") 3717 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3718 returncodes = [0]) 3719 self.assertLess(len(run.output), 1) 3720 # self.assertEqual(len(errors(run.errors)), 1) 3721 # 3722 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3723 returncodes = [0]) 3724 self.assertLess(len(run.output), 1) 3725 self.assertEqual(os.path.getsize(tmpdir+"/2020_10_OutagesPUReasons.csv"), 2590160) 3726 # 3727 run = shell("cd {tmpdir} && ../{exe} -p {filename} ".format(**locals()), 3728 returncodes = [0]) 3729 self.rm_testdir() 3730 @unittest.expectedFailure 3731 def test_65573(self): 3732 """ unzzip-mix -l $(CVE).zip """ 3733 tmpdir = self.testdir() 3734 filename = self.zip_CVE_2020_04 3735 file_url = self.url_CVE_2020_04 3736 if not download_raw(file_url, filename, tmpdir): 3737 self.skipTest("no zip_CVE_2020_04 available: " + filename) 3738 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3739 exe = self.bins("unzzip-mix") 3740 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3741 returncodes = [0]) 3742 # 3743 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3744 returncodes = [0,2]) 3745 self.assertLess(len(run.output), 30) 3746 self.assertEqual(os.path.getsize(tmpdir+"/2020_10_OutagesPUReasons.csv"), 2590160) 3747 self.rm_testdir() 3748 @unittest.expectedFailure 3749 def test_65574(self): 3750 """ unzzip-zap -l $(CVE).zip """ 3751 tmpdir = self.testdir() 3752 filename = self.zip_CVE_2020_04 3753 file_url = self.url_CVE_2020_04 3754 if not download_raw(file_url, filename, tmpdir): 3755 self.skipTest("no zip_CVE_2020_04 available: " + filename) 3756 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3757 exe = self.bins("unzzip") 3758 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3759 returncodes = [0]) 3760 # 3761 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3762 returncodes = [0]) 3763 self.assertEqual(os.path.getsize(tmpdir+"/2020_10_OutagesPUReasons.csv"), 2590160) 3764 self.rm_testdir() 3765 def test_65579(self): 3766 """ check $(CVE).zip """ 3767 tmpdir = self.testdir() 3768 filename = self.zip_CVE_2020_04 3769 file_url = self.url_CVE_2020_04 3770 if not download_raw(file_url, filename, tmpdir): 3771 self.skipTest("no zip_CVE_2020_04 available: " + filename) 3772 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3773 shell("ls -l {tmpdir}/{filename}".format(**locals())) 3774 size = os.path.getsize(os.path.join(tmpdir, filename)) 3775 self.assertEqual(size, 171344) 3776 3777 3778 url_CVE_2019_69 = "https://github.com/gdraheim/zziplib/files/3001317" 3779 zip_CVE_2019_69 = "zip_poc.zip" 3780 def test_65670(self): 3781 """ info unzip -l $(CVE).zip """ 3782 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 3783 tmpdir = self.testdir() 3784 filename = self.zip_CVE_2019_69 3785 file_url = self.url_CVE_2019_69 3786 if not download_raw(file_url, filename, tmpdir): 3787 self.skipTest("no zip_CVE_2019_69 available: " + filename) 3788 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3789 exe = self.bins("unzip") 3790 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3791 returncodes = [2]) 3792 self.assertTrue(greps(run.errors, "missing 6 bytes in zipfile")) 3793 # 3794 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 3795 returncodes = [3]) 3796 self.rm_testdir() 3797 def test_65671(self): 3798 """ unzzip-big -l $(CVE).zip """ 3799 tmpdir = self.testdir() 3800 filename = self.zip_CVE_2019_69 3801 file_url = self.url_CVE_2019_69 3802 if not download_raw(file_url, filename, tmpdir): 3803 self.skipTest("no zip_CVE_2019_69 available: " + filename) 3804 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3805 exe = self.bins("unzzip-big") 3806 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3807 returncodes = [0]) 3808 # 3809 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3810 returncodes = [1]) 3811 self.rm_testdir() 3812 def test_65672(self): 3813 """ unzzip-mem -l $(CVE).zip """ 3814 tmpdir = self.testdir() 3815 filename = self.zip_CVE_2019_69 3816 file_url = self.url_CVE_2019_69 3817 if not download_raw(file_url, filename, tmpdir): 3818 self.skipTest("no zip_CVE_2019_69 available: " + filename) 3819 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3820 exe = self.bins("unzzip-mem") 3821 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3822 returncodes = [0]) 3823 # self.assertLess(len(run.output), 1) 3824 # self.assertEqual(len(errors(run.errors)), 1) 3825 # 3826 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3827 returncodes = [0]) 3828 self.assertLess(len(run.output), 1) 3829 # 3830 run = shell("cd {tmpdir} && ../{exe} -p {filename} ".format(**locals()), 3831 returncodes = [0]) 3832 self.rm_testdir() 3833 def test_65673(self): 3834 """ unzzip-mix -l $(CVE).zip """ 3835 tmpdir = self.testdir() 3836 filename = self.zip_CVE_2019_69 3837 file_url = self.url_CVE_2019_69 3838 if not download_raw(file_url, filename, tmpdir): 3839 self.skipTest("no zip_CVE_2019_69 available: " + filename) 3840 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3841 exe = self.bins("unzzip-mix") 3842 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3843 returncodes = [2]) 3844 self.assertTrue(greps(run.errors, "Invalid or incomplete")) 3845 # 3846 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3847 returncodes = [2]) 3848 # self.assertLess(len(run.output), 30) 3849 self.assertTrue(greps(run.errors, "Invalid or incomplete")) 3850 self.rm_testdir() 3851 def test_65674(self): 3852 """ unzzip-zap -l $(CVE).zip """ 3853 tmpdir = self.testdir() 3854 filename = self.zip_CVE_2019_69 3855 file_url = self.url_CVE_2019_69 3856 if not download_raw(file_url, filename, tmpdir): 3857 self.skipTest("no zip_CVE_2019_69 available: " + filename) 3858 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3859 exe = self.bins("unzzip") 3860 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3861 returncodes = [3]) 3862 # 3863 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3864 returncodes = [3]) 3865 self.assertTrue(greps(run.errors, "Zipfile corrupted")) 3866 self.rm_testdir() 3867 def test_65679(self): 3868 """ check $(CVE).zip """ 3869 tmpdir = self.testdir() 3870 filename = self.zip_CVE_2019_69 3871 file_url = self.url_CVE_2019_69 3872 if not download_raw(file_url, filename, tmpdir): 3873 self.skipTest("no zip_CVE_2019_69 available: " + filename) 3874 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3875 shell("ls -l {tmpdir}/{filename}".format(**locals())) 3876 size = os.path.getsize(os.path.join(tmpdir, filename)) 3877 self.assertEqual(size, 155) 3878 3879 url_CVE_2019_70 = "https://github.com/gdraheim/zziplib/files/3006594" 3880 zip_CVE_2019_70 = "POC.zip" 3881 def test_65770(self): 3882 """ info unzip -l $(CVE).zip """ 3883 if unzip_skip: self.skipTest("skip tests using infozip 'unzip'") 3884 tmpdir = self.testdir() 3885 filename = self.zip_CVE_2019_70 3886 file_url = self.url_CVE_2019_70 3887 if not download_raw(file_url, filename, tmpdir): 3888 self.skipTest("no zip_CVE_2019_70 available: " + filename) 3889 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3890 exe = self.bins("unzip") 3891 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3892 returncodes = [0]) 3893 # 3894 run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()), 3895 returncodes = [0]) 3896 self.assertEqual(os.path.getsize(tmpdir+"/POC1"), 135) 3897 self.assertEqual(os.path.getsize(tmpdir+"/POC2"), 135) 3898 self.assertEqual(os.path.getsize(tmpdir+"/POC3"), 303) 3899 self.rm_testdir() 3900 def test_65771(self): 3901 """ unzzip-big -l $(CVE).zip """ 3902 tmpdir = self.testdir() 3903 filename = self.zip_CVE_2019_70 3904 file_url = self.url_CVE_2019_70 3905 if not download_raw(file_url, filename, tmpdir): 3906 self.skipTest("no zip_CVE_2019_70 available: " + filename) 3907 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3908 exe = self.bins("unzzip-big") 3909 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3910 returncodes = [0]) 3911 # 3912 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3913 returncodes = [0]) 3914 self.assertEqual(os.path.getsize(tmpdir+"/POC1"), 135) 3915 self.assertEqual(os.path.getsize(tmpdir+"/POC2"), 135) 3916 self.assertEqual(os.path.getsize(tmpdir+"/POC3"), 303) 3917 self.rm_testdir() 3918 def test_65772(self): 3919 """ unzzip-mem -l $(CVE).zip """ 3920 tmpdir = self.testdir() 3921 filename = self.zip_CVE_2019_70 3922 file_url = self.url_CVE_2019_70 3923 if not download_raw(file_url, filename, tmpdir): 3924 self.skipTest("no zip_CVE_2019_70 available: " + filename) 3925 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3926 exe = self.bins("unzzip-mem") 3927 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3928 returncodes = [0]) 3929 # self.assertLess(len(run.output), 1) 3930 # self.assertEqual(len(errors(run.errors)), 1) 3931 # 3932 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3933 returncodes = [0]) 3934 self.assertLess(len(run.output), 1) 3935 self.assertEqual(os.path.getsize(tmpdir+"/POC1"), 135) 3936 self.assertEqual(os.path.getsize(tmpdir+"/POC2"), 135) 3937 self.assertEqual(os.path.getsize(tmpdir+"/POC3"), 303) 3938 # 3939 run = shell("cd {tmpdir} && ../{exe} -p {filename} ".format(**locals()), 3940 returncodes = [0]) 3941 self.rm_testdir() 3942 @unittest.expectedFailure 3943 def test_65773(self): 3944 """ unzzip-mix -l $(CVE).zip """ 3945 tmpdir = self.testdir() 3946 filename = self.zip_CVE_2019_70 3947 file_url = self.url_CVE_2019_70 3948 if not download_raw(file_url, filename, tmpdir): 3949 self.skipTest("no zip_CVE_2019_70 available: " + filename) 3950 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3951 exe = self.bins("unzzip-mix") 3952 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3953 returncodes = [0]) 3954 # 3955 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3956 returncodes = [0,2]) 3957 # self.assertLess(len(run.output), 30) 3958 self.assertEqual(os.path.getsize(tmpdir+"/POC1"), 135) 3959 self.assertEqual(os.path.getsize(tmpdir+"/POC2"), 135) 3960 self.assertEqual(os.path.getsize(tmpdir+"/POC3"), 303) 3961 self.rm_testdir() 3962 def test_65774(self): 3963 """ unzzip-zap -l $(CVE).zip """ 3964 tmpdir = self.testdir() 3965 filename = self.zip_CVE_2019_70 3966 file_url = self.url_CVE_2019_70 3967 if not download_raw(file_url, filename, tmpdir): 3968 self.skipTest("no zip_CVE_2019_70 available: " + filename) 3969 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3970 exe = self.bins("unzzip") 3971 run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()), 3972 returncodes = [0]) 3973 # 3974 run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()), 3975 returncodes = [0]) 3976 self.assertEqual(os.path.getsize(tmpdir+"/POC1"), 135) 3977 self.assertEqual(os.path.getsize(tmpdir+"/POC2"), 135) 3978 self.assertEqual(os.path.getsize(tmpdir+"/POC3"), 303) 3979 self.rm_testdir() 3980 def test_65779(self): 3981 """ check $(CVE).zip """ 3982 tmpdir = self.testdir() 3983 filename = self.zip_CVE_2019_70 3984 file_url = self.url_CVE_2019_70 3985 if not download_raw(file_url, filename, tmpdir): 3986 self.skipTest("no zip_CVE_2019_70 available: " + filename) 3987 if not os.path.isfile(os.path.join(tmpdir, filename)): self.skipTest("missing " + filename) 3988 shell("ls -l {tmpdir}/{filename}".format(**locals())) 3989 size = os.path.getsize(os.path.join(tmpdir, filename)) 3990 self.assertEqual(size, 771) 3991 3992 3993 def test_91000_zzshowme_check_sfx(self): 3994 """ create an *.exe that can extract its own zip content """ 3995 mkzip=self.bins("mkzip") 3996 exefile = "tmp.zzshowme" + exeext 3997 libstub1 = ".libs/zzipself" + exeext 3998 libstub2 = "zzipself" + exeext 3999 libstub = os.path.exists(libstub1) and libstub1 or libstub2 4000 txtfile_name = readme 4001 txtfile = self.src(readme) 4002 # add the extract-stub so we have reserved the size 4003 run = shell("{mkzip} -0 -j {exefile}.zip {libstub}".format(**locals())) 4004 self.assertFalse(run.returncode) 4005 # add the actual content which may now be compressed 4006 run = shell("{mkzip} -9 -j {exefile}.zip {txtfile}".format(**locals())) 4007 self.assertFalse(run.returncode) 4008 # rename .zip to .exe and put the extract-stub at the start 4009 shutil.copy(exefile+".zip", exefile) 4010 setstub="./zzipsetstub" + exeext 4011 run = shell("{setstub} {exefile} {libstub}".format(**locals())) 4012 self.assertFalse(run.returncode) 4013 os.chmod(exefile, 0o755) 4014 # now ask the new .exe to show some of its own content 4015 run = shell("./{exefile} {txtfile_name}".format(**locals())) 4016 self.assertFalse(run.returncode) 4017 txt = open(txtfile).read() 4018 self.assertEqual(txt.split("\n"), run.output.split("\n")) 4019 4020 def test_99000_make_test1w_zip(self): 4021 """ create a test1w.zip using zzip/write functions. """ 4022 exe=self.bins("zzip") 4023 run = shell("{exe} --version".format(**locals())) 4024 if "- NO -" in run.output: 4025 self.skipTest("- NO -D_ZZIP_ENABLE_WRITE") 4026 return 4027 zipfile=self.testzip() 4028 tmpdir=self.testdir() 4029 exe=self.bins("zzip") 4030 for i in [1,2,3,4,5,6,7,8,9]: 4031 filename = os.path.join(tmpdir,"file.%i" % i) 4032 filetext = "file-%i\n" % i 4033 self.mkfile(filename, filetext) 4034 filename = os.path.join(tmpdir,"README") 4035 filetext = self.readme() 4036 self.mkfile(filename, filetext) 4037 self.rm_zipfile() 4038 shell("../{exe} ../{zipfile} ??*.* README".format(**locals()), cwd=tmpdir) 4039 self.assertGreater(os.path.getsize(zipfile), 10) 4040 4041 4042 4043 4044if __name__ == "__main__": 4045 import optparse 4046 _o = optparse.OptionParser("%prog [options] test_xxx") 4047 _o.add_option("-D", "--downloadonly", action="store_true", default=downloadonly, 4048 help="setup helper: get downloads only [%default]") 4049 _o.add_option("-d", "--downloaddir", metavar="DIR", default=downloaddir, 4050 help="put and get downloads from here [%default]") 4051 _o.add_option("-n", "--nodownloads", action="store_true", default=nodownloads, 4052 help="no downloads / skipping CVE zip file tests [%default]") 4053 _o.add_option("--downloads", metavar="YES", default="") 4054 _o.add_option("-b", "--bindir", metavar="DIR", default=bindir, 4055 help="path to the bindir to use [%default]") 4056 _o.add_option("-s", "--topsrcdir", metavar="DIR", default=topsrcdir, 4057 help="path to the top srcdir / unpack directory [%default]") 4058 _o.add_option("-t", "--testdatadir", metavar="DIR", default=testdatadir, 4059 help="path where temporary testdata is created [%default]") 4060 _o.add_option("-Z", "--mkzip", metavar="EXE", default=mkzip, 4061 help="name or path to zip.exe for *.zip creation [%default]") 4062 _o.add_option("-U", "--unzip", metavar="EXE", default=unzip, 4063 help="name or path to unzip.exe to unpack *.zip [%default]") 4064 _o.add_option("-E", "--exeext", metavar="EXT", default=exeext, 4065 help="the executable extension (automake $(EXEEXT)) [%default]") 4066 _o.add_option("--xmlresults", metavar="FILE", default=None, 4067 help="capture results as a junit xml file [%default]") 4068 _o.add_option("-v", "--verbose", action="count", default=0, 4069 help="increase logging output [%default]") 4070 opt, args = _o.parse_args() 4071 logging.basicConfig(level = logging.WARNING - 10 * opt.verbose) 4072 downloadonly = opt.downloadonly 4073 downloaddir = opt.downloaddir 4074 nodownloads = yesno(opt.nodownloads) 4075 if opt.downloads: 4076 nodownloads = not yesno(opt.downloads) 4077 topsrcdir = opt.topsrcdir 4078 bindir = opt.bindir 4079 testdatdir = opt.testdatadir 4080 if opt.mkzip.endswith("-NOTFOUND"): 4081 logg.error(" no infozip 'zip' found, expect failing tests (given -Z %s)", opt.mkzip) 4082 else: 4083 mkzip = opt.mkzip 4084 if opt.unzip.endswith("-NOTFOUND") or len(opt.unzip) < 3: 4085 logg.error("no infozip 'unzip' found, expect skipped tests (given -U %s)", opt.unzip) 4086 unzip_skip = True 4087 else: 4088 unzip = opt.unzip 4089 exeext = opt.exeext 4090 # 4091 if downloadonly: 4092 downloads = 0 4093 for classname in sorted(list(globals())): 4094 if not classname.endswith("Test"): 4095 continue 4096 testclass = globals()[classname] 4097 for item in sorted(dir(testclass)): 4098 if item.startswith("url_"): 4099 name = item.replace("url_", "zip_") 4100 if name in testclass.__dict__: 4101 url = testclass.__dict__[item] 4102 zip = testclass.__dict__[name] 4103 download(url, zip) 4104 downloads += 1 4105 if downloads: 4106 sys.exit(0) 4107 logg.error("could not download any file") 4108 sys.exit(1) 4109 # 4110 if not args: args += [ "test_" ] 4111 suite = unittest.TestSuite() 4112 for arg in args: 4113 for classname in sorted(list(globals())): 4114 if not classname.endswith("Test"): 4115 continue 4116 testclass = globals()[classname] 4117 for method in sorted(dir(testclass)): 4118 if "*" not in arg: arg += "*" 4119 if arg.startswith("_"): arg = arg[1:] 4120 if matches(method, arg): 4121 suite.addTest(testclass(method)) 4122 4123 xmlresults = opt.xmlresults 4124 if xmlresults: 4125 try: import xmlrunner 4126 except: xmlresults=None 4127 if xmlresults: 4128 if os.path.exists(opt.xmlresults): 4129 os.remove(opt.xmlresults) 4130 logg.info("xml results into %s", opt.xmlresults) 4131 Runner = xmlrunner.XMLTestRunner 4132 result = Runner(output=opt.xmlresults).run(suite) 4133 else: 4134 Runner = unittest.TextTestRunner 4135 result = Runner(verbosity=opt.verbose).run(suite) 4136 if not result.wasSuccessful(): 4137 sys.exit(1) 4138