kc3-lang/angle/src/common/system_utils_win32.cpp

• Show log

  Commit

• Hash : be947198
  Author :
  Date : 2021-10-20T17:33:34
  

  avoid reading past end of stack array in GetEnvironmentVar
  
  I ran into a case where GetEnvironmentVariableA returned a nonzero
  value, but std::string() read past the end of the oldValue array when it
  tried to strlen() it.
  
  It seems it tried to read an environment variable that was already huge,
  because MSDN says:
  
      If lpBuffer is not large enough to hold the data, the return value
      is the buffer size, in characters, required to hold the string and
      its terminating null character and the contents of lpBuffer are
      undefined.
  
  So if the buffer isn't large enough, it doesn't just truncate the value
  (like GetModuleFilenameA would). It instead returns the size we would
  need to allocate to store the value. It also vaguely states that the
  contents of the buffer are undefined in this scenario, which means that
  the std::array used here could still be filled with uninitialized data
  without a null character in there.
  
  A better solution here is to use a FastVector, so we can resize it to
  fit whatever variable we're reading (MSDN states the maximum environment
  variable size is 32,767 characters, including the null terminator -- not
  MAX_PATH as this code seems to have assumed).
  
  Bug: angleproject:6600
  Change-Id: I1582867578c5b879e71d58ab494a5134848b180f
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3235902
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/common/system_utils_win32.cpp

• //
  // Copyright 2019 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // system_utils_win32.cpp: Implementation of OS-specific functions for Windows.
  
  #include "common/FastVector.h"
  #include "system_utils.h"
  
  #include <windows.h>
  #include <array>
  
  namespace angle
  {
  bool UnsetEnvironmentVar(const char *variableName)
  {
      return (SetEnvironmentVariableA(variableName, nullptr) == TRUE);
  }
  
  bool SetEnvironmentVar(const char *variableName, const char *value)
  {
      return (SetEnvironmentVariableA(variableName, value) == TRUE);
  }
  
  std::string GetEnvironmentVar(const char *variableName)
  {
      FastVector<char, MAX_PATH> value;
  
      DWORD result;
  
      // First get the length of the variable, including the null terminator
      result = GetEnvironmentVariableA(variableName, nullptr, 0);
  
      // Zero means the variable was not found, so return now.
      if (result == 0)
      {
          return std::string();
      }
  
      // Now size the vector to fit the data, and read the environment variable.
      value.resize(result, 0);
      result = GetEnvironmentVariableA(variableName, value.data(), result);
  
      return std::string(value.data());
  }
  
  class Win32Library : public Library
  {
    public:
      Win32Library(const char *libraryName, SearchType searchType)
      {
          switch (searchType)
          {
              case SearchType::ModuleDir:
              {
                  std::string moduleRelativePath = ConcatenatePath(GetModuleDirectory(), libraryName);
                  mModule                        = LoadLibraryA(moduleRelativePath.c_str());
                  break;
              }
  
              case SearchType::SystemDir:
                  mModule = LoadLibraryExA(libraryName, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
                  break;
              case SearchType::AlreadyLoaded:
                  mModule = GetModuleHandleA(libraryName);
                  break;
          }
      }
  
      ~Win32Library() override
      {
          if (mModule)
          {
              FreeLibrary(mModule);
          }
      }
  
      void *getSymbol(const char *symbolName) override
      {
          if (!mModule)
          {
              fprintf(stderr, "Module was not loaded\n");
              return nullptr;
          }
  
          return reinterpret_cast<void *>(GetProcAddress(mModule, symbolName));
      }
  
      void *getNative() const override { return reinterpret_cast<void *>(mModule); }
  
      std::string getPath() const override
      {
          if (!mModule)
          {
              return "";
          }
  
          std::array<char, MAX_PATH> buffer;
          if (GetModuleFileNameA(mModule, buffer.data(), buffer.size()) == 0)
          {
              return "";
          }
  
          return std::string(buffer.data());
      }
  
    private:
      HMODULE mModule = nullptr;
  };
  
  Library *OpenSharedLibrary(const char *libraryName, SearchType searchType)
  {
      char buffer[MAX_PATH];
      int ret = snprintf(buffer, MAX_PATH, "%s.%s", libraryName, GetSharedLibraryExtension());
      if (ret > 0 && ret < MAX_PATH)
      {
          return new Win32Library(buffer, searchType);
      }
      else
      {
          fprintf(stderr, "Error loading shared library: 0x%x", ret);
          return nullptr;
      }
  }
  
  Library *OpenSharedLibraryWithExtension(const char *libraryName, SearchType searchType)
  {
      return new Win32Library(libraryName, searchType);
  }
  }  // namespace angle
  

Download