diff --git a/Doc/library/netrc.rst b/Doc/library/netrc.rst
@@ -18,7 +18,7 @@ the Unix :program:`ftp` program and other FTP clients.
 
 .. class:: netrc([file])
 
-   A :class:`~netrc.netrc` instance or subclass instance encapsulates data from  a netrc
+   A :class:`~netrc.netrc` instance or subclass instance encapsulates data from a netrc
    file.  The initialization argument, if present, specifies the file to parse.  If
    no argument is given, the file :file:`.netrc` in the user's home directory will
    be read.  Parse errors will raise :exc:`NetrcParseError` with diagnostic
@@ -32,6 +32,12 @@ the Unix :program:`ftp` program and other FTP clients.
 
    .. versionchanged:: 3.4 Added the POSIX permission check.
 
+   .. versionchanged:: 3.7
+      The entry in the netrc file no longer needs to contain all tokens.  The missing
+      tokens' value default to an empty string.  All the tokens and their values now
+      can contain arbitrary characters, like whitespace and non-ASCII characters.
+      If the login name is anonymous, it won't trigger the security check.
+
 
 .. exception:: NetrcParseError
 
@@ -75,11 +81,3 @@ Instances of :class:`~netrc.netrc` have public instance variables:
 .. attribute:: netrc.macros
 
    Dictionary mapping macro names to string lists.
-
-.. note::
-
-   Passwords are limited to a subset of the ASCII character set.  All ASCII
-   punctuation is allowed in passwords, however, note that whitespace and
-   non-printable characters are not allowed in passwords.  This is a limitation
-   of the way the .netrc file is parsed and may be removed in the future.
-
diff --git a/Lib/netrc.py b/Lib/netrc.py
@@ -19,6 +19,51 @@ def __str__(self):
         return "%s (%s, line %s)" % (self.msg, self.filename, self.lineno)
 
 
+class _netrclex:
+    def __init__(self, fp):
+        self.lineno = 1
+        self.instream = fp
+        self.whitespace = "\n\t\r "
+        self._stack = []
+
+    def _read_char(self):
+        ch = self.instream.read(1)
+        if ch == "\n":
+            self.lineno += 1
+        return ch
+
+    def get_token(self):
+        if self._stack:
+            return self._stack.pop(0)
+        token = ""
+        fiter = iter(self._read_char, "")
+        for ch in fiter:
+            if ch in self.whitespace:
+                continue
+            if ch == "\"":
+                for ch in fiter:
+                    if ch != "\"":
+                        if ch == "\\":
+                            ch = self._read_char()
+                        token += ch
+                        continue
+                    return token
+            else:
+                if ch == "\\":
+                    ch = self._read_char()
+                token += ch
+                for ch in fiter:
+                    if ch not in self.whitespace:
+                        if ch == "\\":
+                            ch = self._read_char()
+                        token += ch
+                        continue
+                    return token
+        return token
+
+    def push_token(self, token):
+        self._stack.append(token)
+
 class netrc:
     def __init__(self, file=None):
         default_netrc = file is None
@@ -33,61 +78,61 @@ def __init__(self, file=None):
             self._parse(file, fp, default_netrc)
 
     def _parse(self, file, fp, default_netrc):
-        lexer = shlex.shlex(fp)
-        lexer.wordchars += r"""!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""
-        lexer.commenters = lexer.commenters.replace('#', '')
+        lexer = _netrclex(fp)
         while 1:
             # Look for a machine, default, or macdef top-level keyword
-            saved_lineno = lexer.lineno
-            toplevel = tt = lexer.get_token()
+            prev_lineno = lexer.lineno
+            tt = lexer.get_token()
             if not tt:
                 break
             elif tt[0] == '#':
-                if lexer.lineno == saved_lineno and len(tt) == 1:
+                if prev_lineno == lexer.lineno:
                     lexer.instream.readline()
                 continue
             elif tt == 'machine':
                 entryname = lexer.get_token()
             elif tt == 'default':
                 entryname = 'default'
-            elif tt == 'macdef':                # Just skip to end of macdefs
+            elif tt == 'macdef':
                 entryname = lexer.get_token()
                 self.macros[entryname] = []
-                lexer.whitespace = ' \t'
                 while 1:
                     line = lexer.instream.readline()
-                    if not line or line == '\012':
-                        lexer.whitespace = ' \t\r\n'
+                    if not line:
+                        raise NetrcParseError(
+                            "Macro definition missing null line terminator.",
+                            file, lexer.lineno)
+                    if line == '\n':
                         break
                     self.macros[entryname].append(line)
                 continue
             else:
                 raise NetrcParseError(
                     "bad toplevel token %r" % tt, file, lexer.lineno)
 
+            if not entryname:
+                raise NetrcParseError("missing %r name" % tt, file, lexer.lineno)
+
             # We're looking at start of an entry for a named machine or default.
-            login = ''
-            account = password = None
+            login = account = password = ''
             self.hosts[entryname] = {}
             while 1:
+                prev_lineno = lexer.lineno
                 tt = lexer.get_token()
-                if (tt.startswith('#') or
-                    tt in {'', 'machine', 'default', 'macdef'}):
-                    if password:
-                        self.hosts[entryname] = (login, account, password)
-                        lexer.push_token(tt)
-                        break
-                    else:
-                        raise NetrcParseError(
-                            "malformed %s entry %s terminated by %s"
-                            % (toplevel, entryname, repr(tt)),
-                            file, lexer.lineno)
+                if tt.startswith('#'):
+                    if lexer.lineno == prev_lineno:
+                        lexer.instream.readline()
+                    continue
+                if tt in {'', 'machine', 'default', 'macdef'}:
+                    self.hosts[entryname] = (login, account, password)
+                    lexer.push_token(tt)
+                    break
                 elif tt == 'login' or tt == 'user':
                     login = lexer.get_token()
                 elif tt == 'account':
                     account = lexer.get_token()
                 elif tt == 'password':
-                    if os.name == 'posix' and default_netrc:
+                    if os.name == 'posix' and default_netrc and login != "anonymous":
                         prop = os.fstat(fp.fileno())
                         if prop.st_uid != os.getuid():
                             import pwd
@@ -127,10 +172,10 @@ def __repr__(self):
         rep = ""
         for host in self.hosts.keys():
             attrs = self.hosts[host]
-            rep = rep + "machine "+ host + "\n\tlogin " + repr(attrs[0]) + "\n"
+            rep = rep + "machine "+ host + "\n\tlogin " + attrs[0] + "\n"
             if attrs[1]:
-                rep = rep + "account " + repr(attrs[1])
-            rep = rep + "\tpassword " + repr(attrs[2]) + "\n"
+                rep = rep + "account " + attrs[1]
+            rep = rep + "\tpassword " + attrs[2] + "\n"
         for macro in self.macros.keys():
             rep = rep + "macdef " + macro + "\n"
             for line in self.macros[macro]: