XML Schema for OVAL v1.1

classic Classic list List threaded Threaded
1 message Options
Reply | Threaded
Open this post in threaded view
|

XML Schema for OVAL v1.1

David Proulx-2
Hello all,

Nothing shows you how bad a perfect Schema is faster than a user trying
to incorporate it.  After releasing v1.0, we started building a tool to
use the new Schema, and found a number of problems.  As a result, I've
made the following changes:

- Moved assertions and bindings outside of the query definition.
- Removed/restructured <vulnerability_description>.
- Removed absolute reference requirement for elements and attributes
since we're using a single namespace.
- Changed <column> to <column_name> in <assertion>
- Changed <value> to <operand> in <assertion>
- Changed oval:type attribute to oval:data_type
- Converted references to integers, dropped "assertion_" and "binding_"
prefix from assertion and assertion_binding id's
- Collapsed references into a single <reference> tag with an integer
equal to a binding or assertion id, and two attributes:
        - reference_type - can either be "assertion", or "binding"
        - operator - bind this reference to previous references
- Added optional <comment> tag to assertions
- Changed <result> tag result_type attributes to include ability to
reference an assertion


I've also included updated versions of the Schema, OVAL96 marked in XML,
XML to OVAL HTML table stylesheet, and the resultant HTML table.

As always, if you have any comments or questions, please feel free to
send them along.  Now to start working on XML-izing the existing queries
again.

Thanks.
Dave.


--
David Proulx
The MITRE Corp.
[hidden email]


  2:53 p.m. A copy of the town bylaw was given to a Bedford
  Road homeowner who was in apparent violation of a town
  regulation about moving soil.


<xs:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" targetNamespace="http://oval.mitre.org/XML" xmlns:oval="http://oval.mitre.org/XML">

        <xs:annotation>
                <xs:documentation xml:language="en">
                XML Schema for encoding Open Vulnerability Assessment Language (OVAL) definitions.  The <a href="http://oval.mitre.org/XML/oval.xs">OVAL Schema</a> is developed and maintained by the Mitre Corporation.
        </xs:documentation>
                <xs:appinfo>
                        <schema>OVAL</schema>
                        <version>1.1</version>
                        <date>22 July 2003</date>
                </xs:appinfo>
        </xs:annotation>


<!--
        =====================================================================

        Change Log:

        v1.1
        - Moved assertions and bindings outside of the query definition.
        - Removed/restructured <vulnerability_description>.
        - Removed absolute reference requirement for elements and attributes since we're
          using a single namespace.
        - Changed <column> to <column_name> in <assertion>
        - Changed <value> to <operand> in <assertion>
        - Changed oval:type attribute to oval:data_type
        - Converted references to integers, dropped "assertion_" and "binding_" prefix from
          assertion and assertion_binding id's
        - Collapsed references into a single <reference> tag with an integer equal to a
          binding or assertion id, and two attributes:
                - operator - the operator binding this reference to previous references
                - reference_type - can either be "assertion", or "binding"
        - Added optional <comment> tag to assertions
        - Changed <result> tag result_type attributes to include ability to reference an
          assertion


        Schema Description:
       
        The following is an outline of a typical OVAL.xml file:
       
        <oval:oval_queries>
                <query id="OVAL0">
                        <header>
                                <date_modified>2003-07-22</date_modified>
                                <description>Example OVAL Query</description>
                                <platforms>
                                        <name>platform A</name>
                                        .
                                        .
                                        .
                                        <name>platform Z</name>
                                </platforms>
                                <products>
                                        <name>product A</name>
                                        .
                                        .
                                        .
                                        <name>product Z</name>
                                </products>
                                <query_version>1</query_version>
                                <status>ACCEPTED</status>
                                <schema_version>1<schema_version>

                                [<cveid>CVE-2000-0000</cveid>]
                                [<summary>Vulnerable vulnerability</summary>]
                        </header>
                        <definition>
                                [<comment>Definition for OVAL0</comment>]
                                <result data_type="string">CVE-2000-0000</result>
                                <table_name>Placeholder</table_name>

                                <reference [operator="EXISTS"] reference_type="binding">1</reference>>
                                .
                                .
                                .
                                <reference [operator="AND EXISTS"] reference_type="binding">100</reference>>
                        </definition>
                </query>
                .
                .
                .
                <query id="OVAL00>
                ...
                </query>
               
               
                <assertion id="1">
                        [<comment>Patch file A test</comment>]
                        <column>file_name</column>
                        <operator>EQ</operator>

                        <operand data_type="string">/patched/file/name</operand>
                        OR
                        <reference [operator="AND"] reference_type="binding">1</reference>
                        OR
                        <set>
                                <set_element data_type="string">element_1</set_element>
                                .
                                .
                                .
                                <set_element data_type="string">element_100</set_element>
                        </set>
                </assertion>
                .
                .
                .
                <assertion id="100">
                ...
                </assertion>
               
               
                <assertion_binding id="1" [vulnerable="software"]>
                        [<comment>Vulnerable program A</comment>]
                        [<result type="string">Unpatched program A</result>]
                        [<table_name>Program_Patches</table_name>]
                       
                        <reference [operator="AND"] reference_type="assertion">1</reference>
                        .
                        .
                        .
                        <reference [operator="AND"] reference_type="assertion">100</reference>
                </assertion_binding>
                .
                .
                .
                <assertion_binding id="100" [vulnerable="configuration"]>
                ...
                </assertion_binding>
               
        </oval_queries>


        The top-level <oval_queries> tag, contains three elements - all of which can appear an unbounded number of times,
        <query>, <assertion>, and <assertion_binding>.
       
        The <query> tag represents an individual OVAL query, and contains a <header> tag, and a <definition> tag.  The <header> tag is a
        container for various meta-data associated with the query.  The <definition> tag defines all of the query elements.  An OVAL query
        is composed of a number of sub-queries.  Each of these sub-queries identifies a system configuration parameter involved in describing
        a vulnerability.

        In many cases, elements of a sub-query, or an entire sub-query appear in multiple OVAL queries.  The Schema has
        been designed to take advantage of this fact by structuring the data into reusable packets.  At the lowest level,
        each condition statment within each WHERE clause in the query is represented as an <assertion>.  Assertions are grouped
        into sub-queries through an <assertion_binding>.  Finally, the assertion bindings are grouped into a complete OVAL Query
        in the <definition> tag.  At each stage, the elements are assigned a unique identifier, allowing them to be
        referenced from multiple sources.

        The goal of this modular design is to ease the creation, storage, implementation, and manipulation of the data contained
        within an OVAL Query, while maintaining the integrity of that data.

        =====================================================================
-->


<!--  Top level element bounding all of the query definitions  -->

        <xs:element name="oval_queries">
                <xs:complexType>
                        <xs:sequence>
                                <xs:element name="query" type="oval:query" maxOccurs="unbounded"/>
                                <xs:element name="assertion" type="oval:assertion" minOccurs="0" maxOccurs="unbounded"/>
                                <xs:element name="assertion_binding" type="oval:assertion_binding" minOccurs="0" maxOccurs="unbounded"/>
                        </xs:sequence>
                </xs:complexType>
        </xs:element>


<!-- =========================== Simple Types =========================== -->


<!--
        Define acceptable CVE names

        A 'CAN' or 'CVE' string, followed by two strings of four digits
        each, and each string separated by a dash.

-->
        <xs:simpleType name="cve_name">
                <xs:restriction base="xs:string">
                        <xs:pattern value="CAN|CVE-\d\d\d\d-\d\d\d\d"/>
                </xs:restriction>
        </xs:simpleType>


<!--
        Define acceptable data types

        The data type parameter is used primarily to define the type of
        a value used within an assertion.  Currrently, the only two
        types in use are integers and strings.  Other types may be
        added as the need arises.

-->
        <xs:simpleType name="data_type">
                <xs:union memberTypes="xs:integer xs:string"/>
        </xs:simpleType>


<!--
        Define acceptable operators

        Some of the operators are SQL specific, while others are more
        generic.  For the most part, their names should be self explainatory.
        We've chosen these names instead of symbols, since the meaning of a symbol can
        differ according to the data type of the elements being operated on, and the
        language processing them.

-->
        <xs:simpleType name="operator">
                <xs:restriction base="xs:string">
                        <xs:enumeration value="AND"/>
                        <xs:enumeration value="AND EXISTS"/>
                        <xs:enumeration value="AND NOT EXISTS"/>
                        <xs:enumeration value="CONCAT"/>
                        <xs:enumeration value="EQ"/>
                        <xs:enumeration value="EXISTS"/>
                        <xs:enumeration value="IN"/>
                        <xs:enumeration value="GT"/>
                        <xs:enumeration value="LIKE"/>
                        <xs:enumeration value="LT"/>
                        <xs:enumeration value="NE"/>
                        <xs:enumeration value="OR"/>
                </xs:restriction>
        </xs:simpleType>


<!--
        Define acceptable OVAL names

        The string 'OVAL', followed by some number of digits.

-->
        <xs:simpleType name="oval_name">
                <xs:restriction base="xs:string">
                        <xs:pattern value="OVAL\d+"/>
                </xs:restriction>
        </xs:simpleType>


<!--
        Define acceptable OVAL status values

        OVAL queries can exist in three possible states; DRAFT,
        INTERIM, and ACCEPTED.

-->
        <xs:simpleType name="status">
                <xs:restriction base="xs:string">
                        <xs:enumeration value="DRAFT"/>
                        <xs:enumeration value="INTERIM"/>
                        <xs:enumeration value="ACCEPTED"/>
                </xs:restriction>
        </xs:simpleType>


<!-- =========================== Complex Types =========================== -->


<!--
        Define the structure of the <assertion> tag

        <assertion id="y">
                [<comment>assertion comment</comment>]
                <column_name>column name</column_name>
                <operator>oval:operator</operator>

                <operand>oval:operand</operand>
                OR
                <reference>oval:reference</reference>
                OR
                <set>oval:set</set>

        </assertion>

        The <column_name> tag refers to the name of a column within the OVAL
        Schema against which the assertion is being made.

        The <operator> tag defines the conditional operator that is to
        be used in this assertion.

        The right-hand side of the operator can be one of three possible
        elements:
                <operand> - A simple integer or string
                <reference> - Represents the beginning of a new sub-query
                <set> - Perform the operation against a group of elements

        Each assertion contains a required 'id' attribute. This unique
        identifier provides resuability by allowing a single assertion
        to be referred to over and over again.

-->
        <xs:complexType name="assertion">
                <xs:sequence>
                        <xs:element name="comment" type="oval:data_type" minOccurs="0"/>  <!-- optional -->
                        <xs:element name="column_name" type="xs:string"/>
                        <xs:element name="operator" type="oval:operator"/>
               
                        <xs:choice>
                                <xs:element name="operand" type="oval:operand"/>
                                <xs:element name="reference" type="oval:reference"/>
                                <xs:element name="set" type="oval:set"/>
                        </xs:choice>
                </xs:sequence>
       
                <xs:attribute name="id" type="xs:integer" use="required"/>
        </xs:complexType>


<!--
        Define the structure of the <assertion_binding> tag

        <assertion_binding id="y" [vulnerable="configuration|software"]>
                [<comment>binding description</comment>]
                [<result>oval:result</result>]
                [<table_name>OVAL table name</table_name>]
                <reference>oval:reference</reference>
                ...
        </assertion_binding>

        The optional <comment> tag provides a description of this binding.

        The optional <result> tag represents the value generated by a
        successful execution of the SQL statement being defined by the binding.

        The optional <table_name> tag defines the table being referenced
        in the SQL statement for this binding.

        The <reference> tag is unbounded.  Each reference defines an assertion
        or another assertion_binding incorporated into this binding.

        Each assertion_binding contains a required 'id' attribute. This
        unique identifier provides resuability by allowing a single binding
        to be referred to over and over again.

        Assertion bindings may also contain an optional 'vulnerable'
        attribute.  The purpose of this attribute is to identify the nature
        of the vulnerability indicator being defined by this SQL statement.
        The accepted values in this attribute are 'configuration' to
        represent an insecure configuration parameter, or 'software' to
        represent flawed software.

-->
        <xs:complexType name="assertion_binding">
                <xs:sequence>
                        <xs:element name="comment" type="xs:string" minOccurs="0"/>     <!-- optional -->
                        <xs:element name="result" type="oval:result" minOccurs="0"/>    <!-- optional -->
                        <xs:element name="table_name" type="xs:string" minOccurs="0"/>  <!-- optional -->
                        <xs:element name="reference" type="oval:reference" maxOccurs="unbounded"/>
                </xs:sequence>
       
                <xs:attribute name="id" type="xs:integer" use="required"/>
       
                <xs:attribute name="vulnerable" use="optional">
                        <xs:simpleType>
                                <xs:restriction base="xs:string">
                                        <xs:enumeration value="configuration"/>
                                        <xs:enumeration value="software"/>
                                </xs:restriction>
                        </xs:simpleType>
                </xs:attribute>
        </xs:complexType>


<!--
        Define the structure of the <definition> tag

        <definition id="oval:oval_name">
                [<comment>OVAL query description</comment>]
                <result>oval:result</result>
                <table_name>OVAL table name</table_name>
                <reference>oval:reference</reference>
                ...
        </definition>

        The <definition> is, in essence, the top-level assertion_binding.  It ties together some
        set of the bindings and assertions to represent a single OVAL query.  The only difference being,
        unlike an assertion_binding, the result and table_name elements are required.

-->
        <xs:complexType name="definition">
                <xs:sequence>
                        <xs:element name="comment" type="xs:string" minOccurs="0"/>  <!-- optional -->
                        <xs:element name="result" type="oval:result"/>
                        <xs:element name="table_name" type="xs:string"/>
                        <xs:element name="reference" type="oval:reference" maxOccurs="unbounded"/>
                </xs:sequence>

        </xs:complexType>


<!--
        Define the structure of the <header> tag
       
        <header>
                <date_modified>query modification date</date_modified>
                <description>vulnerability description</description>
                <platforms>oval:platforms</platforms>
                <products>oval:products</products>
                <query_version>version of query</query_version>
                <status>oval:status</status>
                <schema_version>version of schema<schema_version>
               
                [<cveid>CVE-2000-0000</cveid>]
                [<summary>Vulnerable vulnerability</summary>]
        </header>
       
        For each query, there is some amount of meta information associated with it.  The <header> serves
        as the container for this information.
-->

        <xs:complexType name="header">
                <xs:sequence>
                        <!-- Required elements -->
                        <xs:element name="date_modified" type="xs:date"/>
                        <xs:element name="description" type="xs:string"/>
                        <xs:element name="platforms" type="oval:platforms"/>
                        <xs:element name="products" type="oval:products"/>
                        <xs:element name="query_version" type="xs:integer"/>
                        <xs:element name="status" type="oval:status"/>
                        <xs:element name="schema_version" type="xs:integer"/>

                        <!-- Optional elements -->
                        <xs:element name="cveid" type="oval:cve_name" minOccurs="0"/>
                        <xs:element name="summary" type="xs:string" minOccurs="0"/>
                </xs:sequence>
        </xs:complexType>


<!--
        Define the structure of the <operand> tag

        <operand type="int|string">assertion operand</operand>

        The <operand> tag represents a single element being acted upon within
        an assertion.  Values are assigned a data type, which is restricted
        to integers and strings.

-->
        <xs:complexType name="operand">
                <xs:simpleContent>
                        <xs:extension base="oval:data_type">
                                <xs:attribute name="data_type" use="required">
                                        <xs:simpleType>
                                                <xs:restriction base="xs:string">
                                                        <xs:enumeration value="int"/>
                                                        <xs:enumeration value="string"/>
                                                </xs:restriction>
                                        </xs:simpleType>
                                </xs:attribute>
                        </xs:extension>
                </xs:simpleContent>

        </xs:complexType>


<!--
        Define the structure of the <platforms> tag

        <platforms>
                <name>platform_1</name>
                ...
                <name>platform_n</name>
        </platforms>

        The <platforms> tag defines the operating system versions to which
        this OVAL query applies.

-->
        <xs:complexType name="platforms">
                <xs:sequence>
                        <xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
                </xs:sequence>
        </xs:complexType>


<!--
        Define the structure of the <products> tag

        <products>
                <name>product_1</name>
                ...
                <name>product_n</name>
        </products>

        The <products> tag defines the software packages to which this
        OVAL query applies.

-->
        <xs:complexType name="products">
                <xs:sequence>
                        <xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
                </xs:sequence>
        </xs:complexType>


<!--
        Define structure of the <query> tag
       
        <query id="oval:oval_name">
                <header>oval:header</header>
                <definition>oval:definition</definition>
        </query>
       
        The <query> tag bounds the meta-data and definition for an individual OVAL Query.
        The query 'id' is the OVAL-id of the OVAL Query it represents.
-->
        <xs:complexType name="query">
                <xs:sequence>
                        <xs:element name="header"/>
                        <xs:element name="definition" type="oval:definition"/>
                </xs:sequence>
       
                <xs:attribute name="id" type="oval:oval_name" use="required"/>
        </xs:complexType>


<!--
        Define the structure of the <reference> tag

        <reference [operator="oval:operator"] reference_type="assertion|binding">x</reference>

        The <reference> tag allows assertions and bindings to be bound together
        through their 'id' attributes.  The optional operator attribute provides this binding.
        The reference_type attribute defines which kind of element is being referenced,
        assertion or binding, while the value of the reference provides to the id to the referred
        element.

-->
        <xs:complexType name="reference">
                <xs:simpleContent>
                        <xs:extension base="xs:integer">
                                <xs:attribute name="operator" type="oval:operator" use="optional"/>
                       
                                <xs:attribute name="reference_type" use="required">
                                        <xs:simpleType>
                                                <xs:restriction base="xs:string">
                                                        <xs:enumeration value="assertion"/>
                                                        <xs:enumeration value="binding"/>
                                                </xs:restriction>
                                        </xs:simpleType>
                                </xs:attribute>
                        </xs:extension>
                </xs:simpleContent>
        </xs:complexType>


<!--
        Define the structure of the <result> tag

        <result type="assertion|string">SQL statment output</result>

        The <result> tag represents the value generated by the successful
        execution of a SQL statement.  Successful meaning that the conditions
        of the SQL statement were met.  In most cases, OVAL is not concerned
        with the actual value of the result, but just the success or failure
        of the statment.  In these cases, the result is normally a static
        string, and the result_type attribute is set to 'string'.
       
        For more advanced cases, where the actual query results are required,
        concatenation being a primary example, the result can reference an assertion
        by setting the result value to an assertion id, and the result_type to "assertion".
        In this case, all of the elements of the assertion comprise the result string.

-->
        <xs:complexType name="result">
                <xs:simpleContent>
                        <xs:extension base="oval:data_type">
                                <xs:attribute name="result_type" use="required">
                                        <xs:simpleType>
                                                <xs:restriction base="xs:string">
                                                        <xs:enumeration value="assertion"/>
                                                        <xs:enumeration value="string"/>
                                                </xs:restriction>
                                        </xs:simpleType>
                                </xs:attribute>
                        </xs:extension>
                </xs:simpleContent>
        </xs:complexType>


<!--
        Define the structure of the <set> tag

        <set>
                <set_element type="int|string">element_1</set_element>
                ...
                <set_element type="int|string">element_n</set_element>
        </set>

        The <set> tag is used to represent a group of elements to be acted
        upon in an assertion.  The most common need for the <set> tag is
        when the IN operator is being used to test for the existence of
        a single element within the set.

-->
        <xs:complexType name="set">
                <xs:sequence>
                        <xs:element name="set_element" maxOccurs="unbounded">
                                <xs:complexType>
                                        <xs:simpleContent>
                                                <xs:extension base="oval:data_type">
                                                        <xs:attribute name="data_type" use="required">
                                                                <xs:simpleType>
                                                                        <xs:restriction base="xs:string">
                                                                                <xs:enumeration value="int"/>
                                                                                <xs:enumeration value="string"/>
                                                                        </xs:restriction>
                                                                </xs:simpleType>
                                                        </xs:attribute>
                                                </xs:extension>
                                        </xs:simpleContent>
                                </xs:complexType>
                        </xs:element>
                </xs:sequence>
        </xs:complexType>


</xs:schema>

<?xml version="1.0" encoding="UTF-8"?>

<oval:oval_queries xmlns:oval="http://oval.mitre.org/XML" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://oval.mitre.org/XML http://oval.mitre.org/XML/oval.xs">

        <query id="OVAL96">
                <header>
                        <date_modified>2003-05-20</date_modified>
                        <description>
                                The zone determination function in Microsoft Internet Explorer 5.5
                                and 6.0 allows remote attackers to run scripts in the Local Computer
                                zone by embedding the script in a cookie, aka the "Cookie-based
                                Script Execution" vulnerability.
                        </description>
                        <platforms>
                                <name>Windows 2000</name>
                        </platforms>
                        <products>
                                <name>Internet Explorer 6.0</name>
                        </products>
                        <query_version>2</query_version>
                        <status>ACCEPTED</status>
                        <schema_version>1</schema_version>
                       
                        <cveid>CVE-2002-0078</cveid>
                        <summary>CVE-2002-0078</summary>
                </header>
               
                <definition>
                        <result result_type="string">CVE-2002-0078</result>
                        <table_name>Placeholder</table_name>
                       
                        <reference operator="EXISTS" reference_type="binding">1</reference>
                        <reference operator="AND EXISTS" reference_type="binding">7</reference>
                        <reference operator="AND NOT EXISTS" reference_type="binding">8</reference>
                        <reference operator="AND NOT EXISTS" reference_type="binding">9</reference>
                        <reference operator="AND NOT EXISTS" reference_type="binding">10</reference>
                        <reference operator="AND NOT EXISTS" reference_type="binding">11</reference>
                        <reference operator="AND NOT EXISTS" reference_type="binding">12</reference>
                        <reference operator="AND NOT EXISTS" reference_type="binding">13</reference>
                        <reference operator="AND EXISTS" reference_type="binding">16</reference>
                </definition>
        </query>


        <!-- Assertions -->
       
        <assertion id="1">
                <column_name>RegistryKey</column_name>
                <operator>EQ</operator>
                <operand data_type="string">HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer</operand>
        </assertion>
       
        <assertion id="2">
                <column_name>EntryName</column_name>
                <operator>EQ</operator>
                <operand data_type="string">Version</operand>
        </assertion>
       
        <assertion id="3">
                <column_name>EntryValue</column_name>
                <operator>EQ</operator>
                <operand data_type="string">6.00.2600.0000</operand>
        </assertion>
       
        <assertion id="4">
                <column_name>FilePath</column_name>
                <operator>EQ</operator>
                <reference reference_type="binding">6</reference>
        </assertion>
       
        <assertion id="5">
                <column_name>RegistryKey</column_name>
                <operator>EQ</operator>
                <operand data_type="string">HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion</operand>
        </assertion>
       
        <assertion id="6">
                <column_name>EntryName</column_name>
                <operator>EQ</operator>
                <operand data_type="string">SystemRoot</operand>
        </assertion>
       
        <assertion id="7">
                <column_name>Version1</column_name>
                <operator>LT</operator>
                <operand data_type="int">6</operand>
        </assertion>
       
        <assertion id="8">
                <column_name>Version1</column_name>
                <operator>EQ</operator>
                <operand data_type="int">6</operand>
        </assertion>
       
        <assertion id="9">
                <column_name>Version2</column_name>
                <operator>EQ</operator>
                <operand data_type="int">0</operand>
        </assertion>
       
        <assertion id="10">
                <column_name>Version3</column_name>
                <operator>LT</operator>
                <operand data_type="int">2715</operand>
        </assertion>
       
        <assertion id="11">
                <column_name>Version3</column_name>
                <operator>EQ</operator>
                <operand data_type="int">2715</operand>
        </assertion>
       
        <assertion id="12">
                <column_name>Version4</column_name>
                <operator>LT</operator>
                <operand data_type="int">400</operand>
        </assertion>
       
        <assertion id="13">
                <column_name>RegistryKey</column_name>
                <operator>EQ</operator>
                <operand data_type="string">HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{2D5974C5-5185-4f5b-80B6-28015ACDD74C}</operand>
        </assertion>
       
        <assertion id="14">
                <column_name>EntryName</column_name>
                <operator>EQ</operator>
                <operand data_type="string">IsInstalled</operand>
        </assertion>
       
        <assertion id="15">
                <column_name>EntryValue</column_name>
                <operator>EQ</operator>
                <operand data_type="string">1</operand>
        </assertion>
       
        <assertion id="16">
                <column_name>RegistryKey</column_name>
                <operator>EQ</operator>
                <operand data_type="string">HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{D7B44F3E-77D3-44C5-8E03-4222D9A18B7B}</operand>
        </assertion>
       
        <assertion id="17">
                <column_name>RegistryKey</column_name>
                <operator>EQ</operator>
                <operand data_type="string">HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{61E6EAE5-7821-4AC1-9BBD-AED032A8E273}</operand>
        </assertion>
       
        <assertion id="18">
                <column_name>RegistryKey</column_name>
                <operator>EQ</operator>
                <operand data_type="string">HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{FF4DD9CD-F25E-425a-8B5C-A2D062781FBB}</operand>
        </assertion>
       
        <assertion id="19">
                <column_name>RegistryKey</column_name>
                <operator>EQ</operator>
                <operand data_type="string">HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{2757B1D6-0367-4663-877C-93ECC5C01BF6}</operand>
        </assertion>
       
        <assertion id="20">
                <column_name>RegistryKey</column_name>
                <operator>EQ</operator>
                <operand data_type="string">HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{C34F4917-ED43-439f-9023-97B0024A2B3B}</operand>
        </assertion>
       
        <assertion id="21">
                <column_name>RegistryKey</column_name>
                <operator>EQ</operator>
                <operand data_type="string">HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\CurrentVersion\Internet Settings</operand>
        </assertion>
       
        <assertion id="22">
                <column_name>EntryName</column_name>
                <operator>EQ</operator>
                <operand data_type="string">Security_HKLM_only</operand>
        </assertion>
       
        <assertion id="23">
                <column_name>RegistryKey</column_name>
                <operator>IN</operator>
                <set>
                        <set_element data_type="string">HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\0</set_element>
                        <set_element data_type="string">HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\1</set_element>
                        <set_element data_type="string">HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\2</set_element>
                        <set_element data_type="string">HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\3</set_element>
                        <set_element data_type="string">HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\4</set_element>
                </set>
        </assertion>
       
        <assertion id="24">
                <column_name>EntryName</column_name>
                <operator>IN</operator>
                <set>
                        <set_element data_type="string">1A02</set_element>
                        <set_element data_type="string">1A03</set_element>
                </set>
        </assertion>
       
        <assertion id="25">
                <column_name>EntryValue</column_name>
                <operator>NE</operator>
                <operand data_type="string">3</operand>
        </assertion>
       
        <assertion id="26">
                <column_name>EntryValue</column_name>
                <operator>CONCAT</operator>
                <operand data_type="string">\System32\mshtml.dll</operand>
        </assertion>
       
        <!-- Assertion Binding Statements -->
       
        <assertion_binding id="1" vulnerable="software">
                <comment>Internet Explorer 6.0</comment>
                <result result_type="string">Internet Explorer 6.0 Installed</result>
                <table_name>Win2K_RegistryKeys</table_name>
               
                <reference reference_type="assertion">1</reference>
                <reference operator="AND" reference_type="assertion">2</reference>
                <reference operator="AND" reference_type="assertion">3</reference>
        </assertion_binding>
       
        <assertion_binding id="2">
                <reference reference_type="assertion">7</reference>
        </assertion_binding>
       
        <assertion_binding id="3">
                <reference reference_type="assertion">8</reference>
                <reference operator="AND" reference_type="assertion">9</reference>
                <reference operator="AND" reference_type="assertion">10</reference>
        </assertion_binding>
       
        <assertion_binding id="4">
                <reference reference_type="assertion">8</reference>
                <reference operator="AND" reference_type="assertion">9</reference>
                <reference operator="AND" reference_type="assertion">11</reference>
                <reference operator="AND" reference_type="assertion">12</reference>
        </assertion_binding>
       
        <assertion_binding id="5">
                <reference reference_type="binding">2</reference>
                <reference operator="OR" reference_type="binding">3</reference>
                <reference operator="OR" reference_type="binding">4</reference>
        </assertion_binding>
       
        <assertion_binding id="6">
                <result result_type="assertion">26</result>
                <table_name>Win2K_RegistryKeys</table_name>
               
                <reference reference_type="assertion">5</reference>
                <reference operator="AND" reference_type="assertion">6</reference>
        </assertion_binding>
       
        <assertion_binding id="7" vulnerable="software">
                <comment>Affected mshtml.dll versions</comment>
                <result result_type="string">File %windir%\System32\inetsrv\mshtml.dll &lt; 6.0.2715.400</result>
                <table_name>Win2K_FileAttributes</table_name>
               
                <reference reference_type="assertion">4</reference>
                <reference operator="AND" reference_type="binding">5</reference>
        </assertion_binding>
       
        <assertion_binding id="8" vulnerable="software">
                <comment>Patch Q319282.exe Installed</comment>
                <result result_type="string">Patch Q319282 Installed</result>
                <table_name>Win2K_RegistryKeys</table_name>
                       
                <reference reference_type="assertion">13</reference>
                <reference operator="AND" reference_type="assertion">14</reference>
                <reference operator="AND" reference_type="assertion">15</reference>
        </assertion_binding>
       
        <assertion_binding id="9" vulnerable="software">
                <comment>Patch Q321232.exe (cumulative patch from MS02-023) installed</comment>
                <result result_type="string">Patch Q321232 Installed</result>
                <table_name>Win2K_RegistryKeys</table_name>
                       
                <reference reference_type="assertion">16</reference>
                <reference operator="AND" reference_type="assertion">14</reference>
                <reference operator="AND" reference_type="assertion">15</reference>
        </assertion_binding>
       
        <assertion_binding id="10" vulnerable="software">
                <comment>Patch Q323759.exe (cumulative patch from MS02-047) installed</comment>
                <result result_type="string">Patch Q323759 Installed</result>
                <table_name>Win2K_RegistryKeys</table_name>
                       
                <reference reference_type="assertion">17</reference>
                <reference operator="AND" reference_type="assertion">14</reference>
                <reference operator="AND" reference_type="assertion">15</reference>
        </assertion_binding>
       
        <assertion_binding id="11" vulnerable="software">
                <comment>Patch Q328970.exe (cumulative patch from MS02-066) installed</comment>
                <result result_type="string">Patch Q328970 Installed</result>
                <table_name>Win2K_RegistryKeys</table_name>
                       
                <reference reference_type="assertion">18</reference>
                <reference operator="AND" reference_type="assertion">14</reference>
                <reference operator="AND" reference_type="assertion">15</reference>
        </assertion_binding>
       
        <assertion_binding id="12" vulnerable="software">
                <comment>Patch Q324929.exe (cumulative patch from MS02-068) installed</comment>
                <result result_type="string">Patch Q324929 Installed</result>
                <table_name>Win2K_RegistryKeys</table_name>
                       
                <reference reference_type="assertion">19</reference>
                <reference operator="AND" reference_type="assertion">14</reference>
                <reference operator="AND" reference_type="assertion">15</reference>
        </assertion_binding>
       
        <assertion_binding id="13" vulnerable="software">
                <comment>Patch Q810847.exe (cumulative patch from MS03-004) installed</comment>
                <result result_type="string">Patch Q810847 Installed</result>
                <table_name>Win2K_RegistryKeys</table_name>
                       
                <reference reference_type="assertion">20</reference>
                <reference operator="AND" reference_type="assertion">14</reference>
                <reference operator="AND" reference_type="assertion">15</reference>
        </assertion_binding>
       
        <assertion_binding id="14">
                <result result_type="string">Use Machine Settings</result>
                <table_name>Win2K_RegistryKeys</table_name>
                       
                <reference reference_type="assertion">21</reference>
                <reference operator="AND" reference_type="assertion">22</reference>
                <reference operator="AND" reference_type="assertion">15</reference>
        </assertion_binding>
       
        <assertion_binding id="15">
                <result result_type="string">Use Machine Settings</result>
                <table_name>Win2K_RegistryKeys</table_name>
                       
                <reference reference_type="assertion">23</reference>
                <reference operator="AND" reference_type="assertion">24</reference>
                <reference operator="AND" reference_type="assertion">25</reference>
        </assertion_binding>
       
        <assertion_binding id="16" vulnerable="configuration">
                <comment>Cookies Enabled</comment>
                <result result_type="string">Cookies Enabled</result>
                <table_name>Placeholder</table_name>
                       
                <reference operator="EXISTS" reference_type="binding">14</reference>
                <reference operator="AND EXISTS" reference_type="binding">15</reference>
        </assertion_binding>

</oval:oval_queries>

<?xml version="1.0" encoding="utf-8"?>
<!--
        Author: David Proulx
        Organization: The MITRE Corporation
       
        File: oval.to.html.xsl
        Date: 22 July 2003
        Version: 1.1
       
        Purpose: Style sheet to generate an HTML table for an OVAL SQL Definition from an XML
                representation of the definition.

        Change Log:
       
        v1.1
        - Significant modifications to account for changes in the XML Schema:
                - Assertions and bindings no longer contained within the query definition
                - Absolute reference requirements removed
                - <reference> tag restructured
                - <result> tag types modified to refer to assertions
                - <value> tag changed to <operand>
                - <column> tag changed to <column_name>
                - Assertion and binding id's changed from strings to integers
               
-->

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:oval="http://oval.mitre.org/XML">

        <xsl:output method="html" indent="yes" encoding="UTF-8"/>


        <!--
                OVAL Query Template
               
                Traverse each <query> tag and print the query <header> and <definition> in a nicely formatted
                HTML table.
        -->
        <xsl:template match="oval:oval_queries">
                <xsl:apply-templates select="query"/>
        </xsl:template>


        <!-- Templates -->


        <!--
                Assertion Template

                Search all of the assertion blocks for the 'id' matching
                the input param 'id'.  When a match is found, output the assertion elements
        -->
        <xsl:template name="assertion">
                <xsl:param name="id"/>

                <!-- Loop through all of the assertions -->
                <xsl:for-each select="/oval:oval_queries/assertion">
                        <xsl:if test="@id = $id">
                       
                                <!-- Output the column name and operator elements -->
                                <xsl:value-of select="column_name"/>
                               
                                <xsl:call-template name="operator">
                                        <xsl:with-param name="op">
                                                <xsl:value-of select="operator"/>
                                        </xsl:with-param>
                                </xsl:call-template>
                               
                                <!--
                                        The right-hand side of the <operator> can be:
                                                <operand> - Print it
                                                <reference> - Follow it
                                                <set> - Print each member
                                -->
                                <xsl:choose>
                                        <xsl:when test="operand">
                                                <xsl:apply-templates select="operand"/>
                                        </xsl:when>
                                       
                                        <xsl:when test="reference">
                                                <xsl:apply-templates select="reference"/>
                                        </xsl:when>
                                       
                                        <xsl:when test="set">
                                                <xsl:apply-templates select="set"/>
                                        </xsl:when>
                                </xsl:choose>
                        </xsl:if>
                </xsl:for-each>
        </xsl:template>


        <!--
                Assertion_Binding Template
               
                Search all of the assertion_binding blocks for the 'id' matching
                the input param 'id'.  When a match is found, output the elements of
                the binding.
               
        -->
        <xsl:template name="assertion_binding">
                <!-- ID of the desired assertion_binding -->
                <xsl:param name="id"/>

                <!-- An operator joining two bindings (optional) -->
                <xsl:param name="reference_operator"/>
               
                <!-- If set, only process the binding if it has a vulnerable attribute, and it matches (optional) -->
                <xsl:param name="vulnerable_flag"/>

                <!-- Loop through all of the assertion_bindings -->
                <xsl:for-each select="/oval:oval_queries/assertion_binding">
                       
                        <!-- Test if the binding matches the input 'id', and vulnerable_flag -->
                        <xsl:if test="(@id = $id) and (contains($vulnerable_flag, @vulnerable) or string-length($vulnerable_flag)=0)">

                                <!-- If there is a reference_operator - print it -->
                                <xsl:if test="string-length($reference_operator)>0">
                                        <p class="pad"><b>
                                        <xsl:call-template name="operator">
                                                <xsl:with-param name="op">
                                                        <xsl:value-of select="$reference_operator"/>
                                                </xsl:with-param>
                                        </xsl:call-template>

                                        </b></p>
                                </xsl:if>

                                <!-- If there is a comment, print it -->
                                <xsl:if test="comment">
                                        <p class="pad"><xsl:apply-templates select="comment"/></p>
                                </xsl:if>
                               
                                <!-- All assertion_bindings are enclosed by parens, use <ul> for indenting sections-->
                                <ul>(

                                <!-- If there is a result, print it -->
                                <xsl:if test="result">
                                        <xsl:apply-templates select="result"/>
                                </xsl:if>
                               
                                <!-- If there is a table name, print it -->
                                <xsl:if test="table_name">
                                        <xsl:apply-templates select="table_name"/>
                                </xsl:if>

                                <!-- Process all the references in the assertion_binding -->
                                <xsl:apply-templates select="reference"/>
                               
                                )</ul>
                        </xsl:if>
                </xsl:for-each>
        </xsl:template>


        <!--
                Comment Template
               
                Output SQL-style comments
        -->
        <xsl:template match="comment">
                <p class="tight">--<xsl:value-of select="."/></p>
        </xsl:template>


        <!--
                Definition Template
               
                Print the SQL statement based upon the contained <reference> tags.  First process all
                of the vulnerable software references, then the vulnerable configuration references.
                Enclose each group of sub-queries with delimiters.
        -->
        <xsl:template match="definition">
                <!-- If there is a comment, print it -->
                <xsl:if test="comment">
                        <p class="pad"><xsl:apply-templates select="comment"/></p>
                </xsl:if>
               
                <!-- Print query header -->
                <xsl:apply-templates select="result"/>
                <xsl:apply-templates select="table_name"/>

                <!-- Process Vulnerable Software queries -->
                <p class="pad"><i>--### BEGIN VULNERABLE SOFTWARE ###</i></p>  <!-- Open vulnerable software header -->

                <!-- Loop through all of the <reference> blocks, search for those with "vulnerable=software" attribute -->
                <xsl:for-each select="reference">
                        <xsl:call-template name="assertion_binding">

                                <xsl:with-param name="reference_operator">
                                        <xsl:value-of select="operator"/>
                                </xsl:with-param>
                               
                                <xsl:with-param name="id">
                                        <xsl:value-of select="."/>
                                </xsl:with-param>

                                <xsl:with-param name="vulnerable_flag">software</xsl:with-param>

                        </xsl:call-template>
                </xsl:for-each>

                <p class="pad"><i>--### END VULNERABLE SOFTWARE ###</i></p>  <!-- Close vulnerable software header -->

                <!-- Process Vulnerable Configuration queries -->
                <p class="pad"><i>--### BEGIN VULNERABLE CONFIGURATION ###</i></p>  <!-- Open vulnerable configuration header -->

                <!-- Loop through all of the <reference> blocks, search for those with "vulnerable=configuration" attribute -->
                <xsl:for-each select="reference">
                        <xsl:call-template name="assertion_binding">

                                <xsl:with-param name="reference_operator">
                                        <xsl:value-of select="operator"/>
                                </xsl:with-param>

                                <xsl:with-param name="id">
                                        <xsl:value-of select="."/>
                                </xsl:with-param>
                               
                                <xsl:with-param name="vulnerable_flag">configuration</xsl:with-param>

                        </xsl:call-template>
                </xsl:for-each>
                <p class="pad"><i>--### END VULNERABLE CONFIGURATION ###</i></p>  <!-- Close vulnerable configuration header -->
        </xsl:template>
       

        <!--
                OVAL Header Template
               
                Output the various elements of the OVAL header that constitute the OVAL
                meta-data section of the HTML page
        -->
        <xsl:template match="header">
                <p align="right"><b>Date Modified: <xsl:value-of select="date_modified"/></b></p>
               
                <table border="1" width="100%" cellpadding="2">
                        <tr valign="top">
                                <!-- Print the OVALid -->
                                <td width="30%">
                                        <p class="pad"><b>OVAL-id:</b>&#xA0;<xsl:value-of select="../@id"/></p>
                                </td>
                               
                                <!-- Print the CVEid -->
                                <td width="30%">
                                        <p class="pad"><b>CVE-id:</b>&#xA0;
                                        <xsl:choose>
                                                <xsl:when test="cveid">
                                                        <xsl:value-of select="cveid"/>
                                                </xsl:when>
                                                <xsl:otherwise>
                                                        Undefined
                                                </xsl:otherwise>
                                        </xsl:choose>
                                        </p>
                                </td>
                               
                                <!-- Print the Platforms-->
                                <td width="40%" rowspan="2">
                                        <p class="pad"><b>Platform(s):</b>
                                        <xsl:apply-templates select="platforms"/>
                                        </p>
                                </td>
                        </tr>
                        <tr valign="top">
                                <!-- Print the query version -->
                                <td>
                                        <p class="pad"><b>Version:</b>&#xA0;<xsl:value-of select="query_version"/></p>
                                </td>
                               
                                <!-- Print the query status -->
                                <td>
                                        <p class="pad"><b>Status:</b>&#xA0;<xsl:value-of select="status"/></p>
                                </td>
                        </tr>
                        <tr valign="top">
                                <!-- Print the schema version -->
                                <td colspan="2">
                                        <p class="pad"><b>Schema Version Used:</b>&#xA0;<xsl:value-of select="schema_version"/></p>
                                </td>
                               
                                <!-- Print the summary - Note: if there is no summary, this field is left empty-->
                                <td>
                                        <p class="pad"><b>Summary:</b>&#xA0;<xsl:value-of select="summary"/></p>
                                </td>
                        </tr>
                </table>

                <table border="1" width="100%" cellpadding="2">
                        <tr valign="top">
                                <!-- Print the vulnerability description -->
                                <td width="50%">
                                        <p class="pad"><b>Description:</b></p>
                                        <p class="tight"><xsl:value-of select="description"/></p>
                                </td>
                               
                                <!--
                                        Print the query synopsis.  First print the vulnerable software comments, then
                                        print the vulnerable configration comments.
                                 -->
                                <td width="50%">
                                        <p class="pad"><b>Query Synopsis:</b></p>
                                       
                                        <!-- Loop through the vulnerability_description references and pull out the vulnerable software comments -->
                                        <p class="pad">--Vulnerable software</p>
                                       
                                        <ul>
                                        <xsl:for-each select="../definition/reference">
                                                <xsl:call-template name="synopsis">
                                                        <xsl:with-param name="vulnerable">software</xsl:with-param>
                                                        <xsl:with-param name="id">
                                                                <xsl:value-of select="."/>
                                                        </xsl:with-param>

                                                </xsl:call-template>
                                        </xsl:for-each>
                                        </ul>

                                        <!-- Loop through the vulnerability_description references and pull out the vulnerable configuration comments -->
                                        <p class="pad">--Vulnerable configuration</p>
                                        <ul>
                                        <xsl:for-each select="../definition/reference">
                                                <xsl:call-template name="synopsis">
                                                        <xsl:with-param name="vulnerable">configuration</xsl:with-param>
                                                        <xsl:with-param name="id">
                                                                <xsl:value-of select="."/>
                                                        </xsl:with-param>

                                                </xsl:call-template>
                                        </xsl:for-each>
                                        </ul>
                                </td>
                        </tr>
                </table>
        </xsl:template>


        <!--
                Operand Template
               
                Output the assertion value accordign to its type
        -->
        <xsl:template match="operand">
                <xsl:choose>
                        <xsl:when test="@data_type='int'">
                                <xsl:value-of select="."/>
                        </xsl:when>

                        <!-- Enclose strings with single quotes -->
                        <xsl:when test="@data_type='string'">
                                '<xsl:value-of select="."/>'
                        </xsl:when>

                        <!-- If we can't identify the type, output it as is -->
                        <xsl:otherwise>
                                <xsl:value-of select="."/>
                        </xsl:otherwise>
                </xsl:choose>
        </xsl:template>


        <!--
                Operator Template
               
                Translate the operator tags into SQL operators
        -->
        <xsl:template name="operator">
                <xsl:param name="op"/>

                <xsl:choose>
                        <xsl:when test="$op='AND'">
                                <xsl:value-of select="$op"/>&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='AND EXISTS'">
                                <xsl:value-of select="$op"/>&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='AND NOT EXISTS'">
                                <xsl:value-of select="$op"/>&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='CONCAT'">
                                &#xA0;||&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='EQ'">
                                &#xA0;=&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='EXISTS'">
                                <xsl:value-of select="$op"/>&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='GT'">
                                &#xA0;&gt;&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='IN'">
                                &#xA0;<xsl:value-of select="$op"/>&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='LIKE'">
                                <xsl:value-of select="$op"/>&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='LT'">
                                &#xA0;&lt;&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='NE'">
                                &#xA0;!=&#xA0;
                        </xsl:when>
                        <xsl:when test="$op='OR'">
                                <xsl:value-of select="$op"/>&#xA0;
                        </xsl:when>

                        <xsl:otherwise>
                                <b>Invalid Operator</b>
                        </xsl:otherwise>
                </xsl:choose>

        </xsl:template>


        <!--
                OVAL Query Template
               
                Spit out HTML wrapper and CSS formatting definitions
        -->
        <xsl:template match="query">
                <html>
                        <head>
                                <title>Definition for <xsl:value-of select="@id"/></title>
                                <style type="text/css">
                                        <xsl:comment>
                                        P.tight {
                                                margin : 0;
                                                padding : 0;
                                        }

                                        P.pad {
                                                margin : 0;
                                                padding : 0;
                                                line-height : 175%;
                                        }

                                        UL {
                                                margin-top : 0;
                                                margin-bottom : 0;
                                                margin-left : 2em;
                                                margin-right : 0;
                                                padding : 0;
                                        }
                                        </xsl:comment>
                                </style>
                        </head>

                        <body>
                                <!-- Process the header -->
                                <xsl:apply-templates select="header"/>
                               
                                <!-- Wrap the SQL statement in a table -->
                                <table border="1" width="100%" cellpadding="2">
                                        <tr valign="top">
                                                <td colspan="2">
                                                        <p class="pad"><b>Query:</b></p>
                                                        <p class="tight"><xsl:apply-templates select="definition"/></p>
                                                        <p class="tight">;</p>
                                                </td>
                                        </tr>
                                </table>
                        </body>
                </html>
        </xsl:template>


        <!--
                Platform Template
               
                Loop through all of the <name> elements, and print them out
        -->
        <xsl:template match="platforms">
                <xsl:for-each select="name">
                        <p class="tight"><xsl:value-of select="."/></p>
                </xsl:for-each>
        </xsl:template>
       
       
        <!--
                Reference Template
               
                Follow a reference to an assertion or binding, depending upon the
                value contained within the 'reference_type' attribute.  If an 'operator'
                attribute exists, print the operator.
        -->
        <xsl:template match="reference">
                <ul>
               
                <!-- If there is an operator, print it -->
                <xsl:if test="@operator">
                        <b>
                        <xsl:call-template name="operator">
                                <xsl:with-param name="op">
                                        <xsl:value-of select="@operator"/>
                                </xsl:with-param>
                        </xsl:call-template>
                        </b>
                </xsl:if>
               
                <!-- Determine the reference type, and call the appropriate template -->
                <xsl:choose>
                        <xsl:when test="@reference_type='binding'">
                       
                                <xsl:call-template name="assertion_binding">
                                        <xsl:with-param name="id">
                                                <xsl:value-of select="."/>
                                        </xsl:with-param>
                                </xsl:call-template>
                        </xsl:when>

                        <xsl:when test="@reference_type='assertion'">
                                <xsl:call-template name="assertion">
                                        <xsl:with-param name="id">
                                                <xsl:value-of select="."/>
                                        </xsl:with-param>
                                </xsl:call-template>
                        </xsl:when>
                </xsl:choose>
                </ul>
        </xsl:template>


        <!--
                Result Template
               
                Output the result field as part of the SQL SELECT statement header
        -->
        <xsl:template match="result">

                <b>SELECT</b>&#xA0;

                <!-- Output the result based upon the result_type-->
                <xsl:choose>
                        <!-- If this is an assertion, use the assertion parameters as the result -->
                        <xsl:when test="@result_type='assertion'">
                                <xsl:call-template name="assertion">
                                        <xsl:with-param name="id">
                                                <xsl:value-of select="."/>
                                        </xsl:with-param>
                                </xsl:call-template>
                        </xsl:when>
                       
                        <!-- Must be a string -->
                        <xsl:otherwise>
                                '<xsl:value-of select="."/>'
                        </xsl:otherwise>
                </xsl:choose>
               
        </xsl:template>


        <!--
                Set Template
               
                Process data sets for SQL operators such as 'IN'.  Print the
                set elements as a comma separated list.
        -->
        <xsl:template match="set">
                <!-- All sets are enclosed by parens -->
                <ul>(
               
                <!-- Loop through the set elements -->
                <xsl:for-each select="set_element">
                        <!-- Determine the data type for the element -->
                        <xsl:choose>
                                <xsl:when test="@data_type='string'">
                                        '<xsl:value-of select="."/>'
                                </xsl:when>

                                <xsl:otherwise>
                                        <xsl:value-of select="."/>
                                </xsl:otherwise>
                        </xsl:choose>

                        <!-- Only print the comma if this is not the last element -->
                        <xsl:if test="position() != last()">
                                ,
                        </xsl:if>

                </xsl:for-each>
                )</ul>
        </xsl:template>


        <!--
                Synopsis Template
               
                Loop through all of the assertion bindings.  If the vulnerable and
                id values match, print the comment for that binding
        -->
        <xsl:template name="synopsis">
                <xsl:param name="vulnerable"/>
                <xsl:param name="id"/>
               
                <!-- Loop through all of the bindings -->
                <xsl:for-each select="/oval:oval_queries/assertion_binding">
               
                        <xsl:if test="(@vulnerable=$vulnerable) and (@id=$id)">
                                <li><xsl:value-of select="comment"/></li>
                        </xsl:if>
                </xsl:for-each>
        </xsl:template>
       
       
        <!--
                Table Template
               
                Output the SQL table name
        -->
        <xsl:template match="table_name">
                &#xA0;<b>FROM</b>&#xA0;<xsl:value-of select="."/>&#xA0;<b>WHERE</b>
        </xsl:template>


</xsl:stylesheet>

Definition for OVAL96

Date Modified: 2003-05-20

OVAL-id: OVAL96

CVE-id:  CVE-2002-0078

Platform(s):

Windows 2000

Version: 2

Status: ACCEPTED

Schema Version Used: 1

Summary: CVE-2002-0078

Description:

The zone determination function in Microsoft Internet Explorer 5.5 and 6.0 allows remote attackers to run scripts in the Local Computer zone by embedding the script in a cookie, aka the "Cookie-based Script Execution" vulnerability.

Query Synopsis:

--Vulnerable software

  • Internet Explorer 6.0
  • Affected mshtml.dll versions
  • Patch Q319282.exe Installed
  • Patch Q321232.exe (cumulative patch from MS02-023) installed
  • Patch Q323759.exe (cumulative patch from MS02-047) installed
  • Patch Q328970.exe (cumulative patch from MS02-066) installed
  • Patch Q324929.exe (cumulative patch from MS02-068) installed
  • Patch Q810847.exe (cumulative patch from MS03-004) installed

--Vulnerable configuration

  • Cookies Enabled

Query:

SELECT  'CVE-2002-0078'  FROM Placeholder WHERE

--### BEGIN VULNERABLE SOFTWARE ###

--Internet Explorer 6.0

    ( SELECT  'Internet Explorer 6.0 Installed'  FROM Win2K_RegistryKeys WHERE
      RegistryKey  =  'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer'
      AND  EntryName  =  'Version'
      AND  EntryValue  =  '6.00.2600.0000'
    )

--Affected mshtml.dll versions

    ( SELECT  'File %windir%\System32\inetsrv\mshtml.dll < 6.0.2715.400'  FROM Win2K_FileAttributes WHERE
      FilePath  = 
          ( SELECT  EntryValue  ||  '\System32\mshtml.dll'  FROM Win2K_RegistryKeys WHERE
            RegistryKey  =  'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion'
            AND  EntryName  =  'SystemRoot'
          )
      AND 
        (
            (
              Version1  <  6
            )
          OR 
            (
              Version1  =  6
              AND  Version2  =  0
              AND  Version3  <  2715
            )
          OR 
            (
              Version1  =  6
              AND  Version2  =  0
              AND  Version3  =  2715
              AND  Version4  <  400
            )
        )
    )

--Patch Q319282.exe Installed

    ( SELECT  'Patch Q319282 Installed'  FROM Win2K_RegistryKeys WHERE
      RegistryKey  =  'HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{2D5974C5-5185-4f5b-80B6-28015ACDD74C}'
      AND  EntryName  =  'IsInstalled'
      AND  EntryValue  =  '1'
    )

--Patch Q321232.exe (cumulative patch from MS02-023) installed

    ( SELECT  'Patch Q321232 Installed'  FROM Win2K_RegistryKeys WHERE
      RegistryKey  =  'HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{D7B44F3E-77D3-44C5-8E03-4222D9A18B7B}'
      AND  EntryName  =  'IsInstalled'
      AND  EntryValue  =  '1'
    )

