Issue #29392: Prevent crash when passing invalid arguments into msvcrt module.

1 files changed, 54 insertions, 48 deletions

diff --git a/Lib/importlib/_bootstrap_external.py b/Lib/importlib/_bootstrap_external.py
index e54d6916e8..9feec50842 100644
--- a/Lib/importlib/_bootstrap_external.py
+++ b/Lib/importlib/_bootstrap_external.py
@@ -137,10 +137,6 @@ _code_type = type(_write_atomic.__code__)
 # a .pyc file in text mode the magic number will be wrong; also, the
 # Apple MPW compiler swaps their values, botching string constants.
 #
-# The magic numbers must be spaced apart at least 2 values, as the
-# -U interpeter flag will cause MAGIC+1 being used. They have been
-# odd numbers for some time now.
-#
 # There were a variety of old schemes for setting the magic number.
 # The current working scheme is to increment the previous value by
 # 10.
@@ -231,6 +227,19 @@ _code_type = type(_write_atomic.__code__)
 #     Python 3.5b2  3340 (fix dictionary display evaluation order #11205)
 #     Python 3.5b2  3350 (add GET_YIELD_FROM_ITER opcode #24400)
 #     Python 3.5.2  3351 (fix BUILD_MAP_UNPACK_WITH_CALL opcode #27286)
+#     Python 3.6a0  3360 (add FORMAT_VALUE opcode #25483
+#     Python 3.6a0  3361 (lineno delta of code.co_lnotab becomes signed)
+#     Python 3.6a1  3370 (16 bit wordcode)
+#     Python 3.6a1  3371 (add BUILD_CONST_KEY_MAP opcode #27140)
+#     Python 3.6a1  3372 (MAKE_FUNCTION simplification, remove MAKE_CLOSURE
+#                         #27095)
+#     Python 3.6b1  3373 (add BUILD_STRING opcode #27078)
+#     Python 3.6b1  3375 (add SETUP_ANNOTATIONS and STORE_ANNOTATION opcodes
+#                         #27985)
+#     Python 3.6b1  3376 (simplify CALL_FUNCTIONs & BUILD_MAP_UNPACK_WITH_CALL)
+#     Python 3.6b1  3377 (set __class__ cell from type.__new__ #23722)
+#     Python 3.6b2  3378 (add BUILD_TUPLE_UNPACK_WITH_CALL #28257)
+#     Python 3.6rc1 3379 (more thorough __class__ validation #23722)
 #
 # MAGIC must change whenever the bytecode emitted by the compiler may no
 # longer be understood by older implementations of the eval loop (usually
@@ -239,7 +248,7 @@ _code_type = type(_write_atomic.__code__)
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3351).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (3379).to_bytes(2, 'little') + b'\r\n'
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 
 _PYCACHE = '__pycache__'
@@ -276,6 +285,7 @@ def cache_from_source(path, debug_override=None, *, optimization=None):
             message = 'debug_override or optimization must be set to None'
             raise TypeError(message)
         optimization = '' if debug_override else 1
+    path = _os.fspath(path)
     head, tail = _path_split(path)
     base, sep, rest = tail.rpartition('.')
     tag = sys.implementation.cache_tag
@@ -306,6 +316,7 @@ def source_from_cache(path):
     """
     if sys.implementation.cache_tag is None:
         raise NotImplementedError('sys.implementation.cache_tag is None')
+    path = _os.fspath(path)
     head, pycache_filename = _path_split(path)
     head, pycache = _path_split(head)
     if pycache != _PYCACHE:
@@ -371,14 +382,6 @@ def _calc_mode(path):
     return mode
 
 
-def _verbose_message(message, *args, verbosity=1):
-    """Print the message to stderr if -v/PYTHONVERBOSE is turned on."""
-    if sys.flags.verbose >= verbosity:
-        if not message.startswith(('#', 'import ')):
-            message = '# ' + message
-        print(message.format(*args), file=sys.stderr)
-
-
 def _check_name(method):
     """Decorator to verify that the module being requested matches the one the
     loader can handle.
@@ -448,15 +451,15 @@ def _validate_bytecode_header(data, source_stats=None, name=None, path=None):
     raw_size = data[8:12]
     if magic != MAGIC_NUMBER:
         message = 'bad magic number in {!r}: {!r}'.format(name, magic)
-        _verbose_message('{}', message)
+        _bootstrap._verbose_message('{}', message)
         raise ImportError(message, **exc_details)
     elif len(raw_timestamp) != 4:
         message = 'reached EOF while reading timestamp in {!r}'.format(name)
-        _verbose_message('{}', message)
+        _bootstrap._verbose_message('{}', message)
         raise EOFError(message)
     elif len(raw_size) != 4:
         message = 'reached EOF while reading size of source in {!r}'.format(name)
-        _verbose_message('{}', message)
+        _bootstrap._verbose_message('{}', message)
         raise EOFError(message)
     if source_stats is not None:
         try:
@@ -466,7 +469,7 @@ def _validate_bytecode_header(data, source_stats=None, name=None, path=None):
         else:
             if _r_long(raw_timestamp) != source_mtime:
                 message = 'bytecode is stale for {!r}'.format(name)
-                _verbose_message('{}', message)
+                _bootstrap._verbose_message('{}', message)
                 raise ImportError(message, **exc_details)
         try:
             source_size = source_stats['size'] & 0xFFFFFFFF
@@ -483,7 +486,7 @@ def _compile_bytecode(data, name=None, bytecode_path=None, source_path=None):
     """Compile bytecode as returned by _validate_bytecode_header()."""
     code = marshal.loads(data)
     if isinstance(code, _code_type):
-        _verbose_message('code object from {!r}', bytecode_path)
+        _bootstrap._verbose_message('code object from {!r}', bytecode_path)
         if source_path is not None:
             _imp._fix_co_filename(code, source_path)
         return code
@@ -541,6 +544,8 @@ def spec_from_file_location(name, location=None, *, loader=None,
                 location = loader.get_filename(name)
             except ImportError:
                 pass
+    else:
+        location = _os.fspath(location)
 
     # If the location is on the filesystem, but doesn't actually exist,
     # we could return None here, indicating that the location is not
@@ -610,7 +615,7 @@ class WindowsRegistryFinder:
         else:
             registry_key = cls.REGISTRY_KEY
         key = registry_key.format(fullname=fullname,
-                                  sys_version=sys.version[:3])
+                                  sys_version='%d.%d' % sys.version_info[:2])
         try:
             with cls._open_registry(key) as hkey:
                 filepath = _winreg.QueryValue(hkey, '')
@@ -673,6 +678,7 @@ class _LoaderBasics:
         _bootstrap._call_with_frames_removed(exec, code, module.__dict__)
 
     def load_module(self, fullname):
+        """This module is deprecated."""
         return _bootstrap._load_module_shim(self, fullname)
 
 
@@ -766,21 +772,21 @@ class SourceLoader(_LoaderBasics):
                     except (ImportError, EOFError):
                         pass
                     else:
-                        _verbose_message('{} matches {}', bytecode_path,
-                                        source_path)
+                        _bootstrap._verbose_message('{} matches {}', bytecode_path,
+                                                    source_path)
                         return _compile_bytecode(bytes_data, name=fullname,
                                                  bytecode_path=bytecode_path,
                                                  source_path=source_path)
         source_bytes = self.get_data(source_path)
         code_object = self.source_to_code(source_bytes, source_path)
-        _verbose_message('code object from {}', source_path)
+        _bootstrap._verbose_message('code object from {}', source_path)
         if (not sys.dont_write_bytecode and bytecode_path is not None and
                 source_mtime is not None):
             data = _code_to_bytecode(code_object, source_mtime,
                     len(source_bytes))
             try:
                 self._cache_bytecode(source_path, bytecode_path, data)
-                _verbose_message('wrote {!r}', bytecode_path)
+                _bootstrap._verbose_message('wrote {!r}', bytecode_path)
             except NotImplementedError:
                 pass
         return code_object
@@ -860,14 +866,16 @@ class SourceFileLoader(FileLoader, SourceLoader):
             except OSError as exc:
                 # Could be a permission error, read-only filesystem: just forget
                 # about writing the data.
-                _verbose_message('could not create {!r}: {!r}', parent, exc)
+                _bootstrap._verbose_message('could not create {!r}: {!r}',
+                                            parent, exc)
                 return
         try:
             _write_atomic(path, data, _mode)
-            _verbose_message('created {!r}', path)
+            _bootstrap._verbose_message('created {!r}', path)
         except OSError as exc:
             # Same as above: just don't write the bytecode.
-            _verbose_message('could not create {!r}: {!r}', path, exc)
+            _bootstrap._verbose_message('could not create {!r}: {!r}', path,
+                                        exc)
 
 
 class SourcelessFileLoader(FileLoader, _LoaderBasics):
@@ -912,14 +920,14 @@ class ExtensionFileLoader(FileLoader, _LoaderBasics):
         """Create an unitialized extension module"""
         module = _bootstrap._call_with_frames_removed(
             _imp.create_dynamic, spec)
-        _verbose_message('extension module {!r} loaded from {!r}',
+        _bootstrap._verbose_message('extension module {!r} loaded from {!r}',
                          spec.name, self.path)
         return module
 
     def exec_module(self, module):
         """Initialize an extension module"""
         _bootstrap._call_with_frames_removed(_imp.exec_dynamic, module)
-        _verbose_message('extension module {!r} executed from {!r}',
+        _bootstrap._verbose_message('extension module {!r} executed from {!r}',
                          self.name, self.path)
 
     def is_package(self, fullname):
@@ -985,6 +993,9 @@ class _NamespacePath:
     def __iter__(self):
         return iter(self._recalculate())
 
+    def __setitem__(self, index, path):
+        self._path[index] = path
+
     def __len__(self):
         return len(self._recalculate())
 
@@ -1034,7 +1045,8 @@ class _NamespaceLoader:
 
         """
         # The import system never calls this method.
-        _verbose_message('namespace module loaded with path {!r}', self._path)
+        _bootstrap._verbose_message('namespace module loaded with path {!r}',
+                                    self._path)
         return _bootstrap._load_module_shim(self, fullname)
 
 
@@ -1054,11 +1066,7 @@ class PathFinder:
 
     @classmethod
     def _path_hooks(cls, path):
-        """Search sequence of hooks for a finder for 'path'.
-
-        If 'hooks' is false then use sys.path_hooks.
-
-        """
+        """Search sys.path_hooks for a finder for 'path'."""
         if sys.path_hooks is not None and not sys.path_hooks:
             _warnings.warn('sys.path_hooks is empty', ImportWarning)
         for hook in sys.path_hooks:
@@ -1140,8 +1148,10 @@ class PathFinder:
 
     @classmethod
     def find_spec(cls, fullname, path=None, target=None):
-        """find the module on sys.path or 'path' based on sys.path_hooks and
-        sys.path_importer_cache."""
+        """Try to find a spec for 'fullname' on sys.path or 'path'.
+
+        The search is based on sys.path_hooks and sys.path_importer_cache.
+        """
         if path is None:
             path = sys.path
         spec = cls._get_spec(fullname, path, target)
@@ -1221,8 +1231,10 @@ class FileFinder:
                                        submodule_search_locations=smsl)
 
     def find_spec(self, fullname, target=None):
-        """Try to find a spec for the specified module.  Returns the
-        matching spec, or None if not found."""
+        """Try to find a spec for the specified module.
+
+        Returns the matching spec, or None if not found.
+        """
         is_namespace = False
         tail_module = fullname.rpartition('.')[2]
         try:
@@ -1254,12 +1266,13 @@ class FileFinder:
         # Check for a file w/ a proper suffix exists.
         for suffix, loader_class in self._loaders:
             full_path = _path_join(self.path, tail_module + suffix)
-            _verbose_message('trying {}'.format(full_path), verbosity=2)
+            _bootstrap._verbose_message('trying {}', full_path, verbosity=2)
             if cache_module + suffix in cache:
                 if _path_isfile(full_path):
-                    return self._get_spec(loader_class, fullname, full_path, None, target)
+                    return self._get_spec(loader_class, fullname, full_path,
+                                          None, target)
         if is_namespace:
-            _verbose_message('possible namespace for {}'.format(base_path))
+            _bootstrap._verbose_message('possible namespace for {}', base_path)
             spec = _bootstrap.ModuleSpec(fullname, None)
             spec.submodule_search_locations = [base_path]
             return spec
@@ -1427,11 +1440,4 @@ def _install(_bootstrap_module):
     _setup(_bootstrap_module)
     supported_loaders = _get_supported_file_loaders()
     sys.path_hooks.extend([FileFinder.path_hook(*supported_loaders)])
-    if _os.__name__ == 'nt':
-        sys.meta_path.append(WindowsRegistryFinder)
     sys.meta_path.append(PathFinder)
-
-    # XXX We expose a couple of classes in _bootstrap for the sake of
-    # a setuptools bug (https://bitbucket.org/pypa/setuptools/issue/378).
-    _bootstrap_module.FileFinder = FileFinder
-    _bootstrap_module.SourceFileLoader = SourceFileLoader