--Patch Q323759.exe (cumulative patch from MS02-047) installed

    ( SELECT  'Patch Q323759 Installed'  FROM Win2K_RegistryKeys WHERE
      RegistryKey  =  'HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{61E6EAE5-7821-4AC1-9BBD-AED032A8E273}'
      AND  EntryName  =  'IsInstalled'
      AND  EntryValue  =  '1'
    )

--Patch Q328970.exe (cumulative patch from MS02-066) installed

    ( SELECT  'Patch Q328970 Installed'  FROM Win2K_RegistryKeys WHERE
      RegistryKey  =  'HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{FF4DD9CD-F25E-425a-8B5C-A2D062781FBB}'
      AND  EntryName  =  'IsInstalled'
      AND  EntryValue  =  '1'
    )

--Patch Q324929.exe (cumulative patch from MS02-068) installed

    ( SELECT  'Patch Q324929 Installed'  FROM Win2K_RegistryKeys WHERE
      RegistryKey  =  'HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{2757B1D6-0367-4663-877C-93ECC5C01BF6}'
      AND  EntryName  =  'IsInstalled'
      AND  EntryValue  =  '1'
    )

--Patch Q810847.exe (cumulative patch from MS03-004) installed

    ( SELECT  'Patch Q810847 Installed'  FROM Win2K_RegistryKeys WHERE
      RegistryKey  =  'HKEY_LOCAL_MACHINE\Software\Microsoft\Active Setup\Installed Components\{C34F4917-ED43-439f-9023-97B0024A2B3B}'
      AND  EntryName  =  'IsInstalled'
      AND  EntryValue  =  '1'
    )

--### END VULNERABLE SOFTWARE ###

--### BEGIN VULNERABLE CONFIGURATION ###

--Cookies Enabled

    ( SELECT  'Cookies Enabled'  FROM Placeholder WHERE
      EXISTS 
        ( SELECT  'Use Machine Settings'  FROM Win2K_RegistryKeys WHERE
          RegistryKey  =  'HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\CurrentVersion\Internet Settings'
          AND  EntryName  =  'Security_HKLM_only'
          AND  EntryValue  =  '1'
        )
      AND EXISTS 
        ( SELECT  'Use Machine Settings'  FROM Win2K_RegistryKeys WHERE
          RegistryKey  IN 
            ( 'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\0' , 'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\1' , 'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\2' , 'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\3' , 'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\4' )
          AND  EntryName  IN 
            ( '1A02' , '1A03' )
          AND  EntryValue  !=  '3'
        )
    )

--### END VULNERABLE CONFIGURATION ###

;