././@PaxHeader 0000000 0000000 0000000 00000000033 00000000000 010211 x ustar 00 27 mtime=1775359349.820776
pyexploitdb-0.3.21/ 0000755 0001751 0001751 00000000000 15164352566 013623 5 ustar 00runner runner ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359319.0
pyexploitdb-0.3.21/LICENSE 0000644 0001751 0001751 00000104515 15164352527 014633 0 ustar 00runner runner GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
././@PaxHeader 0000000 0000000 0000000 00000000033 00000000000 010211 x ustar 00 27 mtime=1775359349.820752
pyexploitdb-0.3.21/PKG-INFO 0000644 0001751 0001751 00000007547 15164352566 014735 0 ustar 00runner runner Metadata-Version: 2.4
Name: pyexploitdb
Version: 0.3.21
Summary: An optimized Python3 library to fetch the most recent exploit-database,
Home-page: https://github.com/Hackman238/pyExploitDb
Author: Shane William Scott
Author-email: shane@shanewilliamscott.com
License: GPL-3.0-only
Project-URL: Source, https://github.com/Hackman238/pyExploitDb
Project-URL: Issue Tracker, https://github.com/Hackman238/pyExploitDb/issues
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Operating System :: OS Independent
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: GitPython>=3.1
Requires-Dist: requests>=2.28
Dynamic: author
Dynamic: author-email
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: license
Dynamic: license-file
Dynamic: project-url
Dynamic: requires-dist
Dynamic: requires-python
Dynamic: summary
## NOTICE
This is the new home of "pyexploitdb".
##
pyexploitdb (https://shanewilliamscott.com)
==
[](https://github.com/Hackman238/pyExploitDb/actions/workflows/master.yml)
[](https://snyk.io/test/github/Hackman238/pyExploitDb?targetFile=requirements.txt)
## Authors:
Shane William Scott
## About pyexploitdb
pyexploitdb builds and maintains local CVE↔EDB indexes from the official exploit-db repository with a focus on resilience and observability.
### Highlights
- Validates on-disk caches and normalises mappings to keep indexes trustworthy.
- Rebuilds quickly by parsing `files_exploits.csv` first and only scraping missing CVEs with bounded concurrency.
- Ships with a practical smoke-test suite (`python -m tests.smoke_test`) so releases can be verified before publishing.
## Upcoming features
> CPE database, indexes and mappings
## Installation
pip install pyexploitdb
> Note: This assumes pip is for your python3 environment. Use pip3 if pip is for your python2 environment.
## Example Usage
```python
from pyexploitdb import PyExploitDb
exploit_db = PyExploitDb()
exploit_db.debug = False
exploit_db.open_file()
results = exploit_db.search_cve("CVE-2018-14592")
for exploit in results:
print(f"{exploit['id']} -> {exploit['file']}")
```
`search_cve` returns a list of dictionaries (one per matching exploit). The library raises `pyexploitdb.PyExploitDbError` when required data is missing or network/git operations fail after retrying.
To rebuild the CVE caches from scratch without hammering exploit-db, metadata is extracted from `files_exploits.csv` first and any missing CVEs fall back to concurrent (throttled) scraping:
```python
from pyexploitdb import PyExploitDb
with PyExploitDb() as exploit_db:
exploit_db.update_db(workers=6) # adjust workers to control parallel HTTP fetches
```
## Tests
Run the practical smoke tests before publishing to PyPI:
```
python -m tests.smoke_test
```
## Example debug/verbose output
CVE-2018-1459
Found
Exploit DB Id: 45447
File: ./exploit-database/exploits/php/webapps/45447.txt
Date: 2018-09-24
Author: Haboob Team
Platform: webapps
Type: php
Port: 80
{'edbid': '45447', 'exploit': './exploit-database/exploits/php/webapps/45447.txt', 'date': '2018-09-24', 'author': 'Haboob Team', 'platform': 'webapps', 'type': 'php', 'port': '80'}
## Credits
Based on fork from https://github.com/GoVanguard/pyExploitDb by Shane Scott.
Originally based on fork of cve_searchsploit by Andrea Fioraldi.
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359319.0
pyexploitdb-0.3.21/README.md 0000644 0001751 0001751 00000005174 15164352527 015106 0 ustar 00runner runner ## NOTICE
This is the new home of "pyexploitdb".
##
pyexploitdb (https://shanewilliamscott.com)
==
[](https://github.com/Hackman238/pyExploitDb/actions/workflows/master.yml)
[](https://snyk.io/test/github/Hackman238/pyExploitDb?targetFile=requirements.txt)
## Authors:
Shane William Scott
## About pyexploitdb
pyexploitdb builds and maintains local CVE↔EDB indexes from the official exploit-db repository with a focus on resilience and observability.
### Highlights
- Validates on-disk caches and normalises mappings to keep indexes trustworthy.
- Rebuilds quickly by parsing `files_exploits.csv` first and only scraping missing CVEs with bounded concurrency.
- Ships with a practical smoke-test suite (`python -m tests.smoke_test`) so releases can be verified before publishing.
## Upcoming features
> CPE database, indexes and mappings
## Installation
pip install pyexploitdb
> Note: This assumes pip is for your python3 environment. Use pip3 if pip is for your python2 environment.
## Example Usage
```python
from pyexploitdb import PyExploitDb
exploit_db = PyExploitDb()
exploit_db.debug = False
exploit_db.open_file()
results = exploit_db.search_cve("CVE-2018-14592")
for exploit in results:
print(f"{exploit['id']} -> {exploit['file']}")
```
`search_cve` returns a list of dictionaries (one per matching exploit). The library raises `pyexploitdb.PyExploitDbError` when required data is missing or network/git operations fail after retrying.
To rebuild the CVE caches from scratch without hammering exploit-db, metadata is extracted from `files_exploits.csv` first and any missing CVEs fall back to concurrent (throttled) scraping:
```python
from pyexploitdb import PyExploitDb
with PyExploitDb() as exploit_db:
exploit_db.update_db(workers=6) # adjust workers to control parallel HTTP fetches
```
## Tests
Run the practical smoke tests before publishing to PyPI:
```
python -m tests.smoke_test
```
## Example debug/verbose output
CVE-2018-1459
Found
Exploit DB Id: 45447
File: ./exploit-database/exploits/php/webapps/45447.txt
Date: 2018-09-24
Author: Haboob Team
Platform: webapps
Type: php
Port: 80
{'edbid': '45447', 'exploit': './exploit-database/exploits/php/webapps/45447.txt', 'date': '2018-09-24', 'author': 'Haboob Team', 'platform': 'webapps', 'type': 'php', 'port': '80'}
## Credits
Based on fork from https://github.com/GoVanguard/pyExploitDb by Shane Scott.
Originally based on fork of cve_searchsploit by Andrea Fioraldi.
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1775359349.8184428
pyexploitdb-0.3.21/pyexploitdb/ 0000755 0001751 0001751 00000000000 15164352566 016166 5 ustar 00runner runner ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359319.0
pyexploitdb-0.3.21/pyexploitdb/__init__.py 0000644 0001751 0001751 00000042762 15164352527 020307 0 ustar 00runner runner from __future__ import annotations
import csv
import json
import os
import re
import shutil
import time
import warnings
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
from typing import Dict, Iterable, List, Optional, Sequence, Set
import git
import requests
__all__ = ["PyExploitDb", "PyExploitDbError", "InvalidDataError"]
CveDetails = Dict[str, str]
ExploitMap = Dict[str, List[str]]
_CVE_PATTERN = re.compile(r"CVE-\d{4}-\d{4,7}", re.IGNORECASE)
_CVE_PATTERN_BYTES = re.compile(rb"CVE-\d{4}-\d{4,7}", re.IGNORECASE)
class PyExploitDbError(Exception):
"""Base exception for pyexploitdb related failures."""
class InvalidDataError(PyExploitDbError):
"""Raised when on-disk data cannot be parsed or validated."""
class PyExploitDb:
"""High level interface for working with exploit-db offline data."""
EXPLOIT_DB_REPO = "https://gitlab.com/exploit-database/exploitdb.git"
FILES_EXPLOITS = "files_exploits.csv"
USER_AGENT = {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) Chrome/39.0 Safari/537.36"}
def __init__(
self,
*,
exploit_db_path: Optional[Path] = None,
request_cool_off_time: float = 1.0,
max_retries: int = 3,
session: Optional[requests.Session] = None,
) -> None:
self.current_path = Path(__file__).resolve().parent
self.exploit_db_path = exploit_db_path or self.current_path / "exploit-database"
self.edbid_to_cve_file = self.current_path / "edbidToCve.json"
self.cve_to_edbid_file = self.current_path / "cveToEdbid.json"
self.request_cool_off_time = max(0.0, float(request_cool_off_time))
self.max_retries = max(1, int(max_retries))
self.cve_to_exploit_map: ExploitMap = {}
self._exploit_cache: Dict[str, Sequence[str]] = {}
self._session = session or requests.Session()
self._owns_session = session is None
self._session.headers.setdefault("User-Agent", self.USER_AGENT["User-Agent"])
self.debug = False
def log_debug(self, message: str) -> None:
if self.debug:
print(message)
def clone_or_update_repo(self) -> None:
if not self.exploit_db_path.exists():
self._clone_repo()
return
try:
repo = git.Repo(self.exploit_db_path)
except (git.exc.InvalidGitRepositoryError, git.exc.NoSuchPathError):
self.log_debug("Existing exploit-database directory invalid, re-cloning...")
self.delete_and_reclone_repo()
return
try:
self.log_debug("Pulling exploit-database updates...")
repo.remotes.origin.pull("main")
except git.exc.GitCommandError as exc:
self.log_debug(f"Pull failed ({exc}); attempting to re-clone repository.")
self.delete_and_reclone_repo()
def pull_latest_updates(self) -> None:
self.clone_or_update_repo()
def delete_and_reclone_repo(self) -> None:
if self.exploit_db_path.exists():
shutil.rmtree(self.exploit_db_path, ignore_errors=True)
self._clone_repo()
self._exploit_cache.clear()
def open_file(self, exploit_map: str = "cveToEdbid.json", encoding: str = "utf-8") -> None:
self.clone_or_update_repo()
data = self._load_json_file(self.current_path / exploit_map, encoding)
self._set_cve_map(data)
def get_cve_details(self, cve_search: str) -> List[CveDetails]:
if not self.cve_to_exploit_map:
raise PyExploitDbError("Exploit data is not loaded; call open_file() or update_db() first.")
if not cve_search:
return []
edb_ids = self.cve_to_exploit_map.get(cve_search.upper(), [])
if not edb_ids:
return []
self._ensure_exploit_cache()
results: List[CveDetails] = []
for edb_id in edb_ids:
row = self._exploit_cache.get(edb_id)
if row:
results.append(self.extract_cve_details(row))
else:
self.log_debug(f"EDB {edb_id} referenced by CVE {cve_search} not present in CSV data.")
return results
def extract_cve_details(self, row: Sequence[str]) -> CveDetails:
if len(row) < 16:
raise InvalidDataError("files_exploits.csv row is malformed; expected at least 16 columns.")
details = {
"id": row[0],
"file": row[1],
"description": row[2],
"date": row[3],
"author": row[4],
"type": row[5],
"platform": row[6],
"port": row[7],
"date_updated": row[9],
"verified": row[10],
"codes": row[11],
"tags": row[12],
"aliases": row[13],
"app_url": row[14],
"src_url": row[15],
}
self.log_debug(f"CVE details extracted: {details}")
return details
def search_cve(self, cve_search: str) -> List[CveDetails]:
return self.get_cve_details(cve_search)
def update_db(self, *, workers: Optional[int] = None) -> None:
self.clone_or_update_repo()
data = self.load_existing_data(self.edbid_to_cve_file)
exploits = self.load_exploit_csv()
missing_ids: List[str] = []
for row in exploits:
if not row or not row[0]:
continue
edb_id = row[0]
if edb_id in data:
continue
cves = self._extract_cves_from_row(row)
if cves:
data[edb_id] = sorted(cves)
else:
missing_ids.append(edb_id)
if missing_ids:
unique_ids = list(dict.fromkeys(missing_ids))
fetched = self._fetch_missing_cves(unique_ids, workers=workers)
data.update(fetched)
self.write_json(self.edbid_to_cve_file, data)
self.create_cve_to_exploit_map(data)
self.write_json(self.cve_to_edbid_file, self.cve_to_exploit_map)
def load_existing_data(self, file_path: Path | str) -> ExploitMap:
path = Path(file_path)
if not path.exists():
return {}
try:
with path.open(encoding="utf-8") as file_data:
raw = json.load(file_data)
except json.JSONDecodeError as exc:
raise InvalidDataError(f"Corrupt JSON detected at {path}; delete file and retry.") from exc
except OSError as exc:
raise PyExploitDbError(f"Unable to read {path}") from exc
return self._normalise_edbid_mapping(raw)
def load_exploit_csv(self) -> List[List[str]]:
path = self.exploit_db_path / self.FILES_EXPLOITS
try:
with path.open(encoding="utf-8", newline="") as file:
reader = csv.reader(file)
next(reader, None) # skip header
rows = [row for row in reader if row]
except FileNotFoundError as exc:
raise PyExploitDbError(f"{self.FILES_EXPLOITS} not found at {path}.") from exc
except OSError as exc:
raise PyExploitDbError(f"Unable to read {path}") from exc
self._exploit_cache = {row[0]: row for row in rows if row and row[0]}
return rows
def fetch_cves_for_exploit(self, edb_id: str, session: Optional[requests.Session] = None) -> Set[str]:
request_uri = f"https://www.exploit-db.com/exploits/{edb_id}"
active_session = session or self._session
for attempt in range(1, self.max_retries + 1):
try:
response = active_session.get(request_uri, timeout=10)
except requests.RequestException as exc:
self.log_debug(f"Request error for {request_uri} (attempt {attempt}/{self.max_retries}): {exc}")
else:
if response.status_code == 404:
self.log_debug(f"Exploit {edb_id} returned 404; no CVEs available.")
return set()
if response.ok:
return self.parse_cves_from_content(response.content)
self.log_debug(
f"Unexpected status {response.status_code} for {request_uri} "
f"(attempt {attempt}/{self.max_retries})."
)
if attempt < self.max_retries:
time.sleep(self.request_cool_off_time)
raise PyExploitDbError(f"Failed to fetch CVEs for exploit {edb_id} after {self.max_retries} attempts.")
def parse_cves_from_content(self, content: bytes) -> Set[str]:
return {match.group(0).decode("ascii").upper() for match in _CVE_PATTERN_BYTES.finditer(content)}
def write_json(self, file_path: Path | str, data: ExploitMap) -> None:
path = Path(file_path)
path.parent.mkdir(parents=True, exist_ok=True)
try:
with path.open("w", encoding="utf-8") as file_data:
json.dump(data, file_data, indent=2, sort_keys=True)
except OSError as exc:
raise PyExploitDbError(f"Unable to write {path}") from exc
def create_cve_to_exploit_map(self, data: Dict[str, Iterable[str]]) -> None:
mapping: ExploitMap = {}
for edb_id, cves in data.items():
if not edb_id:
continue
for cve in cves:
cve_key = str(cve).upper()
if not cve_key:
continue
mapping.setdefault(cve_key, []).append(str(edb_id))
for ids in mapping.values():
ids.sort()
self.cve_to_exploit_map = mapping
self._exploit_cache.clear()
def _fetch_missing_cves(self, missing_ids: Sequence[str], *, workers: Optional[int]) -> ExploitMap:
max_workers = workers or min(8, max(1, (os.cpu_count() or 4) // 2))
results: ExploitMap = {}
def task(edb_id: str) -> tuple[str, List[str]]:
with requests.Session() as session:
session.headers["User-Agent"] = self.USER_AGENT["User-Agent"]
try:
cves = sorted(self.fetch_cves_for_exploit(edb_id, session=session))
except PyExploitDbError as exc:
self.log_debug(f"Failed to hydrate CVEs for {edb_id}: {exc}")
return edb_id, []
return edb_id, cves
with ThreadPoolExecutor(max_workers=max_workers) as executor:
future_map = {executor.submit(task, edb_id): edb_id for edb_id in missing_ids}
for future in as_completed(future_map):
edb_id = future_map[future]
try:
resolved_id, cves = future.result()
except Exception as exc: # noqa: BLE001
self.log_debug(f"Unhandled exception while hydrating CVEs for {edb_id}: {exc}")
results[edb_id] = []
continue
results[resolved_id] = cves
return results
def _extract_cves_from_row(self, row: Sequence[str]) -> Set[str]:
cve_fields = [
row[11] if len(row) > 11 else "",
row[12] if len(row) > 12 else "",
row[13] if len(row) > 13 else "",
row[2] if len(row) > 2 else "",
]
cves: Set[str] = set()
for field in cve_fields:
if not field:
continue
cves.update(match.group(0).upper() for match in _CVE_PATTERN.finditer(field))
return cves
def close(self) -> None:
if self._owns_session:
self._session.close()
def __enter__(self) -> "PyExploitDb":
return self
def __exit__(self, exc_type, exc_val, exc_tb) -> None:
self.close()
def _clone_repo(self) -> None:
self.log_debug("Cloning exploit-database repository...")
git.Repo.clone_from(self.EXPLOIT_DB_REPO, str(self.exploit_db_path))
def _ensure_exploit_cache(self) -> None:
if not self._exploit_cache:
self.load_exploit_csv()
def _set_cve_map(self, raw: object) -> None:
self.cve_to_exploit_map = self._normalise_cve_mapping(raw)
def _load_json_file(self, path: Path, encoding: str) -> object:
try:
with path.open(encoding=encoding) as file_data:
return json.load(file_data)
except FileNotFoundError as exc:
raise PyExploitDbError(f"Required JSON file not found: {path}") from exc
except json.JSONDecodeError as exc:
raise InvalidDataError(f"Corrupt JSON detected in {path}") from exc
except OSError as exc:
raise PyExploitDbError(f"Unable to read {path}") from exc
def _normalise_edbid_mapping(self, raw: object) -> ExploitMap:
if not isinstance(raw, dict):
raise InvalidDataError("Expected mapping of exploit IDs to CVE lists.")
result: ExploitMap = {}
for edb_id, cves in raw.items():
if not isinstance(edb_id, str):
self.log_debug(f"Skipping non-string exploit ID key {edb_id!r}")
continue
if not isinstance(cves, (list, tuple, set)):
self.log_debug(f"Skipping malformed CVE container for exploit {edb_id}")
continue
normalised = sorted({str(cve).upper() for cve in cves if str(cve).strip()})
if normalised:
result[edb_id] = normalised
return result
def _normalise_cve_mapping(self, raw: object) -> ExploitMap:
if not isinstance(raw, dict):
raise InvalidDataError("Expected mapping of CVE IDs to exploit lists.")
mapping: ExploitMap = {}
for cve, exploits in raw.items():
if not isinstance(cve, str):
continue
if not isinstance(exploits, (list, tuple, set)):
continue
cleaned = [str(edb).strip() for edb in exploits if str(edb).strip()]
if cleaned:
mapping[cve.upper()] = sorted(cleaned)
return mapping
def __del__(self) -> None:
self.close()
def logDebug(self, message: str) -> None:
warnings.warn("logDebug is deprecated; use log_debug instead.", DeprecationWarning, stacklevel=2)
self.log_debug(message)
def cloneOrUpdateRepo(self) -> None:
warnings.warn("cloneOrUpdateRepo is deprecated; use clone_or_update_repo instead.", DeprecationWarning, stacklevel=2)
self.clone_or_update_repo()
def pullLatestUpdates(self) -> None:
warnings.warn("pullLatestUpdates is deprecated; use pull_latest_updates instead.", DeprecationWarning, stacklevel=2)
self.pull_latest_updates()
def deleteAndRecloneRepo(self) -> None:
warnings.warn("deleteAndRecloneRepo is deprecated; use delete_and_reclone_repo instead.", DeprecationWarning, stacklevel=2)
self.delete_and_reclone_repo()
def openFile(self, exploitMap: str = "cveToEdbid.json", encoding: str = "utf-8") -> None:
warnings.warn("openFile is deprecated; use open_file instead.", DeprecationWarning, stacklevel=2)
self.open_file(exploit_map=exploitMap, encoding=encoding)
def getCveDetails(self, cveSearch: str) -> List[CveDetails]:
warnings.warn("getCveDetails is deprecated; use get_cve_details instead.", DeprecationWarning, stacklevel=2)
return self.get_cve_details(cveSearch)
def extractCveDetails(self, row: Sequence[str]) -> CveDetails:
warnings.warn("extractCveDetails is deprecated; use extract_cve_details instead.", DeprecationWarning, stacklevel=2)
return self.extract_cve_details(row)
def searchCve(self, cveSearch: str) -> List[CveDetails]:
warnings.warn("searchCve is deprecated; use search_cve instead.", DeprecationWarning, stacklevel=2)
return self.search_cve(cveSearch)
def updateDb(self, *, workers: Optional[int] = None) -> None:
warnings.warn("updateDb is deprecated; use update_db instead.", DeprecationWarning, stacklevel=2)
self.update_db(workers=workers)
def loadExistingData(self, file_path: Path | str) -> ExploitMap:
warnings.warn("loadExistingData is deprecated; use load_existing_data instead.", DeprecationWarning, stacklevel=2)
return self.load_existing_data(file_path)
def loadExploitCsv(self) -> List[List[str]]:
warnings.warn("loadExploitCsv is deprecated; use load_exploit_csv instead.", DeprecationWarning, stacklevel=2)
return self.load_exploit_csv()
def fetchCvesForExploit(self, edb_id: str) -> Set[str]:
warnings.warn(
"fetchCvesForExploit is deprecated; use fetch_cves_for_exploit instead.",
DeprecationWarning,
stacklevel=2,
)
return self.fetch_cves_for_exploit(edb_id)
def parseCvesFromContent(self, content: bytes) -> Set[str]:
warnings.warn(
"parseCvesFromContent is deprecated; use parse_cves_from_content instead.",
DeprecationWarning,
stacklevel=2,
)
return self.parse_cves_from_content(content)
def writeJson(self, file_path: Path | str, data: ExploitMap) -> None:
warnings.warn("writeJson is deprecated; use write_json instead.", DeprecationWarning, stacklevel=2)
self.write_json(file_path, data)
def createCveToExploitMap(self, data: Dict[str, Iterable[str]]) -> None:
warnings.warn(
"createCveToExploitMap is deprecated; use create_cve_to_exploit_map instead.",
DeprecationWarning,
stacklevel=2,
)
self.create_cve_to_exploit_map(data)
def test() -> None:
exploit_db = PyExploitDb()
exploit_db.debug = False
exploit_db.open_file()
results = exploit_db.search_cve("CVE-2018-14592")
print("PASS" if results else "FAIL")
if __name__ == "__main__":
test()
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359319.0
pyexploitdb-0.3.21/pyexploitdb/cveToEdbid.json 0000644 0001751 0001751 00003602760 15164352527 021104 0 ustar 00runner runner {
"CVE-2003-0132": [
"9",
"11"
],
"CVE-2003-0276": [
"22",
"22587"
],
"CVE-2003-0226": [
"35",
"22670"
],
"CVE-2003-0245": [
"38"
],
"CVE-2003-0567": [
"59",
"60",
"62"
],
"CVE-2003-0605": [
"61",
"64",
"66",
"69",
"70",
"76",
"97",
"103",
"109",
"117"
],
"CVE-2003-0232": [
"65"
],
"CVE-2003-0619": [
"68"
],
"CVE-2002-1487": [
"73",
"21819"
],
"CVE-2003-0717": [
"111",
"385",
"135",
"23247"
],
"CVE-2003-0714": [
"113",
"16820"
],
"CVE-2003-0854": [
"115"
],
"CVE-2003-0543": [
"146"
],
"CVE-2004-2099": [
"147"
],
"CVE-2003-0818": [
"153",
"3022",
"16377"
],
"CVE-2004-0345": [
"161"
],
"CVE-2004-0176": [
"170",
"167"
],
"CVE-2004-0120": [
"176"
],
"CVE-2000-0972": [
"195",
"20329"
],
"CVE-2000-0699": [
"212"
],
"CVE-2000-0305": [
"214"
],
"CVE-2001-0095": [
"233",
"235",
"20520",
"20521"
],
"CVE-2001-0136": [
"241",
"244",
"20536"
],
"CVE-2001-0040": [
"251"
],
"CVE-2001-0486": [
"264"
],
"CVE-2004-0424": [
"274"
],
"CVE-2004-0230": [
"276",
"291",
"942",
"24030",
"24031",
"24032",
"24033"
],
"CVE-2004-0445": [
"299"
],
"CVE-2004-0554": [
"306"
],
"CVE-2004-0683": [
"312"
],
"CVE-2000-0418": [
"324"
],
"CVE-1999-0128": [
"324"
],
"CVE-1999-0224": [
"329"
],
"CVE-1999-0116": [
"343"
],
"CVE-2004-0735": [
"357",
"826",
"16695"
],
"CVE-2004-0740": [
"358"
],
"CVE-2004-0493": [
"360",
"371"
],
"CVE-2004-2045": [
"363"
],
"CVE-2004-0484": [
"365"
],
"CVE-2004-0728": [
"366"
],
"CVE-2004-1705": [
"370",
"424",
"437"
],
"CVE-2004-2434": [
"376"
],
"CVE-2002-0741": [
"383",
"21409"
],
"CVE-2004-1727": [
"419"
],
"CVE-2004-1739": [
"420"
],
"CVE-2004-1745": [
"422"
],
"CVE-2004-1744": [
"423"
],
"CVE-2004-1642": [
"427"
],
"CVE-2004-1751": [
"429"
],
"CVE-2004-1664": [
"433"
],
"CVE-2004-1675": [
"463"
],
"CVE-2004-1688": [
"468"
],
"CVE-2004-1696": [
"471"
],
"CVE-2004-0200": [
"474",
"472",
"475",
"478",
"480",
"556"
],
"CVE-2004-1698": [
"477"
],
"CVE-2004-2517": [
"551"
],
"CVE-2004-1560": [
"562"
],
"CVE-2004-1587": [
"571"
],
"CVE-2004-0574": [
"578"
],
"CVE-2003-0718": [
"585"
],
"CVE-2006-2027": [
"593"
],
"CVE-2004-1493": [
"603"
],
"CVE-2004-1619": [
"604"
],
"CVE-2004-1207": [
"605"
],
"CVE-2004-2151": [
"606"
],
"CVE-2004-1109": [
"626"
],
"CVE-2004-1118": [
"649",
"650"
],
"CVE-2004-1539": [
"651"
],
"CVE-2004-1542": [
"653"
],
"CVE-2004-1195": [
"655"
],
"CVE-2004-1194": [
"655"
],
"CVE-2004-1135": [
"664",
"16719"
],
"CVE-2004-1208": [
"665"
],
"CVE-2004-1216": [
"672"
],
"CVE-2004-1215": [
"672"
],
"CVE-2004-1214": [
"672"
],
"CVE-2004-0575": [
"677",
"640"
],
"CVE-2004-1220": [
"679",
"1183"
],
"CVE-2004-1395": [
"683"
],
"CVE-2004-1016": [
"685"
],
"CVE-2004-1137": [
"686"
],
"CVE-2004-2496": [
"687"
],
"CVE-2004-1333": [
"690"
],
"CVE-2004-1335": [
"692"
],
"CVE-2004-1305": [
"721"
],
"CVE-2005-0280": [
"736"
],
"CVE-2005-0382": [
"755"
],
"CVE-2005-0122": [
"762"
],
"CVE-2005-0325": [
"780"
],
"CVE-2005-0330": [
"783"
],
"CVE-2005-0636": [
"797"
],
"CVE-2005-0339": [
"797"
],
"CVE-2005-0340": [
"799"
],
"CVE-2005-0370": [
"810"
],
"CVE-2005-0369": [
"810"
],
"CVE-2005-0430": [
"813"
],
"CVE-2005-2535": [
"815",
"16408"
],
"CVE-2005-0436": [
"817"
],
"CVE-2005-0435": [
"817"
],
"CVE-2004-0465": [
"838"
],
"CVE-2005-0568": [
"841"
],
"CVE-2005-0256": [
"842"
],
"CVE-2005-0575": [
"843",
"24897",
"24950"
],
"CVE-2005-0621": [
"849"
],
"CVE-2005-0633": [
"852"
],
"CVE-2004-0942": [
"855"
],
"CVE-2005-0681": [
"856"
],
"CVE-2005-1649": [
"861"
],
"CVE-2005-0688": [
"861",
"942"
],
"CVE-2005-0739": [
"874"
],
"CVE-2005-0768": [
"882",
"16817"
],
"CVE-2005-0804": [
"887"
],
"CVE-2005-0847": [
"893"
],
"CVE-2005-0916": [
"911"
],
"CVE-2005-1013": [
"916"
],
"CVE-2005-0554": [
"931"
],
"CVE-2005-1165": [
"941"
],
"CVE-2005-1164": [
"941"
],
"CVE-2005-0048": [
"942",
"25383",
"25384"
],
"CVE-2004-1060": [
"942",
"25388"
],
"CVE-2004-0790": [
"942",
"948",
"25389"
],
"CVE-2005-1280": [
"956"
],
"CVE-2005-1279": [
"957",
"958"
],
"CVE-2005-1278": [
"959"
],
"CVE-2005-1667": [
"983"
],
"CVE-2005-1470": [
"984"
],
"CVE-2005-1603": [
"988"
],
"CVE-2005-1589": [
"998"
],
"CVE-2005-1261": [
"999"
],
"CVE-2005-0356": [
"1008"
],
"CVE-2005-1812": [
"1027",
"16344"
],
"CVE-2005-1267": [
"1037"
],
"CVE-2005-0045": [
"1065"
],
"CVE-2005-2141": [
"1090"
],
"CVE-2005-2208": [
"1093"
],
"CVE-2005-2287": [
"1101",
"1463",
"16819"
],
"CVE-2005-2307": [
"1104"
],
"CVE-2005-2295": [
"1105"
],
"CVE-2005-2305": [
"1107"
],
"CVE-2005-1219": [
"1116",
"1506"
],
"CVE-2005-2426": [
"1121"
],
"CVE-2005-2472": [
"1126",
"1164"
],
"CVE-2006-7167": [
"1127"
],
"CVE-2005-2479": [
"1129"
],
"CVE-2005-2303": [
"1143"
],
"CVE-2005-1218": [
"1143"
],
"CVE-2017-2482": [
"41796"
],
"CVE-2005-2581": [
"1153"
],
"CVE-2005-2639": [
"1156"
],
"CVE-2001-1021": [
"1158",
"21036"
],
"CVE-2004-2513": [
"1159",
"663",
"668",
"670",
"4316"
],
"CVE-2004-1211": [
"1159",
"663",
"668",
"670",
"3561",
"4316",
"16484"
],
"CVE-2005-1931": [
"1162"
],
"CVE-2005-2083": [
"1163"
],
"CVE-2005-2085": [
"1165",
"1166"
],
"CVE-2005-2719": [
"1176"
],
"CVE-2004-2029": [
"1199"
],
"CVE-2004-2534": [
"1220"
],
"CVE-2005-3002": [
"1222"
],
"CVE-2005-3064": [
"1235"
],
"CVE-2005-3135": [
"1239"
],
"CVE-2005-3294": [
"1251",
"12604",
"15860"
],
"CVE-2001-1156": [
"1251"
],
"CVE-2005-4718": [
"1254",
"1255"
],
"CVE-2005-3120": [
"1256"
],
"CVE-2005-3243": [
"1266"
],
"CVE-2005-2120": [
"1269",
"1271"
],
"CVE-2005-3475": [
"1274"
],
"CVE-2005-3493": [
"1281"
],
"CVE-2005-3492": [
"1283"
],
"CVE-2005-3491": [
"1283"
],
"CVE-2005-3485": [
"1284"
],
"CVE-2005-3488": [
"1285"
],
"CVE-2005-3487": [
"1285"
],
"CVE-2005-3486": [
"1285"
],
"CVE-2005-3483": [
"1286"
],
"CVE-2005-3640": [
"1327"
],
"CVE-2005-3644": [
"1328"
],
"CVE-2005-3591": [
"1331"
],
"CVE-2005-3589": [
"1336"
],
"CVE-2005-3774": [
"1338",
"26548"
],
"CVE-2005-3812": [
"1339"
],
"CVE-2005-2119": [
"1341",
"1352"
],
"CVE-2005-2124": [
"1343",
"1346"
],
"CVE-2005-3929": [
"1345"
],
"CVE-2005-2123": [
"1346"
],
"CVE-2005-0803": [
"1346",
"25231"
],
"CVE-2005-3992": [
"1353"
],
"CVE-2005-4216": [
"1371"
],
"CVE-2005-4360": [
"1376",
"1377"
],
"CVE-2005-4584": [
"1390"
],
"CVE-2005-3187": [
"1409"
],
"CVE-2006-0179": [
"1411"
],
"CVE-2006-0355": [
"1416"
],
"CVE-2006-0357": [
"1422"
],
"CVE-2006-0328": [
"1424"
],
"CVE-2006-0354": [
"1447"
],
"CVE-2002-0256": [
"1464"
],
"CVE-2006-0671": [
"1473"
],
"CVE-2006-0544": [
"1475"
],
"CVE-2006-0734": [
"1483"
],
"CVE-2003-1325": [
"1483"
],
"CVE-2006-0564": [
"1488",
"1470",
"1490",
"1495",
"7727",
"10321",
"16648",
"16683"
],
"CVE-2009-0133": [
"1488",
"1470",
"1490",
"1495",
"7727",
"10321",
"16631"
],
"CVE-2006-0888": [
"1489",
"12382"
],
"CVE-2005-4723": [
"1496"
],
"CVE-2006-0006": [
"1500",
"1502"
],
"CVE-2006-1090": [
"1517"
],
"CVE-2006-0865": [
"1517"
],
"CVE-2006-1010": [
"1535"
],
"CVE-2006-0900": [
"1540"
],
"CVE-2006-2226": [
"1552"
],
"CVE-2006-0047": [
"1557"
],
"CVE-2006-1103": [
"1559"
],
"CVE-2006-1102": [
"1559"
],
"CVE-2006-1101": [
"1559",
"1560"
],
"CVE-2006-1100": [
"1559"
],
"CVE-2006-1147": [
"1564"
],
"CVE-2006-1146": [
"1564"
],
"CVE-2006-1145": [
"1564"
],
"CVE-2006-1206": [
"1572"
],
"CVE-2006-1224": [
"1573"
],
"CVE-2006-0021": [
"1599",
"1603"
],
"CVE-2006-1364": [
"1601"
],
"CVE-2006-1540": [
"1615"
],
"CVE-2006-0323": [
"1622",
"27460"
],
"CVE-2005-2856": [
"1633"
],
"CVE-2008-1110": [
"1641"
],
"CVE-2006-1664": [
"1641"
],
"CVE-2006-7051": [
"1657"
],
"CVE-2006-2012": [
"1708"
],
"CVE-2006-1999": [
"1709"
],
"CVE-2006-1998": [
"1709"
],
"CVE-2006-2019": [
"1715"
],
"CVE-2006-1993": [
"1716"
],
"CVE-2006-2108": [
"1718"
],
"CVE-2006-2107": [
"1721"
],
"CVE-2006-2180": [
"1743"
],
"CVE-2006-2222": [
"1746"
],
"CVE-2006-2225": [
"1748"
],
"CVE-2006-2242": [
"1749",
"1757"
],
"CVE-2006-2254": [
"1754"
],
"CVE-2006-7007": [
"1758"
],
"CVE-2006-7031": [
"1775"
],
"CVE-2006-2402": [
"1781"
],
"CVE-2006-2401": [
"1781"
],
"CVE-2006-2400": [
"1781"
],
"CVE-2006-2399": [
"1781"
],
"CVE-2006-2393": [
"1782"
],
"CVE-2006-2555": [
"1783"
],
"CVE-2006-2554": [
"1783"
],
"CVE-2006-2412": [
"1784"
],
"CVE-2006-2411": [
"1784"
],
"CVE-2006-2410": [
"1784"
],
"CVE-2006-2409": [
"1784"
],
"CVE-2006-2408": [
"1784"
],
"CVE-2006-2413": [
"1792"
],
"CVE-2006-2458": [
"1801"
],
"CVE-2006-2587": [
"1819"
],
"CVE-2006-2575": [
"1820"
],
"CVE-2006-1388": [
"1838"
],
"CVE-2006-1359": [
"1838",
"1606",
"1620",
"1628",
"16578"
],
"CVE-2006-1245": [
"1838",
"27433"
],
"CVE-2006-1192": [
"1838"
],
"CVE-2006-1191": [
"1838"
],
"CVE-2006-1190": [
"1838"
],
"CVE-2006-1189": [
"1838"
],
"CVE-2006-1188": [
"1838"
],
"CVE-2006-1186": [
"1838"
],
"CVE-2006-1185": [
"1838"
],
"CVE-2006-2802": [
"1852"
],
"CVE-2006-2723": [
"1867"
],
"CVE-2006-2444": [
"1880"
],
"CVE-2006-2971": [
"1894"
],
"CVE-2006-3086": [
"1927"
],
"CVE-2006-3228": [
"1935"
],
"CVE-2006-3199": [
"1937"
],
"CVE-2006-6750": [
"1949"
],
"CVE-2006-2379": [
"1967"
],
"CVE-2006-3353": [
"1972"
],
"CVE-2006-3400": [
"1976"
],
"CVE-2006-3325": [
"1976",
"1977"
],
"CVE-2006-3324": [
"1976"
],
"CVE-2006-3401": [
"1977"
],
"CVE-2006-3546": [
"1980",
"1297"
],
"CVE-2006-3912": [
"1984",
"1985",
"1992"
],
"CVE-2006-3471": [
"1989"
],
"CVE-2006-3524": [
"2000",
"16351",
"16352",
"16353"
],
"CVE-2006-3493": [
"2001"
],
"CVE-2006-3668": [
"2037"
],
"CVE-2006-5162": [
"2039"
],
"CVE-2006-0058": [
"2051"
],
"CVE-2006-3942": [
"2057"
],
"CVE-2006-1315": [
"2057"
],
"CVE-2006-1314": [
"2057"
],
"CVE-2006-3879": [
"2073"
],
"CVE-2006-4455": [
"2124",
"2147"
],
"CVE-2006-4192": [
"2160"
],
"CVE-2006-4464": [
"2176"
],
"CVE-2006-7210": [
"2194",
"2204",
"2210"
],
"CVE-2006-4364": [
"2245",
"2258"
],
"CVE-2009-3962": [
"2246"
],
"CVE-2006-4523": [
"2246"
],
"CVE-2006-4781": [
"2334"
],
"CVE-2006-4924": [
"2444"
],
"CVE-2006-5296": [
"2523"
],
"CVE-2006-4516": [
"2524"
],
"CVE-2006-5482": [
"2541"
],
"CVE-2006-5483": [
"2542"
],
"CVE-2006-5391": [
"2571"
],
"CVE-2006-5295": [
"2586"
],
"CVE-2006-4182": [
"2587"
],
"CVE-2006-5444": [
"2597"
],
"CVE-2006-5551": [
"2625",
"2649",
"3067"
],
"CVE-2006-5559": [
"2629"
],
"CVE-2006-5550": [
"2639"
],
"CVE-2006-5552": [
"2650"
],
"CVE-2006-5614": [
"2672",
"2682"
],
"CVE-2006-5633": [
"2695"
],
"CVE-2006-5710": [
"2700"
],
"CVE-2006-5567": [
"2708"
],
"CVE-2006-5728": [
"2715"
],
"CVE-2006-5850": [
"2716",
"21298"
],
"CVE-2006-5826": [
"2734"
],
"CVE-2006-5789": [
"2735"
],
"CVE-2006-6884": [
"2783",
"2785",
"3055"
],
"CVE-2008-5431": [
"2787"
],
"CVE-2006-6183": [
"2855",
"2865",
"3170",
"3388",
"16347"
],
"CVE-2006-6261": [
"2860"
],
"CVE-2006-6250": [
"2861"
],
"CVE-2006-6652": [
"2874",
"29204"
],
"CVE-2006-6296": [
"2879"
],
"CVE-2006-6352": [
"2892"
],
"CVE-2006-6293": [
"2893"
],
"CVE-2006-3441": [
"2900"
],
"CVE-2006-3440": [
"2900"
],
"CVE-2006-6564": [
"2901",
"2914"
],
"CVE-2006-5646": [
"2910"
],
"CVE-2006-5647": [
"2911"
],
"CVE-2006-5645": [
"2912"
],
"CVE-2006-6565": [
"2914"
],
"CVE-2006-6538": [
"2915"
],
"CVE-2006-6628": [
"2922"
],
"CVE-2006-6561": [
"2922"
],
"CVE-2006-6558": [
"2926"
],
"CVE-2006-6563": [
"2928",
"394",
"3330",
"3333"
],
"CVE-2006-6624": [
"2934"
],
"CVE-2006-6601": [
"2935",
"29285"
],
"CVE-2006-6643": [
"2942"
],
"CVE-2006-6659": [
"2946",
"29295"
],
"CVE-2006-6719": [
"2947"
],
"CVE-2006-6651": [
"2949"
],
"CVE-2006-6673": [
"2952"
],
"CVE-2006-6660": [
"2954",
"29296"
],
"CVE-2006-6759": [
"2966"
],
"CVE-2006-6696": [
"2967",
"3024"
],
"CVE-2006-6724": [
"2972"
],
"CVE-2006-6751": [
"2978"
],
"CVE-2006-6775": [
"2985"
],
"CVE-2006-6723": [
"3013"
],
"CVE-2006-6811": [
"3023"
],
"CVE-2006-6847": [
"3030"
],
"CVE-2006-6855": [
"3034"
],
"CVE-2006-6853": [
"3038",
"3037"
],
"CVE-2006-6827": [
"3041"
],
"CVE-2006-6885": [
"3042"
],
"CVE-2006-6797": [
"3052"
],
"CVE-2007-0138": [
"3056"
],
"CVE-2006-6910": [
"3056"
],
"CVE-2007-0017": [
"3069",
"3070"
],
"CVE-2007-0120": [
"3078"
],
"CVE-2007-0051": [
"3080"
],
"CVE-2007-0148": [
"3098"
],
"CVE-2007-0126": [
"3101"
],
"CVE-2007-0197": [
"3110"
],
"CVE-2006-4071": [
"3111"
],
"CVE-2007-0228": [
"3112"
],
"CVE-2007-0256": [
"3119",
"29443"
],
"CVE-2007-0311": [
"3126"
],
"CVE-2006-0441": [
"3127",
"1448",
"1452",
"1462",
"3140",
"16702",
"40675"
],
"CVE-2007-0338": [
"3128"
],
"CVE-2007-0236": [
"3130"
],
"CVE-2003-1318": [
"3138"
],
"CVE-2007-0344": [
"3139"
],
"CVE-2007-0356": [
"3142"
],
"CVE-2007-0355": [
"3151"
],
"CVE-2007-0371": [
"3155"
],
"CVE-2007-0429": [
"3157"
],
"CVE-2007-0020": [
"3160"
],
"CVE-2007-0021": [
"3166"
],
"CVE-2007-0430": [
"3167"
],
"CVE-2007-0548": [
"3182",
"15422"
],
"CVE-2007-0562": [
"3190"
],
"CVE-2007-0031": [
"3193"
],
"CVE-2007-0464": [
"3200"
],
"CVE-2007-0444": [
"3204"
],
"CVE-2007-0347": [
"3223"
],
"CVE-2007-0686": [
"3224"
],
"CVE-2007-0643": [
"3229"
],
"CVE-2007-0710": [
"3230"
],
"CVE-2007-0614": [
"3230"
],
"CVE-2007-0613": [
"3230"
],
"CVE-2007-0816": [
"3248"
],
"CVE-2007-0766": [
"3254"
],
"CVE-2007-0756": [
"3257"
],
"CVE-2007-0811": [
"3272"
],
"CVE-2007-0825": [
"3276"
],
"CVE-2007-0790": [
"3277"
],
"CVE-2007-0886": [
"3289"
],
"CVE-2007-0887": [
"3290"
],
"CVE-2007-0955": [
"3306",
"3308"
],
"CVE-2007-0976": [
"3307",
"3610",
"3844"
],
"CVE-2007-1014": [
"3331"
],
"CVE-2007-1080": [
"3341"
],
"CVE-2007-1075": [
"3341"
],
"CVE-2007-1079": [
"3343"
],
"CVE-2007-1082": [
"3347"
],
"CVE-2007-1162": [
"3350"
],
"CVE-2006-5276": [
"3362",
"3391",
"3609",
"18723"
],
"CVE-2007-1195": [
"3385",
"19131"
],
"CVE-2007-1294": [
"3392"
],
"CVE-2007-1383": [
"3394"
],
"CVE-2007-1286": [
"3396",
"9939",
"16310"
],
"CVE-2007-1251": [
"3399"
],
"CVE-2007-1381": [
"3404"
],
"CVE-2007-1306": [
"3407"
],
"CVE-2007-1373": [
"3418",
"1223",
"16473"
],
"CVE-2007-1347": [
"3419"
],
"CVE-2007-1403": [
"3421"
],
"CVE-2007-1377": [
"3430"
],
"CVE-2007-1404": [
"3432",
"9468"
],
"CVE-2007-1402": [
"3433"
],
"CVE-2007-1398": [
"3434"
],
"CVE-2007-0005": [
"3441"
],
"CVE-2007-0217": [
"3444"
],
"CVE-2007-1569": [
"3464"
],
"CVE-2007-1501": [
"3514"
],
"CVE-2007-1542": [
"3526"
],
"CVE-2007-1578": [
"3527"
],
"CVE-2007-1590": [
"3535"
],
"CVE-2007-1648": [
"3547"
],
"CVE-2007-1561": [
"3566"
],
"CVE-2007-1711": [
"3586"
],
"CVE-2007-1675": [
"3602",
"3616",
"4207"
],
"CVE-2007-2367": [
"3674"
],
"CVE-2007-0038": [
"3684",
"3617",
"3647",
"3652",
"3688",
"3695",
"3755",
"3634",
"3635",
"3636",
"3651",
"3804",
"4045",
"16526",
"16698"
],
"CVE-2007-1765": [
"3684",
"3617",
"3647",
"3652",
"3695",
"3634",
"3635",
"3636",
"3651",
"4045",
"16698"
],
"CVE-2007-1911": [
"3690"
],
"CVE-2007-1910": [
"3690"
],
"CVE-2007-1912": [
"3693"
],
"CVE-2007-2180": [
"3768"
],
"CVE-2007-2187": [
"3769"
],
"CVE-2007-2186": [
"3770"
],
"CVE-2007-2274": [
"3784"
],
"CVE-2007-1690": [
"3788"
],
"CVE-2007-1691": [
"3789"
],
"CVE-2007-2678": [
"3790"
],
"CVE-2007-2270": [
"3791",
"3792"
],
"CVE-2007-2362": [
"3807"
],
"CVE-2007-2497": [
"3819"
],
"CVE-2007-2494": [
"3826"
],
"CVE-2007-2495": [
"3830"
],
"CVE-2007-2496": [
"3836"
],
"CVE-2007-2588": [
"3845"
],
"CVE-2007-1669": [
"3851"
],
"CVE-2007-2563": [
"3866",
"4200"
],
"CVE-2007-2526": [
"3873"
],
"CVE-2007-2585": [
"3883",
"3882"
],
"CVE-2007-2623": [
"3891"
],
"CVE-2007-2656": [
"3898"
],
"CVE-2007-2657": [
"3910"
],
"CVE-2007-2658": [
"3917"
],
"CVE-2007-2648": [
"3921"
],
"CVE-2007-1531": [
"3926",
"29813"
],
"CVE-2007-2726": [
"3929"
],
"CVE-2007-2722": [
"3930"
],
"CVE-2007-2744": [
"3937"
],
"CVE-2007-2772": [
"3939",
"3940"
],
"CVE-2007-2761": [
"3945",
"3975"
],
"CVE-2007-2827": [
"3969"
],
"CVE-2007-2903": [
"3973"
],
"CVE-2007-2884": [
"3976",
"3977"
],
"CVE-2007-2888": [
"3978",
"4001",
"4002",
"16627"
],
"CVE-2007-2895": [
"3979"
],
"CVE-2007-2946": [
"3986"
],
"CVE-2007-3169": [
"4009"
],
"CVE-2007-2980": [
"4011"
],
"CVE-2007-2981": [
"4012"
],
"CVE-2007-3006": [
"4017",
"6329"
],
"CVE-2007-3098": [
"4033"
],
"CVE-2007-2237": [
"4044",
"30160"
],
"CVE-2007-3159": [
"4046"
],
"CVE-2007-3157": [
"4047"
],
"CVE-2007-3162": [
"4056",
"14938"
],
"CVE-2007-3161": [
"4058"
],
"CVE-2007-3282": [
"4067"
],
"CVE-2007-3410": [
"4118"
],
"CVE-2007-3488": [
"4120"
],
"CVE-2007-3490": [
"4121"
],
"CVE-2007-3548": [
"4126"
],
"CVE-2007-3554": [
"4137",
"30257"
],
"CVE-2007-3608": [
"4148",
"4149"
],
"CVE-2007-3607": [
"4148",
"4149"
],
"CVE-2007-3605": [
"4148",
"16498"
],
"CVE-2007-3606": [
"4149"
],
"CVE-2007-3655": [
"4168",
"30284"
],
"CVE-2007-3790": [
"4175"
],
"CVE-2007-3806": [
"4181"
],
"CVE-2007-3764": [
"4196"
],
"CVE-2007-3956": [
"4205"
],
"CVE-2007-3958": [
"4215"
],
"CVE-2007-3957": [
"4216"
],
"CVE-2007-4033": [
"4227",
"30401"
],
"CVE-2007-3763": [
"4249"
],
"CVE-2006-4301": [
"4251",
"28421"
],
"CVE-2007-4255": [
"4260",
"4270"
],
"CVE-2007-4286": [
"4272"
],
"CVE-2007-4366": [
"4281"
],
"CVE-2007-4382": [
"4285"
],
"CVE-2004-2466": [
"4289",
"16772",
"33326",
"50999"
],
"CVE-2007-4441": [
"4293",
"4302",
"4303"
],
"CVE-2007-4440": [
"4294",
"4301",
"16821"
],
"CVE-2007-4459": [
"4297",
"4298"
],
"CVE-2007-4507": [
"4304"
],
"CVE-2007-4586": [
"4318"
],
"CVE-2007-4553": [
"4319",
"30530"
],
"CVE-2007-4391": [
"4335",
"30500"
],
"CVE-2007-3034": [
"4337"
],
"CVE-2007-4646": [
"4344"
],
"CVE-2007-6113": [
"4347"
],
"CVE-2007-2394": [
"4359",
"30292"
],
"CVE-2007-4790": [
"4369"
],
"CVE-2007-4821": [
"4373"
],
"CVE-2007-4816": [
"4375"
],
"CVE-2007-4814": [
"4379",
"4398"
],
"CVE-2007-4911": [
"4403"
],
"CVE-2007-4916": [
"4409",
"30593"
],
"CVE-2007-5036": [
"4426"
],
"CVE-2007-5019": [
"4432"
],
"CVE-2007-5257": [
"4474"
],
"CVE-2007-5219": [
"4479"
],
"CVE-2007-5300": [
"4498"
],
"CVE-2007-5467": [
"4532",
"4535",
"4533",
"4534"
],
"CVE-2007-5466": [
"4535",
"4533",
"4534"
],
"CVE-2007-4980": [
"4540"
],
"CVE-2007-5082": [
"4569",
"16402"
],
"CVE-2007-5824": [
"4600"
],
"CVE-2008-5010": [
"4601"
],
"CVE-2007-5365": [
"4601"
],
"CVE-2007-5911": [
"4610"
],
"CVE-2007-5941": [
"4613"
],
"CVE-2007-4684": [
"4624"
],
"CVE-2007-6166": [
"4648",
"4651",
"4657",
"4664",
"6013",
"11027",
"16424",
"16873"
],
"CVE-2007-6236": [
"4682"
],
"CVE-2007-6235": [
"4683"
],
"CVE-2007-4904": [
"4683"
],
"CVE-2007-6262": [
"4688"
],
"CVE-2007-6261": [
"4689"
],
"CVE-2007-6276": [
"4690"
],
"CVE-2007-5583": [
"4692"
],
"CVE-2007-6327": [
"4716"
],
"CVE-2007-6326": [
"4717"
],
"CVE-2007-6359": [
"4723"
],
"CVE-2007-6015": [
"4732"
],
"CVE-2007-6473": [
"4742"
],
"CVE-2007-6457": [
"4748"
],
"CVE-2007-6506": [
"4757"
],
"CVE-2006-4343": [
"4773",
"28726"
],
"CVE-2007-6605": [
"4801"
],
"CVE-2008-0090": [
"4829"
],
"CVE-2008-7203": [
"4856"
],
"CVE-2008-0127": [
"4878"
],
"CVE-2007-0634": [
"4881",
"29540"
],
"CVE-2008-0234": [
"4885",
"4906"
],
"CVE-2008-0352": [
"4893"
],
"CVE-2008-0324": [
"4911"
],
"CVE-2008-0379": [
"4931"
],
"CVE-2008-0384": [
"4935"
],
"CVE-2008-0702": [
"5036"
],
"CVE-2008-0624": [
"5043",
"5046",
"5048",
"5051"
],
"CVE-2008-0623": [
"5043",
"5046",
"5048",
"5051"
],
"CVE-2008-0590": [
"5044"
],
"CVE-2008-0680": [
"5054"
],
"CVE-2008-0619": [
"5063"
],
"CVE-2008-0661": [
"5067",
"5069"
],
"CVE-2008-0747": [
"5085",
"10650"
],
"CVE-2008-0748": [
"5086",
"5100"
],
"CVE-2008-0778": [
"5110"
],
"CVE-2008-1138": [
"5142"
],
"CVE-2008-0830": [
"5151"
],
"CVE-2007-5958": [
"5152"
],
"CVE-2008-5160": [
"5184"
],
"CVE-2008-0177": [
"5191"
],
"CVE-2008-1127": [
"5201"
],
"CVE-2008-7136": [
"5217"
],
"CVE-2008-7135": [
"5217"
],
"CVE-2008-1307": [
"5225"
],
"CVE-2008-1322": [
"5229"
],
"CVE-2008-1321": [
"5229"
],
"CVE-2008-1320": [
"5229"
],
"CVE-2008-1275": [
"5235"
],
"CVE-2008-1480": [
"5258"
],
"CVE-2008-1478": [
"5270"
],
"CVE-2008-1501": [
"5306"
],
"CVE-2008-1558": [
"5307"
],
"CVE-2008-1713": [
"5341"
],
"CVE-2008-1855": [
"5343"
],
"CVE-2008-1709": [
"5349",
"4892"
],
"CVE-2008-0250": [
"5349",
"4892"
],
"CVE-2008-6519": [
"5354"
],
"CVE-2008-3544": [
"5396"
],
"CVE-2008-1910": [
"5427"
],
"CVE-2008-1912": [
"5453",
"5492"
],
"CVE-2008-6583": [
"5455"
],
"CVE-2008-1878": [
"5458"
],
"CVE-2008-1898": [
"5460",
"5530",
"16649"
],
"CVE-2008-1973": [
"5472"
],
"CVE-2008-2069": [
"5515"
],
"CVE-2008-0927": [
"5547"
],
"CVE-2008-1801": [
"5561"
],
"CVE-2008-1802": [
"5585"
],
"CVE-2008-2511": [
"5682"
],
"CVE-2008-2549": [
"5687"
],
"CVE-2008-2573": [
"5709",
"5751"
],
"CVE-2008-4189": [
"5712"
],
"CVE-2008-1105": [
"5712"
],
"CVE-2008-4193": [
"5718",
"5827",
"16803"
],
"CVE-2008-2631": [
"5727"
],
"CVE-2008-2119": [
"5749"
],
"CVE-2007-5962": [
"5814",
"31818",
"31819"
],
"CVE-2008-2922": [
"5817",
"6302"
],
"CVE-2008-6742": [
"5843"
],
"CVE-2008-2959": [
"5851"
],
"CVE-2008-0071": [
"5918"
],
"CVE-2008-7182": [
"5968"
],
"CVE-2008-2859": [
"5968"
],
"CVE-2008-2304": [
"6043"
],
"CVE-2008-3210": [
"6046"
],
"CVE-2008-3208": [
"6059"
],
"CVE-2008-3269": [
"6077"
],
"CVE-2008-3209": [
"6083"
],
"CVE-2008-3242": [
"6090"
],
"CVE-2008-2595": [
"6101"
],
"CVE-2008-3360": [
"6103",
"6116",
"6121",
"6238"
],
"CVE-2008-3447": [
"6174"
],
"CVE-2008-3493": [
"6181"
],
"CVE-2008-3571": [
"6196"
],
"CVE-2008-3578": [
"6201"
],
"CVE-2008-3702": [
"6216"
],
"CVE-2008-3431": [
"6218"
],
"CVE-2008-3680": [
"6237"
],
"CVE-2008-3443": [
"6239"
],
"CVE-2008-4321": [
"6240",
"6248",
"6256"
],
"CVE-2008-3704": [
"6244",
"6317",
"16507"
],
"CVE-2008-7107": [
"6251"
],
"CVE-2008-3732": [
"6252"
],
"CVE-2008-3733": [
"6253",
"8176"
],
"CVE-2008-3795": [
"6257"
],
"CVE-2008-3734": [
"6257"
],
"CVE-2008-3761": [
"6262"
],
"CVE-2008-3794": [
"6293"
],
"CVE-2008-3879": [
"6319"
],
"CVE-2008-7053": [
"6326"
],
"CVE-2008-7103": [
"6327"
],
"CVE-2008-1083": [
"6330",
"5442",
"6656"
],
"CVE-2008-3892": [
"6345"
],
"CVE-2008-6995": [
"6353"
],
"CVE-2008-6998": [
"6372"
],
"CVE-2008-6997": [
"6386"
],
"CVE-2008-4380": [
"6394"
],
"CVE-2008-4071": [
"6424"
],
"CVE-2008-4136": [
"6458"
],
"CVE-2008-4135": [
"6459"
],
"CVE-2008-4114": [
"6463"
],
"CVE-2008-4116": [
"6471"
],
"CVE-2008-4042": [
"6472"
],
"CVE-2008-2005": [
"6474"
],
"CVE-2008-2032": [
"6481",
"8283"
],
"CVE-2008-7014": [
"6493"
],
"CVE-2008-1141": [
"6496",
"5141"
],
"CVE-2008-4363": [
"6497",
"6498"
],
"CVE-2008-4362": [
"6515"
],
"CVE-2008-4340": [
"6554"
],
"CVE-2009-0259": [
"6560"
],
"CVE-2008-4841": [
"6560"
],
"CVE-2008-5072": [
"6565"
],
"CVE-2008-5666": [
"6581",
"6717"
],
"CVE-2008-4295": [
"6582"
],
"CVE-2008-4327": [
"6588"
],
"CVE-2008-4324": [
"6614"
],
"CVE-2008-4323": [
"6616"
],
"CVE-2007-5348": [
"6619"
],
"CVE-2008-4682": [
"6622"
],
"CVE-2008-4451": [
"6647"
],
"CVE-2008-4452": [
"6651"
],
"CVE-2008-4449": [
"6654",
"6666",
"16422"
],
"CVE-2008-5667": [
"6658"
],
"CVE-2008-4500": [
"6660"
],
"CVE-2008-5884": [
"6668"
],
"CVE-2008-4510": [
"6671"
],
"CVE-2008-5937": [
"6672"
],
"CVE-2008-5870": [
"6673"
],
"CVE-2008-5712": [
"6689",
"6704"
],
"CVE-2008-4514": [
"6689",
"6704"
],
"CVE-2008-3013": [
"6716"
],
"CVE-2008-5698": [
"6718"
],
"CVE-2008-2245": [
"6732"
],
"CVE-2008-4572": [
"6738"
],
"CVE-2008-5626": [
"6741",
"8294"
],
"CVE-2008-6186": [
"6742"
],
"CVE-2008-4588": [
"6752"
],
"CVE-2008-6082": [
"6753"
],
"CVE-2008-4558": [
"6756"
],
"CVE-2008-4729": [
"6761"
],
"CVE-2008-4619": [
"6775"
],
"CVE-2008-4762": [
"6800",
"6812"
],
"CVE-2008-2469": [
"6805"
],
"CVE-2008-6175": [
"6815"
],
"CVE-2008-4250": [
"6824",
"6841",
"7104",
"7132",
"16362",
"40279"
],
"CVE-2008-4748": [
"6832"
],
"CVE-2008-6829": [
"6834"
],
"CVE-2008-2031": [
"6834"
],
"CVE-2008-6791": [
"6838"
],
"CVE-2008-1311": [
"6863"
],
"CVE-2008-5045": [
"6926"
],
"CVE-2008-6605": [
"7060"
],
"CVE-2008-6252": [
"7088"
],
"CVE-2008-6953": [
"7090"
],
"CVE-2008-2214": [
"7099"
],
"CVE-2008-2292": [
"7100"
],
"CVE-2008-6938": [
"7109"
],
"CVE-2008-5492": [
"7126",
"32587",
"16520"
],
"CVE-2008-5183": [
"7150"
],
"CVE-2008-5409": [
"7178"
],
"CVE-2008-7079": [
"7207"
],
"CVE-2008-5282": [
"7209",
"7213"
],
"CVE-2008-7065": [
"7220"
],
"CVE-2008-7074": [
"7249"
],
"CVE-2008-5180": [
"7262",
"12079"
],
"CVE-2008-5406": [
"7296"
],
"CVE-2008-5405": [
"7297",
"7309",
"7329",
"16659"
],
"CVE-2008-5383": [
"7307"
],
"CVE-2008-7078": [
"7314"
],
"CVE-2008-5314": [
"7330"
],
"CVE-2008-6496": [
"7358"
],
"CVE-2008-6363": [
"7362"
],
"CVE-2008-6497": [
"7387"
],
"CVE-2008-5660": [
"7401"
],
"CVE-2008-5079": [
"7405"
],
"CVE-2008-4255": [
"7431"
],
"CVE-2008-5081": [
"7520"
],
"CVE-2009-2953": [
"7554"
],
"CVE-2008-5715": [
"7554"
],
"CVE-2008-6393": [
"7555"
],
"CVE-2008-5731": [
"7556"
],
"CVE-2008-6897": [
"7564"
],
"CVE-2008-5753": [
"7571",
"37056"
],
"CVE-2008-5722": [
"7578"
],
"CVE-2008-5745": [
"7585",
"32684"
],
"CVE-2008-5754": [
"7589",
"8420",
"9998"
],
"CVE-2008-5756": [
"7592"
],
"CVE-2009-0490": [
"7634",
"9501",
"10322"
],
"CVE-2009-0491": [
"7637"
],
"CVE-2009-0177": [
"7647"
],
"CVE-2009-3429": [
"7649",
"7652",
"7651",
"7654",
"9321",
"16684"
],
"CVE-2009-0070": [
"7673"
],
"CVE-2009-0833": [
"7696"
],
"CVE-2009-0175": [
"7708"
],
"CVE-2009-0174": [
"7709",
"7713",
"7714",
"7715"
],
"CVE-2009-0119": [
"7720"
],
"CVE-2009-0266": [
"7737"
],
"CVE-2009-0262": [
"7737"
],
"CVE-2009-0263": [
"7742"
],
"CVE-2008-3834": [
"7822"
],
"CVE-2009-0349": [
"7852"
],
"CVE-2009-0350": [
"7857",
"8126"
],
"CVE-2009-0304": [
"7865"
],
"CVE-2009-0298": [
"7869"
],
"CVE-2004-0964": [
"7887",
"559",
"7888",
"8267",
"16688",
"17600"
],
"CVE-2009-0323": [
"7902",
"16548"
],
"CVE-2009-0443": [
"7942"
],
"CVE-2009-0410": [
"7985"
],
"CVE-2009-0183": [
"7986",
"16777"
],
"CVE-2009-0388": [
"7990",
"8024"
],
"CVE-2009-0546": [
"7995",
"8010",
"11379",
"16640"
],
"CVE-2009-0680": [
"8008"
],
"CVE-2009-0478": [
"8021"
],
"CVE-2009-0649": [
"8051"
],
"CVE-2009-0659": [
"8058"
],
"CVE-2009-0650": [
"8058"
],
"CVE-2009-0075": [
"8077",
"8079",
"8080",
"8082",
"8152",
"16555"
],
"CVE-2009-0071": [
"8091"
],
"CVE-2009-0658": [
"8099",
"16593",
"16672"
],
"CVE-2008-6775": [
"8125"
],
"CVE-2009-0192": [
"8129"
],
"CVE-2009-0885": [
"8135",
"8137"
],
"CVE-2009-0751": [
"8148"
],
"CVE-2009-0537": [
"8163"
],
"CVE-2009-1059": [
"8180"
],
"CVE-2009-1058": [
"8180"
],
"CVE-2009-1057": [
"8180"
],
"CVE-2009-1028": [
"8180",
"12059",
"17210"
],
"CVE-2009-0879": [
"8190"
],
"CVE-2009-0967": [
"8212"
],
"CVE-2009-1045": [
"8213"
],
"CVE-2009-1040": [
"8224"
],
"CVE-2009-1022": [
"8225"
],
"CVE-2009-1902": [
"8241"
],
"CVE-2009-1152": [
"8260"
],
"CVE-2009-1236": [
"8262"
],
"CVE-2009-1237": [
"8263",
"8264"
],
"CVE-2009-1238": [
"8265"
],
"CVE-2009-1217": [
"8281"
],
"CVE-2009-1169": [
"8285"
],
"CVE-2009-1232": [
"8306"
],
"CVE-2009-1210": [
"8308"
],
"CVE-2009-1227": [
"8313"
],
"CVE-2009-1209": [
"8314",
"8321",
"9330"
],
"CVE-2009-1234": [
"8320"
],
"CVE-2009-1233": [
"8325"
],
"CVE-2009-0172": [
"8344"
],
"CVE-2009-1497": [
"8370"
],
"CVE-2009-1370": [
"8390"
],
"CVE-2009-1330": [
"8402",
"8403",
"8404",
"8405",
"8407",
"8427",
"10602",
"10619",
"14550",
"39933"
],
"CVE-2009-1329": [
"8402",
"8403",
"8404",
"8405",
"8407",
"8427"
],
"CVE-2009-1328": [
"8402",
"8403",
"8404",
"8405",
"8407",
"8413",
"20116"
],
"CVE-2009-1327": [
"8402",
"8403",
"8404",
"8405",
"8407",
"8411"
],
"CVE-2009-1326": [
"8402",
"8403",
"8404",
"8405",
"8407",
"8410",
"10423"
],
"CVE-2009-1325": [
"8402",
"8403",
"8404",
"8405",
"8407",
"8416",
"17847"
],
"CVE-2009-1324": [
"8402",
"8403",
"8404",
"8405",
"8407",
"8412",
"34921"
],
"CVE-2009-0687": [
"8406",
"8430",
"8581"
],
"CVE-2009-1352": [
"8434"
],
"CVE-2009-1331": [
"8445"
],
"CVE-2009-1353": [
"8447"
],
"CVE-2009-1351": [
"8451"
],
"CVE-2009-1356": [
"8452"
],
"CVE-2009-1257": [
"8462",
"8343"
],
"CVE-2009-1511": [
"8466"
],
"CVE-2008-5904": [
"8469"
],
"CVE-2009-0553": [
"8479"
],
"CVE-2009-4932": [
"8484"
],
"CVE-2009-1437": [
"8489",
"8519",
"8520"
],
"CVE-2009-0991": [
"8507"
],
"CVE-2009-1517": [
"8523"
],
"CVE-2009-1647": [
"8526"
],
"CVE-2009-1627": [
"8531",
"8536",
"8540"
],
"CVE-2009-1516": [
"8542"
],
"CVE-2009-4758": [
"8568"
],
"CVE-2009-1514": [
"8573"
],
"CVE-2009-4754": [
"8578",
"8583"
],
"CVE-2009-4753": [
"8584"
],
"CVE-2009-4756": [
"8588",
"8590",
"8591",
"8592"
],
"CVE-2009-1478": [
"8597"
],
"CVE-2009-4757": [
"8601"
],
"CVE-2009-1602": [
"8606"
],
"CVE-2009-4759": [
"8607"
],
"CVE-2009-1592": [
"8611",
"8614"
],
"CVE-2009-2568": [
"8617",
"8620"
],
"CVE-2009-1644": [
"8625",
"8640"
],
"CVE-2009-1660": [
"8644"
],
"CVE-2009-1668": [
"8650"
],
"CVE-2009-1672": [
"8665"
],
"CVE-2009-1671": [
"8665"
],
"CVE-2009-1574": [
"8669"
],
"CVE-2009-1817": [
"8677"
],
"CVE-2009-1789": [
"8695"
],
"CVE-2009-1379": [
"8720"
],
"CVE-2009-1831": [
"8767",
"8770",
"8772",
"8783",
"21256"
],
"CVE-2009-1830": [
"8777",
"9084",
"8804"
],
"CVE-2009-1827": [
"8794"
],
"CVE-2008-3529": [
"8798"
],
"CVE-2009-1828": [
"8822"
],
"CVE-2009-1915": [
"8832"
],
"CVE-2009-1944": [
"8837"
],
"CVE-2009-1955": [
"8842"
],
"CVE-2009-0955": [
"8862"
],
"CVE-2009-1386": [
"8873"
],
"CVE-2009-2256": [
"8964"
],
"CVE-2009-2173": [
"8971"
],
"CVE-2009-2286": [
"8982",
"9302"
],
"CVE-2009-0714": [
"9006",
"9007"
],
"CVE-2009-2484": [
"9029",
"16678"
],
"CVE-2009-2403": [
"9033"
],
"CVE-2009-2384": [
"9061"
],
"CVE-2009-2305": [
"9067"
],
"CVE-2009-3812": [
"9090",
"9113"
],
"CVE-2009-2433": [
"9100"
],
"CVE-2009-3717": [
"9102"
],
"CVE-2009-3859": [
"9114"
],
"CVE-2009-4588": [
"9116",
"16524"
],
"CVE-2009-3947": [
"9131"
],
"CVE-2009-3857": [
"9133"
],
"CVE-2009-2649": [
"9134"
],
"CVE-2009-3948": [
"9139"
],
"CVE-2009-3807": [
"9147"
],
"CVE-2009-2550": [
"9157",
"9172"
],
"CVE-2009-2479": [
"9158"
],
"CVE-2009-2535": [
"9160"
],
"CVE-2009-1136": [
"9163",
"16537"
],
"CVE-2009-3811": [
"9167"
],
"CVE-2009-2650": [
"9173",
"9551",
"10744"
],
"CVE-2009-3808": [
"9178"
],
"CVE-2009-2534": [
"9198"
],
"CVE-2009-2533": [
"9198"
],
"CVE-2009-3536": [
"9200"
],
"CVE-2009-3809": [
"9212"
],
"CVE-2009-3810": [
"9213"
],
"CVE-2009-2896": [
"9220"
],
"CVE-2007-4924": [
"9240"
],
"CVE-2007-4897": [
"9241"
],
"CVE-2009-2655": [
"9253"
],
"CVE-2009-0692": [
"9265"
],
"CVE-2009-2620": [
"9295"
],
"CVE-2009-0696": [
"9300"
],
"CVE-2009-2715": [
"9323"
],
"CVE-2009-2764": [
"9362"
],
"CVE-2009-4867": [
"9364"
],
"CVE-2009-4863": [
"9368"
],
"CVE-2009-2917": [
"9382"
],
"CVE-2009-4553": [
"9392"
],
"CVE-2009-3020": [
"9417"
],
"CVE-2009-2918": [
"9449"
],
"CVE-2009-3019": [
"9455"
],
"CVE-2009-3213": [
"9457"
],
"CVE-2009-2961": [
"9467"
],
"CVE-2007-3340": [
"9478"
],
"CVE-2009-3967": [
"9480"
],
"CVE-2009-3969": [
"9487"
],
"CVE-2009-3038": [
"9517"
],
"CVE-2009-2966": [
"9537"
],
"CVE-2009-5134": [
"9539"
],
"CVE-2009-3253": [
"9546"
],
"CVE-2009-3115": [
"9547"
],
"CVE-2009-3170": [
"9561",
"9974",
"10280"
],
"CVE-2009-2521": [
"9587",
"17476"
],
"CVE-2009-3103": [
"9594",
"10005",
"12524",
"14674",
"16363",
"40280"
],
"CVE-2009-3272": [
"9606"
],
"CVE-2009-4775": [
"9607"
],
"CVE-2009-2958": [
"9617"
],
"CVE-2009-2957": [
"9617"
],
"CVE-2009-3201": [
"9620"
],
"CVE-2009-5141": [
"9622"
],
"CVE-2009-3111": [
"9642"
],
"CVE-2009-3322": [
"9646"
],
"CVE-2009-3663": [
"9657"
],
"CVE-2009-3545": [
"9664"
],
"CVE-2009-3271": [
"9666"
],
"CVE-2009-3574": [
"9671"
],
"CVE-2008-7162": [
"9677"
],
"CVE-2009-3244": [
"9682",
"10093"
],
"CVE-2009-3863": [
"9683"
],
"CVE-2008-6447": [
"9685",
"7402"
],
"CVE-2008-5032": [
"9686"
],
"CVE-2009-3449": [
"9689"
],
"CVE-2009-4656": [
"9691",
"10827",
"18501",
"18547"
],
"CVE-2009-4661": [
"9695",
"9734"
],
"CVE-2009-4659": [
"9707"
],
"CVE-2009-4658": [
"9717"
],
"CVE-2009-4657": [
"9717"
],
"CVE-2009-3643": [
"9804"
],
"CVE-2009-3693": [
"9806",
"16598"
],
"CVE-2009-3484": [
"9815"
],
"CVE-2009-4051": [
"9852"
],
"CVE-2009-4587": [
"9874"
],
"CVE-2009-3744": [
"9879"
],
"CVE-2009-3837": [
"9881",
"10235",
"16443"
],
"CVE-2009-5098": [
"9956"
],
"CVE-2009-3641": [
"9969",
"33306"
],
"CVE-2009-3749": [
"9980"
],
"CVE-2009-3704": [
"9987"
],
"CVE-2009-3591": [
"10004",
"33269"
],
"CVE-2009-3888": [
"10017"
],
"CVE-2009-3621": [
"10022"
],
"CVE-2009-2514": [
"10068"
],
"CVE-2009-4171": [
"10092",
"33350"
],
"CVE-2007-1580": [
"10100"
],
"CVE-2009-4186": [
"10102"
],
"CVE-2009-4108": [
"10104",
"10221"
],
"CVE-2009-4048": [
"10104",
"10221"
],
"CVE-2009-3522": [
"10106"
],
"CVE-2009-4654": [
"10163"
],
"CVE-2009-4114": [
"10164"
],
"CVE-2009-3840": [
"10176",
"10377"
],
"CVE-2009-0689": [
"10184",
"10185",
"10186",
"10187",
"33058",
"33312",
"33479",
"33480",
"10380",
"33363",
"33364"
],
"CVE-2009-4118": [
"10190"
],
"CVE-2009-3726": [
"10202"
],
"CVE-2009-1284": [
"10203"
],
"CVE-2009-2285": [
"10205",
"33049"
],
"CVE-2009-2473": [
"10206"
],
"CVE-2009-4105": [
"10223"
],
"CVE-2008-4864": [
"10229",
"32534"
],
"CVE-2000-0470": [
"10237"
],
"CVE-2009-4017": [
"10242"
],
"CVE-2009-4413": [
"10338"
],
"CVE-2009-3305": [
"10338"
],
"CVE-2009-3586": [
"10349"
],
"CVE-2016-4227": [
"40307"
],
"CVE-2004-1585": [
"10553"
],
"CVE-2006-6184": [
"10603",
"24952",
"2887",
"16350"
],
"CVE-2010-0317": [
"11009"
],
"CVE-2010-0278": [
"11070"
],
"CVE-2010-0187": [
"11182"
],
"CVE-2010-0496": [
"11273"
],
"CVE-2010-0304": [
"11288",
"16289",
"16292"
],
"CVE-2010-0453": [
"11351"
],
"CVE-2009-3960": [
"11529",
"41855"
],
"CVE-2010-0718": [
"11531"
],
"CVE-2010-1029": [
"11567",
"11574"
],
"CVE-2010-1544": [
"11597"
],
"CVE-2010-1349": [
"11622"
],
"CVE-2010-2782": [
"14367"
],
"CVE-2010-1226": [
"11769"
],
"CVE-2010-1131": [
"11838",
"12487"
],
"CVE-2010-1174": [
"11878"
],
"CVE-2010-0619": [
"11880"
],
"CVE-2010-1179": [
"11890"
],
"CVE-2010-1176": [
"11891"
],
"CVE-2009-1642": [
"11930",
"8629",
"8630",
"11957",
"11958",
"18781"
],
"CVE-2011-5165": [
"11975",
"11976",
"12012",
"17727",
"18142",
"36465",
"36826",
"36827"
],
"CVE-2010-5289": [
"12030"
],
"CVE-2010-0805": [
"12032",
"16567"
],
"CVE-2010-5300": [
"12081",
"32899"
],
"CVE-2009-2754": [
"12109"
],
"CVE-2009-2753": [
"12109"
],
"CVE-2010-1316": [
"12131"
],
"CVE-2009-3732": [
"12188"
],
"CVE-2010-1159": [
"12217"
],
"CVE-2010-1687": [
"12240"
],
"CVE-2010-4259": [
"15732"
],
"CVE-2010-1460": [
"12252"
],
"CVE-2010-0017": [
"12258"
],
"CVE-2010-0477": [
"12273"
],
"CVE-2010-0476": [
"12273"
],
"CVE-2010-0270": [
"12273"
],
"CVE-2010-0269": [
"12273"
],
"CVE-2010-1318": [
"12274",
"16452"
],
"CVE-2010-1033": [
"12302"
],
"CVE-2010-0740": [
"12334"
],
"CVE-2010-1894": [
"12336",
"14611"
],
"CVE-2010-1735": [
"12336"
],
"CVE-2010-1734": [
"12337"
],
"CVE-2010-0105": [
"12375"
],
"CVE-2008-5821": [
"12408",
"32694",
"32695"
],
"CVE-2010-0050": [
"12425"
],
"CVE-2010-2028": [
"12482",
"12530"
],
"CVE-2009-3270": [
"12509"
],
"CVE-2008-7246": [
"12509"
],
"CVE-2008-7245": [
"12509"
],
"CVE-2008-7244": [
"12509"
],
"CVE-2010-0028": [
"12518"
],
"CVE-2010-0816": [
"12564"
],
"CVE-2010-1280": [
"12578"
],
"CVE-2007-1683": [
"12605",
"3877"
],
"CVE-2013-2470": [
"28050"
],
"CVE-2010-2115": [
"12683"
],
"CVE-2010-2102": [
"12740"
],
"CVE-2010-1296": [
"12751",
"12752",
"12753"
],
"CVE-2010-1938": [
"12762"
],
"CVE-2016-4135": [
"40087"
],
"CVE-2016-4136": [
"40088"
],
"CVE-2016-4137": [
"40089"
],
"CVE-2016-4138": [
"40090"
],
"CVE-2016-4205": [
"40095"
],
"CVE-2012-5329": [
"18615",
"36972"
],
"CVE-2010-2321": [
"13817"
],
"CVE-2010-2310": [
"13836"
],
"CVE-2010-2332": [
"13871"
],
"CVE-2010-2330": [
"13876"
],
"CVE-2010-2505": [
"13888"
],
"CVE-2010-2351": [
"13906"
],
"CVE-2010-2349": [
"13920"
],
"CVE-2010-3885": [
"13921"
],
"CVE-2010-3227": [
"13921"
],
"CVE-2010-2439": [
"13934",
"13942",
"14397"
],
"CVE-2010-2440": [
"13965"
],
"CVE-2010-2020": [
"14003",
"14002"
],
"CVE-2010-1930": [
"14010"
],
"CVE-2010-1929": [
"14010"
],
"CVE-2010-2435": [
"14012"
],
"CVE-2010-3886": [
"14295"
],
"CVE-2010-2204": [
"14121"
],
"CVE-2010-2549": [
"14156"
],
"CVE-2010-2156": [
"14185"
],
"CVE-2010-2621": [
"14268"
],
"CVE-2010-2777": [
"14379"
],
"CVE-2010-1205": [
"14422"
],
"CVE-2010-2932": [
"14504",
"14505",
"14519"
],
"CVE-2010-5075": [
"14533"
],
"CVE-2010-2008": [
"14537"
],
"CVE-2010-2482": [
"14573"
],
"CVE-2010-1173": [
"14594"
],
"CVE-2010-2550": [
"14607"
],
"CVE-2010-1897": [
"14608"
],
"CVE-2010-2561": [
"14609"
],
"CVE-2010-2862": [
"14642"
],
"CVE-2007-3336": [
"14646"
],
"CVE-2010-1888": [
"14666"
],
"CVE-2010-1889": [
"14667"
],
"CVE-2010-1887": [
"14669"
],
"CVE-2010-1890": [
"14670"
],
"CVE-2010-1818": [
"14843",
"16589"
],
"CVE-2010-0519": [
"14869"
],
"CVE-2010-2703": [
"14916",
"17030"
],
"CVE-2010-1199": [
"14949",
"34192"
],
"CVE-2010-1813": [
"14967"
],
"CVE-2010-1900": [
"14971"
],
"CVE-2010-3396": [
"14987"
],
"CVE-2010-3000": [
"14992"
],
"CVE-2010-1248": [
"15019",
"15065"
],
"CVE-2010-1214": [
"15027",
"34358"
],
"CVE-2010-0520": [
"15035"
],
"CVE-2010-0824": [
"15065"
],
"CVE-2010-2866": [
"15076"
],
"CVE-2010-2553": [
"15112",
"15122"
],
"CVE-2010-2168": [
"15086"
],
"CVE-2010-0480": [
"15096",
"14895",
"17659"
],
"CVE-2010-2752": [
"15104"
],
"CVE-2010-1245": [
"15148"
],
"CVE-2010-2738": [
"15158"
],
"CVE-2010-1899": [
"15167"
],
"CVE-2010-3631": [
"15212"
],
"CVE-2010-2632": [
"15215"
],
"CVE-2010-2745": [
"15242"
],
"CVE-2010-3503": [
"15245"
],
"CVE-2010-4371": [
"15248",
"15287",
"15312"
],
"CVE-2010-4142": [
"15259",
"15337",
"16382",
"16383",
"16384"
],
"CVE-2010-4057": [
"15261"
],
"CVE-2010-4056": [
"15261"
],
"CVE-2010-4055": [
"15261"
],
"CVE-2010-3329": [
"15262"
],
"CVE-2010-2891": [
"15293"
],
"CVE-2010-3639": [
"15426"
],
"CVE-2010-3765": [
"15341",
"15342",
"15352",
"16509"
],
"CVE-2010-3962": [
"15418",
"15421",
"16551"
],
"CVE-2010-4091": [
"15419"
],
"CVE-2010-3709": [
"15431"
],
"CVE-2010-4711": [
"15463"
],
"CVE-2010-4717": [
"15464"
],
"CVE-2010-3678": [
"15467"
],
"CVE-2010-3894": [
"15474"
],
"CVE-2010-3899": [
"15476"
],
"CVE-2010-1840": [
"15491"
],
"CVE-2010-4230": [
"15504"
],
"CVE-2010-4234": [
"15508"
],
"CVE-2010-4243": [
"15619"
],
"CVE-2010-3858": [
"15619"
],
"CVE-2010-4249": [
"15622"
],
"CVE-2010-4300": [
"15676"
],
"CVE-2010-4557": [
"15707"
],
"CVE-2010-3971": [
"15708",
"15746",
"16533"
],
"CVE-2010-4409": [
"15722"
],
"CVE-2010-3972": [
"15803"
],
"CVE-2010-3944": [
"15758"
],
"CVE-2010-4597": [
"15767"
],
"CVE-2010-4701": [
"15839"
],
"CVE-2010-2744": [
"15894"
],
"CVE-2011-0502": [
"15897"
],
"CVE-2010-4538": [
"15898"
],
"CVE-2010-4051": [
"15935"
],
"CVE-2010-4052": [
"15935",
"35061"
],
"CVE-2011-0514": [
"15940"
],
"CVE-2010-4301": [
"15973"
],
"CVE-2010-4254": [
"15974"
],
"CVE-2011-0507": [
"15986"
],
"CVE-2011-0489": [
"15988"
],
"CVE-2011-0517": [
"15992",
"17430"
],
"CVE-2011-0515": [
"15998"
],
"CVE-2011-0652": [
"16021"
],
"CVE-2010-4709": [
"16040"
],
"CVE-2011-0901": [
"16095"
],
"CVE-2011-0900": [
"16095"
],
"CVE-2011-0522": [
"16108"
],
"CVE-2011-1137": [
"16129"
],
"CVE-2011-0654": [
"16166"
],
"CVE-2011-0420": [
"16182",
"35354"
],
"CVE-2011-0917": [
"16190"
],
"CVE-2010-4323": [
"16191"
],
"CVE-2010-4328": [
"16192"
],
"CVE-2010-4227": [
"16234"
],
"CVE-2011-0708": [
"16261"
],
"CVE-2011-0045": [
"16262"
],
"CVE-2010-4165": [
"16263",
"16952"
],
"CVE-2011-0762": [
"16270"
],
"CVE-2004-0397": [
"16284",
"304",
"9935"
],
"CVE-2005-1983": [
"16365",
"1146",
"1149",
"1179"
],
"CVE-2017-2474": [
"41793"
],
"CVE-2009-4265": [
"16657",
"10319",
"10332"
],
"CVE-2017-2489": [
"41798"
],
"CVE-2004-0313": [
"16790",
"156",
"23732",
"23733",
"23734"
],
"CVE-2009-3699": [
"16929"
],
"CVE-2011-1092": [
"16966"
],
"CVE-2010-4077": [
"16973"
],
"CVE-2011-0421": [
"17004"
],
"CVE-2011-1525": [
"17019"
],
"CVE-2010-4228": [
"17020"
],
"CVE-2011-1564": [
"17025"
],
"CVE-2011-1563": [
"17025"
],
"CVE-2011-1547": [
"17097"
],
"CVE-2011-1071": [
"17120"
],
"CVE-2011-1206": [
"17188"
],
"CVE-2012-2386": [
"17201"
],
"CVE-2011-1761": [
"17222"
],
"CVE-2011-0978": [
"17227"
],
"CVE-2011-0614": [
"17278"
],
"CVE-2011-2194": [
"17372"
],
"CVE-2011-2641": [
"17396"
],
"CVE-2011-1872": [
"17401"
],
"CVE-2011-1865": [
"17458",
"17467",
"17468",
"17490"
],
"CVE-2011-1866": [
"17461"
],
"CVE-2011-0041": [
"17544"
],
"CVE-2011-0222": [
"17567",
"17575"
],
"CVE-2010-3609": [
"17610"
],
"CVE-2011-1276": [
"17643"
],
"CVE-2011-2900": [
"17658",
"17669"
],
"CVE-2014-5329": [
"17696",
"18221"
],
"CVE-2011-3192": [
"17696",
"18221"
],
"CVE-2011-2131": [
"17712"
],
"CVE-2017-1130": [
"42604"
],
"CVE-2011-2918": [
"17769"
],
"CVE-2012-0242": [
"17772"
],
"CVE-2012-0241": [
"17772",
"18051"
],
"CVE-2011-1248": [
"17830"
],
"CVE-2011-1984": [
"17831"
],
"CVE-2011-3486": [
"17835"
],
"CVE-2011-3488": [
"17836"
],
"CVE-2011-3494": [
"17837",
"17880"
],
"CVE-2011-3493": [
"17838",
"17884"
],
"CVE-2011-3501": [
"17839"
],
"CVE-2011-3492": [
"17841",
"17855"
],
"CVE-2011-3499": [
"17842"
],
"CVE-2011-3498": [
"17842"
],
"CVE-2011-3491": [
"17842"
],
"CVE-2011-3489": [
"17843"
],
"CVE-2011-3497": [
"17844"
],
"CVE-2011-3496": [
"17844",
"17848"
],
"CVE-2011-3495": [
"17844"
],
"CVE-2011-3490": [
"17844",
"17848"
],
"CVE-2011-5166": [
"17856",
"17819",
"17870",
"18089"
],
"CVE-2011-4045": [
"17896"
],
"CVE-2011-4044": [
"17896",
"17975"
],
"CVE-2011-4043": [
"17896"
],
"CVE-2011-4042": [
"17896"
],
"CVE-2011-0182": [
"17901"
],
"CVE-2011-4062": [
"17908"
],
"CVE-2011-3633": [
"17908"
],
"CVE-2011-2443": [
"17918"
],
"CVE-2011-2841": [
"17929"
],
"CVE-2011-4883": [
"17963"
],
"CVE-2011-4882": [
"17963"
],
"CVE-2011-4881": [
"17963"
],
"CVE-2011-4880": [
"17963"
],
"CVE-2011-4871": [
"17965"
],
"CVE-2011-2003": [
"17978"
],
"CVE-2011-1965": [
"17981"
],
"CVE-2011-1985": [
"18024"
],
"CVE-2011-4520": [
"18049"
],
"CVE-2011-4519": [
"18049"
],
"CVE-2011-4518": [
"18049"
],
"CVE-2011-5012": [
"18119"
],
"CVE-2012-5049": [
"18112"
],
"CVE-2012-5048": [
"18112"
],
"CVE-2011-5129": [
"18159"
],
"CVE-2011-4532": [
"18165"
],
"CVE-2011-4531": [
"18165"
],
"CVE-2011-4530": [
"18165"
],
"CVE-2011-4529": [
"18165"
],
"CVE-2011-4879": [
"18166"
],
"CVE-2011-4878": [
"18166"
],
"CVE-2011-4877": [
"18166"
],
"CVE-2011-4876": [
"18166"
],
"CVE-2011-4875": [
"18166"
],
"CVE-2011-5173": [
"18173"
],
"CVE-2011-4720": [
"18188"
],
"CVE-2011-4040": [
"18196",
"18057"
],
"CVE-2011-5171": [
"18220",
"18747"
],
"CVE-2011-5033": [
"18225"
],
"CVE-2011-5233": [
"18257"
],
"CVE-2011-5043": [
"18254"
],
"CVE-2012-0025": [
"18256"
],
"CVE-2011-5232": [
"18256"
],
"CVE-2011-5049": [
"18269"
],
"CVE-2011-5046": [
"18275"
],
"CVE-2011-4362": [
"18295"
],
"CVE-2011-4885": [
"18296",
"18305",
"2012"
],
"CVE-2012-0904": [
"18309"
],
"CVE-2011-4191": [
"18327",
"18328",
"18351"
],
"CVE-2012-0902": [
"18336"
],
"CVE-2012-6044": [
"18337"
],
"CVE-2012-6042": [
"18339"
],
"CVE-2012-0781": [
"18370"
],
"CVE-2011-4153": [
"18370"
],
"CVE-2012-0207": [
"18378"
],
"CVE-2012-5324": [
"18427"
],
"CVE-2012-0809": [
"18436",
"25134"
],
"CVE-2012-1008": [
"18453"
],
"CVE-2012-1009": [
"18454"
],
"CVE-2012-0830": [
"18460"
],
"CVE-2012-0292": [
"18493"
],
"CVE-2012-1783": [
"18524"
],
"CVE-2012-1465": [
"18541",
"18604"
],
"CVE-2011-4189": [
"18546"
],
"CVE-2012-1502": [
"18579"
],
"CVE-2012-1774": [
"18584"
],
"CVE-2012-0002": [
"18606"
],
"CVE-2012-2210": [
"18705"
],
"CVE-2012-2027": [
"18633"
],
"CVE-2012-4865": [
"18636"
],
"CVE-2012-4864": [
"18637"
],
"CVE-2012-0284": [
"18641",
"20202"
],
"CVE-2015-6750": [
"18643"
],
"CVE-2012-5002": [
"18643",
"18658"
],
"CVE-2012-1904": [
"18661"
],
"CVE-2012-5905": [
"18671"
],
"CVE-2012-0407": [
"18688"
],
"CVE-2012-0406": [
"18688"
],
"CVE-2012-5917": [
"18692"
],
"CVE-2012-2277": [
"18734"
],
"CVE-2012-2276": [
"18734"
],
"CVE-2012-0278": [
"18739"
],
"CVE-2012-4330": [
"18751",
"18765"
],
"CVE-2012-4329": [
"18751",
"18765"
],
"CVE-2011-1249": [
"18755",
"40564"
],
"CVE-2012-2131": [
"18756"
],
"CVE-2012-2110": [
"18756"
],
"CVE-2012-2396": [
"18757"
],
"CVE-2012-1593": [
"18758"
],
"CVE-2012-4335": [
"18765"
],
"CVE-2012-4334": [
"18765"
],
"CVE-2012-4333": [
"18765",
"19027"
],
"CVE-2012-0163": [
"18777"
],
"CVE-2012-4057": [
"18799"
],
"CVE-2012-2442": [
"18795"
],
"CVE-2012-3845": [
"18816"
],
"CVE-2012-6050": [
"18817"
],
"CVE-2012-6048": [
"18851"
],
"CVE-2012-2612": [
"18853",
"20705"
],
"CVE-2012-2611": [
"18853",
"20705",
"21034"
],
"CVE-2012-2514": [
"18853",
"20705"
],
"CVE-2012-2513": [
"18853",
"20705"
],
"CVE-2012-2512": [
"18853",
"20705"
],
"CVE-2012-2511": [
"18853",
"20705"
],
"CVE-2011-1516": [
"18853"
],
"CVE-2012-1184": [
"18855"
],
"CVE-2012-3797": [
"18878"
],
"CVE-2012-3796": [
"18878"
],
"CVE-2012-3795": [
"18878"
],
"CVE-2012-3794": [
"18878"
],
"CVE-2012-3793": [
"18878"
],
"CVE-2012-3792": [
"18878"
],
"CVE-2012-0181": [
"18894"
],
"CVE-2012-2940": [
"18902"
],
"CVE-2012-0289": [
"18916"
],
"CVE-2012-2393": [
"18918"
],
"CVE-2012-3826": [
"18919"
],
"CVE-2012-3825": [
"18919"
],
"CVE-2012-2392": [
"18919"
],
"CVE-2012-2394": [
"18920"
],
"CVE-2012-3816": [
"18945"
],
"CVE-2012-2763": [
"18956",
"18973"
],
"CVE-2012-0985": [
"18958"
],
"CVE-1999-1015": [
"19046"
],
"CVE-2012-1493": [
"19064",
"19091",
"19099"
],
"CVE-1999-1442": [
"19082"
],
"CVE-1999-1441": [
"19085"
],
"CVE-2012-0677": [
"19098",
"19387"
],
"CVE-1999-0015": [
"19103"
],
"CVE-1999-0513": [
"19117"
],
"CVE-2009-0695": [
"19137",
"9934"
],
"CVE-2009-0693": [
"19137"
],
"CVE-1999-0918": [
"19413",
"19414",
"19415"
],
"CVE-2011-4222": [
"19391",
"19392",
"19393"
],
"CVE-2011-4221": [
"19391",
"19392",
"19393"
],
"CVE-2011-4220": [
"19391",
"19392",
"19393"
],
"CVE-1999-1423": [
"19161"
],
"CVE-2012-1831": [
"19389"
],
"CVE-2012-1830": [
"19388"
],
"CVE-1999-1033": [
"19207"
],
"CVE-1999-1030": [
"19212"
],
"CVE-1999-0771": [
"19225"
],
"CVE-1999-1028": [
"19230"
],
"CVE-1999-0288": [
"19238"
],
"CVE-1999-0804": [
"19241"
],
"CVE-1999-0460": [
"19250"
],
"CVE-1999-0451": [
"19271"
],
"CVE-1999-0400": [
"19272"
],
"CVE-1999-1408": [
"19278"
],
"CVE-1999-1018": [
"19301"
],
"CVE-1999-0441": [
"19410"
],
"CVE-1999-0417": [
"19326"
],
"CVE-2012-0282": [
"19335"
],
"CVE-2012-0277": [
"19336"
],
"CVE-2012-0276": [
"19337",
"19338"
],
"CVE-2012-2614": [
"19340"
],
"CVE-1999-1399": [
"19357"
],
"CVE-1999-0562": [
"19372"
],
"CVE-1999-1557": [
"19377"
],
"CVE-1999-1046": [
"19379"
],
"CVE-1999-1551": [
"19380"
],
"CVE-2012-4357": [
"19409"
],
"CVE-2012-4356": [
"19409"
],
"CVE-2012-4355": [
"19409"
],
"CVE-2012-4354": [
"19409"
],
"CVE-2012-4353": [
"19409"
],
"CVE-2012-3815": [
"19409",
"19025"
],
"CVE-1999-0752": [
"19416"
],
"CVE-1999-1518": [
"19423"
],
"CVE-1999-0770": [
"19436"
],
"CVE-1999-0683": [
"19441"
],
"CVE-1999-0681": [
"19445"
],
"CVE-1999-0867": [
"19457"
],
"CVE-1999-0746": [
"19463"
],
"CVE-1999-1016": [
"19471"
],
"CVE-1999-1515": [
"19477"
],
"CVE-2012-3236": [
"19482"
],
"CVE-2012-3585": [
"19483"
],
"CVE-2000-0489": [
"19488"
],
"CVE-1999-0912": [
"19505"
],
"CVE-1999-0908": [
"19507"
],
"CVE-1999-1533": [
"19513"
],
"CVE-1999-0063": [
"19531"
],
"CVE-1999-0045": [
"19536"
],
"CVE-1999-0931": [
"19562"
],
"CVE-1999-0905": [
"19564"
],
"CVE-1999-0950": [
"19569",
"19570"
],
"CVE-1999-1532": [
"19571"
],
"CVE-1999-0980": [
"19577",
"19578"
],
"CVE-1999-0986": [
"19675"
],
"CVE-1999-0904": [
"19596"
],
"CVE-2012-3375": [
"19605"
],
"CVE-1999-0848": [
"19615"
],
"CVE-1999-1539": [
"19619"
],
"CVE-1999-1519": [
"19624"
],
"CVE-1999-0999": [
"19638"
],
"CVE-1999-0844": [
"19639",
"19640"
],
"CVE-1999-0838": [
"19664"
],
"CVE-1999-0991": [
"19666"
],
"CVE-2000-0032": [
"19681"
],
"CVE-2000-0001": [
"19687"
],
"CVE-2000-0014": [
"19695"
],
"CVE-1999-1109": [
"19701"
],
"CVE-2000-0043": [
"19702"
],
"CVE-2000-0011": [
"19703"
],
"CVE-2000-0056": [
"19711"
],
"CVE-2000-0049": [
"19720"
],
"CVE-2000-0075": [
"19725"
],
"CVE-2000-0131": [
"19740"
],
"CVE-2000-0146": [
"19744"
],
"CVE-2000-0152": [
"19746"
],
"CVE-2000-0139": [
"19748"
],
"CVE-2000-0142": [
"19750"
],
"CVE-2000-0166": [
"19755"
],
"CVE-2000-0211": [
"19759"
],
"CVE-2000-0212": [
"19760"
],
"CVE-2000-0221": [
"19766"
],
"CVE-2012-6303": [
"19772"
],
"CVE-2012-1858": [
"19777"
],
"CVE-2000-0204": [
"19780"
],
"CVE-2000-0179": [
"19782"
],
"CVE-1999-0744": [
"19783",
"263",
"19705"
],
"CVE-2000-0168": [
"19799"
],
"CVE-2000-0198": [
"19806",
"19807"
],
"CVE-2000-0239": [
"19810"
],
"CVE-2000-0227": [
"19818"
],
"CVE-2000-0243": [
"19820"
],
"CVE-2000-0232": [
"19827"
],
"CVE-2000-0280": [
"19834"
],
"CVE-2000-0278": [
"19835"
],
"CVE-2000-0262": [
"19843"
],
"CVE-2000-0286": [
"19850"
],
"CVE-2000-0263": [
"19850"
],
"CVE-2000-0256": [
"19853"
],
"CVE-2000-0257": [
"19854"
],
"CVE-2000-0272": [
"19856"
],
"CVE-2012-1744": [
"19960"
],
"CVE-2000-1198": [
"19869"
],
"CVE-2000-0338": [
"19870"
],
"CVE-2000-0324": [
"19880"
],
"CVE-2000-0341": [
"19884"
],
"CVE-2003-0336": [
"19885"
],
"CVE-2000-0342": [
"19885",
"22627",
"23398",
"23399"
],
"CVE-2000-0440": [
"19896"
],
"CVE-2000-0426": [
"19899"
],
"CVE-2000-0408": [
"19907"
],
"CVE-1999-0416": [
"19919"
],
"CVE-2000-0395": [
"19920"
],
"CVE-2000-0417": [
"19923"
],
"CVE-2000-0444": [
"19965"
],
"CVE-2000-0463": [
"19938"
],
"CVE-2000-0394": [
"19940",
"19941"
],
"CVE-2000-0453": [
"19950"
],
"CVE-2012-1770": [
"19961"
],
"CVE-2012-1769": [
"19962"
],
"CVE-2000-0495": [
"19974"
],
"CVE-2000-0474": [
"19977"
],
"CVE-2000-0476": [
"19984"
],
"CVE-2000-0482": [
"19994"
],
"CVE-2000-0538": [
"19996"
],
"CVE-2000-0377": [
"20005",
"20006"
],
"CVE-2000-0473": [
"20015"
],
"CVE-2000-0480": [
"20016"
],
"CVE-2000-0484": [
"20017"
],
"CVE-2000-0501": [
"20020"
],
"CVE-2000-0504": [
"20023"
],
"CVE-2000-0508": [
"20025"
],
"CVE-2000-0531": [
"20026"
],
"CVE-2000-0601": [
"20039"
],
"CVE-2000-0581": [
"20047"
],
"CVE-2000-0582": [
"20049"
],
"CVE-2000-0569": [
"20051"
],
"CVE-2000-0570": [
"20052"
],
"CVE-2000-0571": [
"20054"
],
"CVE-2000-0648": [
"20069"
],
"CVE-2000-1078": [
"20071"
],
"CVE-2000-0669": [
"20072"
],
"CVE-2000-0626": [
"20080",
"20085"
],
"CVE-2000-0636": [
"20090"
],
"CVE-2000-0624": [
"20094"
],
"CVE-2000-0655": [
"20098"
],
"CVE-2000-0656": [
"20099"
],
"CVE-2000-0644": [
"20100"
],
"CVE-2000-0645": [
"20101"
],
"CVE-2000-0647": [
"20102"
],
"CVE-2017-9675": [
"43147"
],
"CVE-2011-2702": [
"20167"
],
"CVE-2000-1002": [
"20175"
],
"CVE-2000-0708": [
"20175"
],
"CVE-2000-0766": [
"20178"
],
"CVE-2000-0880": [
"20192"
],
"CVE-2000-0829": [
"20217"
],
"CVE-2000-0830": [
"20219"
],
"CVE-2000-0833": [
"20221"
],
"CVE-2000-1021": [
"20225"
],
"CVE-2012-3549": [
"20226"
],
"CVE-2000-1035": [
"20228"
],
"CVE-2000-0848": [
"20229"
],
"CVE-2000-0908": [
"20233"
],
"CVE-2000-1058": [
"20239"
],
"CVE-2000-0914": [
"20271"
],
"CVE-1999-0926": [
"20272"
],
"CVE-1999-0925": [
"20272"
],
"CVE-2000-0953": [
"20282"
],
"CVE-2000-0983": [
"20289"
],
"CVE-1999-0970": [
"20304"
],
"CVE-2000-0991": [
"20307"
],
"CVE-2000-0167": [
"20310"
],
"CVE-2000-0971": [
"20311"
],
"CVE-2000-0984": [
"20323"
],
"CVE-2000-0989": [
"20328"
],
"CVE-1999-0193": [
"20331",
"20332"
],
"CVE-2000-1025": [
"20336"
],
"CVE-2017-11861": [
"43153"
],
"CVE-2000-1028": [
"20373",
"245"
],
"CVE-2000-0299": [
"20379"
],
"CVE-2000-0887": [
"20388"
],
"CVE-2000-0897": [
"20403"
],
"CVE-2000-1129": [
"20432"
],
"CVE-1999-0153 ": [
"20437"
],
"CVE-1999-0153": [
"20438",
"20439",
"20440"
],
"CVE-2001-0052": [
"20470"
],
"CVE-2001-0041": [
"20473"
],
"CVE-1999-0178": [
"20484"
],
"CVE-2001-0049": [
"20487"
],
"CVE-2001-0026": [
"20494"
],
"CVE-1999-0140": [
"20508"
],
"CVE-2001-0080": [
"20509"
],
"CVE-2001-0097": [
"20518"
],
"CVE-2001-0122": [
"20531"
],
"CVE-2001-0007": [
"20532"
],
"CVE-2001-0177": [
"20534"
],
"CVE-2001-0172": [
"20535"
],
"CVE-2001-0322": [
"20552"
],
"CVE-1999-0107": [
"20558"
],
"CVE-1999-0144": [
"20561",
"20562"
],
"CVE-1999-0294": [
"20564"
],
"CVE-1999-0431": [
"20566"
],
"CVE-2001-0324": [
"20613"
],
"CVE-2001-0270": [
"20644"
],
"CVE-2001-0184": [
"20589"
],
"CVE-2001-0006": [
"20596"
],
"CVE-2001-0302": [
"20634"
],
"CVE-2001-0277": [
"20641"
],
"CVE-2001-0298": [
"20650"
],
"CVE-2001-0564": [
"20654"
],
"CVE-2001-0647": [
"20655"
],
"CVE-2001-0697": [
"20659"
],
"CVE-2001-0171": [
"20662"
],
"CVE-2001-0151": [
"20664"
],
"CVE-2001-0460": [
"20681"
],
"CVE-2001-0584": [
"20696"
],
"CVE-2001-0375": [
"20734"
],
"CVE-2001-0579": [
"20735"
],
"CVE-2001-0578": [
"20736"
],
"CVE-2001-0575": [
"20737"
],
"CVE-2001-0576": [
"20739"
],
"CVE-2001-0577": [
"20742"
],
"CVE-2001-0419": [
"20747"
],
"CVE-2001-0432": [
"20750"
],
"CVE-2001-0390": [
"20753"
],
"CVE-2001-0239": [
"20763"
],
"CVE-2001-0385": [
"20770"
],
"CVE-2001-0386": [
"20771"
],
"CVE-2001-0675": [
"20783"
],
"CVE-2001-0442": [
"20792"
],
"CVE-1999-0281": [
"20802"
],
"CVE-1999-0016": [
"20810",
"20811",
"20812",
"20813",
"20814"
],
"CVE-2001-0741": [
"20821"
],
"CVE-2001-0566": [
"20824"
],
"CVE-2001-0580": [
"20827"
],
"CVE-2001-0581": [
"20828"
],
"CVE-2001-0558": [
"20830"
],
"CVE-2001-0563": [
"20834"
],
"CVE-2001-0649": [
"20844"
],
"CVE-2001-0646": [
"20845"
],
"CVE-2001-0336": [
"20846"
],
"CVE-2001-0740": [
"20847"
],
"CVE-2001-0746": [
"20852",
"20853"
],
"CVE-2001-0616": [
"20883"
],
"CVE-2001-1263": [
"20904"
],
"CVE-2001-0348": [
"20907"
],
"CVE-2001-0706": [
"20922"
],
"CVE-2001-0500": [
"20930",
"16472",
"20931",
"20932",
"20933"
],
"CVE-2001-0702": [
"20946"
],
"CVE-2001-0703": [
"20949"
],
"CVE-2001-1078": [
"20952",
"49",
"20953",
"20954"
],
"CVE-2012-4170": [
"20971"
],
"CVE-2001-1083": [
"20973"
],
"CVE-2001-1243": [
"20989",
"20991"
],
"CVE-2001-1244": [
"20997"
],
"CVE-1999-1569": [
"21012"
],
"CVE-2016-4275": [
"40421"
],
"CVE-2001-1097": [
"21028"
],
"CVE-2001-1055": [
"21040"
],
"CVE-2001-1289": [
"21042"
],
"CVE-2001-1122": [
"21047"
],
"CVE-2001-0965": [
"21074"
],
"CVE-2001-1133": [
"21077"
],
"CVE-2001-1064": [
"21092"
],
"CVE-2001-1518": [
"21099"
],
"CVE-2001-1137": [
"21103"
],
"CVE-2001-0907": [
"21122"
],
"CVE-2001-0663": [
"21123"
],
"CVE-2001-0830": [
"21126"
],
"CVE-2001-1560": [
"21131"
],
"CVE-2001-0852": [
"21141"
],
"CVE-2001-0932": [
"21162",
"21163"
],
"CVE-2001-1559": [
"21167"
],
"CVE-2001-0952": [
"21170"
],
"CVE-2001-0951": [
"21171",
"21172"
],
"CVE-2001-1184": [
"21174",
"21175"
],
"CVE-2001-1186": [
"21177"
],
"CVE-2015-0040": [
"40757"
],
"CVE-2001-1491": [
"21181"
],
"CVE-2001-1490": [
"21181"
],
"CVE-2001-1489": [
"21181"
],
"CVE-2002-0115": [
"21213"
],
"CVE-2012-3221": [
"21224"
],
"CVE-2002-0128": [
"21228"
],
"CVE-2002-0135": [
"21234"
],
"CVE-2002-0140": [
"21236"
],
"CVE-2002-0201": [
"21237"
],
"CVE-2002-2105": [
"21240"
],
"CVE-2002-1712": [
"21245",
"21246"
],
"CVE-2002-2071": [
"21261"
],
"CVE-2002-0227": [
"21262"
],
"CVE-2002-1773": [
"21275"
],
"CVE-2002-0289": [
"21293",
"21294"
],
"CVE-2002-0013": [
"21296"
],
"CVE-2002-0336": [
"21305"
],
"CVE-2002-0335": [
"21306"
],
"CVE-2002-0338": [
"21307"
],
"CVE-2012-0271": [
"21326"
],
"CVE-2002-0448": [
"21336"
],
"CVE-2002-0406": [
"21337"
],
"CVE-2002-0431": [
"21338"
],
"CVE-2002-0454": [
"21345"
],
"CVE-2002-0461": [
"21346"
],
"CVE-2002-0552": [
"21379"
],
"CVE-2002-0595": [
"21387"
],
"CVE-2002-0597": [
"21388",
"21389"
],
"CVE-2002-1714": [
"21404"
],
"CVE-2002-0748": [
"21413"
],
"CVE-2002-0606": [
"21429"
],
"CVE-2000-1193": [
"21431"
],
"CVE-2002-0106": [
"21432"
],
"CVE-2002-2315": [
"21465"
],
"CVE-2002-0894": [
"21471"
],
"CVE-2002-0886": [
"21472"
],
"CVE-2002-1827": [
"21476",
"21477"
],
"CVE-2002-1831": [
"21481"
],
"CVE-2002-0900": [
"21482"
],
"CVE-2002-0876": [
"21498"
],
"CVE-2002-0913": [
"21512"
],
"CVE-2011-1613": [
"21523"
],
"CVE-2002-0936": [
"21534"
],
"CVE-2002-0937": [
"21536"
],
"CVE-2002-1891": [
"21537"
],
"CVE-2002-2338": [
"21539"
],
"CVE-2002-0186": [
"21540"
],
"CVE-2002-1766": [
"21544"
],
"CVE-2002-1705": [
"21556"
],
"CVE-2002-1071": [
"21561"
],
"CVE-2002-0859": [
"21569"
],
"CVE-2002-0964": [
"21572"
],
"CVE-2002-0653": [
"21575"
],
"CVE-2002-1013": [
"21580"
],
"CVE-2002-1029": [
"21594"
],
"CVE-2002-1023": [
"21600"
],
"CVE-2002-1043": [
"21612"
],
"CVE-2002-1028": [
"21620"
],
"CVE-2002-2309": [
"21632"
],
"CVE-2002-1059": [
"21634",
"16460",
"21635"
],
"CVE-2002-1072": [
"21637"
],
"CVE-2002-2325": [
"21644"
],
"CVE-2002-2306": [
"21653"
],
"CVE-2002-0813": [
"21655"
],
"CVE-2002-2149": [
"21656"
],
"CVE-2002-1426": [
"21657"
],
"CVE-2002-1077": [
"21673"
],
"CVE-2002-2174": [
"21694"
],
"CVE-2002-1444": [
"21712"
],
"CVE-2012-6307": [
"21739"
],
"CVE-2012-4988": [
"21741"
],
"CVE-2002-0724": [
"21746",
"21747"
],
"CVE-2002-1811": [
"21756"
],
"CVE-2002-1101": [
"21770"
],
"CVE-2002-2370": [
"21775"
],
"CVE-2002-2164": [
"21789"
],
"CVE-2002-1501": [
"21791"
],
"CVE-2002-1828": [
"21792"
],
"CVE-2002-1489": [
"21795"
],
"CVE-2002-1486": [
"21813",
"21816",
"21823",
"21804",
"21810"
],
"CVE-2002-1488": [
"21821"
],
"CVE-2002-1147": [
"21828"
],
"CVE-2002-1850": [
"21854"
],
"CVE-2012-5470": [
"21889"
],
"CVE-2002-1522": [
"21907",
"21908",
"21909"
],
"CVE-2002-0386": [
"21911"
],
"CVE-2002-2336": [
"21915"
],
"CVE-2009-4462": [
"33403",
"10451"
],
"CVE-2002-1897": [
"21935"
],
"CVE-2002-1907": [
"21938"
],
"CVE-2002-1906": [
"21939"
],
"CVE-2002-1905": [
"21941"
],
"CVE-2002-1911": [
"21943"
],
"CVE-2002-1169": [
"21949"
],
"CVE-2002-1561": [
"21951",
"21952",
"21953",
"21954"
],
"CVE-2002-1542": [
"21963"
],
"CVE-2002-1539": [
"21965"
],
"CVE-2002-2379": [
"21971"
],
"CVE-2002-1862": [
"21972"
],
"CVE-2002-1945": [
"21973"
],
"CVE-2002-1236": [
"21975"
],
"CVE-2002-1865": [
"21978"
],
"CVE-2002-1663": [
"21981"
],
"CVE-2002-1248": [
"21982"
],
"CVE-2002-1983": [
"21984"
],
"CVE-2002-1320": [
"21985"
],
"CVE-2012-4750": [
"22006"
],
"CVE-2002-2385": [
"22010"
],
"CVE-2002-1220": [
"22011"
],
"CVE-2002-2404": [
"22019"
],
"CVE-2002-1322": [
"22031"
],
"CVE-2002-2258": [
"22053"
],
"CVE-2002-2295": [
"22056"
],
"CVE-2002-2300": [
"22060"
],
"CVE-2002-1580": [
"22061"
],
"CVE-2002-2272": [
"22068"
],
"CVE-2002-2232": [
"22081"
],
"CVE-2002-1380": [
"22105"
],
"CVE-2003-1263": [
"22117",
"22118"
],
"CVE-2003-1275": [
"22119"
],
"CVE-2003-1266": [
"22121",
"22122",
"22123",
"22124"
],
"CVE-2003-1342": [
"22172"
],
"CVE-2003-1354": [
"22183"
],
"CVE-2003-0056": [
"22197"
],
"CVE-2003-1369": [
"22220"
],
"CVE-2003-1368": [
"22221"
],
"CVE-2003-1431": [
"22223"
],
"CVE-2001-0909": [
"22232"
],
"CVE-2003-1387": [
"22239"
],
"CVE-2003-1397": [
"22240"
],
"CVE-2003-1445": [
"22243"
],
"CVE-2003-1407": [
"22245"
],
"CVE-2003-0087": [
"22249"
],
"CVE-1999-1566": [
"22250"
],
"CVE-2003-1450": [
"22259"
],
"CVE-2003-0107": [
"22273",
"22274"
],
"CVE-2003-1419": [
"22287"
],
"CVE-2003-1355": [
"22290"
],
"CVE-2003-0108": [
"22294"
],
"CVE-2003-0125": [
"22345"
],
"CVE-2003-0128": [
"22370"
],
"CVE-2012-5409": [
"22397"
],
"CVE-2012-4515": [
"22406"
],
"CVE-2012-4514": [
"22406"
],
"CVE-2012-4513": [
"22406"
],
"CVE-2012-4512": [
"22406"
],
"CVE-2003-0220": [
"22417",
"28",
"1537",
"16465",
"22418"
],
"CVE-2003-0166": [
"22419",
"22425",
"22426"
],
"CVE-2003-0169": [
"22447"
],
"CVE-2003-1364": [
"22460"
],
"CVE-2003-1054": [
"22505"
],
"CVE-2003-0211": [
"22508"
],
"CVE-2003-0390": [
"22537",
"22538"
],
"CVE-2003-1396": [
"22550"
],
"CVE-2003-1472": [
"22551"
],
"CVE-2003-1097": [
"22552"
],
"CVE-2003-0117": [
"22553"
],
"CVE-2003-1478": [
"22560"
],
"CVE-2003-1461": [
"22561"
],
"CVE-2003-0263": [
"22568",
"22569"
],
"CVE-2003-0280": [
"22581",
"22582"
],
"CVE-2003-0290": [
"22585",
"22586"
],
"CVE-2003-0293": [
"22602"
],
"CVE-2003-0314": [
"22608"
],
"CVE-2003-0315": [
"22610"
],
"CVE-2003-0195": [
"22619"
],
"CVE-2003-0372": [
"22634"
],
"CVE-2003-0371": [
"22637"
],
"CVE-2003-0409": [
"22650"
],
"CVE-2009-5022": [
"22681"
],
"CVE-2016-5725": [
"40411"
],
"CVE-2003-1032": [
"22718"
],
"CVE-2012-2619": [
"22739"
],
"CVE-2003-0487": [
"22800",
"22801",
"22802",
"22803",
"46"
],
"CVE-2003-0470": [
"22816"
],
"CVE-2003-0723": [
"22831",
"22832"
],
"CVE-2003-0478": [
"22839"
],
"CVE-2003-0508": [
"22846"
],
"CVE-2012-3755": [
"22855"
],
"CVE-2012-5533": [
"22902"
],
"CVE-2012-0698": [
"22904"
],
"CVE-2003-0562": [
"22949"
],
"CVE-2003-0625": [
"22952"
],
"CVE-2003-0231": [
"22957"
],
"CVE-2003-0511": [
"22962"
],
"CVE-2003-0595": [
"22926"
],
"CVE-2012-4409": [
"22938",
"22928"
],
"CVE-2003-0540": [
"22981",
"22982"
],
"CVE-2016-3357": [
"40406"
],
"CVE-2016-5310": [
"40405"
],
"CVE-2016-5309": [
"40405"
],
"CVE-2003-1321": [
"23050"
],
"CVE-2003-0760": [
"23056"
],
"CVE-2012-5611": [
"23075"
],
"CVE-2012-5612": [
"23076"
],
"CVE-2012-5614": [
"23078"
],
"CVE-2003-0757": [
"23087"
],
"CVE-2003-0762": [
"23102"
],
"CVE-2012-6470": [
"23107"
],
"CVE-2003-0758": [
"23112"
],
"CVE-2003-0706": [
"23116"
],
"CVE-2003-0766": [
"23117",
"23118"
],
"CVE-2003-0765": [
"23124"
],
"CVE-2003-0780": [
"23138",
"98"
],
"CVE-1999-0284": [
"23145",
"23146",
"23113"
],
"CVE-2003-1158": [
"23166"
],
"CVE-1999-0393": [
"23167"
],
"CVE-2003-0831": [
"23170",
"107",
"110"
],
"CVE-2013-1868": [
"23201"
],
"CVE-2003-0840": [
"23236"
],
"CVE-2003-0864": [
"23239"
],
"CVE-2003-1512": [
"23240",
"23241"
],
"CVE-2003-1518": [
"23242"
],
"CVE-2003-0866": [
"23245"
],
"CVE-2012-5340": [
"23246"
],
"CVE-2013-1773": [
"23248"
],
"CVE-2012-5451": [
"23254"
],
"CVE-2003-0870": [
"23263"
],
"CVE-2003-1177": [
"23267"
],
"CVE-2003-1505": [
"23273"
],
"CVE-2003-0853": [
"23274"
],
"CVE-2003-0896": [
"23276"
],
"CVE-2003-1143": [
"23314"
],
"CVE-2003-1134": [
"23292"
],
"CVE-2003-1135": [
"23293"
],
"CVE-2003-0899": [
"23305",
"23306"
],
"CVE-2003-1191": [
"23311"
],
"CVE-2003-1165": [
"23325"
],
"CVE-2001-1259": [
"23337"
],
"CVE-2003-1050": [
"23347",
"23348",
"23349"
],
"CVE-2012-6007": [
"23361"
],
"CVE-2012-5992": [
"23361"
],
"CVE-2012-5991": [
"23361"
],
"CVE-2003-0376": [
"23374"
],
"CVE-2003-0795": [
"23375"
],
"CVE-2003-0967": [
"23391"
],
"CVE-2017-8751": [
"43151"
],
"CVE-2003-1029": [
"23452"
],
"CVE-2003-1006": [
"23442"
],
"CVE-2004-2082": [
"23693"
],
"CVE-2003-1200": [
"23501",
"16812",
"23502"
],
"CVE-2003-1041": [
"23504"
],
"CVE-2004-1792": [
"23508"
],
"CVE-2004-1781": [
"23512"
],
"CVE-2004-2081": [
"23692"
],
"CVE-2004-0164": [
"23540"
],
"CVE-2012-5875": [
"23574"
],
"CVE-2004-0095": [
"23584"
],
"CVE-2004-2120": [
"23590"
],
"CVE-2004-2117": [
"23595"
],
"CVE-2004-2129": [
"23614"
],
"CVE-2004-0276": [
"23686"
],
"CVE-2004-0282": [
"23689"
],
"CVE-2004-0084": [
"23690"
],
"CVE-2003-1207": [
"23633"
],
"CVE-2004-0244": [
"23638"
],
"CVE-2004-0247": [
"23641",
"23642"
],
"CVE-2004-0245": [
"23648"
],
"CVE-2004-0255": [
"23654"
],
"CVE-2004-0277": [
"23660"
],
"CVE-2004-2077": [
"23662"
],
"CVE-2004-2086": [
"23664",
"16756"
],
"CVE-2004-0264": [
"23665"
],
"CVE-2004-0270": [
"23667"
],
"CVE-2004-2078": [
"23672"
],
"CVE-2004-0268": [
"23681"
],
"CVE-2004-0298": [
"23700"
],
"CVE-2004-0287": [
"23701"
],
"CVE-2004-0286": [
"23708",
"23709"
],
"CVE-2004-0295": [
"23715"
],
"CVE-2004-0299": [
"23716"
],
"CVE-2004-0325": [
"23731"
],
"CVE-2004-2368": [
"23750"
],
"CVE-2004-2371": [
"23755"
],
"CVE-2004-0330": [
"23760",
"23761",
"23762",
"158",
"16715",
"23763"
],
"CVE-2004-2675": [
"23769"
],
"CVE-2012-5667": [
"23779"
],
"CVE-2004-2549": [
"23786"
],
"CVE-2004-2375": [
"23787"
],
"CVE-2004-0361": [
"23793"
],
"CVE-2004-1805": [
"23799"
],
"CVE-2004-2360": [
"23805"
],
"CVE-2004-2449": [
"23902"
],
"CVE-2004-2366": [
"23839"
],
"CVE-2004-2367": [
"23842"
],
"CVE-2004-0375": [
"23846"
],
"CVE-2004-1854": [
"23876"
],
"CVE-2004-1866": [
"23884"
],
"CVE-2004-0386": [
"23896"
],
"CVE-2004-2451": [
"23904"
],
"CVE-2004-1903": [
"23916"
],
"CVE-2004-1904": [
"23917"
],
"CVE-2004-1910": [
"23919"
],
"CVE-2004-1906": [
"23920"
],
"CVE-2004-1907": [
"23925"
],
"CVE-2004-1919": [
"23943"
],
"CVE-2013-0722": [
"23945"
],
"CVE-2012-0722": [
"23945"
],
"CVE-2004-0179": [
"23999"
],
"CVE-2004-1944": [
"24000"
],
"CVE-2004-0389": [
"24010"
],
"CVE-2004-1940": [
"24011"
],
"CVE-2004-2505": [
"24013"
],
"CVE-2012-5877": [
"24022"
],
"CVE-2012-5876": [
"24022"
],
"CVE-2004-1992": [
"24029"
],
"CVE-2004-0214": [
"24051"
],
"CVE-2004-1973": [
"24066"
],
"CVE-2004-1983": [
"24078"
],
"CVE-2004-0437": [
"24080"
],
"CVE-2004-2003": [
"24095"
],
"CVE-2004-2005": [
"24096"
],
"CVE-2004-2727": [
"24103"
],
"CVE-2004-0479": [
"24119"
],
"CVE-2004-2022": [
"24128"
],
"CVE-2004-2286": [
"24130"
],
"CVE-2004-2037": [
"24142"
],
"CVE-2004-2344": [
"24143"
],
"CVE-2004-2035": [
"24144"
],
"CVE-2004-2033": [
"24145",
"24146",
"24147"
],
"CVE-2016-7084": [
"40399"
],
"CVE-2004-0605": [
"24222"
],
"CVE-2004-0618": [
"24233"
],
"CVE-2004-0668": [
"24243"
],
"CVE-2004-2280": [
"24275"
],
"CVE-2004-2519": [
"24282"
],
"CVE-2004-2520": [
"24283"
],
"CVE-2016-7083": [
"40398"
],
"CVE-2004-0722": [
"24346"
],
"CVE-2004-2646": [
"24351"
],
"CVE-2004-2647": [
"24352"
],
"CVE-2004-1701": [
"24360",
"24361"
],
"CVE-2004-1714": [
"24362"
],
"CVE-2004-1728": [
"24386"
],
"CVE-2004-2277": [
"24388"
],
"CVE-2004-1748": [
"24411"
],
"CVE-2004-1643": [
"24416"
],
"CVE-2013-1638": [
"24448"
],
"CVE-2011-0418": [
"24450"
],
"CVE-2012-4914": [
"24463",
"24876"
],
"CVE-2013-1592": [
"24511"
],
"CVE-2013-0658": [
"24474"
],
"CVE-2013-0008": [
"24485",
"27296"
],
"CVE-2013-0249": [
"24487"
],
"CVE-2013-7280": [
"24556",
"29445"
],
"CVE-2005-4316": [
"24634",
"24635",
"24636",
"24637"
],
"CVE-2004-0751": [
"24590"
],
"CVE-2004-1681": [
"24593",
"24594",
"24595",
"24596"
],
"CVE-2004-0558": [
"24599"
],
"CVE-2004-1691": [
"24610"
],
"CVE-2004-1695": [
"24619"
],
"CVE-2004-1699": [
"24621"
],
"CVE-2005-4869": [
"24677"
],
"CVE-2004-2184": [
"24684"
],
"CVE-2004-0816": [
"24696"
],
"CVE-2004-1623": [
"24699"
],
"CVE-2004-2592": [
"24710"
],
"CVE-2013-1828": [
"24747"
],
"CVE-2004-1029": [
"24763"
],
"CVE-2004-1018": [
"24854",
"24855"
],
"CVE-2004-0953": [
"24770"
],
"CVE-2004-1074": [
"24777"
],
"CVE-2004-2761": [
"24807"
],
"CVE-2004-1491": [
"24828"
],
"CVE-2012-1663": [
"24865"
],
"CVE-2013-2760": [
"24930"
],
"CVE-2013-0238": [
"24951"
],
"CVE-2013-2419": [
"24966"
],
"CVE-2013-2416": [
"24966"
],
"CVE-2004-1291": [
"25004"
],
"CVE-2004-1269": [
"25012"
],
"CVE-2004-2652": [
"25046",
"25047"
],
"CVE-2004-1150": [
"25061"
],
"CVE-2005-0312": [
"25063"
],
"CVE-2005-0199": [
"25070"
],
"CVE-2005-0245": [
"25076"
],
"CVE-2005-0101": [
"25077",
"785"
],
"CVE-2003-1085": [
"25124"
],
"CVE-2012-4886": [
"25140"
],
"CVE-2005-0779": [
"25218"
],
"CVE-2005-0815": [
"25234"
],
"CVE-2005-0848": [
"25255"
],
"CVE-2005-0852": [
"25259"
],
"CVE-2005-0904": [
"25268"
],
"CVE-2005-0895": [
"25277"
],
"CVE-2005-0903": [
"25281"
],
"CVE-2005-0750": [
"25287",
"926",
"25288",
"25289"
],
"CVE-2013-4631": [
"25295"
],
"CVE-2013-4630": [
"25295"
],
"CVE-2005-0468": [
"25303"
],
"CVE-2005-0979": [
"25326"
],
"CVE-2005-0984": [
"25329"
],
"CVE-2005-0989": [
"25334"
],
"CVE-2005-0986": [
"25353"
],
"CVE-2005-1086": [
"25364"
],
"CVE-2004-0791": [
"25387"
],
"CVE-2005-1078": [
"25393"
],
"CVE-2005-1125": [
"25429"
],
"CVE-2005-1184": [
"25439"
],
"CVE-2005-1061": [
"25465"
],
"CVE-2005-1204": [
"25470"
],
"CVE-2013-0145": [
"25472"
],
"CVE-2013-2028": [
"25499",
"25775",
"26737",
"32277"
],
"CVE-2005-1275": [
"25527"
],
"CVE-2005-1402": [
"25584"
],
"CVE-2013-3661": [
"25611",
"25912",
"26554"
],
"CVE-2013-3660": [
"25611",
"25912",
"26554"
],
"CVE-2013-3130": [
"25611",
"25912",
"26554"
],
"CVE-2005-1666": [
"25629",
"25631"
],
"CVE-2005-1655": [
"25633"
],
"CVE-2005-1263": [
"25647"
],
"CVE-2005-1618": [
"25658"
],
"CVE-2005-1718": [
"25680"
],
"CVE-2005-1703": [
"25692"
],
"CVE-2005-1741": [
"25699"
],
"CVE-2005-1801": [
"25736"
],
"CVE-2005-1807": [
"25752"
],
"CVE-2005-1899": [
"25791"
],
"CVE-2013-3724": [
"25837"
],
"CVE-2005-3077": [
"26292"
],
"CVE-2013-2765": [
"25852"
],
"CVE-2005-2078": [
"25911"
],
"CVE-2005-2239": [
"25943"
],
"CVE-2005-2242": [
"25967"
],
"CVE-2013-0984": [
"25974"
],
"CVE-2005-1988": [
"25991",
"1144"
],
"CVE-2005-2308": [
"25992"
],
"CVE-2008-1610": [
"26010",
"5315",
"16348"
],
"CVE-2003-0001": [
"26076",
"3555",
"22131"
],
"CVE-2005-2594": [
"26128"
],
"CVE-2013-1606": [
"26138"
],
"CVE-2005-2103": [
"26139"
],
"CVE-2005-2577": [
"26145"
],
"CVE-2013-3543": [
"26173"
],
"CVE-2005-2767": [
"26194"
],
"CVE-2013-6079": [
"26214",
"27316"
],
"CVE-2005-2844": [
"26216"
],
"CVE-2005-2850": [
"26219"
],
"CVE-2005-2898": [
"26220"
],
"CVE-2005-2841": [
"26233"
],
"CVE-2005-2800": [
"26248"
],
"CVE-2005-2904": [
"26249"
],
"CVE-2005-3018": [
"26271"
],
"CVE-2005-2804": [
"26301"
],
"CVE-2005-3206": [
"26331"
],
"CVE-2005-4720": [
"26325"
],
"CVE-2005-3207": [
"26336"
],
"CVE-2005-2661": [
"26340"
],
"CVE-2005-1979": [
"26341",
"1352"
],
"CVE-2005-3262": [
"26342"
],
"CVE-2005-2973": [
"26382"
],
"CVE-2005-4717": [
"26457"
],
"CVE-2005-2709": [
"26489"
],
"CVE-2014-2671": [
"26517",
"26951",
"32477",
"32478",
"32481",
"32482",
"32483"
],
"CVE-2013-4695": [
"26557"
],
"CVE-2013-4694": [
"26558",
"27874"
],
"CVE-2005-3813": [
"26575"
],
"CVE-2005-3862": [
"26601"
],
"CVE-2005-3857": [
"26648"
],
"CVE-2005-3934": [
"26665"
],
"CVE-2005-3694": [
"26666"
],
"CVE-2005-3981": [
"26690"
],
"CVE-2013-2160": [
"26710"
],
"CVE-2005-3807": [
"26749"
],
"CVE-2005-4093": [
"26754"
],
"CVE-2005-4134": [
"26762"
],
"CVE-2005-4131": [
"26769"
],
"CVE-2005-4194": [
"26776"
],
"CVE-2005-4209": [
"26779"
],
"CVE-2013-2784": [
"26802"
],
"CVE-2005-3808": [
"26811"
],
"CVE-2005-4296": [
"26816"
],
"CVE-2005-4276": [
"26834"
],
"CVE-2005-4275": [
"26835"
],
"CVE-2013-4123": [
"26886"
],
"CVE-2013-1950": [
"26887"
],
"CVE-2005-4466": [
"26922"
],
"CVE-2013-4858": [
"26951"
],
"CVE-2005-4503": [
"26967"
],
"CVE-2005-4504": [
"26971"
],
"CVE-2005-3358": [
"27031"
],
"CVE-2013-4890": [
"27043"
],
"CVE-2013-2576": [
"27047"
],
"CVE-2013-2577": [
"27049"
],
"CVE-2013-3174": [
"27050"
],
"CVE-2006-0143": [
"27051"
],
"CVE-2006-0030": [
"27055"
],
"CVE-2005-2340": [
"27069"
],
"CVE-2006-0359": [
"27089",
"27090"
],
"CVE-2006-0306": [
"27101"
],
"CVE-2006-0304": [
"27108"
],
"CVE-2013-0699": [
"27131"
],
"CVE-2005-4676": [
"27140"
],
"CVE-2006-0468": [
"27144"
],
"CVE-2006-0528": [
"27145"
],
"CVE-2006-0539": [
"27159"
],
"CVE-2006-0647": [
"27171"
],
"CVE-2006-0717": [
"27196"
],
"CVE-2006-0738": [
"27210"
],
"CVE-2006-0737": [
"27211"
],
"CVE-2006-0710": [
"27212"
],
"CVE-2006-0797": [
"27232"
],
"CVE-2006-0784": [
"27241"
],
"CVE-2006-0836": [
"27246"
],
"CVE-2006-0884": [
"27257"
],
"CVE-2006-0911": [
"27258"
],
"CVE-2013-5578": [
"27317"
],
"CVE-2006-0925": [
"27329"
],
"CVE-2006-1046": [
"27365"
],
"CVE-2006-1159": [
"27377"
],
"CVE-2006-1214": [
"27407"
],
"CVE-2006-1240": [
"27418"
],
"CVE-2006-1194": [
"27420"
],
"CVE-2006-1275": [
"27421"
],
"CVE-2006-1269": [
"27425"
],
"CVE-2006-1356": [
"27474"
],
"CVE-2006-1510": [
"27476"
],
"CVE-2006-1992": [
"27727"
],
"CVE-2006-1593": [
"27547"
],
"CVE-2006-1618": [
"27566"
],
"CVE-2006-0053": [
"27581"
],
"CVE-2006-1900": [
"27639",
"27640"
],
"CVE-2006-1834": [
"27641"
],
"CVE-2006-2875": [
"27969"
],
"CVE-2006-3637": [
"27971"
],
"CVE-2006-1941": [
"27668"
],
"CVE-2006-1905": [
"27670"
],
"CVE-2013-6283": [
"27700"
],
"CVE-2006-1982": [
"27714"
],
"CVE-2006-1985": [
"27715"
],
"CVE-2006-1931": [
"27723"
],
"CVE-2006-2111": [
"27745"
],
"CVE-2006-2024": [
"27762"
],
"CVE-2006-2025": [
"27764"
],
"CVE-2006-2026": [
"27765"
],
"CVE-2006-2362": [
"27856"
],
"CVE-2013-4776": [
"27775"
],
"CVE-2013-4124": [
"27778"
],
"CVE-2006-2277": [
"27790"
],
"CVE-2006-2230": [
"27791"
],
"CVE-2006-2297": [
"27850"
],
"CVE-2013-5575": [
"27875"
],
"CVE-2006-2426": [
"27882"
],
"CVE-2006-2480": [
"27903"
],
"CVE-2006-2646": [
"27914"
],
"CVE-2006-2629": [
"27925"
],
"CVE-2006-2766": [
"27930"
],
"CVE-2013-4982": [
"27942"
],
"CVE-2013-4981": [
"27942"
],
"CVE-2013-4980": [
"27942"
],
"CVE-2013-3111": [
"40907"
],
"CVE-2006-2661": [
"27993"
],
"CVE-2006-2906": [
"27981"
],
"CVE-2006-2374": [
"28001",
"1911"
],
"CVE-2006-3081": [
"28026"
],
"CVE-2006-3082": [
"28077"
],
"CVE-2013-5716": [
"28080"
],
"CVE-2006-3014": [
"28087"
],
"CVE-2006-3298": [
"28099"
],
"CVE-2006-2310": [
"28100"
],
"CVE-2006-3277": [
"28103"
],
"CVE-2006-1470": [
"28135"
],
"CVE-2006-3354": [
"28145"
],
"CVE-2006-3355": [
"28160"
],
"CVE-2006-3472": [
"28164"
],
"CVE-2006-3372": [
"28165"
],
"CVE-2006-3427": [
"28169"
],
"CVE-2006-3510": [
"28194"
],
"CVE-2006-3513": [
"28196"
],
"CVE-2006-3512": [
"28197"
],
"CVE-2006-3511": [
"28202"
],
"CVE-2006-3591": [
"28207"
],
"CVE-2006-3605": [
"28213"
],
"CVE-2006-3672": [
"28220"
],
"CVE-2006-3653": [
"28222"
],
"CVE-2006-3787": [
"28228"
],
"CVE-2006-3687": [
"28230"
],
"CVE-2006-3696": [
"28232"
],
"CVE-2006-3469": [
"28234"
],
"CVE-2006-3729": [
"28244"
],
"CVE-2006-3910": [
"28246"
],
"CVE-2006-3899": [
"28252"
],
"CVE-2006-3898": [
"28256"
],
"CVE-2006-3746": [
"28257"
],
"CVE-2006-3944": [
"28258"
],
"CVE-2006-3897": [
"28259"
],
"CVE-2006-3880": [
"28263"
],
"CVE-2006-3915": [
"28265"
],
"CVE-2006-4029": [
"28266"
],
"CVE-2006-3943": [
"28286"
],
"CVE-2006-7066": [
"28301"
],
"CVE-2013-5745": [
"28338"
],
"CVE-2006-7065": [
"28343"
],
"CVE-2006-4126": [
"28345"
],
"CVE-2006-4018": [
"28348"
],
"CVE-2006-3468": [
"28358"
],
"CVE-2006-4024": [
"28361"
],
"CVE-2006-4089": [
"28367"
],
"CVE-2006-4374": [
"28369"
],
"CVE-2006-4253": [
"28380"
],
"CVE-2006-4138": [
"28381"
],
"CVE-2006-4144": [
"28383"
],
"CVE-2006-4197": [
"28384"
],
"CVE-2006-3121": [
"28386"
],
"CVE-2006-4193": [
"28387",
"28389"
],
"CVE-2006-4261": [
"28391"
],
"CVE-2006-4494": [
"28401"
],
"CVE-2006-4495": [
"28420"
],
"CVE-2006-4541": [
"28469"
],
"CVE-2006-4611": [
"28491"
],
"CVE-2006-5033": [
"28513"
],
"CVE-2006-4384": [
"28521"
],
"CVE-2006-4832": [
"28542"
],
"CVE-2006-4866": [
"28578"
],
"CVE-2006-4855": [
"28588"
],
"CVE-2006-4178": [
"28648"
],
"CVE-2006-5058": [
"28666"
],
"CVE-2013-5680": [
"28683"
],
"CVE-2006-5177": [
"28735"
],
"CVE-2006-5196": [
"28739"
],
"CVE-2006-6692": [
"28775"
],
"CVE-2006-7157": [
"28785"
],
"CVE-2013-4988": [
"30208",
"30788",
"49959"
],
"CVE-2013-6114": [
"28811"
],
"CVE-2006-7139": [
"28816"
],
"CVE-2006-5395": [
"28822"
],
"CVE-2013-7409": [
"28855",
"29549",
"29798",
"32041",
"32074"
],
"CVE-2006-5568": [
"28860"
],
"CVE-2006-5721": [
"28894"
],
"CVE-2006-5701": [
"28895"
],
"CVE-2006-5726": [
"28911"
],
"CVE-2006-5757": [
"28912"
],
"CVE-2006-5836": [
"28948"
],
"CVE-2011-3918": [
"28957"
],
"CVE-2006-6015": [
"29007"
],
"CVE-2006-7235": [
"29036",
"28984"
],
"CVE-2006-6027": [
"29076"
],
"CVE-2006-6062": [
"29144",
"29161"
],
"CVE-2006-6340": [
"29170"
],
"CVE-2006-6310": [
"29229"
],
"CVE-2006-6311": [
"29236"
],
"CVE-2006-6602": [
"29286"
],
"CVE-2006-6619": [
"29287"
],
"CVE-2006-6752": [
"29305"
],
"CVE-2007-0247": [
"29473"
],
"CVE-2006-6810": [
"29362"
],
"CVE-2014-4138": [
"40960"
],
"CVE-2007-0103": [
"29399"
],
"CVE-2007-0113": [
"29402"
],
"CVE-2007-0165": [
"29406"
],
"CVE-2007-0229": [
"29441"
],
"CVE-2007-0168": [
"29444"
],
"CVE-2007-0264": [
"29447"
],
"CVE-2007-0267": [
"29452"
],
"CVE-2007-0235": [
"29458"
],
"CVE-2007-0342": [
"29461"
],
"CVE-2006-6767": [
"29470"
],
"CVE-2007-0462": [
"29509"
],
"CVE-2007-5332": [
"30046"
],
"CVE-2007-2583": [
"30020"
],
"CVE-2007-2645": [
"30024"
],
"CVE-2007-0010": [
"29520"
],
"CVE-2007-0463": [
"29523"
],
"CVE-2007-0768": [
"29531"
],
"CVE-2007-0465": [
"29532"
],
"CVE-2007-0466": [
"29535"
],
"CVE-2007-0612": [
"29536"
],
"CVE-2016-1848": [
"39839"
],
"CVE-2007-0001": [
"29683"
],
"CVE-2007-0646": [
"29551"
],
"CVE-2007-0647": [
"29553"
],
"CVE-2007-0645": [
"29554"
],
"CVE-2007-0644": [
"29555"
],
"CVE-2007-0708": [
"29558"
],
"CVE-2007-0911": [
"29577"
],
"CVE-2007-1029": [
"29607"
],
"CVE-2007-1008": [
"29616"
],
"CVE-2007-1037": [
"29617",
"29618"
],
"CVE-2007-1071": [
"29620"
],
"CVE-2013-6356": [
"29671",
"30154"
],
"CVE-2007-1090": [
"29659"
],
"CVE-2007-3009": [
"30187"
],
"CVE-2007-1285": [
"29692"
],
"CVE-2006-1549": [
"29693"
],
"CVE-2007-1308": [
"29713"
],
"CVE-2007-1327": [
"29716"
],
"CVE-2007-1371": [
"29717"
],
"CVE-2007-1362": [
"29720"
],
"CVE-2007-1397": [
"29721",
"17181"
],
"CVE-2007-1420": [
"29724"
],
"CVE-2007-1492": [
"29738"
],
"CVE-2007-1657": [
"29740"
],
"CVE-2007-1476": [
"29743"
],
"CVE-2007-1586": [
"29767"
],
"CVE-2007-1388": [
"29781"
],
"CVE-2007-1772": [
"29787"
],
"CVE-2007-2894": [
"30110"
],
"CVE-2007-3086": [
"30139"
],
"CVE-2007-1685": [
"30163"
],
"CVE-2007-3151": [
"30167"
],
"CVE-2007-1804": [
"29809"
],
"CVE-2007-1793": [
"29810"
],
"CVE-2007-1942": [
"29816"
],
"CVE-2007-1943": [
"29818"
],
"CVE-2007-1948": [
"29819"
],
"CVE-2007-1001": [
"29823"
],
"CVE-2007-1357": [
"29826"
],
"CVE-2007-2434": [
"29937"
],
"CVE-2007-2059": [
"29850"
],
"CVE-2007-2083": [
"29860"
],
"CVE-2007-2210": [
"29867"
],
"CVE-2007-2195": [
"29875"
],
"CVE-2007-2565": [
"29896"
],
"CVE-2007-2293": [
"29900",
"29901"
],
"CVE-2007-1861": [
"29916"
],
"CVE-2007-2437": [
"29939"
],
"CVE-2007-2671": [
"29940"
],
"CVE-2007-2487": [
"29942"
],
"CVE-2007-2506": [
"29943"
],
"CVE-2007-2536": [
"29949"
],
"CVE-2007-2878": [
"30080"
],
"CVE-2007-2964": [
"30104"
],
"CVE-2007-3284": [
"30193"
],
"CVE-2007-3334": [
"30224"
],
"CVE-2007-3398": [
"30233"
],
"CVE-2007-3473": [
"30251"
],
"CVE-2007-3492": [
"30252"
],
"CVE-2007-3479": [
"30255"
],
"CVE-2007-3638": [
"30314"
],
"CVE-2007-6103": [
"30791"
],
"CVE-2013-6420": [
"30395"
],
"CVE-2013-5058": [
"30397"
],
"CVE-2013-7185": [
"30413"
],
"CVE-2013-7184": [
"30414"
],
"CVE-2007-4321": [
"30430"
],
"CVE-2007-4229": [
"30444"
],
"CVE-2007-4288": [
"30462"
],
"CVE-2007-1749": [
"30494"
],
"CVE-2007-4358": [
"30497"
],
"CVE-2007-4430": [
"30506"
],
"CVE-2007-4463": [
"30512"
],
"CVE-2007-4442": [
"30513"
],
"CVE-2007-4498": [
"30517"
],
"CVE-2007-4508": [
"30519"
],
"CVE-2007-4531": [
"30524"
],
"CVE-2007-4533": [
"30526"
],
"CVE-2007-4535": [
"30527"
],
"CVE-2007-4534": [
"30528"
],
"CVE-2006-7222": [
"30529"
],
"CVE-2007-4638": [
"30540"
],
"CVE-2007-4639": [
"30542"
],
"CVE-2007-4635": [
"30544"
],
"CVE-2007-4754": [
"30566"
],
"CVE-2007-4838": [
"30574"
],
"CVE-2007-4938": [
"30578"
],
"CVE-2007-4939": [
"30579"
],
"CVE-2008-5839": [
"32400"
],
"CVE-2007-4941": [
"30580"
],
"CVE-2007-4915": [
"30584",
"4542"
],
"CVE-2007-4964": [
"30590"
],
"CVE-2007-4965": [
"30592"
],
"CVE-2007-5133": [
"30619"
],
"CVE-2007-5256": [
"30628",
"4484",
"30627"
],
"CVE-2007-5265": [
"30644"
],
"CVE-2007-5198": [
"30646"
],
"CVE-2007-5301": [
"30648",
"5424"
],
"CVE-2007-5464": [
"30672"
],
"CVE-2007-5637": [
"30679"
],
"CVE-2007-5740": [
"30724"
],
"CVE-2007-5925": [
"30744"
],
"CVE-2007-5984": [
"30753"
],
"CVE-2007-6039": [
"30760"
],
"CVE-2007-6005": [
"30761"
],
"CVE-2007-6000": [
"30763"
],
"CVE-2016-7190": [
"40602"
],
"CVE-2007-4476": [
"30766"
],
"CVE-2007-4812": [
"30767"
],
"CVE-2016-7189": [
"40604"
],
"CVE-2007-6036": [
"30776"
],
"CVE-2007-6041": [
"30779"
],
"CVE-2008-0095": [
"30974"
],
"CVE-2007-6228": [
"30832"
],
"CVE-2007-6227": [
"30837"
],
"CVE-2007-6273": [
"30840"
],
"CVE-2007-6454": [
"30894"
],
"CVE-2007-6341": [
"30895"
],
"CVE-2007-6509": [
"30896"
],
"CVE-2007-5849": [
"30898"
],
"CVE-2007-4567": [
"30902"
],
"CVE-2007-6510": [
"30906"
],
"CVE-2007-6537": [
"30922"
],
"CVE-2007-6609": [
"30956"
],
"CVE-2007-6558": [
"30934"
],
"CVE-2007-6699": [
"30936"
],
"CVE-2007-6731": [
"30942"
],
"CVE-2007-6631": [
"30943"
],
"CVE-2007-6613": [
"30985"
],
"CVE-2008-0132": [
"30989"
],
"CVE-2008-0151": [
"30990"
],
"CVE-2008-0153": [
"30991"
],
"CVE-2008-0225": [
"31002"
],
"CVE-2008-0298": [
"31021"
],
"CVE-2007-6697": [
"31054"
],
"CVE-2008-0729": [
"31057"
],
"CVE-2008-0633": [
"31100"
],
"CVE-2008-5281": [
"31105"
],
"CVE-2007-5659": [
"31114",
"16674"
],
"CVE-2008-0944": [
"31122"
],
"CVE-2008-5284": [
"31128"
],
"CVE-2008-0756": [
"31136"
],
"CVE-2008-0763": [
"31138"
],
"CVE-2008-0764": [
"31139"
],
"CVE-2008-0755": [
"31148"
],
"CVE-2008-4999": [
"31306"
],
"CVE-2008-0985": [
"31307"
],
"CVE-2013-6040": [
"31176",
"31177",
"31178"
],
"CVE-2014-0038": [
"31305",
"31346",
"31347",
"40503"
],
"CVE-2008-0912": [
"31271"
],
"CVE-2008-5105": [
"31205"
],
"CVE-2008-0852": [
"31218"
],
"CVE-2006-2465": [
"31220",
"32358"
],
"CVE-2013-5791": [
"31222"
],
"CVE-2013-6674": [
"31223"
],
"CVE-2008-7031": [
"31232"
],
"CVE-2016-4231": [
"40356"
],
"CVE-2008-1215": [
"31333"
],
"CVE-2008-7126": [
"31330"
],
"CVE-2016-4232": [
"40355"
],
"CVE-2008-5280": [
"31285"
],
"CVE-2008-1055": [
"31300"
],
"CVE-2008-1054": [
"31301"
],
"CVE-2008-1052": [
"31302"
],
"CVE-2008-0986": [
"31308"
],
"CVE-2008-1365": [
"31310",
"16768"
],
"CVE-2008-1303": [
"31338"
],
"CVE-2008-1193": [
"31343"
],
"CVE-2008-1277": [
"31360"
],
"CVE-2008-0118": [
"31361",
"5320"
],
"CVE-2008-1471": [
"31363"
],
"CVE-2008-1278": [
"31378"
],
"CVE-2008-0532": [
"31394"
],
"CVE-2014-0980": [
"31461",
"31524",
"36104",
"36437"
],
"CVE-2008-1357": [
"31399"
],
"CVE-2008-1353": [
"31403"
],
"CVE-2014-1684": [
"31429"
],
"CVE-2008-1289": [
"31440"
],
"CVE-2008-2092": [
"31478"
],
"CVE-2008-1391": [
"31550"
],
"CVE-2008-1561": [
"31552"
],
"CVE-2008-1562": [
"31553"
],
"CVE-2008-1563": [
"31554"
],
"CVE-2008-1690": [
"31563"
],
"CVE-2008-1084": [
"31585",
"5518"
],
"CVE-2008-1762": [
"31594"
],
"CVE-2008-1854": [
"31607"
],
"CVE-2014-0050": [
"31615"
],
"CVE-2008-2006": [
"31619",
"31613"
],
"CVE-2008-1035": [
"31620"
],
"CVE-2008-1996": [
"31627"
],
"CVE-2008-1842": [
"31629"
],
"CVE-2008-1920": [
"31656"
],
"CVE-2008-1979": [
"31707"
],
"CVE-2008-2040": [
"31713"
],
"CVE-2008-2106": [
"31728"
],
"CVE-2008-2111": [
"31748"
],
"CVE-2014-10001": [
"31763",
"31831",
"32163",
"30911",
"31898",
"32814",
"34555",
"35248"
],
"CVE-2008-1767": [
"31815"
],
"CVE-2008-2419": [
"31817"
],
"CVE-2008-2542": [
"31872"
],
"CVE-2008-0953": [
"31876"
],
"CVE-2007-5607": [
"31877"
],
"CVE-2008-0952": [
"31878"
],
"CVE-2007-5610": [
"31879"
],
"CVE-2008-2703": [
"31889",
"16814"
],
"CVE-2008-6702": [
"31919"
],
"CVE-2008-6712": [
"31931"
],
"CVE-2008-2748": [
"31932"
],
"CVE-2008-2752": [
"31934"
],
"CVE-2008-6713": [
"31957"
],
"CVE-2008-6670": [
"31958"
],
"CVE-2008-3116": [
"31964"
],
"CVE-2008-2365": [
"31965",
"31966"
],
"CVE-2008-7185": [
"31968"
],
"CVE-2008-3263": [
"32095"
],
"CVE-2008-6703": [
"31998"
],
"CVE-2008-2943": [
"31999"
],
"CVE-2008-2952": [
"32000"
],
"CVE-2008-3140": [
"32006"
],
"CVE-2008-3024": [
"32009"
],
"CVE-2008-3162": [
"32019"
],
"CVE-2008-3286": [
"32086"
],
"CVE-2008-3314": [
"32104"
],
"CVE-2008-3396": [
"32125"
],
"CVE-2008-3409": [
"32127"
],
"CVE-2008-2321": [
"32136"
],
"CVE-2008-5120": [
"32193"
],
"CVE-2008-3607": [
"32194"
],
"CVE-2008-3606": [
"32195"
],
"CVE-2014-0983": [
"32208",
"34334"
],
"CVE-2014-0982": [
"32208"
],
"CVE-2014-0981": [
"32208"
],
"CVE-2008-4310": [
"32222"
],
"CVE-2008-3656": [
"32222"
],
"CVE-2008-3676": [
"32229"
],
"CVE-2008-3533": [
"32248"
],
"CVE-2014-2087": [
"32332"
],
"CVE-2008-3790": [
"32292"
],
"CVE-2008-5232": [
"32294"
],
"CVE-2008-2930": [
"32304"
],
"CVE-2008-4041": [
"32310"
],
"CVE-2008-7061": [
"32311"
],
"CVE-2014-1287": [
"32333"
],
"CVE-2008-3950": [
"32341"
],
"CVE-2008-3963": [
"32348"
],
"CVE-2008-2326": [
"32350"
],
"CVE-2008-7009": [
"32356"
],
"CVE-2008-7015": [
"32362"
],
"CVE-2008-4166": [
"32381"
],
"CVE-2008-4302": [
"32384"
],
"CVE-2008-7011": [
"32386"
],
"CVE-2008-7025": [
"32428"
],
"CVE-2008-3832": [
"32451"
],
"CVE-2008-4546": [
"32452"
],
"CVE-2008-4409": [
"32454"
],
"CVE-2014-2668": [
"32519"
],
"CVE-2008-4800": [
"32550"
],
"CVE-2008-4907": [
"32551"
],
"CVE-2008-5044": [
"32573"
],
"CVE-2008-5102": [
"32581"
],
"CVE-2008-6122": [
"32583"
],
"CVE-2008-5185": [
"32596"
],
"CVE-2009-0341": [
"32763"
],
"CVE-2008-2382": [
"32675"
],
"CVE-2008-5713": [
"32682"
],
"CVE-2014-3976": [
"32702"
],
"CVE-2009-0120": [
"32712"
],
"CVE-2009-0241": [
"32726"
],
"CVE-2008-2955": [
"32749"
],
"CVE-2013-6799": [
"32754"
],
"CVE-2009-0321": [
"32761"
],
"CVE-2009-0754": [
"32769"
],
"CVE-2009-0734": [
"32772"
],
"CVE-2009-0769": [
"32774"
],
"CVE-2009-0746": [
"32775"
],
"CVE-2009-0756": [
"32800"
],
"CVE-2009-0755": [
"32800"
],
"CVE-2009-0028": [
"32815"
],
"CVE-2009-0744": [
"32817"
],
"CVE-2009-0821": [
"32836"
],
"CVE-2009-0819": [
"32838"
],
"CVE-2009-0922": [
"32849"
],
"CVE-2008-4610": [
"32856",
"32857"
],
"CVE-2009-1219": [
"32860"
],
"CVE-2009-1335": [
"32902"
],
"CVE-2014-2851": [
"32926"
],
"CVE-2009-1435": [
"32939"
],
"CVE-2009-1313": [
"32961"
],
"CVE-2009-1415": [
"32964"
],
"CVE-2009-2446": [
"33077"
],
"CVE-2009-1490": [
"32995"
],
"CVE-2009-1961": [
"33015"
],
"CVE-2009-3431": [
"33017"
],
"CVE-2009-0949": [
"33020"
],
"CVE-2009-2044": [
"33031"
],
"CVE-2009-2108": [
"33036"
],
"CVE-2009-2174": [
"33040"
],
"CVE-2009-1959": [
"33041"
],
"CVE-2009-2043": [
"33042"
],
"CVE-2009-1914": [
"33043"
],
"CVE-2013-1612": [
"33056"
],
"CVE-2009-2617": [
"33059"
],
"CVE-2009-2419": [
"33062"
],
"CVE-2013-5211": [
"33073"
],
"CVE-2009-1963": [
"33080"
],
"CVE-2009-1970": [
"33083"
],
"CVE-2009-1897": [
"33088",
"9191"
],
"CVE-2009-2464": [
"33101"
],
"CVE-2009-1868": [
"33133"
],
"CVE-2009-1869": [
"33134"
],
"CVE-2009-2767": [
"33148"
],
"CVE-2009-2732": [
"33176"
],
"CVE-2009-3043": [
"33193"
],
"CVE-2009-3662": [
"33220"
],
"CVE-2009-3241": [
"33222"
],
"CVE-2009-3243": [
"33223"
],
"CVE-2009-3242": [
"33224"
],
"CVE-2009-3234": [
"33228"
],
"CVE-2009-4880": [
"33230"
],
"CVE-2009-4637": [
"33233"
],
"CVE-2009-2817": [
"33235",
"11491"
],
"CVE-2009-3707": [
"33271"
],
"CVE-2009-2983": [
"33283"
],
"CVE-2009-3613": [
"33289"
],
"CVE-2009-3382": [
"33314"
],
"CVE-2010-0295": [
"33591"
],
"CVE-2014-2085": [
"33328"
],
"CVE-2014-2084": [
"33328",
"33327"
],
"CVE-2014-3443": [
"33332"
],
"CVE-2014-3216": [
"33335"
],
"CVE-2014-5116": [
"33384"
],
"CVE-2009-4019": [
"33397",
"33398"
],
"CVE-2010-0313": [
"33483"
],
"CVE-2010-0303": [
"33581"
],
"CVE-2010-0071": [
"33506"
],
"CVE-2010-0437": [
"33635"
],
"CVE-2010-0359": [
"33531"
],
"CVE-2013-4074": [
"33556"
],
"CVE-2010-0388": [
"33560"
],
"CVE-2010-0442": [
"33571"
],
"CVE-2010-0307": [
"33585"
],
"CVE-2010-1130": [
"33625"
],
"CVE-2014-4643": [
"33713"
],
"CVE-2010-1128": [
"33677"
],
"CVE-2010-0733": [
"33729"
],
"CVE-2010-0397": [
"33755"
],
"CVE-2010-1042": [
"33770"
],
"CVE-2010-0166": [
"33800"
],
"CVE-2010-0167": [
"33801"
],
"CVE-2014-4334": [
"33804"
],
"CVE-2010-1152": [
"33850"
],
"CVE-2014-0282": [
"33860",
"34010"
],
"CVE-2010-2089": [
"34145"
],
"CVE-2010-1437": [
"33886"
],
"CVE-2016-4204": [
"40096"
],
"CVE-2016-4203": [
"40097"
],
"CVE-2016-4208": [
"40098"
],
"CVE-2014-4927": [
"34102"
],
"CVE-2010-0552": [
"33965"
],
"CVE-2010-0553": [
"33966"
],
"CVE-2014-5349": [
"33951"
],
"CVE-2014-2782": [
"34010"
],
"CVE-2014-2777": [
"34010"
],
"CVE-2014-2776": [
"34010"
],
"CVE-2014-2775": [
"34010"
],
"CVE-2014-2773": [
"34010"
],
"CVE-2014-2772": [
"34010"
],
"CVE-2014-2771": [
"34010"
],
"CVE-2014-2770": [
"34010"
],
"CVE-2014-2769": [
"34010"
],
"CVE-2014-2768": [
"34010"
],
"CVE-2014-2767": [
"34010"
],
"CVE-2014-2766": [
"34010"
],
"CVE-2014-2765": [
"34010"
],
"CVE-2014-2764": [
"34010"
],
"CVE-2014-2763": [
"34010"
],
"CVE-2014-2761": [
"34010"
],
"CVE-2014-2760": [
"34010"
],
"CVE-2014-2759": [
"34010"
],
"CVE-2014-2758": [
"34010"
],
"CVE-2014-2757": [
"34010"
],
"CVE-2014-2756": [
"34010"
],
"CVE-2014-2755": [
"34010"
],
"CVE-2014-2754": [
"34010"
],
"CVE-2014-2753": [
"34010"
],
"CVE-2014-1805": [
"34010"
],
"CVE-2014-1804": [
"34010"
],
"CVE-2014-1803": [
"34010"
],
"CVE-2014-1802": [
"34010"
],
"CVE-2014-1800": [
"34010"
],
"CVE-2014-1799": [
"34010"
],
"CVE-2014-1797": [
"34010"
],
"CVE-2014-1796": [
"34010"
],
"CVE-2014-1795": [
"34010"
],
"CVE-2014-1794": [
"34010"
],
"CVE-2014-1792": [
"34010"
],
"CVE-2014-1791": [
"34010"
],
"CVE-2014-1790": [
"34010"
],
"CVE-2014-1789": [
"34010"
],
"CVE-2014-1788": [
"34010"
],
"CVE-2014-1786": [
"34010"
],
"CVE-2014-1785": [
"34010",
"40946"
],
"CVE-2014-1784": [
"34010"
],
"CVE-2014-1783": [
"34010"
],
"CVE-2014-1782": [
"34010"
],
"CVE-2014-1781": [
"34010"
],
"CVE-2014-1780": [
"34010"
],
"CVE-2014-1779": [
"34010"
],
"CVE-2014-1778": [
"34010"
],
"CVE-2014-1777": [
"34010"
],
"CVE-2014-1775": [
"34010"
],
"CVE-2014-1774": [
"34010"
],
"CVE-2014-1773": [
"34010"
],
"CVE-2014-1772": [
"34010"
],
"CVE-2014-1771": [
"34010"
],
"CVE-2014-1770": [
"34010"
],
"CVE-2014-1769": [
"34010"
],
"CVE-2014-1766": [
"34010"
],
"CVE-2014-1764": [
"34010"
],
"CVE-2014-1762": [
"34010"
],
"CVE-2010-2159": [
"34058"
],
"CVE-2014-7192": [
"34090"
],
"CVE-2014-0226": [
"34133"
],
"CVE-2014-2973": [
"34162",
"34540",
"35449",
"35712"
],
"CVE-2014-3136": [
"34203"
],
"CVE-2012-6083": [
"34249"
],
"CVE-2010-2630": [
"34278"
],
"CVE-2010-2631": [
"34279"
],
"CVE-2010-0916": [
"34309"
],
"CVE-2010-0211": [
"34348"
],
"CVE-2009-5018": [
"34356"
],
"CVE-2008-7258": [
"34375"
],
"CVE-2010-2939": [
"34427"
],
"CVE-2014-1815": [
"34458"
],
"CVE-2010-3680": [
"34505"
],
"CVE-2010-3682": [
"34506"
],
"CVE-2010-3683": [
"34510"
],
"CVE-2010-3681": [
"34520"
],
"CVE-2010-3679": [
"34521"
],
"CVE-2010-3676": [
"34522"
],
"CVE-2010-3325": [
"34602"
],
"CVE-2014-7222": [
"34857"
],
"CVE-2014-7221": [
"34857"
],
"CVE-2010-3879": [
"34953"
],
"CVE-2010-4715": [
"34980"
],
"CVE-2010-4250": [
"35013"
],
"CVE-2014-0995": [
"35000"
],
"CVE-2016-4207": [
"40099"
],
"CVE-2016-4206": [
"40100"
],
"CVE-2016-4201": [
"40101"
],
"CVE-2016-4179": [
"40102"
],
"CVE-2016-4175": [
"40103"
],
"CVE-2014-6277": [
"35081",
"34860",
"36933"
],
"CVE-2014-9448": [
"35105",
"18726",
"35377"
],
"CVE-2010-4543": [
"35162"
],
"CVE-2011-0403": [
"35163"
],
"CVE-2010-4645": [
"35164"
],
"CVE-2011-1159": [
"35240"
],
"CVE-2010-4476": [
"35304"
],
"CVE-2014-9349": [
"35342"
],
"CVE-2014-9350": [
"35345"
],
"CVE-2014-8768": [
"35359"
],
"CVE-2014-10011": [
"35363"
],
"CVE-2014-8652": [
"35379"
],
"CVE-2014-8507": [
"35382"
],
"CVE-2011-1083": [
"35403"
],
"CVE-2011-1082": [
"35404"
],
"CVE-2014-9034": [
"35413",
"35414"
],
"CVE-2014-9016": [
"35415"
],
"CVE-2011-1143": [
"35432"
],
"CVE-2011-1081": [
"35445"
],
"CVE-2010-1677": [
"35478"
],
"CVE-2011-1467": [
"35483"
],
"CVE-2011-1470": [
"35484"
],
"CVE-2011-1471": [
"35485"
],
"CVE-2011-1468": [
"35486",
"35487"
],
"CVE-2010-4777": [
"35489"
],
"CVE-2014-9218": [
"35539"
],
"CVE-2014-6395": [
"35580"
],
"CVE-2014-9456": [
"35589"
],
"CVE-2014-1004": [
"35589"
],
"CVE-2011-1479": [
"35600"
],
"CVE-2011-0761": [
"35725"
],
"CVE-2011-0419": [
"35738"
],
"CVE-2011-2183": [
"35820"
],
"CVE-2014-10003": [
"35842",
"31961"
],
"CVE-2015-2055": [
"35859"
],
"CVE-2015-1362": [
"35870"
],
"CVE-2011-1956": [
"35873"
],
"CVE-2014-0997": [
"35913"
],
"CVE-2014-8612": [
"35938"
],
"CVE-2014-0998": [
"35938"
],
"CVE-2015-0235": [
"35951",
"36421"
],
"CVE-2009-4067": [
"35957"
],
"CVE-2011-2956": [
"36007"
],
"CVE-2011-2132": [
"36037"
],
"CVE-2011-3182": [
"36070"
],
"CVE-2011-2975": [
"36092"
],
"CVE-2011-3483": [
"36128"
],
"CVE-2015-0555": [
"36152",
"36756"
],
"CVE-2015-0273": [
"36158"
],
"CVE-2015-5895": [
"36190"
],
"CVE-2011-3596": [
"36198"
],
"CVE-2011-2007": [
"36211"
],
"CVE-2014-9322": [
"36266",
"44205"
],
"CVE-2014-4943": [
"36267"
],
"CVE-2014-3631": [
"36268"
],
"CVE-2011-2013": [
"36285"
],
"CVE-2011-3336": [
"36288"
],
"CVE-2015-2790": [
"36334",
"36335"
],
"CVE-2015-0081": [
"36336"
],
"CVE-2011-5009": [
"36377",
"36378"
],
"CVE-2015-2291": [
"36392"
],
"CVE-2011-4162": [
"36403"
],
"CVE-2009-5029": [
"36404"
],
"CVE-2015-2572": [
"36783"
],
"CVE-2015-2281": [
"36422"
],
"CVE-2011-2189": [
"36425"
],
"CVE-2011-4684": [
"36443"
],
"CVE-2016-2776": [
"40453"
],
"CVE-2012-0045": [
"36545"
],
"CVE-2012-0221": [
"36570"
],
"CVE-2012-0067": [
"36633"
],
"CVE-2012-0840": [
"36669"
],
"CVE-2012-0788": [
"36682"
],
"CVE-2015-0240": [
"36741"
],
"CVE-2014-7822": [
"36743"
],
"CVE-2015-1635": [
"36773",
"36776"
],
"CVE-2015-0493": [
"36788"
],
"CVE-2015-0474": [
"36788"
],
"CVE-2012-0789": [
"36789"
],
"CVE-2015-1100": [
"36814"
],
"CVE-2012-4999": [
"36868"
],
"CVE-2012-0200": [
"36869"
],
"CVE-2015-0252": [
"36906"
],
"CVE-2015-3456": [
"37053"
],
"CVE-2012-2926": [
"37218"
],
"CVE-2015-3205": [
"37249"
],
"CVE-2012-2385": [
"37306"
],
"CVE-2015-3110": [
"37347"
],
"CVE-2015-3112": [
"37348"
],
"CVE-2015-3111": [
"37348"
],
"CVE-2012-3450": [
"37566"
],
"CVE-2012-2738": [
"37477"
],
"CVE-2012-2138": [
"37487"
],
"CVE-2013-0230": [
"37517",
"25975",
"36839"
],
"CVE-2013-0229": [
"37517",
"38249"
],
"CVE-2012-3571": [
"37538"
],
"CVE-2015-2153": [
"37663"
],
"CVE-2006-0138": [
"37692"
],
"CVE-2015-3246": [
"37706",
"44633"
],
"CVE-2015-3245": [
"37706",
"44633"
],
"CVE-2015-5477": [
"37721",
"37723"
],
"CVE-2015-5696": [
"37739"
],
"CVE-2015-2444": [
"37764"
],
"CVE-2015-1265": [
"37766"
],
"CVE-2012-4412": [
"37783"
],
"CVE-2015-3042": [
"37839"
],
"CVE-2015-3087": [
"37843"
],
"CVE-2015-3088": [
"37844"
],
"CVE-2015-3089": [
"37845"
],
"CVE-2015-3093": [
"37846"
],
"CVE-2015-3106": [
"37847"
],
"CVE-2015-3118": [
"37848"
],
"CVE-2015-3124": [
"37849"
],
"CVE-2015-3107": [
"37850"
],
"CVE-2015-5134": [
"37852"
],
"CVE-2015-3080": [
"37853"
],
"CVE-2015-5130": [
"37854"
],
"CVE-2015-5539": [
"37855"
],
"CVE-2015-5131": [
"37856"
],
"CVE-2015-5132": [
"37857"
],
"CVE-2015-5133": [
"37858"
],
"CVE-2015-5540": [
"37859"
],
"CVE-2015-3128": [
"37860"
],
"CVE-2015-5127": [
"37861"
],
"CVE-2015-3134": [
"37862"
],
"CVE-2015-3137": [
"37864"
],
"CVE-2015-5551": [
"37865"
],
"CVE-2015-5544": [
"37866"
],
"CVE-2015-5545": [
"37867"
],
"CVE-2015-5546": [
"37868"
],
"CVE-2015-5547": [
"37869"
],
"CVE-2015-5548": [
"37870"
],
"CVE-2015-5550": [
"37871"
],
"CVE-2015-5549": [
"37872"
],
"CVE-2015-5556": [
"37873"
],
"CVE-2015-5555": [
"37874"
],
"CVE-2015-4430": [
"37875"
],
"CVE-2015-5554": [
"37876"
],
"CVE-2015-5557": [
"37877"
],
"CVE-2015-5558": [
"37878"
],
"CVE-2015-4432": [
"37879"
],
"CVE-2015-5118": [
"37880"
],
"CVE-2015-5562": [
"37881"
],
"CVE-2015-5560": [
"37882"
],
"CVE-2015-5561": [
"37883"
],
"CVE-2015-5563": [
"37884"
],
"CVE-2012-3819": [
"37905"
],
"CVE-2015-7767": [
"37908",
"38252"
],
"CVE-2015-2469": [
"37910"
],
"CVE-2015-2431": [
"37911"
],
"CVE-2015-2468": [
"37912"
],
"CVE-2015-2467": [
"37913"
],
"CVE-2015-2464": [
"37914"
],
"CVE-2015-2463": [
"37915"
],
"CVE-2015-2462": [
"37916"
],
"CVE-2015-2461": [
"37917"
],
"CVE-2015-2456": [
"37918"
],
"CVE-2015-2455": [
"37919"
],
"CVE-2015-2432": [
"37920"
],
"CVE-2015-2460": [
"37921"
],
"CVE-2015-2459": [
"37922"
],
"CVE-2015-2458": [
"37923"
],
"CVE-2015-2470": [
"37924"
],
"CVE-2015-0065": [
"37966"
],
"CVE-2015-0064": [
"37967"
],
"CVE-2012-5672": [
"37980"
],
"CVE-2015-3214": [
"37990"
],
"CVE-2015-5465": [
"38054"
],
"CVE-2015-5466": [
"38055"
],
"CVE-2014-9208": [
"38108"
],
"CVE-2015-6834": [
"38120",
"38122"
],
"CVE-2015-6835": [
"38123"
],
"CVE-2012-5375": [
"38132"
],
"CVE-2015-6908": [
"38145"
],
"CVE-2015-2523": [
"38214"
],
"CVE-2015-2520": [
"38215"
],
"CVE-2015-2521": [
"38216"
],
"CVE-2015-2510": [
"38217"
],
"CVE-2015-6923": [
"38225"
],
"CVE-2015-3798": [
"38262"
],
"CVE-2015-3796": [
"38263"
],
"CVE-2015-3783": [
"38264"
],
"CVE-2015-1722": [
"38265",
"38275"
],
"CVE-2015-2366": [
"38266"
],
"CVE-2015-2365": [
"38267"
],
"CVE-2015-1727": [
"38268"
],
"CVE-2015-1726": [
"38269"
],
"CVE-2015-1725": [
"38270",
"38271"
],
"CVE-2015-1724": [
"38272"
],
"CVE-2015-1723": [
"38273"
],
"CVE-2015-1721": [
"38274"
],
"CVE-2015-2511": [
"38276"
],
"CVE-2015-2518": [
"38277"
],
"CVE-2015-2517": [
"38278"
],
"CVE-2015-2507": [
"38279"
],
"CVE-2015-2512": [
"38280",
"38307"
],
"CVE-2015-3073": [
"38344"
],
"CVE-2015-5568": [
"38348"
],
"CVE-2013-1861": [
"38392"
],
"CVE-2013-6166": [
"38420"
],
"CVE-2013-1847": [
"38421"
],
"CVE-2013-1884": [
"38422"
],
"CVE-2013-3301": [
"38465"
],
"CVE-2015-7645": [
"38490"
],
"CVE-2015-7892": [
"38555"
],
"CVE-2015-7890": [
"38556"
],
"CVE-2015-7891": [
"38557"
],
"CVE-2015-7889": [
"38558"
],
"CVE-2015-3036": [
"38566",
"38454"
],
"CVE-2015-2554": [
"38580"
],
"CVE-2013-3792": [
"38595"
],
"CVE-2015-7898": [
"38610"
],
"CVE-2015-7897": [
"38611"
],
"CVE-2015-7896": [
"38612"
],
"CVE-2015-7895": [
"38613"
],
"CVE-2015-7894": [
"38614"
],
"CVE-2013-2218": [
"38622"
],
"CVE-2013-3299": [
"38623"
],
"CVE-2015-7047": [
"39374",
"39373",
"39371",
"39375",
"39377"
],
"CVE-2015-6104": [
"38713"
],
"CVE-2015-6103": [
"38714"
],
"CVE-2013-5657": [
"38747"
],
"CVE-2015-6763": [
"38763"
],
"CVE-2015-7622": [
"38787"
],
"CVE-2015-4877": [
"38788"
],
"CVE-2015-4878": [
"38789"
],
"CVE-2015-6098": [
"38793"
],
"CVE-2015-6102": [
"38794"
],
"CVE-2015-6101": [
"38795"
],
"CVE-2015-6100": [
"38796"
],
"CVE-2013-6167": [
"38798"
],
"CVE-2012-6151": [
"38854"
],
"CVE-2013-6890": [
"38909"
],
"CVE-2015-7039": [
"38917"
],
"CVE-2015-7647": [
"38969"
],
"CVE-2015-7648": [
"38970"
],
"CVE-2015-6152": [
"38972"
],
"CVE-2015-8739": [
"38994"
],
"CVE-2015-8732": [
"38995"
],
"CVE-2015-8731": [
"38996"
],
"CVE-2015-8736": [
"38997"
],
"CVE-2015-8735": [
"38998"
],
"CVE-2015-8730": [
"38999"
],
"CVE-2015-8728": [
"39000"
],
"CVE-2015-8729": [
"39001"
],
"CVE-2015-8727": [
"39002"
],
"CVE-2015-8740": [
"39003"
],
"CVE-2015-8725": [
"39003"
],
"CVE-2015-8726": [
"39004"
],
"CVE-2015-8723": [
"39005"
],
"CVE-2015-8046": [
"39019"
],
"CVE-2015-7652": [
"39020"
],
"CVE-2015-8044": [
"39021"
],
"CVE-2015-8043": [
"39022"
],
"CVE-2016-4176": [
"40105"
],
"CVE-2016-4177": [
"40104"
],
"CVE-2015-6171": [
"39025"
],
"CVE-2015-6174": [
"39026"
],
"CVE-2015-6173": [
"39027"
],
"CVE-2015-8664": [
"39039"
],
"CVE-2015-8410": [
"39040"
],
"CVE-2015-8411": [
"39041"
],
"CVE-2015-8412": [
"39042"
],
"CVE-2015-8413": [
"39043"
],
"CVE-2015-8420": [
"39044"
],
"CVE-2015-8421": [
"39045"
],
"CVE-2015-8422": [
"39046"
],
"CVE-2015-8423": [
"39047"
],
"CVE-2015-8424": [
"39048"
],
"CVE-2015-8425": [
"39049"
],
"CVE-2015-8427": [
"39050"
],
"CVE-2015-8428": [
"39051"
],
"CVE-2015-8429": [
"39052"
],
"CVE-2015-8430": [
"39053"
],
"CVE-2015-8431": [
"39054"
],
"CVE-2015-8434": [
"39072"
],
"CVE-2013-7183": [
"39073"
],
"CVE-2015-8733": [
"39076"
],
"CVE-2015-8724": [
"39077"
],
"CVE-2015-8617": [
"39082"
],
"CVE-2015-6787": [
"39162",
"39163",
"39165"
],
"CVE-2015-7945": [
"39169"
],
"CVE-2015-7944": [
"39169"
],
"CVE-2014-3441": [
"39177"
],
"CVE-2014-3442": [
"39180"
],
"CVE-2014-3212": [
"39181"
],
"CVE-2014-3444": [
"39182"
],
"CVE-2014-3736": [
"39183"
],
"CVE-2015-8636": [
"39219"
],
"CVE-2015-8635": [
"39220"
],
"CVE-2015-8634": [
"39221"
],
"CVE-2015-8396": [
"39229"
],
"CVE-2016-0015": [
"39232"
],
"CVE-2016-0016": [
"39233"
],
"CVE-2015-7108": [
"39372"
],
"CVE-2006-2961": [
"39274",
"1906",
"16713"
],
"CVE-2016-1879": [
"39305"
],
"CVE-2015-0569": [
"39308"
],
"CVE-2014-6435": [
"39315"
],
"CVE-2015-7084": [
"39357",
"39366"
],
"CVE-2016-1721": [
"39358"
],
"CVE-2016-1719": [
"39359",
"39360",
"39361",
"39362",
"39363",
"39364"
],
"CVE-2015-7110": [
"39365"
],
"CVE-2016-1720": [
"39367"
],
"CVE-2015-7077": [
"39368"
],
"CVE-2015-7106": [
"39369"
],
"CVE-2015-7078": [
"39370"
],
"CVE-2015-7068": [
"39376"
],
"CVE-2015-7083": [
"39378"
],
"CVE-2015-7112": [
"39379"
],
"CVE-2015-6996": [
"39380"
],
"CVE-2015-6995": [
"39381"
],
"CVE-2016-0951": [
"39429"
],
"CVE-2016-0952": [
"39430"
],
"CVE-2016-0953": [
"39431"
],
"CVE-2015-7547": [
"39454",
"40339"
],
"CVE-2016-0965": [
"39460"
],
"CVE-2016-0985": [
"39461"
],
"CVE-2016-0984": [
"39462"
],
"CVE-2016-0974": [
"39463"
],
"CVE-2016-0971": [
"39465"
],
"CVE-2016-0967": [
"39466"
],
"CVE-2016-0964": [
"39467"
],
"CVE-2015-8285": [
"39475"
],
"CVE-2015-8644": [
"39476"
],
"CVE-2016-2399": [
"39487"
],
"CVE-2016-1839": [
"39491"
],
"CVE-2016-1838": [
"39493"
],
"CVE-2016-3986": [
"39530"
],
"CVE-2016-0954": [
"39533"
],
"CVE-2016-3140": [
"39537"
],
"CVE-2016-3139": [
"39538"
],
"CVE-2016-2782": [
"39539"
],
"CVE-2015-7566": [
"39540"
],
"CVE-2016-3136": [
"39541"
],
"CVE-2015-7515": [
"39544"
],
"CVE-2016-3134": [
"39545"
],
"CVE-2016-3135": [
"39545"
],
"CVE-2016-2851": [
"39550"
],
"CVE-2016-2563": [
"39551"
],
"CVE-2016-2184": [
"39555"
],
"CVE-2016-2188": [
"39556"
],
"CVE-2016-0121": [
"39560"
],
"CVE-2016-0120": [
"39561"
],
"CVE-2016-0108": [
"39562"
],
"CVE-2016-1885": [
"39570"
],
"CVE-2016-1749": [
"39607"
],
"CVE-2016-1002": [
"39608"
],
"CVE-2016-1001": [
"39609"
],
"CVE-2016-1000": [
"39610"
],
"CVE-2016-0999": [
"39611"
],
"CVE-2016-0998": [
"39612",
"39631"
],
"CVE-2016-0997": [
"39613"
],
"CVE-2016-1755": [
"39614"
],
"CVE-2016-1741": [
"39615"
],
"CVE-2016-1744": [
"39616"
],
"CVE-2016-1767": [
"39633"
],
"CVE-2016-1768": [
"39634"
],
"CVE-2016-1769": [
"39635"
],
"CVE-2016-2385": [
"39638"
],
"CVE-2016-0094": [
"39647"
],
"CVE-2016-0093": [
"39648"
],
"CVE-2015-8048": [
"39649"
],
"CVE-2015-8426": [
"39650"
],
"CVE-2015-5574": [
"39652"
],
"CVE-2016-2233": [
"39657"
],
"CVE-2016-0111": [
"39663"
],
"CVE-2016-3672": [
"39669"
],
"CVE-2016-2417": [
"39685"
],
"CVE-2016-0846": [
"39686"
],
"CVE-2016-0143": [
"39712"
],
"CVE-2016-0151": [
"39740"
],
"CVE-2016-0145": [
"39743"
],
"CVE-2016-3718": [
"39767"
],
"CVE-2016-3717": [
"39767"
],
"CVE-2016-3716": [
"39767"
],
"CVE-2016-3715": [
"39767"
],
"CVE-2016-3714": [
"39767",
"39791"
],
"CVE-2016-2107": [
"39768"
],
"CVE-2016-4535": [
"39770"
],
"CVE-2016-4558": [
"39773"
],
"CVE-2016-1013": [
"39778"
],
"CVE-2016-1011": [
"39779"
],
"CVE-2016-1077": [
"39799"
],
"CVE-2016-0801": [
"39801"
],
"CVE-2016-1102": [
"39824"
],
"CVE-2016-1104": [
"39825"
],
"CVE-2016-1103": [
"39826"
],
"CVE-2016-1101": [
"39827"
],
"CVE-2016-1096": [
"39828"
],
"CVE-2016-1105": [
"39829"
],
"CVE-2016-4108": [
"39830"
],
"CVE-2016-1106": [
"39831"
],
"CVE-2016-0168": [
"39832"
],
"CVE-2016-0169": [
"39833"
],
"CVE-2016-0170": [
"39834"
],
"CVE-2016-2208": [
"39835"
],
"CVE-2016-1606": [
"39857"
],
"CVE-2015-4870": [
"39867"
],
"CVE-2016-1846": [
"39920"
],
"CVE-2016-2494": [
"39921"
],
"CVE-2016-1794": [
"39922"
],
"CVE-2016-1793": [
"39923"
],
"CVE-2016-1813": [
"39924"
],
"CVE-2016-1803": [
"39925"
],
"CVE-2016-1821": [
"39926"
],
"CVE-2016-1823": [
"39927"
],
"CVE-2016-1819": [
"39928"
],
"CVE-2016-1807": [
"39929"
],
"CVE-2016-1861": [
"39930"
],
"CVE-2016-0171": [
"39959"
],
"CVE-2016-0173": [
"39960"
],
"CVE-2016-3216": [
"39990"
],
"CVE-2016-3220": [
"39991"
],
"CVE-2016-3219": [
"39993"
],
"CVE-2016-0199": [
"39994"
],
"CVE-2016-2207": [
"40031"
],
"CVE-2016-2210": [
"40032"
],
"CVE-2016-3644": [
"40034"
],
"CVE-2016-3645": [
"40035"
],
"CVE-2016-3646": [
"40036"
],
"CVE-2016-2209": [
"40037"
],
"CVE-2016-4229": [
"40310"
],
"CVE-2016-5399": [
"40155"
],
"CVE-2016-6504": [
"40194"
],
"CVE-2016-6512": [
"40195"
],
"CVE-2016-6503": [
"40196"
],
"CVE-2016-6505": [
"40197"
],
"CVE-2016-5847": [
"40230"
],
"CVE-2016-5845": [
"40230"
],
"CVE-2016-3316": [
"40238"
],
"CVE-2013-2842": [
"40243"
],
"CVE-2016-3288": [
"40253"
],
"CVE-2016-3301": [
"40255"
],
"CVE-2016-3303": [
"40256"
],
"CVE-2016-3304": [
"40257"
],
"CVE-2016-4226": [
"40308"
],
"CVE-2016-6855": [
"40291"
],
"CVE-2016-4228": [
"40309"
],
"CVE-2016-4230": [
"40311"
],
"CVE-2016-5348": [
"40502"
],
"CVE-2016-1464": [
"40508"
],
"CVE-2016-1415": [
"40509"
],
"CVE-2016-4273": [
"40510"
],
"CVE-2016-6689": [
"40515"
],
"CVE-2018-0769": [
"43710"
],
"CVE-2017-11914": [
"43713"
],
"CVE-2018-0774": [
"43715"
],
"CVE-2018-0775": [
"43717"
],
"CVE-2018-0777": [
"43718"
],
"CVE-2018-0780": [
"43720"
],
"CVE-2018-0776": [
"43723"
],
"CVE-2017-12718": [
"43776"
],
"CVE-2017-13878": [
"43780"
],
"CVE-2005-1806": [
"43826",
"1055"
],
"CVE-2018-5319": [
"43856"
],
"CVE-2014-1201": [
"43891"
],
"CVE-2016-3209": [
"40598"
],
"CVE-2016-7182": [
"40599"
],
"CVE-2016-0070": [
"40600"
],
"CVE-2016-3376": [
"40601"
],
"CVE-2016-7194": [
"40603"
],
"CVE-2016-3386": [
"40605"
],
"CVE-2016-9018": [
"40617"
],
"CVE-2016-5228": [
"40649"
],
"CVE-2016-1863": [
"40652"
],
"CVE-2016-4669": [
"40654"
],
"CVE-2016-7386": [
"40656"
],
"CVE-2016-7385": [
"40657"
],
"CVE-2016-7390": [
"40658"
],
"CVE-2016-7387": [
"40659"
],
"CVE-2016-7391": [
"40661"
],
"CVE-2016-8811": [
"40662"
],
"CVE-2016-8806": [
"40663"
],
"CVE-2016-8809": [
"40664"
],
"CVE-2016-8810": [
"40665"
],
"CVE-2016-8808": [
"40666"
],
"CVE-2016-8805": [
"40667"
],
"CVE-2016-8807": [
"40668"
],
"CVE-2014-4141": [
"40685"
],
"CVE-2016-6828": [
"40731"
],
"CVE-2016-7237": [
"40744"
],
"CVE-2016-7255": [
"40745",
"40823",
"41015"
],
"CVE-2016-3325": [
"40747"
],
"CVE-2016-3324": [
"40748"
],
"CVE-2016-7216": [
"40766"
],
"CVE-2016-7240": [
"40773"
],
"CVE-2016-7203": [
"40787"
],
"CVE-2016-9332": [
"40779"
],
"CVE-2016-7201": [
"40784",
"40990"
],
"CVE-2016-7200": [
"40785",
"40990"
],
"CVE-2016-7202": [
"40786",
"40793"
],
"CVE-2016-9150": [
"40790"
],
"CVE-2016-3247": [
"40797"
],
"CVE-2015-2482": [
"40798"
],
"CVE-2016-7434": [
"40806"
],
"CVE-2013-1309": [
"40893"
],
"CVE-2013-1306": [
"40894"
],
"CVE-2015-7855": [
"40840"
],
"CVE-2015-0050": [
"40841"
],
"CVE-2013-3120": [
"40844"
],
"CVE-2016-0063": [
"40845"
],
"CVE-2016-7241": [
"40875"
],
"CVE-2015-6168": [
"40878"
],
"CVE-2013-0019": [
"40879"
],
"CVE-2016-3222": [
"40880"
],
"CVE-2016-6515": [
"40888"
],
"CVE-2016-7054": [
"40899"
],
"CVE-2016-7626": [
"40906"
],
"CVE-2016-8740": [
"40909"
],
"CVE-2016-7866": [
"40915"
],
"CVE-2013-3143": [
"40923",
"28187"
],
"CVE-2013-0090": [
"40935"
],
"CVE-2013-6627": [
"40944"
],
"CVE-2016-6772": [
"40945"
],
"CVE-2016-7286": [
"40947"
],
"CVE-2016-7287": [
"40948"
],
"CVE-2016-7617": [
"40952",
"44237"
],
"CVE-2016-7633": [
"40954"
],
"CVE-2016-7612": [
"40955"
],
"CVE-2016-7661": [
"40958",
"40931"
],
"CVE-2016-7660": [
"40959"
],
"CVE-2017-2930": [
"41008",
"41012"
],
"CVE-2016-5108": [
"41025"
],
"CVE-2016-10079": [
"41030"
],
"CVE-2016-9899": [
"41042"
],
"CVE-2017-3241": [
"41145"
],
"CVE-2017-2370": [
"41163"
],
"CVE-2017-2353": [
"41164"
],
"CVE-2017-2360": [
"41165"
],
"CVE-2017-3730": [
"41192"
],
"CVE-2017-2362": [
"41213"
],
"CVE-2017-2369": [
"41215"
],
"CVE-2017-2373": [
"41216"
],
"CVE-2017-5850": [
"41278"
],
"CVE-2017-0038": [
"41363"
],
"CVE-2017-5972": [
"41350"
],
"CVE-2017-0411": [
"41354"
],
"CVE-2017-0412": [
"41355"
],
"CVE-2016-7288": [
"41357"
],
"CVE-2017-0312": [
"41364"
],
"CVE-2017-0313": [
"41365"
],
"CVE-2017-5881": [
"41367"
],
"CVE-2017-3807": [
"41369"
],
"CVE-2017-2992": [
"41420"
],
"CVE-2017-2988": [
"41421"
],
"CVE-2017-2985": [
"41422"
],
"CVE-2017-2986": [
"41423"
],
"CVE-2017-5358": [
"41425"
],
"CVE-2017-5359": [
"41426"
],
"CVE-2017-0037": [
"41454",
"42354",
"43125"
],
"CVE-2017-6074": [
"41457",
"41458"
],
"CVE-2017-6371": [
"41475"
],
"CVE-2017-6019": [
"41537"
],
"CVE-2017-6427": [
"41547"
],
"CVE-2017-6552": [
"41565"
],
"CVE-2017-6367": [
"41596"
],
"CVE-2017-6444": [
"41601"
],
"CVE-2017-2931": [
"41608"
],
"CVE-2017-2932": [
"41609"
],
"CVE-2017-2933": [
"41610"
],
"CVE-2017-2934": [
"41611"
],
"CVE-2017-2935": [
"41612"
],
"CVE-2016-7274": [
"41615"
],
"CVE-2017-6880": [
"41620"
],
"CVE-2017-15049": [
"43354"
],
"CVE-2017-15048": [
"43355"
],
"CVE-2017-11903": [
"43367"
],
"CVE-2017-11793": [
"43368"
],
"CVE-2017-11890": [
"43369"
],
"CVE-2017-11907": [
"43370"
],
"CVE-2017-11855": [
"43371"
],
"CVE-2017-11906": [
"43372"
],
"CVE-2017-5717": [
"43373"
],
"CVE-2017-11893": [
"43466"
],
"CVE-2017-11909": [
"43467"
],
"CVE-2017-11911": [
"43468"
],
"CVE-2017-17849": [
"43391",
"45087"
],
"CVE-2017-15667": [
"43403"
],
"CVE-2017-17932": [
"43406",
"43407",
"43523"
],
"CVE-2018-0744": [
"43446"
],
"CVE-2017-15662": [
"43451"
],
"CVE-2017-15663": [
"43452",
"43589"
],
"CVE-2017-15664": [
"43453"
],
"CVE-2017-15665": [
"43454"
],
"CVE-2018-0746": [
"43471"
],
"CVE-2018-0758": [
"43491"
],
"CVE-2017-8798": [
"43501"
],
"CVE-2017-13209": [
"43513"
],
"CVE-2018-0748": [
"43514"
],
"CVE-2018-0751": [
"43515"
],
"CVE-2018-0752": [
"43516"
],
"CVE-2018-0749": [
"43517"
],
"CVE-2017-7154": [
"43521"
],
"CVE-2018-0767": [
"43522"
],
"CVE-2018-5282": [
"43547"
],
"CVE-2017-0070": [
"41623"
],
"CVE-2017-7183": [
"41639"
],
"CVE-2018-6191": [
"43903"
],
"CVE-2018-5759": [
"43904"
],
"CVE-2018-4090": [
"43923"
],
"CVE-2018-4089": [
"43937"
],
"CVE-2018-6389": [
"43968"
],
"CVE-2018-6317": [
"43972"
],
"CVE-2018-0101": [
"43986"
],
"CVE-2017-17090": [
"43992"
],
"CVE-2017-13236": [
"43996"
],
"CVE-2018-4083": [
"44007"
],
"CVE-2018-6323": [
"44035"
],
"CVE-2017-18019": [
"44046"
],
"CVE-2017-15649": [
"44053"
],
"CVE-2017-10355": [
"44057"
],
"CVE-2018-0770": [
"44075"
],
"CVE-2018-0860": [
"44076"
],
"CVE-2018-0840": [
"44077"
],
"CVE-2018-0834": [
"44078"
],
"CVE-2018-0835": [
"44079"
],
"CVE-2018-0838": [
"44080"
],
"CVE-2018-0837": [
"44081"
],
"CVE-2018-1041": [
"44099"
],
"CVE-2015-5374": [
"44103"
],
"CVE-2017-0103": [
"41645"
],
"CVE-2017-0085": [
"41646"
],
"CVE-2017-0108": [
"41647"
],
"CVE-2017-0084": [
"41648"
],
"CVE-2017-0086": [
"41649"
],
"CVE-2017-0087": [
"41650"
],
"CVE-2017-0088": [
"41651"
],
"CVE-2017-0089": [
"41652"
],
"CVE-2017-0090": [
"41653"
],
"CVE-2017-0072": [
"41654"
],
"CVE-2017-0128": [
"41655"
],
"CVE-2017-0127": [
"41655"
],
"CVE-2017-0126": [
"41655"
],
"CVE-2017-0125": [
"41655"
],
"CVE-2017-0124": [
"41655"
],
"CVE-2017-0123": [
"41655"
],
"CVE-2017-0122": [
"41655"
],
"CVE-2017-0121": [
"41655"
],
"CVE-2017-0120": [
"41655"
],
"CVE-2017-0119": [
"41655"
],
"CVE-2017-0118": [
"41655"
],
"CVE-2017-0117": [
"41655"
],
"CVE-2017-0116": [
"41655"
],
"CVE-2017-0115": [
"41655"
],
"CVE-2017-0114": [
"41655"
],
"CVE-2017-0113": [
"41655"
],
"CVE-2017-0112": [
"41655"
],
"CVE-2017-0111": [
"41655"
],
"CVE-2017-0092": [
"41655"
],
"CVE-2017-0091": [
"41655"
],
"CVE-2017-0083": [
"41655"
],
"CVE-2017-0060": [
"41656"
],
"CVE-2017-0061": [
"41657"
],
"CVE-2017-0062": [
"41658"
],
"CVE-2017-0063": [
"41659"
],
"CVE-2017-5404": [
"41660"
],
"CVE-2017-0059": [
"41661",
"42354",
"43125"
],
"CVE-2017-6192": [
"41668"
],
"CVE-2017-6193": [
"41669"
],
"CVE-2017-6191": [
"41670"
],
"CVE-2017-2472": [
"41791"
],
"CVE-2017-2473": [
"41792"
],
"CVE-2017-2483": [
"41797"
],
"CVE-2017-2478": [
"41794"
],
"CVE-2017-7185": [
"41826"
],
"CVE-2017-2456": [
"41778"
],
"CVE-2017-7397": [
"41781"
],
"CVE-2017-2443": [
"41790"
],
"CVE-2017-8470": [
"42223"
],
"CVE-2017-8678": [
"42750"
],
"CVE-2017-8644": [
"42459"
],
"CVE-2017-2446": [
"41741",
"41742"
],
"CVE-2017-2447": [
"41743"
],
"CVE-2017-7285": [
"41752"
],
"CVE-2012-4530": [
"41767"
],
"CVE-2012-0031": [
"41768"
],
"CVE-2011-4415": [
"41769"
],
"CVE-2011-3607": [
"41769"
],
"CVE-2017-0561": [
"41806",
"41805"
],
"CVE-2017-2454": [
"41807"
],
"CVE-2017-2455": [
"41809"
],
"CVE-2017-2459": [
"41810"
],
"CVE-2017-2460": [
"41811"
],
"CVE-2017-2466": [
"41812"
],
"CVE-2017-2471": [
"41813"
],
"CVE-2017-2476": [
"41814"
],
"CVE-2017-3195": [
"41823"
],
"CVE-2017-8540": [
"42088"
],
"CVE-2017-7456": [
"41851"
],
"CVE-2017-2470": [
"41867"
],
"CVE-2017-2468": [
"41868"
],
"CVE-2017-2469": [
"41869"
],
"CVE-2017-0058": [
"41879"
],
"CVE-2017-0167": [
"41880"
],
"CVE-2017-0147": [
"41891",
"43970",
"41987",
"47456"
],
"CVE-2017-0146": [
"41891",
"43970",
"41987",
"47456"
],
"CVE-2017-0148": [
"41891",
"41987",
"47456"
],
"CVE-2017-0145": [
"41891",
"41987",
"47456"
],
"CVE-2017-0144": [
"41891",
"41987",
"42030",
"42031",
"42315",
"47456"
],
"CVE-2017-0143": [
"41891",
"43970",
"41987",
"47456"
],
"CVE-2017-7938": [
"41898"
],
"CVE-2017-3561": [
"41905"
],
"CVE-2017-3575": [
"41906"
],
"CVE-2017-2464": [
"41931"
],
"CVE-2017-3587": [
"41932"
],
"CVE-2017-0202": [
"41941"
],
"CVE-2017-3599": [
"41954"
],
"CVE-2017-10003": [
"41965",
"42272",
"42183",
"42271",
"42273",
"42274",
"42275",
"42276",
"45625"
],
"CVE-2017-8779": [
"41974"
],
"CVE-2017-2800": [
"41984"
],
"CVE-2017-8852": [
"41991"
],
"CVE-2017-7478": [
"41993"
],
"CVE-2017-8926": [
"42001"
],
"CVE-2017-8927": [
"42002"
],
"CVE-2017-0258": [
"42006"
],
"CVE-2017-0259": [
"42007"
],
"CVE-2017-0245": [
"42008"
],
"CVE-2017-0220": [
"42009"
],
"CVE-2017-0175": [
"42009"
],
"CVE-2017-6982": [
"42014"
],
"CVE-2017-3068": [
"42017"
],
"CVE-2017-3061": [
"42018"
],
"CVE-2017-3064": [
"42019"
],
"CVE-2017-0214": [
"42021"
],
"CVE-2017-8538": [
"42081"
],
"CVE-2017-8537": [
"42081"
],
"CVE-2017-8536": [
"42081"
],
"CVE-2017-8535": [
"42081"
],
"CVE-2017-2509": [
"42046"
],
"CVE-2017-2516": [
"42047"
],
"CVE-2017-9150": [
"42048"
],
"CVE-2017-2522": [
"42049"
],
"CVE-2017-2523": [
"42050"
],
"CVE-2017-2524": [
"42051"
],
"CVE-2017-2527": [
"42052"
],
"CVE-2017-2501": [
"42054"
],
"CVE-2017-6978": [
"42056"
],
"CVE-2017-2514": [
"42063"
],
"CVE-2017-5447": [
"42071"
],
"CVE-2017-5465": [
"42072"
],
"CVE-2017-8541": [
"42092"
],
"CVE-2017-2521": [
"42103"
],
"CVE-2017-2531": [
"42104"
],
"CVE-2017-9430": [
"42115",
"42424"
],
"CVE-2017-9353": [
"42123"
],
"CVE-2017-9347": [
"42124"
],
"CVE-2017-2671": [
"42135"
],
"CVE-2017-7472": [
"42136"
],
"CVE-2017-6542": [
"42137"
],
"CVE-2017-5991": [
"42138"
],
"CVE-2017-6060": [
"42139"
],
"CVE-2017-4916": [
"42140"
],
"CVE-2017-8871": [
"42147"
],
"CVE-2017-9128": [
"42148"
],
"CVE-2017-9127": [
"42148"
],
"CVE-2017-9126": [
"42148"
],
"CVE-2017-9125": [
"42148"
],
"CVE-2017-9124": [
"42148"
],
"CVE-2017-9123": [
"42148"
],
"CVE-2017-9122": [
"42148"
],
"CVE-2016-9813": [
"42162"
],
"CVE-2017-7005": [
"42188"
],
"CVE-2017-6980": [
"42189"
],
"CVE-2017-2547": [
"42190"
],
"CVE-2017-6984": [
"42191"
],
"CVE-2017-9750": [
"42198"
],
"CVE-2017-9746": [
"42199"
],
"CVE-2017-9747": [
"42200"
],
"CVE-2017-9749": [
"42201"
],
"CVE-2017-9748": [
"42202"
],
"CVE-2017-9742": [
"42203"
],
"CVE-2017-9756": [
"42204"
],
"CVE-2017-9130": [
"42207"
],
"CVE-2017-9129": [
"42207"
],
"CVE-2017-8484": [
"42210"
],
"CVE-2017-8487": [
"42211"
],
"CVE-2017-8488": [
"42212"
],
"CVE-2017-8489": [
"42213"
],
"CVE-2017-8490": [
"42214"
],
"CVE-2017-8491": [
"42215"
],
"CVE-2017-8492": [
"42216"
],
"CVE-2017-8469": [
"42217"
],
"CVE-2017-8462": [
"42218"
],
"CVE-2017-0299": [
"42219"
],
"CVE-2017-8482": [
"42220"
],
"CVE-2017-8471": [
"42224"
],
"CVE-2017-8472": [
"42225"
],
"CVE-2017-8473": [
"42226"
],
"CVE-2017-8485": [
"42228"
],
"CVE-2017-8476": [
"42229"
],
"CVE-2017-8477": [
"42230"
],
"CVE-2017-8478": [
"42231"
],
"CVE-2017-8479": [
"42232"
],
"CVE-2017-8480": [
"42233"
],
"CVE-2017-0283": [
"42234"
],
"CVE-2017-0284": [
"42235"
],
"CVE-2017-0285": [
"42236"
],
"CVE-2017-0282": [
"42237"
],
"CVE-2017-0286": [
"42238"
],
"CVE-2017-0287": [
"42239"
],
"CVE-2017-0289": [
"42240"
],
"CVE-2017-0288": [
"42241"
],
"CVE-2017-8481": [
"42242"
],
"CVE-2017-8483": [
"42243"
],
"CVE-2017-0300": [
"42244"
],
"CVE-2017-8496": [
"42246"
],
"CVE-2017-3076": [
"42247"
],
"CVE-2017-3077": [
"42248"
],
"CVE-2017-3078": [
"42249"
],
"CVE-2017-9869": [
"42258"
],
"CVE-2017-9872": [
"42259"
],
"CVE-2017-1297": [
"42260"
],
"CVE-2017-8558": [
"42264"
],
"CVE-2017-1084": [
"42277",
"42278"
],
"CVE-2017-1085": [
"42279"
],
"CVE-2017-5637": [
"42294"
],
"CVE-2017-10688": [
"42299"
],
"CVE-2017-9936": [
"42300"
],
"CVE-2017-9147": [
"42301"
],
"CVE-2017-8594": [
"42336"
],
"CVE-2017-8618": [
"42337"
],
"CVE-2017-8564": [
"42338"
],
"CVE-2017-7048": [
"42360"
],
"CVE-2017-7043": [
"42361"
],
"CVE-2017-7039": [
"42362"
],
"CVE-2017-7049": [
"42363"
],
"CVE-2017-7042": [
"42364"
],
"CVE-2017-7046": [
"42365"
],
"CVE-2017-7041": [
"42366"
],
"CVE-2017-7040": [
"42367"
],
"CVE-2017-7018": [
"42373"
],
"CVE-2017-7064": [
"42375"
],
"CVE-2017-7056": [
"42376"
],
"CVE-2016-2226": [
"42386"
],
"CVE-2017-9260": [
"42389"
],
"CVE-2017-9259": [
"42389"
],
"CVE-2017-9258": [
"42389"
],
"CVE-2017-9412": [
"42390"
],
"CVE-2017-9411": [
"42390"
],
"CVE-2017-9410": [
"42390"
],
"CVE-2017-9614": [
"42391"
],
"CVE-2017-11330": [
"42396"
],
"CVE-2017-11331": [
"42397"
],
"CVE-2017-11359": [
"42398"
],
"CVE-2017-11358": [
"42398"
],
"CVE-2017-11332": [
"42398"
],
"CVE-2017-11735": [
"42399"
],
"CVE-2017-11333": [
"42399"
],
"CVE-2017-11548": [
"42400"
],
"CVE-2017-11552": [
"42409"
],
"CVE-2017-11664": [
"42433"
],
"CVE-2017-11663": [
"42433"
],
"CVE-2017-11662": [
"42433"
],
"CVE-2017-11661": [
"42433"
],
"CVE-2017-8652": [
"42445"
],
"CVE-2017-8656": [
"42464"
],
"CVE-2017-8641": [
"42465"
],
"CVE-2017-8636": [
"42466",
"42467",
"42468",
"42478"
],
"CVE-2017-8645": [
"42469"
],
"CVE-2017-8646": [
"42470"
],
"CVE-2017-8635": [
"42471"
],
"CVE-2017-8548": [
"42473"
],
"CVE-2017-8634": [
"42474"
],
"CVE-2017-8671": [
"42475"
],
"CVE-2017-8640": [
"42476"
],
"CVE-2017-8670": [
"42477"
],
"CVE-2017-8601": [
"42479"
],
"CVE-2017-3106": [
"42480"
],
"CVE-2017-8657": [
"42481"
],
"CVE-2017-12954": [
"42546"
],
"CVE-2017-12953": [
"42546"
],
"CVE-2017-12952": [
"42546"
],
"CVE-2017-12951": [
"42546"
],
"CVE-2017-12950": [
"42546"
],
"CVE-2017-12786": [
"42518"
],
"CVE-2017-12785": [
"42518"
],
"CVE-2017-12787": [
"42518"
],
"CVE-2016-10504": [
"42600"
],
"CVE-2017-1129": [
"42602",
"42969"
],
"CVE-2017-14266": [
"42652"
],
"CVE-2017-7061": [
"42666"
],
"CVE-2017-8684": [
"42747"
],
"CVE-2017-8680": [
"42741"
],
"CVE-2017-8681": [
"42742"
],
"CVE-2017-8708": [
"42743"
],
"CVE-2017-8682": [
"42744"
],
"CVE-2017-8683": [
"42746"
],
"CVE-2017-8685": [
"42748"
],
"CVE-2017-8687": [
"42749"
],
"CVE-2017-8731": [
"42758"
],
"CVE-2017-8734": [
"42759"
],
"CVE-2017-10002": [
"42762",
"42887"
],
"CVE-2017-8729": [
"42763"
],
"CVE-2017-8740": [
"42764"
],
"CVE-2017-11764": [
"42765"
],
"CVE-2017-8755": [
"42766"
],
"CVE-2017-11281": [
"42781",
"42782"
],
"CVE-2017-11282": [
"42783"
],
"CVE-2017-14089": [
"42920"
],
"CVE-2017-14489": [
"42932"
],
"CVE-2017-14491": [
"42941"
],
"CVE-2017-14492": [
"42942"
],
"CVE-2017-14493": [
"42943"
],
"CVE-2017-14494": [
"42944"
],
"CVE-2017-14495": [
"42945"
],
"CVE-2017-14496": [
"42946"
],
"CVE-2017-7117": [
"42955"
],
"CVE-2017-14939": [
"42970"
],
"CVE-2017-15035": [
"42962"
],
"CVE-2017-0199": [
"42995",
"41894",
"41934"
],
"CVE-2017-11823": [
"42997"
],
"CVE-2017-11799": [
"42998"
],
"CVE-2017-11809": [
"42999"
],
"CVE-2017-11802": [
"43000"
],
"CVE-2017-11785": [
"43001"
],
"CVE-2017-15595": [
"43014"
],
"CVE-2017-7783": [
"43020"
],
"CVE-2017-15223": [
"43026"
],
"CVE-2017-15921": [
"43058"
],
"CVE-2017-15920": [
"43058"
],
"CVE-2017-16353": [
"43111"
],
"CVE-2017-16352": [
"43111"
],
"CVE-2017-16513": [
"43115"
],
"CVE-2017-16249": [
"43119"
],
"CVE-2017-12969": [
"43120"
],
"CVE-2017-11810": [
"43131"
],
"CVE-2017-16642": [
"43133"
],
"CVE-2017-15271": [
"43144"
],
"CVE-2017-15270": [
"43144"
],
"CVE-2017-11811": [
"43152"
],
"CVE-2017-11873": [
"43154"
],
"CVE-2017-13849": [
"43161"
],
"CVE-2017-16902": [
"43164"
],
"CVE-2017-11831": [
"43165"
],
"CVE-2017-13796": [
"43166"
],
"CVE-2017-13792": [
"43167"
],
"CVE-2017-13797": [
"43168"
],
"CVE-2017-13795": [
"43169"
],
"CVE-2017-13785": [
"43170"
],
"CVE-2017-13784": [
"43171"
],
"CVE-2017-13783": [
"43172"
],
"CVE-2017-13802": [
"43173"
],
"CVE-2017-13794": [
"43174"
],
"CVE-2017-13798": [
"43175"
],
"CVE-2017-13791": [
"43176"
],
"CVE-2017-13216": [
"43464"
],
"CVE-2017-16994": [
"43178",
"44304",
"44303"
],
"CVE-2017-11839": [
"43180"
],
"CVE-2017-11841": [
"43181"
],
"CVE-2017-11870": [
"43182"
],
"CVE-2017-11840": [
"43183"
],
"CVE-2017-16944": [
"43184"
],
"CVE-2017-16952": [
"43185"
],
"CVE-2017-16951": [
"43186"
],
"CVE-2017-15118": [
"43194"
],
"CVE-2018-0745": [
"43470"
],
"CVE-2017-10004": [
"43199",
"44305",
"43331",
"43733",
"43462",
"44318",
"45284"
],
"CVE-2017-11918": [
"43469"
],
"CVE-2017-17085": [
"43233"
],
"CVE-2017-8824": [
"43234"
],
"CVE-2017-17538": [
"43317"
],
"CVE-2017-13861": [
"43320"
],
"CVE-2017-13865": [
"43321"
],
"CVE-2017-13869": [
"43319"
],
"CVE-2017-13855": [
"43318"
],
"CVE-2017-17095": [
"43322"
],
"CVE-2017-13876": [
"43325"
],
"CVE-2017-13847": [
"43326"
],
"CVE-2017-13875": [
"43327"
],
"CVE-2017-13867": [
"43328"
],
"CVE-2017-17088": [
"43344"
],
"CVE-2018-0832": [
"44146"
],
"CVE-2018-0866": [
"44153"
],
"CVE-2018-7254": [
"44154",
"44154"
],
"CVE-2018-7286": [
"44181"
],
"CVE-2018-7284": [
"44184"
],
"CVE-2018-0833": [
"44189"
],
"CVE-2016-1886": [
"44211"
],
"CVE-2016-1887": [
"44212"
],
"CVE-2016-4657": [
"44213",
"44836"
],
"CVE-2018-4087": [
"44215"
],
"CVE-2018-7449": [
"44221"
],
"CVE-2018-7583": [
"44222"
],
"CVE-2016-7608": [
"44235"
],
"CVE-2016-1827": [
"44238"
],
"CVE-2017-2388": [
"44236"
],
"CVE-2018-6794": [
"44247"
],
"CVE-2018-7264": [
"44251"
],
"CVE-2018-7658": [
"44255"
],
"CVE-2018-10001": [
"44264",
"44265"
],
"CVE-2017-9417": [
"44268"
],
"CVE-2018-7582": [
"44271"
],
"CVE-2017-13253": [
"44291"
],
"CVE-2016-6187": [
"44301"
],
"CVE-2018-0894": [
"44308"
],
"CVE-2018-0895": [
"44309"
],
"CVE-2018-0897": [
"44310"
],
"CVE-2018-0901": [
"44311"
],
"CVE-2018-0891": [
"44312"
],
"CVE-2017-13262": [
"44326",
"44327"
],
"CVE-2017-13261": [
"44326",
"44327"
],
"CVE-2017-13260": [
"44326",
"44327"
],
"CVE-2017-13258": [
"44326",
"44327"
],
"CVE-2018-1218": [
"44332"
],
"CVE-2018-9115": [
"44375"
],
"CVE-2018-6064": [
"44394"
],
"CVE-2018-0934": [
"44396",
"44397"
],
"CVE-2018-0933": [
"44396"
],
"CVE-2018-0986": [
"44402"
],
"CVE-2018-0935": [
"44404"
],
"CVE-2018-4121": [
"44427"
],
"CVE-2018-9842": [
"44428",
"44829",
"45926"
],
"CVE-2018-0171": [
"44451"
],
"CVE-2018-0975": [
"44458"
],
"CVE-2018-0969": [
"44459"
],
"CVE-2018-0970": [
"44460"
],
"CVE-2018-0971": [
"44461"
],
"CVE-2018-0972": [
"44462"
],
"CVE-2018-0973": [
"44463"
],
"CVE-2018-0974": [
"44464"
],
"CVE-2018-0968": [
"44465"
],
"CVE-2018-0966": [
"44466"
],
"CVE-2018-10253": [
"44500"
],
"CVE-2017-8311": [
"44514"
],
"CVE-2018-4936": [
"44526"
],
"CVE-2018-4935": [
"44527"
],
"CVE-2018-4934": [
"44528"
],
"CVE-2018-4937": [
"44529"
],
"CVE-2018-4139": [
"44561"
],
"CVE-2018-4206": [
"44562"
],
"CVE-2018-4200": [
"44566"
],
"CVE-2018-10809": [
"44600"
],
"CVE-2018-10828": [
"44610"
],
"CVE-2018-10830": [
"44615"
],
"CVE-2018-11034": [
"44619"
],
"CVE-2018-0980": [
"44653"
],
"CVE-2014-5074": [
"44693"
],
"CVE-2018-0953": [
"44694"
],
"CVE-2018-3639": [
"44695"
],
"CVE-2016-3963": [
"44721"
],
"CVE-2018-10751": [
"44724"
],
"CVE-2018-0946": [
"44758"
],
"CVE-2018-5159": [
"44759"
],
"CVE-2015-2177": [
"44802"
],
"CVE-2018-8133": [
"44817"
],
"CVE-2018-11412": [
"44832"
],
"CVE-2018-12904": [
"44944"
],
"CVE-2018-8002": [
"44946"
],
"CVE-2018-7584": [
"44846"
],
"CVE-2018-4230": [
"44847"
],
"CVE-2018-4243": [
"44848"
],
"CVE-2018-4241": [
"44849"
],
"CVE-2018-11646": [
"44876",
"44842"
],
"CVE-2018-4222": [
"44859"
],
"CVE-2018-6092": [
"44860"
],
"CVE-2018-4218": [
"44861"
],
"CVE-2018-6130": [
"44862"
],
"CVE-2018-6129": [
"44863"
],
"CVE-2018-12453": [
"44908"
],
"CVE-2018-12327": [
"44909"
],
"CVE-2018-8208": [
"44914"
],
"CVE-2018-8214": [
"44915"
],
"CVE-2018-12617": [
"44925"
],
"CVE-2018-12706": [
"44934"
],
"CVE-2018-10594": [
"44965",
"45574"
],
"CVE-2018-10906": [
"45106"
],
"CVE-2018-12938": [
"44972"
],
"CVE-2018-0491": [
"44994"
],
"CVE-2018-8145": [
"45011"
],
"CVE-2018-8139": [
"45012"
],
"CVE-2018-8229": [
"45013"
],
"CVE-2018-10018": [
"45017"
],
"CVE-2018-13405": [
"45033"
],
"CVE-2018-14336": [
"45064"
],
"CVE-2018-13458": [
"45082"
],
"CVE-2018-13457": [
"45082"
],
"CVE-2018-13441": [
"45082"
],
"CVE-2018-20658": [
"45091"
],
"CVE-2018-6126": [
"45098"
],
"CVE-2018-12584": [
"45174"
],
"CVE-2018-15181": [
"45199"
],
"CVE-2018-15172": [
"45203"
],
"CVE-2018-8288": [
"45213"
],
"CVE-2018-8279": [
"45214"
],
"CVE-2018-8291": [
"45215"
],
"CVE-2018-8298": [
"45217"
],
"CVE-2013-0662": [
"45219",
"45220"
],
"CVE-2018-15120": [
"45263"
],
"CVE-2018-12827": [
"45268"
],
"CVE-2018-8353": [
"45279"
],
"CVE-2018-15839": [
"45317"
],
"CVE-2018-4240": [
"45391"
],
"CVE-2018-8384": [
"45431"
],
"CVE-2018-8355": [
"45432"
],
"CVE-2018-8449": [
"45435"
],
"CVE-2018-8410": [
"45436"
],
"CVE-2018-16071": [
"45443"
],
"CVE-2018-16083": [
"45444"
],
"CVE-2018-4314": [
"45480"
],
"CVE-2018-4312": [
"45481"
],
"CVE-2018-4306": [
"45482"
],
"CVE-2018-4328": [
"45483"
],
"CVE-2018-4323": [
"45484"
],
"CVE-2018-4315": [
"45485"
],
"CVE-2018-4317": [
"45486"
],
"CVE-2018-4318": [
"45488"
],
"CVE-2018-4197": [
"45489"
],
"CVE-2018-8411": [
"45624"
],
"CVE-2018-18065": [
"45547"
],
"CVE-2015-5621": [
"45547"
],
"CVE-2018-9515": [
"45558"
],
"CVE-2018-8466": [
"45571"
],
"CVE-2018-8467": [
"45572"
],
"CVE-2018-18557": [
"45694"
],
"CVE-2018-15686": [
"45714"
],
"CVE-2018-10712": [
"45716"
],
"CVE-2018-10711": [
"45716"
],
"CVE-2018-10710": [
"45716"
],
"CVE-2018-10709": [
"45716"
],
"CVE-2018-18759": [
"45732"
],
"CVE-2019-0539": [
"46485",
"46203",
"46204"
],
"CVE-2018-4384": [
"45786"
],
"CVE-2018-4367": [
"45787"
],
"CVE-2018-4366": [
"45788"
],
"CVE-2017-10000": [
"45824",
"46341",
"39441",
"45196",
"45198"
],
"CVE-2018-15437": [
"45829"
],
"CVE-2018-4416": [
"45910"
],
"CVE-2018-4382": [
"45911"
],
"CVE-2018-4386": [
"45912",
"47893"
],
"CVE-2018-8544": [
"45923"
],
"CVE-2018-8552": [
"45924"
],
"CVE-2018-8474": [
"45936"
],
"CVE-2018-19627": [
"45951"
],
"CVE-2018-4438": [
"45984"
],
"CVE-2018-8631": [
"46001"
],
"CVE-2018-8625": [
"46022"
],
"CVE-2018-8619": [
"46023"
],
"CVE-2018-1160": [
"46048",
"46034",
"46675"
],
"CVE-2018-4443": [
"46071"
],
"CVE-2018-4441": [
"46072",
"46522"
],
"CVE-2018-8269": [
"46101"
],
"CVE-2018-13042": [
"46165"
],
"CVE-2019-6443": [
"46175"
],
"CVE-2019-6444": [
"46176"
],
"CVE-2019-6445": [
"46177"
],
"CVE-2019-6442": [
"46178"
],
"CVE-2018-4442": [
"46183"
],
"CVE-2019-0570": [
"46184"
],
"CVE-2018-8617": [
"46202"
],
"CVE-2019-0567": [
"46203"
],
"CVE-2019-0568": [
"46205"
],
"CVE-2018-11508": [
"46208"
],
"CVE-2019-6706": [
"46246"
],
"CVE-2019-6225": [
"46248"
],
"CVE-2019-6973": [
"46261"
],
"CVE-2019-6209": [
"46285"
],
"CVE-2019-6208": [
"46296"
],
"CVE-2019-6218": [
"46297"
],
"CVE-2019-6214": [
"46298"
],
"CVE-2019-6205": [
"46299"
],
"CVE-2019-6213": [
"46300"
],
"CVE-2019-9599": [
"46337"
],
"CVE-2019-2000": [
"46356"
],
"CVE-2019-1999": [
"46357"
],
"CVE-2018-19524": [
"46358"
],
"CVE-2019-9601": [
"46380"
],
"CVE-2019-9831": [
"46381"
],
"CVE-2019-6974": [
"46388"
],
"CVE-2019-6224": [
"46433"
],
"CVE-2019-9833": [
"46443"
],
"CVE-2019-9832": [
"46445"
],
"CVE-2019-6215": [
"46448"
],
"CVE-2019-9600": [
"46464"
],
"CVE-2019-8375": [
"46465",
"46465"
],
"CVE-2019-9162": [
"46477"
],
"CVE-2019-9213": [
"46502",
"47957"
],
"CVE-2019-2025": [
"46503"
],
"CVE-2019-2023": [
"46504"
],
"CVE-2016-4578": [
"46529"
],
"CVE-2019-9649": [
"46534"
],
"CVE-2019-9648": [
"46535"
],
"CVE-2019-5797": [
"46565"
],
"CVE-2019-5796": [
"46566"
],
"CVE-2019-0768": [
"46567"
],
"CVE-2019-0667": [
"46568"
],
"CVE-2019-0612": [
"46569"
],
"CVE-2019-5789": [
"46570"
],
"CVE-2019-5788": [
"46571"
],
"CVE-2019-9768": [
"46589"
],
"CVE-2019-7303": [
"46594"
],
"CVE-2019-0808": [
"46604"
],
"CVE-2019-9810": [
"46605",
"47752"
],
"CVE-2019-9791": [
"46613"
],
"CVE-2019-9813": [
"46646"
],
"CVE-2019-8506": [
"46647"
],
"CVE-2019-8514": [
"46648"
],
"CVE-2019-8518": [
"46649"
],
"CVE-2019-8558": [
"46650"
],
"CVE-2018-11492": [
"46720"
],
"CVE-2019-2697": [
"46722"
],
"CVE-2019-2698": [
"46723"
],
"CVE-2018-16517": [
"46726"
],
"CVE-2019-7181": [
"46733"
],
"CVE-2019-3842": [
"46743"
],
"CVE-2019-7439": [
"46752"
],
"CVE-2019-3844": [
"46760"
],
"CVE-2019-3843": [
"46760"
],
"CVE-2019-11599": [
"46781"
],
"CVE-2003-0127": [
"3",
"12",
"22362",
"22363"
],
"CVE-2003-1055": [
"4"
],
"CVE-2003-0171": [
"15"
],
"CVE-2003-1452": [
"21"
],
"CVE-2003-0281": [
"29",
"21565",
"21566"
],
"CVE-2002-2087": [
"29",
"21565",
"21566",
"22580"
],
"CVE-2003-0289": [
"31",
"22594"
],
"CVE-2003-0306": [
"32"
],
"CVE-2003-0454": [
"71"
],
"CVE-2003-0611": [
"72"
],
"CVE-2003-0645": [
"75"
],
"CVE-2003-1030": [
"79",
"23435",
"23436",
"23437"
],
"CVE-2003-0740": [
"91"
],
"CVE-2003-0783": [
"104"
],
"CVE-2003-0759": [
"106"
],
"CVE-2003-0609": [
"114",
"1182"
],
"CVE-2003-0955": [
"118",
"125"
],
"CVE-2003-0659": [
"122",
"23255"
],
"CVE-2003-0961": [
"129",
"131"
],
"CVE-2003-0090": [
"134",
"23341",
"23342"
],
"CVE-2004-0074": [
"140",
"23510"
],
"CVE-2003-0985": [
"141",
"142",
"145"
],
"CVE-2004-0064": [
"144"
],
"CVE-2004-2093": [
"152"
],
"CVE-2004-0077": [
"154",
"160"
],
"CVE-2000-0949": [
"178",
"20250",
"20251",
"20252"
],
"CVE-2000-1125": [
"182",
"184",
"20385"
],
"CVE-2000-0987": [
"183",
"20312"
],
"CVE-2000-1009": [
"193",
"206"
],
"CVE-2000-0844": [
"197",
"209",
"210",
"215",
"249",
"20185",
"20186",
"20187",
"20188",
"20189",
"20190"
],
"CVE-1999-0034": [
"200",
"320",
"19546",
"19547"
],
"CVE-2000-1103": [
"202"
],
"CVE-2000-1096": [
"203"
],
"CVE-2001-0066": [
"216"
],
"CVE-2000-1134": [
"217",
"20436"
],
"CVE-1999-1008": [
"229",
"19676",
"19677"
],
"CVE-2000-0993": [
"243"
],
"CVE-2001-0115": [
"250"
],
"CVE-1999-0821": [
"252",
"19651"
],
"CVE-2000-0170": [
"255",
"19778",
"19779"
],
"CVE-1999-1371": [
"256"
],
"CVE-2001-0110": [
"257"
],
"CVE-2001-0170": [
"258",
"317"
],
"CVE-2002-1616": [
"259"
],
"CVE-2001-0112": [
"260"
],
"CVE-1999-1185": [
"261"
],
"CVE-1999-1041": [
"261"
],
"CVE-2000-0795": [
"265",
"20129"
],
"CVE-2001-0485": [
"270",
"20804"
],
"CVE-2003-0908": [
"271"
],
"CVE-2004-0333": [
"272"
],
"CVE-2004-0524": [
"273",
"417"
],
"CVE-2002-1614": [
"281"
],
"CVE-2001-0221": [
"286"
],
"CVE-2001-0220": [
"287"
],
"CVE-2001-0169": [
"290"
],
"CVE-2000-0218": [
"321"
],
"CVE-1999-0040": [
"322",
"331",
"19200",
"19201",
"19202"
],
"CVE-2000-1220": [
"325"
],
"CVE-1999-0315": [
"328"
],
"CVE-1999-0110": [
"328"
],
"CVE-1999-1191": [
"332",
"19160"
],
"CVE-1999-0112": [
"333"
],
"CVE-1999-0027": [
"334",
"19276",
"19277"
],
"CVE-1999-0064": [
"335"
],
"CVE-1999-0036": [
"336",
"19310"
],
"CVE-1999-0126": [
"338"
],
"CVE-1999-1483": [
"339"
],
"CVE-1999-1158": [
"341",
"19158"
],
"CVE-2004-0213": [
"350",
"351",
"352",
"355"
],
"CVE-2004-0212": [
"353",
"368"
],
"CVE-2004-0824": [
"367"
],
"CVE-2004-0557": [
"369",
"374"
],
"CVE-2004-0415": [
"375"
],
"CVE-2004-2532": [
"381"
],
"CVE-2004-0733": [
"388",
"3757"
],
"CVE-2004-0597": [
"393",
"389",
"25094"
],
"CVE-2004-0636": [
"395",
"431",
"16525"
],
"CVE-2000-0574": [
"396"
],
"CVE-1999-1497": [
"401",
"19683"
],
"CVE-2002-1337": [
"411",
"22313",
"22314"
],
"CVE-2004-0806": [
"438",
"469"
],
"CVE-2004-1689": [
"470"
],
"CVE-2001-0979": [
"482",
"21098"
],
"CVE-2004-0940": [
"587",
"24694"
],
"CVE-2004-1484": [
"591"
],
"CVE-2004-0990": [
"600"
],
"CVE-2004-0110": [
"601"
],
"CVE-2004-0510": [
"602"
],
"CVE-2004-1073": [
"624"
],
"CVE-2004-2442": [
"629"
],
"CVE-2004-1096": [
"629"
],
"CVE-2004-0937": [
"629"
],
"CVE-2004-0936": [
"629"
],
"CVE-2004-0935": [
"629"
],
"CVE-2004-0934": [
"629"
],
"CVE-2004-0933": [
"629"
],
"CVE-2004-0932": [
"629"
],
"CVE-2004-0548": [
"669"
],
"CVE-2005-1307": [
"680"
],
"CVE-2004-1254": [
"694"
],
"CVE-2004-1326": [
"698"
],
"CVE-2004-1330": [
"699"
],
"CVE-2004-1054": [
"701",
"898"
],
"CVE-2003-0834": [
"713",
"714"
],
"CVE-2004-0360": [
"715"
],
"CVE-2004-0497": [
"718"
],
"CVE-2004-1235": [
"744",
"778",
"895"
],
"CVE-2004-0894": [
"749"
],
"CVE-2005-0021": [
"756",
"1009"
],
"CVE-2005-0043": [
"758",
"16562"
],
"CVE-2005-0193": [
"766"
],
"CVE-2010-0788": [
"779"
],
"CVE-2005-3533": [
"788",
"1154"
],
"CVE-2005-0156": [
"791"
],
"CVE-2005-0155": [
"792"
],
"CVE-2005-0342": [
"793"
],
"CVE-2005-0422": [
"798"
],
"CVE-2005-0421": [
"803"
],
"CVE-2005-0517": [
"833"
],
"CVE-2005-0518": [
"834",
"844"
],
"CVE-2005-0521": [
"835"
],
"CVE-2005-0522": [
"837"
],
"CVE-2005-0506": [
"839"
],
"CVE-2005-0619": [
"846",
"848"
],
"CVE-2005-0455": [
"863",
"16586"
],
"CVE-2005-0666": [
"876"
],
"CVE-2005-0385": [
"877"
],
"CVE-2005-0823": [
"884",
"885"
],
"CVE-2005-0716": [
"896",
"2111"
],
"CVE-2005-1009": [
"905",
"906",
"990",
"16448"
],
"CVE-2005-1098": [
"912"
],
"CVE-2005-1019": [
"913",
"914"
],
"CVE-2005-1094": [
"918"
],
"CVE-2005-1097": [
"920"
],
"CVE-2005-1294": [
"926"
],
"CVE-2005-0944": [
"927",
"929",
"951"
],
"CVE-2005-1092": [
"936"
],
"CVE-2005-0063": [
"938"
],
"CVE-2005-1424": [
"963"
],
"CVE-2005-1414": [
"964"
],
"CVE-2005-1411": [
"965"
],
"CVE-2005-1418": [
"966"
],
"CVE-2005-1371": [
"971"
],
"CVE-2005-1394": [
"972"
],
"CVE-2005-1396": [
"973",
"974"
],
"CVE-2005-0047": [
"1019"
],
"CVE-2005-1905": [
"1032"
],
"CVE-2004-1465": [
"1034"
],
"CVE-2005-1725": [
"1043"
],
"CVE-2005-0263": [
"1044"
],
"CVE-2005-0262": [
"1045"
],
"CVE-2005-2236": [
"1046"
],
"CVE-2005-2232": [
"1046"
],
"CVE-2005-2072": [
"1073",
"1074"
],
"CVE-2005-2210": [
"1091"
],
"CVE-2005-1372": [
"1161"
],
"CVE-2005-2694": [
"1168"
],
"CVE-2001-0989": [
"1170"
],
"CVE-2005-2866": [
"1173"
],
"CVE-2005-2868": [
"1174"
],
"CVE-2005-1842": [
"1185"
],
"CVE-2005-1843": [
"1186"
],
"CVE-2005-2772": [
"1187"
],
"CVE-2005-0551": [
"1198"
],
"CVE-2003-0948": [
"1215"
],
"CVE-2003-0947": [
"1215",
"23299",
"23300",
"23301"
],
"CVE-2005-3098": [
"1229",
"1230"
],
"CVE-2005-2943": [
"1267"
],
"CVE-2005-3546": [
"1297"
],
"CVE-2005-3503": [
"1299"
],
"CVE-2005-3346": [
"1300"
],
"CVE-2005-3566": [
"1316"
],
"CVE-2005-3928": [
"1347"
],
"CVE-2005-4076": [
"1360"
],
"CVE-2005-0736": [
"1397",
"25202"
],
"CVE-2006-0072": [
"1402"
],
"CVE-2005-4620": [
"1403",
"1404"
],
"CVE-2006-0097": [
"1406"
],
"CVE-2005-2827": [
"1407"
],
"CVE-2006-0176": [
"1412",
"1415"
],
"CVE-2006-0331": [
"1449"
],
"CVE-2006-0287": [
"1455"
],
"CVE-2006-0620": [
"1479"
],
"CVE-2006-0623": [
"1481"
],
"CVE-2005-2934": [
"1534"
],
"CVE-2005-2713": [
"1545"
],
"CVE-2005-1544": [
"1554"
],
"CVE-2006-1043": [
"1555"
],
"CVE-2005-2925": [
"1577"
],
"CVE-2006-1183": [
"1579"
],
"CVE-2005-0058": [
"1584"
],
"CVE-2006-1542": [
"1591"
],
"CVE-2006-0745": [
"1596",
"45922"
],
"CVE-2006-2505": [
"1719",
"3269"
],
"CVE-2006-2081": [
"1719",
"3269"
],
"CVE-2006-2316": [
"1772"
],
"CVE-2006-2494": [
"1806"
],
"CVE-2006-2656": [
"1831"
],
"CVE-2006-2373": [
"1910",
"1911"
],
"CVE-2006-2909": [
"1917"
],
"CVE-2006-3059": [
"1944"
],
"CVE-2006-2451": [
"2004",
"2005",
"2006",
"2011",
"2031"
],
"CVE-2006-3693": [
"2015",
"2016"
],
"CVE-2006-0026": [
"2056"
],
"CVE-2006-3814": [
"2065"
],
"CVE-2006-3824": [
"2067",
"2241"
],
"CVE-2006-4046": [
"2094"
],
"CVE-2006-4020": [
"2193"
],
"CVE-1999-1587": [
"2242"
],
"CVE-2006-6410": [
"2264"
],
"CVE-2006-2439": [
"2278",
"12053",
"14433"
],
"CVE-2006-4676": [
"2284"
],
"CVE-2006-4359": [
"2286"
],
"CVE-2006-4655": [
"2330",
"2331",
"2332",
"2360"
],
"CVE-2006-4789": [
"2338"
],
"CVE-2006-4438": [
"2404"
],
"CVE-2006-3444": [
"2412"
],
"CVE-2006-4392": [
"2463",
"2464"
],
"CVE-2006-5014": [
"2466"
],
"CVE-2006-4842": [
"2543",
"2569",
"2641",
"28788",
"28789",
"45433"
],
"CVE-2006-5379": [
"2581"
],
"CVE-2006-5557": [
"2633",
"2634"
],
"CVE-2006-5558": [
"2635"
],
"CVE-2006-5556": [
"2636"
],
"CVE-2006-4926": [
"2676"
],
"CVE-2006-5851": [
"2737"
],
"CVE-2006-5852": [
"2738"
],
"CVE-2006-6131": [
"2788"
],
"CVE-2006-6063": [
"2815",
"2824",
"16556"
],
"CVE-2006-6251": [
"2872",
"16617",
"2870"
],
"CVE-2006-6287": [
"2873"
],
"CVE-2009-0450": [
"2880",
"7975",
"9360",
"17939"
],
"CVE-2006-6396": [
"2880"
],
"CVE-2006-6199": [
"2880",
"9329",
"9360",
"13905",
"16618",
"23783",
"26889",
"29263",
"6217"
],
"CVE-2006-6665": [
"2950",
"16675"
],
"CVE-2007-0117": [
"3087",
"3088"
],
"CVE-2007-0085": [
"3094"
],
"CVE-2007-0162": [
"3102"
],
"CVE-2007-1881": [
"3131"
],
"CVE-2007-0427": [
"3149",
"3159"
],
"CVE-2007-0352": [
"3149"
],
"CVE-2007-0368": [
"3154"
],
"CVE-2007-0019": [
"3156"
],
"CVE-2006-3698": [
"3178",
"3358",
"3375"
],
"CVE-2006-0586": [
"3179",
"3359",
"3376"
],
"CVE-2007-0023": [
"3181"
],
"CVE-2007-0602": [
"3213"
],
"CVE-2007-0467": [
"3219"
],
"CVE-2006-5854": [
"3220",
"29146"
],
"CVE-2007-0515": [
"3260",
"29524"
],
"CVE-2007-0805": [
"3273"
],
"CVE-2007-1041": [
"3342",
"3369"
],
"CVE-2007-1074": [
"3349"
],
"CVE-2007-1057": [
"3356"
],
"CVE-2007-1189": [
"3383"
],
"CVE-2006-7098": [
"3384"
],
"CVE-2007-1227": [
"3386"
],
"CVE-2007-1380": [
"3413"
],
"CVE-2007-0908": [
"3414"
],
"CVE-2007-1411": [
"3417"
],
"CVE-2007-1375": [
"3424"
],
"CVE-2007-1376": [
"3426",
"3427"
],
"CVE-2007-1382": [
"3429"
],
"CVE-2007-1401": [
"3431"
],
"CVE-2007-1413": [
"3439",
"4204",
"4274"
],
"CVE-2007-1399": [
"3440"
],
"CVE-2007-1412": [
"3442"
],
"CVE-2007-1584": [
"3460",
"3517"
],
"CVE-2007-1521": [
"3479"
],
"CVE-2007-1522": [
"3480"
],
"CVE-2007-1475": [
"3488"
],
"CVE-2007-1484": [
"3499"
],
"CVE-2007-1582": [
"3525"
],
"CVE-2007-1581": [
"3529"
],
"CVE-2007-1649": [
"3559"
],
"CVE-2007-1700": [
"3571"
],
"CVE-2007-1701": [
"3572"
],
"CVE-2007-1709": [
"3576"
],
"CVE-2007-1719": [
"3578"
],
"CVE-2007-1734": [
"3587",
"3595"
],
"CVE-2007-1730": [
"3587",
"3595"
],
"CVE-2007-1735": [
"3593"
],
"CVE-2007-1867": [
"3648",
"3692"
],
"CVE-2007-1738": [
"3664"
],
"CVE-2007-1215": [
"3688",
"3755",
"3804"
],
"CVE-2007-1213": [
"3688",
"3755",
"3804"
],
"CVE-2007-1212": [
"3688",
"3755",
"3804"
],
"CVE-2007-1211": [
"3688",
"3755",
"3804"
],
"CVE-2006-5758": [
"3688",
"3755",
"3804"
],
"CVE-2006-5586": [
"3688",
"3755",
"3804"
],
"CVE-2007-2062": [
"3727"
],
"CVE-2007-2192": [
"3772",
"12497"
],
"CVE-2007-2193": [
"3776",
"16632"
],
"CVE-2007-2194": [
"3777"
],
"CVE-2007-2209": [
"3779"
],
"CVE-2007-2244": [
"3793"
],
"CVE-2007-2284": [
"3797"
],
"CVE-2007-2283": [
"3798"
],
"CVE-2007-2356": [
"3801",
"3888"
],
"CVE-2007-2363": [
"3811",
"6188"
],
"CVE-2007-2366": [
"3812"
],
"CVE-2007-2365": [
"3812"
],
"CVE-2007-2498": [
"3823"
],
"CVE-2007-2576": [
"3856"
],
"CVE-2007-2666": [
"3912"
],
"CVE-2007-0752": [
"3985"
],
"CVE-2007-0753": [
"4013",
"30096"
],
"CVE-2007-3068": [
"4024",
"17770",
"17788",
"17803"
],
"CVE-2007-3048": [
"4028"
],
"CVE-2007-0016": [
"4051"
],
"CVE-2007-3294": [
"4080"
],
"CVE-2016-6434": [
"40465"
],
"CVE-2007-3681": [
"4165"
],
"CVE-2007-1000": [
"4172"
],
"CVE-2007-3673": [
"4178"
],
"CVE-2007-3855": [
"4203",
"30295"
],
"CVE-2007-4010": [
"4218"
],
"CVE-2007-4032": [
"4229"
],
"CVE-2007-3333": [
"4231",
"30399"
],
"CVE-2007-4003": [
"4232"
],
"CVE-2007-4004": [
"4233"
],
"CVE-2007-4140": [
"4252"
],
"CVE-2007-4191": [
"4257"
],
"CVE-2007-4257": [
"4262",
"4263"
],
"CVE-2007-4528": [
"4311"
],
"CVE-2007-4596": [
"4314"
],
"CVE-2007-4648": [
"4345"
],
"CVE-2007-4735": [
"4354"
],
"CVE-2007-4734": [
"4355",
"9589"
],
"CVE-2007-4776": [
"4361",
"4431",
"16680"
],
"CVE-2007-4803": [
"4364",
"8312"
],
"CVE-2007-3997": [
"4392"
],
"CVE-2007-4573": [
"4460",
"30604"
],
"CVE-2007-5447": [
"4517"
],
"CVE-2007-5487": [
"4531"
],
"CVE-2007-5653": [
"4553"
],
"CVE-2007-5508": [
"4564"
],
"CVE-2007-5511": [
"4570",
"4571",
"4572"
],
"CVE-2007-5709": [
"4583"
],
"CVE-2007-2217": [
"4584",
"4616"
],
"CVE-2006-4254": [
"4612"
],
"CVE-2007-6026": [
"4625"
],
"CVE-2007-6211": [
"4698"
],
"CVE-2007-6402": [
"4701"
],
"CVE-2007-6401": [
"4702"
],
"CVE-2007-6403": [
"4703"
],
"CVE-2007-6478": [
"4749"
],
"CVE-2007-3876": [
"4759"
],
"CVE-2006-6288": [
"4839"
],
"CVE-2008-0392": [
"4938"
],
"CVE-2008-0493": [
"4998"
],
"CVE-2008-0573": [
"5004"
],
"CVE-2007-0949": [
"5077"
],
"CVE-2008-0600": [
"5092",
"5093"
],
"CVE-2008-0010": [
"5092",
"5093"
],
"CVE-2008-0009": [
"5092",
"5093"
],
"CVE-2008-0108": [
"5107",
"31118"
],
"CVE-2008-0105": [
"5107"
],
"CVE-2007-0216": [
"5107"
],
"CVE-2008-1139": [
"5143"
],
"CVE-2008-1140": [
"5144"
],
"CVE-2007-3103": [
"5167"
],
"CVE-2007-5225": [
"5227"
],
"CVE-2008-1881": [
"5250",
"5667"
],
"CVE-2008-0117": [
"5287"
],
"CVE-2008-0116": [
"5287"
],
"CVE-2008-0115": [
"5287"
],
"CVE-2008-0114": [
"5287"
],
"CVE-2008-0112": [
"5287"
],
"CVE-2008-0111": [
"5287"
],
"CVE-2008-0081": [
"5287"
],
"CVE-2008-0113": [
"5320"
],
"CVE-2008-0069": [
"5346"
],
"CVE-2008-1343": [
"5355"
],
"CVE-2008-0310": [
"5355"
],
"CVE-2008-6558": [
"5356"
],
"CVE-2008-6559": [
"5357"
],
"CVE-2008-1087": [
"5442",
"6656"
],
"CVE-2008-1765": [
"5479"
],
"CVE-2008-1769": [
"5498"
],
"CVE-2008-1489": [
"5498"
],
"CVE-2008-0984": [
"5498"
],
"CVE-2008-0296": [
"5498"
],
"CVE-2008-0295": [
"5498"
],
"CVE-2008-0073": [
"5498"
],
"CVE-2007-6681": [
"5498"
],
"CVE-2008-5121": [
"5837"
],
"CVE-2008-2427": [
"5951"
],
"CVE-2008-3182": [
"6030",
"6039"
],
"CVE-2008-3148": [
"6031"
],
"CVE-2008-2950": [
"6032"
],
"CVE-2008-5755": [
"6106",
"7582"
],
"CVE-2008-3408": [
"6157",
"10595",
"15895"
],
"CVE-2008-3877": [
"6322",
"7577"
],
"CVE-2008-4087": [
"6333"
],
"CVE-2008-2936": [
"6337"
],
"CVE-2008-4470": [
"6389"
],
"CVE-2008-3464": [
"6757"
],
"CVE-2008-4434": [
"6787"
],
"CVE-2008-4686": [
"6798",
"6825"
],
"CVE-2008-4654": [
"6798",
"6825",
"16629"
],
"CVE-2008-4779": [
"6831",
"12008",
"17967"
],
"CVE-2008-4210": [
"6851"
],
"CVE-2008-2992": [
"6994",
"7006",
"16504",
"16624"
],
"CVE-2008-5036": [
"7051",
"18548"
],
"CVE-2008-5049": [
"7054"
],
"CVE-2008-5680": [
"7135"
],
"CVE-2008-5178": [
"7135"
],
"CVE-2008-5625": [
"7171"
],
"CVE-2006-3011": [
"7171"
],
"CVE-2008-5394": [
"7313"
],
"CVE-2008-5664": [
"7492",
"16456"
],
"CVE-2008-5416": [
"7501",
"16392",
"16396"
],
"CVE-2008-4270": [
"7501"
],
"CVE-2008-5724": [
"7516"
],
"CVE-2008-5725": [
"7533"
],
"CVE-2008-5735": [
"7536",
"7547"
],
"CVE-2008-5377": [
"7550"
],
"CVE-2008-5868": [
"7608"
],
"CVE-2008-4113": [
"7618"
],
"CVE-2008-5498": [
"7646"
],
"CVE-2008-3984": [
"7675"
],
"CVE-2008-3983": [
"7676"
],
"CVE-2009-0182": [
"7695"
],
"CVE-2009-0261": [
"7839"
],
"CVE-2009-0476": [
"7958",
"7973",
"7974",
"10353",
"11079",
"15013",
"16626"
],
"CVE-2009-0641": [
"8055"
],
"CVE-2009-0390": [
"8067"
],
"CVE-2008-3979": [
"8074"
],
"CVE-2009-0812": [
"8121",
"9550"
],
"CVE-2009-0837": [
"8201",
"18905"
],
"CVE-2009-1039": [
"8231"
],
"CVE-2009-1071": [
"8236",
"9628"
],
"CVE-2009-1068": [
"8249",
"8251"
],
"CVE-2009-1041": [
"8261"
],
"CVE-2009-1235": [
"8266"
],
"CVE-2009-1063": [
"8270"
],
"CVE-2009-0360": [
"8303"
],
"CVE-2009-0686": [
"8322"
],
"CVE-2009-1260": [
"8343",
"16666"
],
"CVE-2009-1337": [
"8369"
],
"CVE-2009-0981": [
"8456"
],
"CVE-2009-1759": [
"8470"
],
"CVE-2009-1185": [
"8478",
"8572",
"21848"
],
"CVE-2009-1449": [
"8527"
],
"CVE-2009-0036": [
"8534"
],
"CVE-2009-4755": [
"8580"
],
"CVE-2009-4761": [
"8594"
],
"CVE-2009-0927": [
"8595",
"9579",
"16606",
"16681"
],
"CVE-2009-1586": [
"8612",
"8637"
],
"CVE-2009-1643": [
"8624",
"9560"
],
"CVE-2009-1646": [
"8628",
"36502"
],
"CVE-2009-1641": [
"8631",
"8632"
],
"CVE-2009-1645": [
"8633",
"8634"
],
"CVE-2009-1674": [
"8656"
],
"CVE-2009-1608": [
"8656"
],
"CVE-2009-1667": [
"8660",
"8661",
"8662",
"10646"
],
"CVE-2009-5137": [
"8663"
],
"CVE-2009-1744": [
"8670"
],
"CVE-2009-1743": [
"8670"
],
"CVE-2009-1527": [
"8673"
],
"CVE-2009-1815": [
"8698",
"8701"
],
"CVE-2009-4676": [
"8780"
],
"CVE-2009-4668": [
"8780"
],
"CVE-2009-1824": [
"8782"
],
"CVE-2009-2450": [
"8875"
],
"CVE-2009-2261": [
"8881",
"16307"
],
"CVE-2009-4832": [
"8983"
],
"CVE-2009-2485": [
"9034",
"9038",
"16646"
],
"CVE-2009-2566": [
"9047"
],
"CVE-2009-2364": [
"9060",
"15489",
"15569"
],
"CVE-2009-2363": [
"9064",
"9070",
"9152"
],
"CVE-2009-2362": [
"9064",
"9070",
"9152"
],
"CVE-2008-3531": [
"9082"
],
"CVE-2009-1046": [
"9083"
],
"CVE-2009-2375": [
"9104"
],
"CVE-2008-4190": [
"9135"
],
"CVE-2009-2564": [
"9199",
"9223"
],
"CVE-2009-1894": [
"9207",
"9208"
],
"CVE-2009-2653": [
"9301"
],
"CVE-2009-2847": [
"9352"
],
"CVE-2005-4605": [
"9363"
],
"CVE-2009-4549": [
"9377"
],
"CVE-2015-7985": [
"9386"
],
"CVE-2009-3428": [
"9412",
"9418",
"9420"
],
"CVE-2009-2934": [
"9428",
"9536"
],
"CVE-2009-2692": [
"9435",
"9436",
"9477",
"9479",
"9545",
"9598",
"9641",
"19933"
],
"CVE-2009-3214": [
"9483",
"9519",
"16655"
],
"CVE-2009-4088": [
"9483",
"10101"
],
"CVE-2009-4089": [
"9483",
"10101"
],
"CVE-2009-4964": [
"9486"
],
"CVE-2009-4962": [
"9495",
"14591",
"15279"
],
"CVE-2009-3001": [
"9513"
],
"CVE-2009-3002": [
"9521",
"9543"
],
"CVE-2009-2698": [
"9542",
"9574",
"9575"
],
"CVE-2009-3254": [
"9548"
],
"CVE-2009-3058": [
"9568"
],
"CVE-2009-3221": [
"9610"
],
"CVE-2009-3670": [
"9624"
],
"CVE-2009-2669": [
"9645"
],
"CVE-2009-4107": [
"9655"
],
"CVE-2009-3338": [
"9659"
],
"CVE-2006-2043": [
"9688"
],
"CVE-2009-3233": [
"9709"
],
"CVE-2009-3489": [
"9807",
"9988"
],
"CVE-2009-3547": [
"9844",
"10018",
"33321",
"33322",
"40812"
],
"CVE-2009-3527": [
"9859"
],
"CVE-2009-2994": [
"9865"
],
"CVE-2009-3709": [
"9866",
"9991"
],
"CVE-2009-3708": [
"9866",
"9991"
],
"CVE-2009-3805": [
"9884"
],
"CVE-2009-4607": [
"9955"
],
"CVE-2009-3692": [
"9973"
],
"CVE-2010-0832": [
"14273",
"14339"
],
"CVE-2009-2990": [
"9990",
"16309"
],
"CVE-2009-0184": [
"10009",
"16634"
],
"CVE-2009-3281": [
"10076"
],
"CVE-2009-4556": [
"10084"
],
"CVE-2009-4781": [
"10201"
],
"CVE-2009-2267": [
"10207"
],
"CVE-2009-3576": [
"10211",
"33273"
],
"CVE-2009-3578": [
"10213"
],
"CVE-2009-4097": [
"10226"
],
"CVE-2009-4117": [
"10244"
],
"CVE-2009-4147": [
"10255"
],
"CVE-2009-4146": [
"10255"
],
"CVE-2009-4195": [
"10281",
"10344",
"16669"
],
"CVE-2009-4148": [
"10295"
],
"CVE-2009-2626": [
"10296",
"33162",
"33163"
],
"CVE-2009-4251": [
"10298"
],
"CVE-2009-4452": [
"10484"
],
"CVE-2009-4454": [
"10487"
],
"CVE-2009-1839": [
"10544"
],
"CVE-2007-4652": [
"10557"
],
"CVE-2006-5178": [
"10557"
],
"CVE-2009-4324": [
"10618",
"16503",
"16623"
],
"CVE-2009-5109": [
"10745",
"10747",
"10782",
"18082"
],
"CVE-2010-2004": [
"11146",
"11154"
],
"CVE-2010-0364": [
"11174"
],
"CVE-2010-0232": [
"11199"
],
"CVE-2009-4606": [
"11264"
],
"CVE-2010-1591": [
"11281"
],
"CVE-2010-0688": [
"11581",
"13940",
"16654"
],
"CVE-2010-1225": [
"11786"
],
"CVE-2010-0188": [
"11787",
"16670",
"21868",
"21869"
],
"CVE-2006-3459": [
"11787",
"16862",
"16868",
"16869",
"21868",
"21869"
],
"CVE-2010-1240": [
"11987",
"16671",
"16682"
],
"CVE-2010-1239": [
"11987"
],
"CVE-2010-1146": [
"12130"
],
"CVE-2010-1458": [
"12293"
],
"CVE-2010-1597": [
"12326"
],
"CVE-2017-17405": [
"43381"
],
"CVE-2010-1685": [
"12368"
],
"CVE-2010-0705": [
"12406"
],
"CVE-2009-3523": [
"12406"
],
"CVE-2008-1625": [
"12406"
],
"CVE-2010-1686": [
"12469"
],
"CVE-2010-1688": [
"12662"
],
"CVE-2007-2683": [
"30093"
],
"CVE-2010-2031": [
"12710"
],
"CVE-2010-2343": [
"13760",
"13761",
"13763",
"31643"
],
"CVE-2010-2311": [
"13820"
],
"CVE-2010-2329": [
"13895"
],
"CVE-2010-2348": [
"13909"
],
"CVE-2010-1964": [
"14256",
"17041"
],
"CVE-2010-0822": [
"14361",
"15094",
"18143"
],
"CVE-2010-5081": [
"14373",
"18113"
],
"CVE-2015-0096": [
"14403"
],
"CVE-2010-2568": [
"14403",
"16574"
],
"CVE-2010-1869": [
"14406"
],
"CVE-2010-2973": [
"14538"
],
"CVE-2010-2972": [
"14538"
],
"CVE-2010-1797": [
"14538",
"14727"
],
"CVE-2010-2739": [
"14566"
],
"CVE-2010-2554": [
"14610"
],
"CVE-2010-2693": [
"14688"
],
"CVE-2009-0565": [
"14693",
"17177"
],
"CVE-2009-3129": [
"14706",
"16625"
],
"CVE-2010-5299": [
"14720",
"17502",
"32261"
],
"CVE-2010-3133": [
"14721"
],
"CVE-2010-3142": [
"14723",
"14782"
],
"CVE-2010-3141": [
"14723",
"14782"
],
"CVE-2010-3129": [
"14726",
"14748"
],
"CVE-2010-3131": [
"14730",
"14783"
],
"CVE-2010-3967": [
"14731"
],
"CVE-2010-5227": [
"14732"
],
"CVE-2010-3147": [
"14733",
"14745",
"14778"
],
"CVE-2010-3143": [
"14733",
"14745",
"14778"
],
"CVE-2010-3128": [
"14734"
],
"CVE-2010-3132": [
"14735",
"14740"
],
"CVE-2010-3148": [
"14744"
],
"CVE-2011-0108": [
"14746"
],
"CVE-2010-3146": [
"14746"
],
"CVE-2010-3125": [
"14747"
],
"CVE-2010-3127": [
"14741"
],
"CVE-2010-3126": [
"14743"
],
"CVE-2010-3124": [
"14750"
],
"CVE-2010-3145": [
"14751"
],
"CVE-2010-3144": [
"14754"
],
"CVE-2010-3149": [
"14755"
],
"CVE-2010-3139": [
"14758"
],
"CVE-2010-3130": [
"14764"
],
"CVE-2010-3138": [
"14765",
"14788"
],
"CVE-2010-3136": [
"14766"
],
"CVE-2010-5236": [
"14768"
],
"CVE-2010-3150": [
"14771"
],
"CVE-2010-3151": [
"14772"
],
"CVE-2010-3152": [
"14773"
],
"CVE-2010-3135": [
"14774"
],
"CVE-2010-3153": [
"14775"
],
"CVE-2010-3140": [
"14780"
],
"CVE-2010-5195": [
"14781"
],
"CVE-2010-3154": [
"14784"
],
"CVE-2010-3155": [
"14785"
],
"CVE-2014-8393": [
"14786",
"14787"
],
"CVE-2010-5240": [
"14786",
"14787"
],
"CVE-2010-3137": [
"14789"
],
"CVE-2010-3134": [
"14790"
],
"CVE-2010-5239": [
"14791"
],
"CVE-2010-5241": [
"14793"
],
"CVE-2010-2959": [
"14814"
],
"CVE-2009-2629": [
"14830"
],
"CVE-2010-1681": [
"14944",
"17451"
],
"CVE-2010-1247": [
"14966"
],
"CVE-2010-1246": [
"14966"
],
"CVE-2010-2201": [
"14982"
],
"CVE-2010-3301": [
"15023"
],
"CVE-2010-3081": [
"15024"
],
"CVE-2010-4740": [
"15026"
],
"CVE-2010-2961": [
"15074"
],
"CVE-2010-3437": [
"15150"
],
"CVE-2010-2943": [
"15155"
],
"CVE-2010-4210": [
"15206"
],
"CVE-2010-3904": [
"15285",
"44677"
],
"CVE-2010-4398": [
"15609"
],
"CVE-2011-0536": [
"15274"
],
"CVE-2010-3847": [
"15274",
"15304",
"44024",
"44025"
],
"CVE-2010-3856": [
"15304",
"18105",
"44025"
],
"CVE-2010-2963": [
"15344"
],
"CVE-2010-4236": [
"15475"
],
"CVE-2010-3895": [
"15475"
],
"CVE-2010-3888": [
"15589",
"19930"
],
"CVE-2010-3338": [
"15589",
"19930"
],
"CVE-2010-4170": [
"15620",
"46730"
],
"CVE-2010-4502": [
"15624"
],
"CVE-2010-4258": [
"15704"
],
"CVE-2010-3850": [
"15704",
"17787"
],
"CVE-2010-3849": [
"15704"
],
"CVE-2010-4604": [
"15745"
],
"CVE-2011-1021": [
"15774"
],
"CVE-2010-4347": [
"15774"
],
"CVE-2011-0501": [
"15901"
],
"CVE-2011-0500": [
"15936",
"17153"
],
"CVE-2011-0499": [
"15936",
"17153"
],
"CVE-2008-5689": [
"15962"
],
"CVE-2011-0513": [
"15972"
],
"CVE-2011-0498": [
"15975"
],
"CVE-2010-2743": [
"15985"
],
"CVE-2011-0096": [
"16071"
],
"CVE-2011-0018": [
"16086"
],
"CVE-2017-2490": [
"41804"
],
"CVE-2016-4997": [
"40435",
"40489"
],
"CVE-2006-0476": [
"16531",
"1458",
"1460",
"3422"
],
"CVE-2009-3459": [
"16546",
"16652"
],
"CVE-2016-9091": [
"41786",
"41785"
],
"CVE-2010-1297": [
"16614",
"16687",
"13787",
"14853"
],
"CVE-2008-0015": [
"16615",
"9108"
],
"CVE-2010-2883": [
"16619",
"16494"
],
"CVE-2009-3953": [
"16622"
],
"CVE-2011-0531": [
"16637"
],
"CVE-2009-3861": [
"16643"
],
"CVE-2005-0308": [
"16645"
],
"CVE-2007-3314": [
"16656"
],
"CVE-2010-3970": [
"16660"
],
"CVE-2010-0033": [
"16665"
],
"CVE-2010-3654": [
"16667",
"17187"
],
"CVE-2007-2864": [
"16677"
],
"CVE-2010-3333": [
"16686",
"17474",
"18334",
"24526"
],
"CVE-2008-5736": [
"16951"
],
"CVE-2011-1496": [
"17147"
],
"CVE-2011-1591": [
"17185",
"17186",
"17195",
"18145"
],
"CVE-2011-2386": [
"17317"
],
"CVE-2011-1938": [
"17318",
"17486"
],
"CVE-2011-0611": [
"17473",
"17175"
],
"CVE-2004-0194": [
"17488"
],
"CVE-2016-0051": [
"40085",
"39432",
"39788"
],
"CVE-2010-4073": [
"17787"
],
"CVE-2010-3848": [
"17787"
],
"CVE-2011-0257": [
"17777"
],
"CVE-2011-4535": [
"17817",
"17833"
],
"CVE-2011-1485": [
"17932",
"17942",
"35021"
],
"CVE-2011-2595": [
"17966"
],
"CVE-2011-4613": [
"18040"
],
"CVE-2011-4029": [
"18040"
],
"CVE-2011-0105": [
"18087"
],
"CVE-2011-5006": [
"18137"
],
"CVE-2011-4089": [
"18147"
],
"CVE-2011-5162": [
"18174"
],
"CVE-2007-0707": [
"18174"
],
"CVE-2011-2005": [
"18176",
"21844"
],
"CVE-2011-5170": [
"18178",
"18195"
],
"CVE-2011-5002": [
"18184"
],
"CVE-2011-5172": [
"18186"
],
"CVE-2011-5044": [
"18201"
],
"CVE-2011-2777": [
"18228"
],
"CVE-2011-4620": [
"18258"
],
"CVE-2012-0013": [
"18372",
"19037"
],
"CVE-2011-2462": [
"18366"
],
"CVE-2012-0056": [
"18411",
"35161"
],
"CVE-2012-1189": [
"18471"
],
"CVE-2008-1602": [
"18515"
],
"CVE-2012-0270": [
"18710"
],
"CVE-2012-2095": [
"18733"
],
"CVE-2012-1586": [
"18783"
],
"CVE-2012-4054": [
"18792"
],
"CVE-2012-4250": [
"18808"
],
"CVE-2011-3479": [
"18823"
],
"CVE-2012-2376": [
"18861"
],
"CVE-2012-2052": [
"18862"
],
"CVE-2012-2271": [
"18892",
"35694"
],
"CVE-2007-5762": [
"18914"
],
"CVE-2012-2760": [
"18917"
],
"CVE-2008-0320": [
"18923"
],
"CVE-2011-3625": [
"18954"
],
"CVE-2012-2915": [
"19006",
"19175"
],
"CVE-1999-1194": [
"19041"
],
"CVE-1999-1123": [
"19042",
"19043"
],
"CVE-1999-0051": [
"19066",
"19067",
"19350"
],
"CVE-1999-1499": [
"19072"
],
"CVE-1999-1498": [
"19074"
],
"CVE-1999-0137": [
"19077",
"19078"
],
"CVE-1999-1390": [
"19080"
],
"CVE-1999-0491": [
"19095"
],
"CVE-1999-0023": [
"19106"
],
"CVE-1999-0014": [
"19108"
],
"CVE-1999-1434": [
"19122"
],
"CVE-1999-0711": [
"19125"
],
"CVE-1999-1432": [
"19126"
],
"CVE-1999-0369": [
"19128"
],
"CVE-2012-1661": [
"19138"
],
"CVE-2012-0780": [
"19139"
],
"CVE-1999-1431": [
"19144"
],
"CVE-1999-0388": [
"19146"
],
"CVE-1999-0109": [
"19159"
],
"CVE-1999-0314": [
"19163"
],
"CVE-1999-1171": [
"19167"
],
"CVE-1999-1170": [
"19167"
],
"CVE-1999-0301": [
"19168"
],
"CVE-1999-0306": [
"19172",
"19173"
],
"CVE-1999-0038": [
"19172",
"19173"
],
"CVE-1999-0030": [
"19172",
"19173"
],
"CVE-1999-0372": [
"19192"
],
"CVE-1999-0755": [
"19196"
],
"CVE-1999-0376": [
"19198"
],
"CVE-1999-0210": [
"19199"
],
"CVE-1999-0046": [
"19203"
],
"CVE-1999-0806": [
"19205"
],
"CVE-1999-0773": [
"19206"
],
"CVE-1999-0716": [
"19209"
],
"CVE-1999-0765": [
"19210"
],
"CVE-1999-0715": [
"19211"
],
"CVE-1999-0767": [
"19213",
"19214",
"19215",
"19216",
"19217"
],
"CVE-1999-0757": [
"19220"
],
"CVE-1999-1414": [
"19227"
],
"CVE-1999-0803": [
"19229"
],
"CVE-1999-0859": [
"19232"
],
"CVE-1999-1026": [
"19233"
],
"CVE-1999-0410": [
"19234"
],
"CVE-1999-0860": [
"19235"
],
"CVE-1999-0735": [
"19240"
],
"CVE-1999-0730": [
"19243"
],
"CVE-1999-1412": [
"19244"
],
"CVE-1999-1553": [
"19249"
],
"CVE-1999-0409": [
"19254"
],
"CVE-2000-0118": [
"19255"
],
"CVE-1999-0914": [
"19256"
],
"CVE-1999-0433": [
"19257"
],
"CVE-1999-0442": [
"19258"
],
"CVE-1999-0363": [
"19259"
],
"CVE-1999-1410": [
"19260"
],
"CVE-1999-1286": [
"19260"
],
"CVE-1999-1409": [
"19261"
],
"CVE-1999-0960": [
"19262"
],
"CVE-1999-0108": [
"19267"
],
"CVE-1999-1494": [
"19269"
],
"CVE-1999-0381": [
"19270"
],
"CVE-1999-0025": [
"19274"
],
"CVE-1999-1491": [
"19279"
],
"CVE-1999-0044": [
"19280"
],
"CVE-1999-1490": [
"19281"
],
"CVE-1999-1489": [
"19283"
],
"CVE-1999-0118": [
"19287"
],
"CVE-1999-1405": [
"19300"
],
"CVE-1999-1461": [
"19304"
],
"CVE-1999-0092": [
"19306"
],
"CVE-1999-1208": [
"19307"
],
"CVE-1999-0122": [
"19309"
],
"CVE-1999-0125": [
"19311",
"19312"
],
"CVE-1999-1120": [
"19313"
],
"CVE-1999-0029": [
"19317"
],
"CVE-1999-0328": [
"19318"
],
"CVE-1999-1394": [
"19411"
],
"CVE-1999-0321": [
"19341",
"19342"
],
"CVE-1999-1117": [
"19345"
],
"CVE-1999-1402": [
"19346"
],
"CVE-1999-0026": [
"19347"
],
"CVE-1999-1022": [
"19351"
],
"CVE-1999-1114": [
"19353"
],
"CVE-1999-1219": [
"19354"
],
"CVE-1999-0959": [
"19355"
],
"CVE-1999-1384": [
"19356"
],
"CVE-1999-1398": [
"19358"
],
"CVE-1999-0382": [
"19359"
],
"CVE-1999-0778": [
"19370"
],
"CVE-1999-0733": [
"19371"
],
"CVE-1999-0405": [
"19373",
"19374"
],
"CVE-1999-0412": [
"19376"
],
"CVE-1999-1543": [
"19417"
],
"CVE-1999-1166": [
"19419"
],
"CVE-1999-1460": [
"19422"
],
"CVE-1999-1011": [
"19425",
"19424"
],
"CVE-1999-0811": [
"19428"
],
"CVE-1999-0350": [
"19429"
],
"CVE-2012-0663": [
"19433"
],
"CVE-1999-0700": [
"19440"
],
"CVE-1999-0674": [
"19447"
],
"CVE-1999-0888": [
"19460",
"19461"
],
"CVE-1999-0749": [
"19462"
],
"CVE-1999-0192": [
"19464",
"19465"
],
"CVE-1999-0720": [
"19467"
],
"CVE-1999-0768": [
"19469",
"19470"
],
"CVE-1999-0718": [
"19472"
],
"CVE-1999-1235": [
"19473"
],
"CVE-1999-0769": [
"19474"
],
"CVE-1999-0705": [
"19480"
],
"CVE-1999-0774": [
"19485"
],
"CVE-1999-0691": [
"19497"
],
"CVE-1999-0689": [
"19498"
],
"CVE-1999-0693": [
"19501"
],
"CVE-1999-0886": [
"19502"
],
"CVE-1999-0708": [
"19504"
],
"CVE-1999-0906": [
"19508"
],
"CVE-1999-0786": [
"19509"
],
"CVE-1999-0787": [
"19510"
],
"CVE-1999-1534": [
"19511"
],
"CVE-1999-1477": [
"19512"
],
"CVE-1999-1484": [
"19516"
],
"CVE-2012-0897": [
"19519"
],
"CVE-1999-1578": [
"19528"
],
"CVE-1999-1575": [
"19528",
"19515",
"19521"
],
"CVE-1999-1014": [
"19529"
],
"CVE-1999-0069": [
"19533",
"19534"
],
"CVE-1999-0050": [
"19535"
],
"CVE-1999-0893": [
"19542"
],
"CVE-1999-0335": [
"19544",
"19545"
],
"CVE-1999-0032": [
"19544",
"19545"
],
"CVE-1999-0041": [
"19551",
"19552"
],
"CVE-1999-0130": [
"19556"
],
"CVE-2000-0362": [
"19565"
],
"CVE-1999-0975": [
"19673"
],
"CVE-1999-0979": [
"19674"
],
"CVE-1999-0948": [
"19582"
],
"CVE-1999-0949": [
"19583"
],
"CVE-1999-0946": [
"19585"
],
"CVE-1999-1340": [
"19590"
],
"CVE-1999-0899": [
"19594"
],
"CVE-1999-0820": [
"19609"
],
"CVE-1999-1112": [
"19610"
],
"CVE-2000-0073": [
"19633"
],
"CVE-1999-0830": [
"19641"
],
"CVE-1999-0845": [
"19643"
],
"CVE-1999-0818": [
"19647"
],
"CVE-1999-0841": [
"19648"
],
"CVE-1999-0855": [
"19649"
],
"CVE-1999-0857": [
"19650"
],
"CVE-1999-0823": [
"19652"
],
"CVE-1999-0826": [
"19653"
],
"CVE-2016-3373": [
"40430"
],
"CVE-1999-0836": [
"19654"
],
"CVE-1999-0834": [
"19655"
],
"CVE-1999-0866": [
"19656"
],
"CVE-1999-0825": [
"19657"
],
"CVE-1999-0828": [
"19658",
"19660",
"19661"
],
"CVE-1999-0864": [
"19659"
],
"CVE-1999-0988": [
"19661"
],
"CVE-1999-0989": [
"19665"
],
"CVE-1999-1007": [
"19678"
],
"CVE-2000-0018": [
"19685"
],
"CVE-2000-0027": [
"19697"
],
"CVE-2000-0035": [
"19698"
],
"CVE-2000-0037": [
"19699",
"19700"
],
"CVE-2000-0009": [
"19704"
],
"CVE-2000-0013": [
"19706"
],
"CVE-2000-0015": [
"19707"
],
"CVE-2000-0052": [
"19709",
"19710"
],
"CVE-2000-0045": [
"19721"
],
"CVE-2000-0048": [
"19723"
],
"CVE-2000-0094": [
"19726"
],
"CVE-2000-0091": [
"19727"
],
"CVE-2000-0100": [
"19728"
],
"CVE-2000-0119": [
"19733"
],
"CVE-2000-0107": [
"19735"
],
"CVE-2000-0121": [
"19739"
],
"CVE-2000-0224": [
"19752"
],
"CVE-2000-0154": [
"19752"
],
"CVE-2000-0155": [
"19754"
],
"CVE-2000-0163": [
"19756"
],
"CVE-2000-0210": [
"19757"
],
"CVE-2000-0214": [
"19762"
],
"CVE-2000-0219": [
"19763"
],
"CVE-2000-0194": [
"19764"
],
"CVE-2000-0195": [
"19765"
],
"CVE-2000-0193": [
"19787"
],
"CVE-2000-0200": [
"19789"
],
"CVE-2000-0206": [
"19794"
],
"CVE-2000-0172": [
"19796"
],
"CVE-1999-1084": [
"19798"
],
"CVE-2000-0223": [
"19802",
"19803"
],
"CVE-2000-0171": [
"19804"
],
"CVE-2000-0230": [
"19811",
"19812"
],
"CVE-2000-0231": [
"19813"
],
"CVE-2000-0229": [
"19816"
],
"CVE-2000-0244": [
"19821"
],
"CVE-2000-0109": [
"19823"
],
"CVE-2000-0300": [
"19836"
],
"CVE-2000-0274": [
"19837"
],
"CVE-2000-0275": [
"19838",
"19839"
],
"CVE-2000-0276": [
"19840"
],
"CVE-2000-0279": [
"19841"
],
"CVE-2000-0250": [
"19851"
],
"CVE-2000-0264": [
"19855"
],
"CVE-2000-0384": [
"19904"
],
"CVE-2000-0293": [
"19867"
],
"CVE-2000-0317": [
"19872",
"19873",
"19874"
],
"CVE-2000-1199": [
"19875"
],
"CVE-2000-0337": [
"19876"
],
"CVE-2000-0316": [
"19878"
],
"CVE-2000-0340": [
"19883"
],
"CVE-2000-0427": [
"19894"
],
"CVE-2000-0378": [
"19900"
],
"CVE-2000-0407": [
"19910",
"19911"
],
"CVE-2000-0409": [
"19912"
],
"CVE-2000-0393": [
"19915"
],
"CVE-2000-0389": [
"19925",
"19924",
"19926"
],
"CVE-2000-0336": [
"19946"
],
"CVE-2000-0438": [
"19952",
"19953",
"19954"
],
"CVE-2000-0442": [
"19955"
],
"CVE-2000-0449": [
"19967"
],
"CVE-2000-0454": [
"19969"
],
"CVE-2000-0460": [
"19970"
],
"CVE-2000-0530": [
"19979",
"19980",
"19981"
],
"CVE-2000-0492": [
"19989"
],
"CVE-2000-0468": [
"19990"
],
"CVE-2000-0545": [
"19991",
"19992"
],
"CVE-2000-0552": [
"19993"
],
"CVE-2000-0537": [
"19999"
],
"CVE-2000-0506": [
"20000",
"20001"
],
"CVE-2000-0515": [
"20002"
],
"CVE-2000-0516": [
"20003"
],
"CVE-2000-0520": [
"20004"
],
"CVE-2000-0559": [
"20012"
],
"CVE-2000-0467": [
"20013"
],
"CVE-2000-0471": [
"20014"
],
"CVE-2000-0494": [
"20018"
],
"CVE-2000-0607": [
"20024"
],
"CVE-2000-0589": [
"20042"
],
"CVE-2000-0572": [
"20056",
"20058"
],
"CVE-2000-0670": [
"20073"
],
"CVE-2000-0684": [
"20081"
],
"CVE-2000-0625": [
"20081"
],
"CVE-2000-0639": [
"20092"
],
"CVE-2000-0617": [
"20093"
],
"CVE-2000-0679": [
"20107"
],
"CVE-2000-0680": [
"20108"
],
"CVE-2000-0797": [
"20126"
],
"CVE-2000-0794": [
"20127"
],
"CVE-2000-0796": [
"20128"
],
"CVE-2000-0799": [
"20130"
],
"CVE-2000-0737": [
"20133"
],
"CVE-2000-0798": [
"20137"
],
"CVE-2000-0703": [
"20141",
"20142"
],
"CVE-2000-0695": [
"20147"
],
"CVE-2000-0693": [
"20147"
],
"CVE-2000-0763": [
"20153",
"20154"
],
"CVE-2000-0721": [
"20155"
],
"CVE-2000-0698": [
"20160"
],
"CVE-2000-0702": [
"20162"
],
"CVE-2000-0691": [
"20179"
],
"CVE-2000-0901": [
"20191"
],
"CVE-2000-0881": [
"20193"
],
"CVE-2012-0946": [
"20201"
],
"CVE-2000-0851": [
"20209"
],
"CVE-2000-0864": [
"20212"
],
"CVE-2000-0873": [
"20213"
],
"CVE-2000-0865": [
"20230"
],
"CVE-2000-0854": [
"20232"
],
"CVE-2000-1008": [
"20241"
],
"CVE-2000-0994": [
"20256"
],
"CVE-1999-1243": [
"20263"
],
"CVE-1999-0944": [
"20274"
],
"CVE-2000-1072": [
"20275"
],
"CVE-2000-1074": [
"20276"
],
"CVE-2000-0816": [
"20285"
],
"CVE-1999-0115": [
"20290"
],
"CVE-2000-0976": [
"20294"
],
"CVE-1999-0971": [
"20333"
],
"CVE-2000-0935": [
"20338",
"20339"
],
"CVE-2000-0936": [
"20341"
],
"CVE-2000-0998": [
"20377",
"20378"
],
"CVE-2000-1140": [
"20380"
],
"CVE-2000-1144": [
"20381"
],
"CVE-2000-1147": [
"20383"
],
"CVE-2000-1127": [
"20386"
],
"CVE-2000-0077": [
"20396"
],
"CVE-2000-1244": [
"20401"
],
"CVE-2000-1095": [
"20402"
],
"CVE-2000-1175": [
"20410"
],
"CVE-2000-1180": [
"20411"
],
"CVE-2012-3483": [
"20417",
"20443"
],
"CVE-2010-1183": [
"20418",
"26709",
"33799"
],
"CVE-2012-3485": [
"20443",
"24578"
],
"CVE-2000-1081": [
"20451"
],
"CVE-2000-1119": [
"20452"
],
"CVE-2000-1120": [
"20453"
],
"CVE-2000-1121": [
"20454"
],
"CVE-2000-1124": [
"20455"
],
"CVE-2000-1083": [
"20456"
],
"CVE-2000-1085": [
"20457"
],
"CVE-2012-4284": [
"20485",
"24579"
],
"CVE-2001-0736": [
"20493"
],
"CVE-2001-0059": [
"20514"
],
"CVE-2001-0087": [
"20517"
],
"CVE-2001-0084": [
"20526"
],
"CVE-2001-0109": [
"20554",
"20555"
],
"CVE-2001-0111": [
"20556"
],
"CVE-2001-0259": [
"20560"
],
"CVE-2001-1274": [
"20581"
],
"CVE-2001-0189": [
"20585"
],
"CVE-2001-0165": [
"20603"
],
"CVE-2001-0193": [
"20604"
],
"CVE-2001-0208": [
"20621"
],
"CVE-2001-0316": [
"20626"
],
"CVE-2001-0293": [
"20651"
],
"CVE-2001-0289": [
"20658"
],
"CVE-2001-0459": [
"20678",
"20679"
],
"CVE-2001-0401": [
"20684"
],
"CVE-2001-0468": [
"20691"
],
"CVE-2001-0369": [
"20697"
],
"CVE-2001-0403": [
"20715"
],
"CVE-2001-0407": [
"20718"
],
"CVE-2001-0317": [
"20720",
"20721"
],
"CVE-2001-0594": [
"20740",
"20741"
],
"CVE-2001-0422": [
"20743"
],
"CVE-2001-0597": [
"20746"
],
"CVE-2001-0423": [
"20751"
],
"CVE-2001-0426": [
"20766"
],
"CVE-2001-0595": [
"20767",
"20768"
],
"CVE-2001-0384": [
"20769"
],
"CVE-2001-0565": [
"20772",
"20773"
],
"CVE-2001-0406": [
"20776"
],
"CVE-2001-1442": [
"20777",
"20778"
],
"CVE-2001-0610": [
"20781"
],
"CVE-2001-0623": [
"20795",
"20798"
],
"CVE-2001-0559": [
"20822",
"20823"
],
"CVE-2001-0641": [
"20843"
],
"CVE-2004-0390": [
"20851"
],
"CVE-2012-0217": [
"20861",
"28718",
"46508"
],
"CVE-2001-1346": [
"20867",
"20868"
],
"CVE-2001-1347": [
"20880"
],
"CVE-2001-0526 ": [
"20885"
],
"CVE-2001-0690": [
"20900"
],
"CVE-2001-0279": [
"20901"
],
"CVE-2001-0685": [
"20905"
],
"CVE-2001-0762": [
"20906"
],
"CVE-2001-0787": [
"20923"
],
"CVE-2001-0759": [
"20927"
],
"CVE-2001-1077": [
"20928"
],
"CVE-2001-0823": [
"20937"
],
"CVE-2001-0701": [
"20945"
],
"CVE-2001-0764": [
"20960"
],
"CVE-2001-0782": [
"20961"
],
"CVE-2001-0735": [
"20962",
"20963",
"20964"
],
"CVE-2001-1080": [
"20965"
],
"CVE-2001-0409": [
"20967"
],
"CVE-2001-1582": [
"20969",
"20970"
],
"CVE-2001-1076": [
"20974"
],
"CVE-2001-1246": [
"20985"
],
"CVE-2001-1561": [
"20986"
],
"CVE-2001-0906": [
"20990"
],
"CVE-2001-1085": [
"20992"
],
"CVE-2001-1177": [
"20999",
"21000",
"21001"
],
"CVE-2001-1178": [
"21010"
],
"CVE-2001-1354": [
"21020"
],
"CVE-2001-0548": [
"21024"
],
"CVE-2001-1036": [
"21043"
],
"CVE-2001-0941": [
"21044"
],
"CVE-2001-0833": [
"21045"
],
"CVE-2001-0652": [
"21058",
"21059"
],
"CVE-2001-0653": [
"21060",
"21061",
"21062",
"21063"
],
"CVE-2001-1519": [
"21069"
],
"CVE-2001-0506": [
"21071"
],
"CVE-2001-0507": [
"21072"
],
"CVE-2001-1165": [
"21076"
],
"CVE-2001-1003": [
"21078"
],
"CVE-2001-0983": [
"21091"
],
"CVE-2001-1000": [
"21101"
],
"CVE-2001-1093": [
"21105"
],
"CVE-2001-0873": [
"21106"
],
"CVE-2001-1092": [
"21107"
],
"CVE-2001-0956": [
"21108"
],
"CVE-2001-1029": [
"21114"
],
"CVE-2001-1127": [
"21117",
"21359"
],
"CVE-2001-1015": [
"21120"
],
"CVE-2001-1384": [
"21124"
],
"CVE-2001-0855": [
"21150"
],
"CVE-2001-0915": [
"21158"
],
"CVE-2001-0916": [
"21159"
],
"CVE-2001-1546": [
"21173"
],
"CVE-2001-1185": [
"21176"
],
"CVE-2002-0137": [
"21216",
"21217",
"21218",
"21219"
],
"CVE-2002-0143": [
"21226"
],
"CVE-2002-0043": [
"21227"
],
"CVE-2002-0004": [
"21229"
],
"CVE-2002-0132": [
"21231"
],
"CVE-2002-0311": [
"21239"
],
"CVE-2002-0211": [
"21244"
],
"CVE-2002-0210": [
"21247"
],
"CVE-2002-2016": [
"21248"
],
"CVE-2002-2072": [
"21259"
],
"CVE-2002-0239": [
"21280",
"21281"
],
"CVE-2002-0244": [
"21282"
],
"CVE-2002-1731": [
"21283"
],
"CVE-2002-0246": [
"21284"
],
"CVE-2002-0265": [
"21288"
],
"CVE-2002-0296": [
"21290"
],
"CVE-2002-0327": [
"21302"
],
"CVE-2012-3524": [
"21323"
],
"CVE-2012-4425": [
"21323"
],
"CVE-2002-0468": [
"21341",
"21342"
],
"CVE-2002-0367": [
"21344"
],
"CVE-2002-0484": [
"21347"
],
"CVE-2002-1673": [
"21348"
],
"CVE-2002-0486": [
"21351"
],
"CVE-2002-0499": [
"21353"
],
"CVE-2002-0162": [
"21356"
],
"CVE-2002-0158": [
"21360"
],
"CVE-2002-1767": [
"21362"
],
"CVE-2002-0542": [
"21373"
],
"CVE-2002-0525": [
"21375"
],
"CVE-2002-0572": [
"21407"
],
"CVE-2002-0740": [
"21408"
],
"CVE-2002-1602": [
"21414"
],
"CVE-2002-0184": [
"21420"
],
"CVE-2002-1826": [
"21458"
],
"CVE-2002-0887": [
"21489"
],
"CVE-2002-0905": [
"21496",
"21497"
],
"CVE-2002-0793": [
"21499",
"21500",
"21501"
],
"CVE-2002-2039": [
"21502"
],
"CVE-2002-2040": [
"21503",
"21504"
],
"CVE-2002-2041": [
"21505",
"21506"
],
"CVE-2002-2042": [
"21507"
],
"CVE-2002-0767": [
"21538"
],
"CVE-2002-0624": [
"21549"
],
"CVE-2002-0942": [
"21550",
"21551"
],
"CVE-2002-1447": [
"21568"
],
"CVE-2002-0991": [
"21577"
],
"CVE-2002-1814": [
"21583",
"21584",
"21585"
],
"CVE-2002-0994": [
"21592"
],
"CVE-2002-1016": [
"21629"
],
"CVE-2002-0658": [
"21667"
],
"CVE-2002-0824": [
"21669"
],
"CVE-2016-3371": [
"40429"
],
"CVE-2002-0817": [
"21674"
],
"CVE-2002-1414": [
"21683"
],
"CVE-2002-1230": [
"21684",
"21685",
"21686",
"21687",
"21688",
"21689",
"21690",
"21691",
"21922",
"21923"
],
"CVE-2002-0851": [
"21700",
"21701"
],
"CVE-2002-0875": [
"21720"
],
"CVE-2002-0976": [
"21721"
],
"CVE-2002-1469": [
"21732"
],
"CVE-2002-0987": [
"21758"
],
"CVE-2002-1812": [
"21760"
],
"CVE-2002-1506": [
"21761",
"21762",
"21763"
],
"CVE-2002-1503": [
"21771"
],
"CVE-2002-1605": [
"21774"
],
"CVE-2002-2162": [
"21781"
],
"CVE-2002-1512": [
"21793"
],
"CVE-2002-1125": [
"21796",
"21797",
"21798",
"21799"
],
"CVE-2002-1492": [
"21805",
"21806"
],
"CVE-2002-1129": [
"21807"
],
"CVE-2002-1896": [
"21814"
],
"CVE-2002-1898": [
"21815"
],
"CVE-2002-1165": [
"21884"
],
"CVE-2002-1192": [
"21881"
],
"CVE-2012-4552": [
"21831"
],
"CVE-2002-1513": [
"21856"
],
"CVE-2002-1514": [
"21865"
],
"CVE-2002-0838": [
"21871",
"21872"
],
"CVE-2002-1468": [
"21904"
],
"CVE-2002-1250": [
"21980"
],
"CVE-2012-6568": [
"21988"
],
"CVE-2002-1239": [
"22002"
],
"CVE-2002-1364": [
"22014"
],
"CVE-2002-1381": [
"22066"
],
"CVE-2002-1576": [
"22067"
],
"CVE-2012-3137": [
"22069"
],
"CVE-2003-1071": [
"22120"
],
"CVE-2003-1247": [
"22128",
"22129"
],
"CVE-2003-0034": [
"22189"
],
"CVE-2003-1073": [
"22203"
],
"CVE-2003-1366": [
"22210"
],
"CVE-2003-0004": [
"22225"
],
"CVE-2003-1375": [
"22231"
],
"CVE-2003-0358": [
"22233",
"22234",
"22235"
],
"CVE-2003-1359": [
"22246",
"22247"
],
"CVE-2003-1358": [
"22248"
],
"CVE-2003-0144": [
"22332",
"22331"
],
"CVE-2003-0102": [
"22324",
"22325"
],
"CVE-2003-1092": [
"22326"
],
"CVE-2003-0150": [
"22340"
],
"CVE-2003-0124": [
"22344"
],
"CVE-2003-0165": [
"22376"
],
"CVE-2003-0161": [
"22442",
"24"
],
"CVE-2001-1287": [
"22458"
],
"CVE-2003-0265": [
"22531"
],
"CVE-2003-0396": [
"22540"
],
"CVE-2003-1480": [
"22565"
],
"CVE-2003-0269": [
"22566"
],
"CVE-2003-0262": [
"22567"
],
"CVE-2003-0274": [
"22573"
],
"CVE-2003-1473": [
"22574"
],
"CVE-2003-0325": [
"22613",
"22614",
"22615"
],
"CVE-2003-0019": [
"22640"
],
"CVE-2003-0408": [
"22661"
],
"CVE-2002-1155": [
"22719",
"22720"
],
"CVE-2003-1123": [
"22732"
],
"CVE-2003-0385": [
"22748"
],
"CVE-2002-0747": [
"22756"
],
"CVE-2003-0449": [
"22773"
],
"CVE-2003-0388": [
"22781"
],
"CVE-2003-0501": [
"22813"
],
"CVE-2016-3237": [
"40409"
],
"CVE-1999-1184": [
"22836"
],
"CVE-2003-0462": [
"22840"
],
"CVE-2003-0497": [
"22847"
],
"CVE-2003-0496": [
"22882",
"22883"
],
"CVE-2003-0863": [
"22911"
],
"CVE-2003-0579": [
"22912"
],
"CVE-2003-0584": [
"22923",
"22924"
],
"CVE-2003-0620": [
"22971"
],
"CVE-2003-0655": [
"22979"
],
"CVE-2003-1310": [
"22980"
],
"CVE-2003-0898": [
"22988"
],
"CVE-2003-1052": [
"22989"
],
"CVE-2003-0649": [
"22996"
],
"CVE-2012-5613": [
"23077",
"23179",
"35777"
],
"CVE-2003-0666": [
"23096",
"92"
],
"CVE-2003-0830": [
"23189"
],
"CVE-2003-0847": [
"23223"
],
"CVE-2003-0848": [
"23228"
],
"CVE-2003-1139": [
"23297"
],
"CVE-2003-1140": [
"23303"
],
"CVE-2003-1167": [
"23308"
],
"CVE-2003-1169": [
"23327"
],
"CVE-2003-0089": [
"23343"
],
"CVE-2003-1051": [
"23344",
"23345",
"23346"
],
"CVE-2003-1308": [
"23414"
],
"CVE-2003-1307": [
"23481",
"23482"
],
"CVE-2004-2131": [
"23609",
"23610"
],
"CVE-2004-2134": [
"23611"
],
"CVE-2004-0238": [
"23634"
],
"CVE-2004-0114": [
"23655"
],
"CVE-2004-2073": [
"23658"
],
"CVE-2004-0186": [
"23674"
],
"CVE-2004-0083": [
"23682"
],
"CVE-2004-0158": [
"23738"
],
"CVE-2004-2359": [
"23739"
],
"CVE-2004-0318": [
"23743"
],
"CVE-2004-2303": [
"23759"
],
"CVE-2004-2312": [
"23838"
],
"CVE-2004-0544": [
"23840",
"23841"
],
"CVE-2004-2686": [
"23874"
],
"CVE-2004-1861": [
"23882"
],
"CVE-2004-2697": [
"23883"
],
"CVE-2003-0910": [
"23989"
],
"CVE-2004-0233": [
"24027"
],
"CVE-2004-0228": [
"24043"
],
"CVE-2004-2012": [
"24113"
],
"CVE-2004-2014": [
"24123"
],
"CVE-2004-0490": [
"24141"
],
"CVE-2004-2555": [
"24171"
],
"CVE-2004-1471": [
"24182"
],
"CVE-2004-0210": [
"24277"
],
"CVE-2004-2502": [
"24278"
],
"CVE-2004-0511": [
"24293"
],
"CVE-2004-1707": [
"24335"
],
"CVE-2004-2698": [
"24398"
],
"CVE-2004-1170": [
"24406"
],
"CVE-2013-0160": [
"24459"
],
"CVE-2013-1763": [
"24555",
"24746",
"33336",
"44299"
],
"CVE-2005-4868": [
"24678"
],
"CVE-2004-2176": [
"24682"
],
"CVE-2004-0996": [
"24749",
"24750"
],
"CVE-2005-1590": [
"24754"
],
"CVE-2004-1329": [
"25039"
],
"CVE-2005-0105": [
"25106"
],
"CVE-2013-5656": [
"25130"
],
"CVE-2013-5660": [
"25131"
],
"CVE-2005-0713": [
"25256"
],
"CVE-2005-0993": [
"25333"
],
"CVE-2005-0464": [
"25361"
],
"CVE-2005-0465": [
"25362"
],
"CVE-2013-2094": [
"25444",
"26131",
"33589"
],
"CVE-2013-0726": [
"25448"
],
"CVE-2013-1959": [
"25450"
],
"CVE-2005-1606": [
"25636"
],
"CVE-2005-1686": [
"25688"
],
"CVE-2004-2135": [
"25707"
],
"CVE-2005-1707": [
"25709"
],
"CVE-2013-2730": [
"25725"
],
"CVE-2005-1858": [
"25789"
],
"CVE-2005-2071": [
"25896"
],
"CVE-2005-2508": [
"26185"
],
"CVE-2005-2725": [
"26195"
],
"CVE-2005-2807": [
"26218"
],
"CVE-2006-0720": [
"26245"
],
"CVE-2005-0023": [
"26321"
],
"CVE-2005-4696": [
"26323"
],
"CVE-2005-3257": [
"26353"
],
"CVE-2013-2171": [
"26368",
"26454"
],
"CVE-2008-3158": [
"26418"
],
"CVE-2013-3956": [
"26452",
"27191"
],
"CVE-2005-3560": [
"26479"
],
"CVE-2003-1232": [
"26492"
],
"CVE-2005-2629": [
"26497"
],
"CVE-2005-4158": [
"26498",
"27056",
"27057"
],
"CVE-2013-4743": [
"26520"
],
"CVE-2013-6128": [
"28085"
],
"CVE-2013-2729": [
"26703"
],
"CVE-2013-3482": [
"26708"
],
"CVE-2005-4176": [
"26752",
"26753"
],
"CVE-2013-3248": [
"26805"
],
"CVE-2013-0742": [
"26805"
],
"CVE-2016-6253": [
"40385",
"40141"
],
"CVE-2013-4679": [
"26950"
],
"CVE-2005-4505": [
"26970"
],
"CVE-2006-0133": [
"26996",
"26997"
],
"CVE-2006-0177": [
"27065",
"27066"
],
"CVE-2005-1528": [
"27168"
],
"CVE-2006-0455": [
"27231"
],
"CVE-2013-4868": [
"27285"
],
"CVE-2013-4867": [
"27285"
],
"CVE-2013-0268": [
"27297"
],
"CVE-2006-1015": [
"27334"
],
"CVE-2006-1014": [
"27335"
],
"CVE-2016-7225": [
"40764"
],
"CVE-2016-7226": [
"40763"
],
"CVE-2006-1342": [
"27461"
],
"CVE-2013-3928": [
"27609"
],
"CVE-2006-1864": [
"27766"
],
"CVE-2006-1863": [
"27769"
],
"CVE-2013-1662": [
"27938",
"40169"
],
"CVE-2013-1775": [
"27944",
"27965"
],
"CVE-2013-6127": [
"28084"
],
"CVE-2012-5383": [
"28130"
],
"CVE-2012-5382": [
"28130"
],
"CVE-2012-5381": [
"28130"
],
"CVE-2012-5380": [
"28130"
],
"CVE-2012-5379": [
"28130"
],
"CVE-2012-5378": [
"28130"
],
"CVE-2012-5377": [
"28130"
],
"CVE-2006-3815": [
"28287"
],
"CVE-2006-3931": [
"28288"
],
"CVE-2013-4984": [
"28332",
"28175"
],
"CVE-2006-4310": [
"28427"
],
"CVE-2006-4625": [
"28504"
],
"CVE-2013-4011": [
"28507",
"32700"
],
"CVE-2013-4660": [
"28655"
],
"CVE-2013-4788": [
"28657"
],
"CVE-2013-4987": [
"28680"
],
"CVE-2006-4927": [
"28763",
"28764"
],
"CVE-2013-4362": [
"28806"
],
"CVE-2006-7129": [
"28817"
],
"CVE-2016-1247": [
"40768"
],
"CVE-2006-6952": [
"29069",
"29070"
],
"CVE-2006-6129": [
"29190"
],
"CVE-2006-6130": [
"29194"
],
"CVE-2006-6173": [
"29201"
],
"CVE-2006-6383": [
"29239"
],
"CVE-2013-6935": [
"29327"
],
"CVE-2007-0081": [
"29374"
],
"CVE-2007-0161": [
"29403"
],
"CVE-2007-0257": [
"29446"
],
"CVE-2007-0333": [
"29465"
],
"CVE-2013-7186": [
"30032"
],
"CVE-2007-2553": [
"30017"
],
"CVE-2007-2617": [
"30021"
],
"CVE-2013-5065": [
"30014",
"30392",
"37732"
],
"CVE-2007-0448": [
"29528"
],
"CVE-2013-6937": [
"29594"
],
"CVE-2007-0843": [
"29630"
],
"CVE-2006-3074": [
"30192"
],
"CVE-2007-1330": [
"29695"
],
"CVE-2007-1369": [
"29712"
],
"CVE-2007-1474": [
"29746"
],
"CVE-2013-6874": [
"29777"
],
"CVE-2007-1835": [
"29801"
],
"CVE-2006-4250": [
"29822"
],
"CVE-2013-0640": [
"29881"
],
"CVE-2013-3934": [
"29922"
],
"CVE-2007-2580": [
"29950"
],
"CVE-2007-2027": [
"29954"
],
"CVE-2013-7030": [
"30237"
],
"CVE-2007-2839": [
"30280"
],
"CVE-2013-0109": [
"30393"
],
"CVE-2013-6767": [
"30374"
],
"CVE-2007-4302": [
"30464"
],
"CVE-2013-7260": [
"30468"
],
"CVE-2013-6877": [
"30468"
],
"CVE-2012-3993": [
"30474"
],
"CVE-2013-1710": [
"30474"
],
"CVE-2014-8359": [
"30477"
],
"CVE-2014-8358": [
"30477"
],
"CVE-2007-4305": [
"30484"
],
"CVE-2007-4390": [
"30503"
],
"CVE-2007-4649": [
"30546"
],
"CVE-2008-0100": [
"30970"
],
"CVE-2007-4571": [
"30605"
],
"CVE-2007-4993": [
"30620"
],
"CVE-2007-5587": [
"30680"
],
"CVE-2007-5633": [
"30681"
],
"CVE-2007-6182": [
"30780"
],
"CVE-2013-5447": [
"30789"
],
"CVE-2007-6210": [
"30839"
],
"CVE-2008-7211": [
"30999"
],
"CVE-2008-0365": [
"31036"
],
"CVE-2014-2013": [
"31090"
],
"CVE-2013-5582": [
"31182"
],
"CVE-2013-5581": [
"31182"
],
"CVE-2013-6282": [
"31574",
"40975"
],
"CVE-2013-3881": [
"31576"
],
"CVE-2008-1436": [
"31667"
],
"CVE-2014-2030": [
"31688"
],
"CVE-2014-1947": [
"31688"
],
"CVE-2008-2712": [
"31911"
],
"CVE-2008-2666": [
"31937"
],
"CVE-2008-2830": [
"31940"
],
"CVE-2008-2827": [
"31959"
],
"CVE-2007-2568": [
"31991"
],
"CVE-2014-2533": [
"32153",
"45575"
],
"CVE-2014-2534": [
"32156"
],
"CVE-2014-3222": [
"32205"
],
"CVE-2008-7002": [
"32343"
],
"CVE-2008-4405": [
"32446"
],
"CVE-2008-5048": [
"32572"
],
"CVE-2008-5229": [
"32590"
],
"CVE-2009-0343": [
"32751"
],
"CVE-2009-0449": [
"32771"
],
"CVE-2014-1761": [
"32793"
],
"CVE-2009-0676": [
"32805"
],
"CVE-2009-0368": [
"32820"
],
"CVE-2009-0835": [
"32829"
],
"CVE-2009-0880": [
"32845",
"23074",
"23203"
],
"CVE-2009-0876": [
"32848"
],
"CVE-2009-0824": [
"32850"
],
"CVE-2014-0514": [
"32884",
"33791"
],
"CVE-2009-0078": [
"32891"
],
"CVE-2009-0079": [
"32892"
],
"CVE-2009-0080": [
"32893"
],
"CVE-2009-1436": [
"32946"
],
"CVE-2009-1526": [
"32947"
],
"CVE-2009-1808": [
"33012"
],
"CVE-2014-2299": [
"33069"
],
"CVE-2013-1300": [
"33213"
],
"CVE-2009-2793": [
"33229"
],
"CVE-2009-3525": [
"33255"
],
"CVE-2010-0233": [
"33593"
],
"CVE-2009-4049": [
"33360"
],
"CVE-2009-4131": [
"33395"
],
"CVE-2010-0002": [
"33508"
],
"CVE-2014-0196": [
"33516"
],
"CVE-2010-0462": [
"33572"
],
"CVE-2009-4141": [
"33523"
],
"CVE-2010-0411": [
"33604"
],
"CVE-2013-0292": [
"33614"
],
"CVE-2009-4648": [
"33623"
],
"CVE-2014-3977": [
"33725"
],
"CVE-2012-2179": [
"33725"
],
"CVE-2014-4014": [
"33824"
],
"CVE-2014-0257": [
"33892"
],
"CVE-2013-5045": [
"33893"
],
"CVE-2014-0476": [
"33899",
"38775"
],
"CVE-2014-4703": [
"33904"
],
"CVE-2014-5453": [
"33961"
],
"CVE-2010-1457": [
"33963"
],
"CVE-2014-4971": [
"34112",
"34131",
"34167",
"34982"
],
"CVE-2010-1636": [
"34001"
],
"CVE-2014-5455": [
"34037"
],
"CVE-2009-2477": [
"40936",
"9137",
"9214",
"16299"
],
"CVE-2014-4699": [
"34134"
],
"CVE-2014-3434": [
"34272"
],
"CVE-2010-2382": [
"34311"
],
"CVE-2010-2383": [
"34313"
],
"CVE-2010-2384": [
"34314"
],
"CVE-2014-2477": [
"34333"
],
"CVE-2014-5119": [
"34421"
],
"CVE-2010-3073": [
"34537"
],
"CVE-2014-5207": [
"34923"
],
"CVE-2010-3039": [
"34954"
],
"CVE-2010-4158": [
"34987"
],
"CVE-2010-3830": [
"35010"
],
"CVE-2014-6352": [
"35019",
"35020",
"35216",
"35235",
"35236",
"35055"
],
"CVE-2014-4114": [
"35019",
"35020",
"35216",
"35235",
"35236",
"35055"
],
"CVE-2014-5507": [
"35040"
],
"CVE-2014-8347": [
"35077"
],
"CVE-2014-4113": [
"35101",
"37064",
"39666",
"46945"
],
"CVE-2013-5467": [
"35112"
],
"CVE-2014-5284": [
"35234"
],
"CVE-2014-3153": [
"35370"
],
"CVE-2014-9113": [
"35395"
],
"CVE-2014-9141": [
"35423"
],
"CVE-2014-4404": [
"35440"
],
"CVE-2011-0180": [
"35488"
],
"CVE-2014-8386": [
"35503"
],
"CVE-2014-7208": [
"35595"
],
"CVE-2015-0002": [
"35661"
],
"CVE-2011-1760": [
"35681"
],
"CVE-2014-4322": [
"35711"
],
"CVE-2014-8835": [
"35742"
],
"CVE-2015-0004": [
"35811"
],
"CVE-2015-1171": [
"35821"
],
"CVE-2014-9632": [
"35993"
],
"CVE-2014-9642": [
"35994"
],
"CVE-2014-4492": [
"35847"
],
"CVE-2014-9643": [
"35992"
],
"CVE-2014-9597": [
"35901"
],
"CVE-2014-9598": [
"35902"
],
"CVE-2014-9633": [
"35905"
],
"CVE-2015-0016": [
"35983"
],
"CVE-2014-8826": [
"35934"
],
"CVE-2014-4076": [
"35936",
"37755"
],
"CVE-2015-1305": [
"35953"
],
"CVE-2014-9641": [
"35962"
],
"CVE-2014-7286": [
"35964"
],
"CVE-2015-1515": [
"36052"
],
"CVE-2011-4122": [
"36296"
],
"CVE-2015-0565": [
"36310",
"36311"
],
"CVE-2015-3693": [
"36311"
],
"CVE-2015-2789": [
"36390"
],
"CVE-2011-4834": [
"36430"
],
"CVE-2015-3315": [
"36747",
"44097"
],
"CVE-2015-1862": [
"36747",
"36746"
],
"CVE-2015-1815": [
"36564"
],
"CVE-2012-0055": [
"36571"
],
"CVE-2015-1130": [
"36692",
"36745"
],
"CVE-2015-1318": [
"36746",
"36782",
"43971"
],
"CVE-2014-7951": [
"36813"
],
"CVE-2015-3643": [
"36820"
],
"CVE-2014-7872": [
"37065"
],
"CVE-2015-3632": [
"36859"
],
"CVE-2012-1096": [
"36887"
],
"CVE-2012-0943": [
"36966"
],
"CVE-2015-1701": [
"37049",
"37367"
],
"CVE-2015-1680": [
"37049"
],
"CVE-2015-1679": [
"37049"
],
"CVE-2015-1678": [
"37049"
],
"CVE-2015-1677": [
"37049"
],
"CVE-2015-1676": [
"37049"
],
"CVE-2015-1674": [
"37052"
],
"CVE-2015-1325": [
"37088"
],
"CVE-2015-3202": [
"37089"
],
"CVE-2015-0060": [
"37098"
],
"CVE-2015-0059": [
"37098"
],
"CVE-2015-0058": [
"37098"
],
"CVE-2015-0057": [
"37098",
"39035"
],
"CVE-2015-0010": [
"37098"
],
"CVE-2015-0003": [
"37098"
],
"CVE-2015-3222": [
"37265"
],
"CVE-2015-1328": [
"37292",
"37293",
"40688"
],
"CVE-2016-3053": [
"40709"
],
"CVE-2012-3430": [
"37543"
],
"CVE-2012-3480": [
"37631"
],
"CVE-2015-0097": [
"37657"
],
"CVE-2015-5602": [
"37710"
],
"CVE-2015-3290": [
"37722"
],
"CVE-2015-2370": [
"37768"
],
"CVE-2015-4495": [
"37772"
],
"CVE-2012-1666": [
"37780"
],
"CVE-2012-0957": [
"37937"
],
"CVE-2015-4481": [
"37925"
],
"CVE-2015-7243": [
"38035",
"44971"
],
"CVE-2015-3673": [
"38036"
],
"CVE-2015-5754": [
"38136"
],
"CVE-2015-5784": [
"38137"
],
"CVE-2015-3704": [
"38138"
],
"CVE-2015-2508": [
"38198"
],
"CVE-2015-2527": [
"38199"
],
"CVE-2015-2525": [
"38200"
],
"CVE-2015-2528": [
"38201"
],
"CVE-2015-2524": [
"38202"
],
"CVE-2015-2433": [
"38222"
],
"CVE-2015-2426": [
"38222"
],
"CVE-2013-0221": [
"38232"
],
"CVE-2015-6305": [
"38289"
],
"CVE-2012-6533": [
"38299"
],
"CVE-2015-6306": [
"38303"
],
"CVE-2015-7805": [
"38447"
],
"CVE-2015-1338": [
"38353"
],
"CVE-2015-5889": [
"38371",
"38540"
],
"CVE-2015-7358": [
"38403"
],
"CVE-2015-2553": [
"38474"
],
"CVE-2013-2852": [
"38559"
],
"CVE-2014-8904": [
"38576"
],
"CVE-2013-4147": [
"38672"
],
"CVE-2015-7422": [
"38751"
],
"CVE-2015-2023": [
"38751"
],
"CVE-2013-5701": [
"38752"
],
"CVE-2015-7865": [
"38792"
],
"CVE-2013-4474": [
"38817"
],
"CVE-2015-5287": [
"38832",
"38835",
"47421"
],
"CVE-2015-5273": [
"38835"
],
"CVE-2015-4027": [
"38847"
],
"CVE-2013-6480": [
"38937"
],
"CVE-2015-8556": [
"39010"
],
"CVE-2014-1664": [
"39061"
],
"CVE-2015-7556": [
"39134"
],
"CVE-2014-1322": [
"39147"
],
"CVE-2015-8660": [
"39166",
"39230",
"40688"
],
"CVE-2014-3865": [
"39207"
],
"CVE-2014-1739": [
"39214"
],
"CVE-2016-0728": [
"39277",
"40003"
],
"CVE-2016-0007": [
"39310",
"39311"
],
"CVE-2016-0006": [
"39311"
],
"CVE-2016-6662": [
"40360"
],
"CVE-2016-8641": [
"40774"
],
"CVE-2016-0049": [
"39442"
],
"CVE-2014-1767": [
"39446",
"39525"
],
"CVE-2016-3984": [
"39531"
],
"CVE-2016-4534": [
"39531"
],
"CVE-2016-1531": [
"39535",
"39549",
"39702"
],
"CVE-2016-0099": [
"39574",
"39719",
"39809",
"40107"
],
"CVE-2016-1757": [
"39595",
"39741"
],
"CVE-2016-2288": [
"39630"
],
"CVE-2016-2087": [
"39656"
],
"CVE-2015-7378": [
"39670"
],
"CVE-2016-3943": [
"39671"
],
"CVE-2016-1743": [
"39675"
],
"CVE-2016-0122": [
"39694"
],
"CVE-2016-3643": [
"39967"
],
"CVE-2015-6639": [
"39757"
],
"CVE-2016-4338": [
"39769"
],
"CVE-2016-4557": [
"39772",
"40759"
],
"CVE-2016-5237": [
"39888"
],
"CVE-2016-1583": [
"39992"
],
"CVE-2016-0400": [
"40039"
],
"CVE-2016-0189": [
"40118"
],
"CVE-2013-1406": [
"40164"
],
"CVE-2016-3223": [
"40219"
],
"CVE-2016-3313": [
"40224"
],
"CVE-2016-7089": [
"40270"
],
"CVE-2016-6367": [
"40271"
],
"CVE-2016-1240": [
"40450"
],
"CVE-2016-5425": [
"40488"
],
"CVE-2004-1569": [
"43816"
],
"CVE-2004-1417": [
"43817"
],
"CVE-2017-14355": [
"43857"
],
"CVE-2017-7310": [
"43875",
"41773",
"44157"
],
"CVE-2018-2698": [
"43878"
],
"CVE-2014-8147": [
"43887"
],
"CVE-2014-8146": [
"43887"
],
"CVE-2016-7188": [
"40562"
],
"CVE-2016-7185": [
"40572"
],
"CVE-2016-0075": [
"40573"
],
"CVE-2016-0073": [
"40574"
],
"CVE-2016-3388": [
"40606"
],
"CVE-2016-3387": [
"40607"
],
"CVE-2016-0079": [
"40608"
],
"CVE-2016-5195": [
"40611",
"40616",
"40838",
"40839",
"40847"
],
"CVE-2011-1974": [
"40627"
],
"CVE-2016-4625": [
"40653",
"40669"
],
"CVE-2016-7384": [
"40655"
],
"CVE-2016-8812": [
"40660"
],
"CVE-2016-6663": [
"40678"
],
"CVE-2016-5616": [
"40678"
],
"CVE-2016-9111": [
"40686"
],
"CVE-2016-6664": [
"40679"
],
"CVE-2016-5617": [
"40679"
],
"CVE-2016-6079": [
"40710"
],
"CVE-2016-7224": [
"40765"
],
"CVE-2016-9151": [
"40788",
"40789"
],
"CVE-2016-8769": [
"40807"
],
"CVE-2010-0415": [
"40810"
],
"CVE-2016-8742": [
"40865"
],
"CVE-2016-8655": [
"40871",
"44696",
"47170"
],
"CVE-2016-9566": [
"40921"
],
"CVE-2016-7644": [
"40931"
],
"CVE-2016-7637": [
"40931",
"40957"
],
"CVE-2016-9951": [
"40937"
],
"CVE-2016-9950": [
"40937"
],
"CVE-2016-9949": [
"40937"
],
"CVE-2014-6271": [
"40938",
"34765",
"34766",
"34777",
"34860",
"34862",
"34879",
"34896",
"34900",
"35115",
"36503",
"36504",
"38849",
"39918",
"40619",
"42938",
"34839",
"34895",
"35146",
"36609",
"37816"
],
"CVE-2016-8972": [
"40950"
],
"CVE-2016-7621": [
"40956"
],
"CVE-2016-10010": [
"40962"
],
"CVE-2016-10031": [
"40967"
],
"CVE-2015-1336": [
"41158"
],
"CVE-2016-10156": [
"41171"
],
"CVE-2015-6565": [
"41173"
],
"CVE-2017-5329": [
"41176"
],
"CVE-2017-3316": [
"41196"
],
"CVE-2017-0358": [
"41240",
"41356"
],
"CVE-2016-10081": [
"41435"
],
"CVE-2017-3813": [
"41476"
],
"CVE-2017-6178": [
"41542"
],
"CVE-2017-0100": [
"41607"
],
"CVE-2017-0045": [
"41619"
],
"CVE-2017-5180": [
"43359"
],
"CVE-2016-6914": [
"43390"
],
"CVE-2017-10001": [
"43418",
"45147",
"42599",
"47169",
"47376",
"49693"
],
"CVE-2017-5753": [
"43427"
],
"CVE-2017-5715": [
"43427"
],
"CVE-2018-5189": [
"43494"
],
"CVE-2017-18016": [
"43499"
],
"CVE-2016-0772": [
"43500"
],
"CVE-2018-10000": [
"43775",
"44889",
"43899",
"44357",
"44638",
"45044",
"44976"
],
"CVE-2017-16928": [
"43925"
],
"CVE-2017-16945": [
"43926"
],
"CVE-2018-5701": [
"43929"
],
"CVE-2017-18078": [
"43935"
],
"CVE-2018-0743": [
"43962"
],
"CVE-2018-6593": [
"43973"
],
"CVE-2018-6606": [
"43987"
],
"CVE-2017-9232": [
"44023"
],
"CVE-2018-6460": [
"44042"
],
"CVE-2017-16939": [
"44049"
],
"CVE-2017-7950": [
"44063"
],
"CVE-2017-2796": [
"44063"
],
"CVE-2017-10803": [
"44064"
],
"CVE-2017-11657": [
"44066"
],
"CVE-2012-6636": [
"41675"
],
"CVE-2013-4710": [
"41675",
"31519"
],
"CVE-2013-0758": [
"41683",
"41684"
],
"CVE-2013-0757": [
"41683",
"41684"
],
"CVE-2010-1423": [
"41700"
],
"CVE-2010-0886": [
"41700",
"12117",
"12122",
"16585"
],
"CVE-2014-4936": [
"41701"
],
"CVE-2013-0074": [
"41702",
"29858"
],
"CVE-2013-3896": [
"41702"
],
"CVE-2011-0647": [
"41704"
],
"CVE-2016-3235": [
"41706"
],
"CVE-2016-0100": [
"41706"
],
"CVE-2016-0041": [
"41706"
],
"CVE-2015-6133": [
"41706"
],
"CVE-2015-6132": [
"41706",
"38968"
],
"CVE-2015-6128": [
"41706",
"38918"
],
"CVE-2011-3011": [
"41707"
],
"CVE-2015-2219": [
"41708"
],
"CVE-2013-2492": [
"41709"
],
"CVE-2012-3274": [
"41710"
],
"CVE-2016-5330": [
"41711"
],
"CVE-2012-4705": [
"41712"
],
"CVE-2017-6999": [
"42555"
],
"CVE-2017-6998": [
"42555"
],
"CVE-2017-6997": [
"42555"
],
"CVE-2017-6996": [
"42555"
],
"CVE-2017-6995": [
"42555"
],
"CVE-2017-6994": [
"42555"
],
"CVE-2017-6989": [
"42555"
],
"CVE-2017-6979": [
"42555"
],
"CVE-2017-6970": [
"42305"
],
"CVE-2017-7874": [
"41886"
],
"CVE-2015-5736": [
"41721",
"41722",
"45149"
],
"CVE-2017-5227": [
"41745"
],
"CVE-2017-5671": [
"41754"
],
"CVE-2016-2856": [
"41760"
],
"CVE-2016-2854": [
"41761"
],
"CVE-2016-2853": [
"41761"
],
"CVE-2016-1575": [
"41762"
],
"CVE-2016-1576": [
"41763"
],
"CVE-2016-0727": [
"41764"
],
"CVE-2015-2285": [
"41765"
],
"CVE-2011-1020": [
"41770"
],
"CVE-2017-7643": [
"41854"
],
"CVE-2017-7228": [
"41870"
],
"CVE-2017-3006": [
"41878"
],
"CVE-2017-0165": [
"41901"
],
"CVE-2017-0211": [
"41902"
],
"CVE-2017-3558": [
"41904"
],
"CVE-2017-3576": [
"41907"
],
"CVE-2017-3563": [
"41908"
],
"CVE-2017-7358": [
"41923"
],
"CVE-2017-7358&": [
"41923"
],
"CVE-2017-7293": [
"41933"
],
"CVE-2017-8291": [
"41955"
],
"CVE-2017-6953": [
"41972"
],
"CVE-2017-8869": [
"41971"
],
"CVE-2017-7308": [
"41994",
"44654",
"47168"
],
"CVE-2016-9793": [
"41995"
],
"CVE-2016-2384": [
"41999"
],
"CVE-2017-8918": [
"42000"
],
"CVE-2017-0213": [
"42020"
],
"CVE-2017-4915": [
"42045",
"47171"
],
"CVE-2017-8849": [
"42053"
],
"CVE-2017-8422": [
"42053"
],
"CVE-2017-9355": [
"42119"
],
"CVE-2017-3141": [
"42121"
],
"CVE-2017-7180": [
"42141"
],
"CVE-2017-7004": [
"42145"
],
"CVE-2017-2533": [
"42146"
],
"CVE-2017-3631": [
"42270",
"45625"
],
"CVE-2017-3630": [
"42270",
"45625"
],
"CVE-2017-3629": [
"42270",
"45625"
],
"CVE-2017-9644": [
"42542"
],
"CVE-2017-11197": [
"42319"
],
"CVE-2017-7642": [
"42334"
],
"CVE-2017-9769": [
"42368"
],
"CVE-2017-8464": [
"42382",
"42429"
],
"CVE-2017-8870": [
"42385"
],
"CVE-2017-7047": [
"42407"
],
"CVE-2017-7442": [
"42418"
],
"CVE-2017-10204": [
"42425"
],
"CVE-2017-10129": [
"42426"
],
"CVE-2017-8665": [
"42454"
],
"CVE-2017-12763": [
"42460"
],
"CVE-2017-13056": [
"42537"
],
"CVE-2016-10277": [
"42601"
],
"CVE-2015-0179": [
"42605"
],
"CVE-2017-0901": [
"42611"
],
"CVE-2017-14153": [
"42624"
],
"CVE-2017-14075": [
"42625"
],
"CVE-2017-14344": [
"42665"
],
"CVE-2017-14311": [
"42735"
],
"CVE-2017-14627": [
"42777",
"45985"
],
"CVE-2017-11322": [
"42936"
],
"CVE-2017-11321": [
"42937"
],
"CVE-2016-3309": [
"42960"
],
"CVE-2017-15083": [
"42963"
],
"CVE-2017-15221": [
"42974"
],
"CVE-2017-5123": [
"43029",
"43127"
],
"CVE-2017-6008": [
"43057"
],
"CVE-2017-16237": [
"43109"
],
"CVE-2017-6331": [
"43134"
],
"CVE-2017-14961": [
"43139"
],
"CVE-2017-11830": [
"43162"
],
"CVE-2017-9095": [
"43187"
],
"CVE-2017-13872": [
"43201",
"43248"
],
"CVE-2017-16895": [
"43216"
],
"CVE-2017-15357": [
"43218"
],
"CVE-2017-16777": [
"43219"
],
"CVE-2017-16001": [
"43220"
],
"CVE-2017-15918": [
"43221"
],
"CVE-2017-15884": [
"43222"
],
"CVE-2017-12579": [
"43223"
],
"CVE-2017-11741": [
"43224"
],
"CVE-2017-7690": [
"43225"
],
"CVE-2017-10661": [
"43345"
],
"CVE-2018-0822": [
"44147"
],
"CVE-2018-0823": [
"44148"
],
"CVE-2018-0821": [
"44149"
],
"CVE-2017-6516": [
"44150"
],
"CVE-2018-0826": [
"44152"
],
"CVE-2018-6947": [
"44167",
"44168"
],
"CVE-2018-7289": [
"44169"
],
"CVE-2018-17775": [
"45568"
],
"CVE-cve 2014-1": [
"44200"
],
"CVE-2014-1303": [
"44204"
],
"CVE-2017-13868": [
"44234"
],
"CVE-2016-1825": [
"44237"
],
"CVE-2016-1828": [
"44239"
],
"CVE-2017-8570": [
"44263"
],
"CVE-2017-5415": [
"44266"
],
"CVE-2018-7581": [
"44270"
],
"CVE-2017-16995": [
"44298",
"45010",
"45058"
],
"CVE-2017-7533": [
"44302"
],
"CVE-2015-8088": [
"44306"
],
"CVE-2018-6084": [
"44307"
],
"CVE-2018-0877": [
"44313"
],
"CVE-2018-0880": [
"44314"
],
"CVE-2018-0882": [
"44315"
],
"CVE-2018-7273": [
"44325"
],
"CVE-2018-4863": [
"44410"
],
"CVE-2018-9233": [
"44411"
],
"CVE-2018-9128": [
"44438",
"46584"
],
"CVE-2018-0492": [
"44452"
],
"CVE-2018-7886": [
"44470"
],
"CVE-2013-5019": [
"44472",
"26739",
"27608",
"31736",
"31814"
],
"CVE-2017-18256": [
"44474"
],
"CVE-2016-10718": [
"44475"
],
"CVE-2018-6546": [
"44476"
],
"CVE-2018-9131": [
"44477"
],
"CVE-2017-0263": [
"44478"
],
"CVE-2017-0101": [
"44479"
],
"CVE-2016-0165": [
"44480"
],
"CVE-2018-10583": [
"44564"
],
"CVE-2018-1038": [
"44581"
],
"CVE-2016-0040": [
"44586"
],
"CVE-2018-10655": [
"44590"
],
"CVE-2018-0494": [
"44601"
],
"CVE-2018-1185": [
"44614"
],
"CVE-2018-8134": [
"44630"
],
"CVE-2018-1111": [
"44652",
"44890"
],
"CVE-2018-11242": [
"44690"
],
"CVE-2018-8897": [
"44697",
"45024"
],
"CVE-2017-15222": [
"46070",
"43448",
"43025",
"47576"
],
"CVE-2018-8174": [
"44741"
],
"CVE-2015-5112": [
"44742"
],
"CVE-2015-2419": [
"44743"
],
"CVE-2018-4878": [
"44744",
"44745",
"44412"
],
"CVE-2018-11505": [
"44776"
],
"CVE-2018-1124": [
"44806"
],
"CVE-2018-1123": [
"44806"
],
"CVE-2018-1122": [
"44806"
],
"CVE-2018-1121": [
"44806"
],
"CVE-2018-1120": [
"44806"
],
"CVE-2018-16302": [
"44828"
],
"CVE-2018-11652": [
"44899"
],
"CVE-2018-10507": [
"44858"
],
"CVE-2018-0982": [
"44888"
],
"CVE-2018-10619": [
"44892"
],
"CVE-2018-12292": [
"44900"
],
"CVE-2018-12326": [
"44904"
],
"CVE-2018-0824": [
"44906"
],
"CVE-2018-1235": [
"44920"
],
"CVE-2018-13108": [
"44983"
],
"CVE-2018-13110": [
"44984"
],
"CVE-2018-4192": [
"45048"
],
"CVE-2018-2892": [
"45126"
],
"CVE-2018-14533": [
"45089"
],
"CVE-2018-0438": [
"45339"
],
"CVE-2018-0437": [
"45339"
],
"CVE-2017-15358": [
"45107"
],
"CVE-2015-4077": [
"45149"
],
"CVE-2017-18344": [
"45175"
],
"CVE-2017-14798": [
"45184"
],
"CVE-2018-9445": [
"45192"
],
"CVE-2018-12293": [
"45205"
],
"CVE-2018-0952": [
"45244"
],
"CVE-2018-9958": [
"45269",
"44941",
"49116"
],
"CVE-2018-9948": [
"45269",
"44941"
],
"CVE-2018-10900": [
"45313"
],
"CVE-2018-16509": [
"45369"
],
"CVE-2018-9488": [
"45379"
],
"CVE-2019-9766": [
"45403"
],
"CVE-2019-9767": [
"45412"
],
"CVE-2017-3622": [
"45479"
],
"CVE-2018-17182": [
"45497"
],
"CVE-2018-14327": [
"45501"
],
"CVE-2018-17776": [
"45503"
],
"CVE-2018-17408": [
"45505",
"45560"
],
"CVE-2018-14634": [
"45516"
],
"CVE-2018-17793": [
"45528"
],
"CVE-2018-17456": [
"45548",
"45631"
],
"CVE-2017-11176": [
"45553"
],
"CVE-2016-3225": [
"45562"
],
"CVE-2018-17961": [
"45573"
],
"CVE-2018-8533": [
"45583"
],
"CVE-2018-8527": [
"45585"
],
"CVE-2018-8532": [
"45587"
],
"CVE-2018-11529": [
"45626"
],
"CVE-2018-8120": [
"45653"
],
"CVE-2018-19459": [
"45687"
],
"CVE-2018-15442": [
"45696",
"45695"
],
"CVE-2018-14665": [
"45697",
"45742",
"45832",
"45908",
"45922",
"45938",
"46142",
"47701"
],
"CVE-2018-15687": [
"45715"
],
"CVE-2018-18859": [
"45782"
],
"CVE-2018-18858": [
"45782"
],
"CVE-2018-18857": [
"45782"
],
"CVE-2018-18856": [
"45782"
],
"CVE-2018-5407": [
"45785"
],
"CVE-2018-18957": [
"45798"
],
"CVE-2016-7567": [
"45804"
],
"CVE-2018-7182": [
"45846"
],
"CVE-2018-18860": [
"45854"
],
"CVE-2017-7089": [
"45866"
],
"CVE-2017-5124": [
"45867"
],
"CVE-2018-18955": [
"45886",
"45915",
"47164",
"47165",
"47166",
"47167"
],
"CVE-2018-16323": [
"45890"
],
"CVE-2018-8550": [
"45893"
],
"CVE-2018-6329": [
"45913",
"44297"
],
"CVE-2018-4237": [
"45916"
],
"CVE-2018-4435": [
"45960"
],
"CVE-2018-6757": [
"45961"
],
"CVE-2018-6756": [
"45961"
],
"CVE-2018-6755": [
"45961"
],
"CVE-2016-4486": [
"46006"
],
"CVE-2018-18629": [
"46044"
],
"CVE-2018-15982": [
"46051"
],
"CVE-2018-18435": [
"46093"
],
"CVE-2018-8584": [
"46104"
],
"CVE-2018-5410": [
"46155"
],
"CVE-2019-0543": [
"46156"
],
"CVE-2019-0572": [
"46157"
],
"CVE-2019-0573": [
"46158"
],
"CVE-2019-0571": [
"46159"
],
"CVE-2019-0574": [
"46160"
],
"CVE-2019-0566": [
"46161"
],
"CVE-2019-0552": [
"46162"
],
"CVE-2019-0555": [
"46185"
],
"CVE-2015-8612": [
"46186"
],
"CVE-2019-5736": [
"46359",
"46369"
],
"CVE-2019-7304": [
"46361",
"46362"
],
"CVE-2018-4193": [
"46428"
],
"CVE-2019-1674": [
"46479"
],
"CVE-2019-0541": [
"46536"
],
"CVE-2018-20250": [
"46552",
"46756"
],
"CVE-2018-5511": [
"46600"
],
"CVE-2019-5512": [
"46601"
],
"CVE-2019-10843": [
"46657"
],
"CVE-2019-0211": [
"46676"
],
"CVE-2019-0841": [
"46683",
"46938",
"46976",
"47128"
],
"CVE-2018-14894": [
"46688"
],
"CVE-2019-10038": [
"46724"
],
"CVE-2018-19374": [
"46707"
],
"CVE-2019-0735": [
"46712"
],
"CVE-2019-0730": [
"46713"
],
"CVE-2019-0731": [
"46714"
],
"CVE-2019-0796": [
"46715"
],
"CVE-2019-0732": [
"46716"
],
"CVE-2019-0805": [
"46717"
],
"CVE-2019-0836": [
"46718"
],
"CVE-2018-16858": [
"46727"
],
"CVE-2019-2721": [
"46747"
],
"CVE-2019-11563": [
"46779"
],
"CVE-2003-0109": [
"1",
"2",
"36",
"51",
"16470",
"22365",
"22366",
"22367",
"22368"
],
"CVE-2003-0003": [
"5",
"22194"
],
"CVE-2003-0201": [
"7",
"10",
"55",
"9924",
"16330",
"16861",
"16876",
"16880",
"22468",
"22469",
"22470",
"22471"
],
"CVE-2003-1118": [
"8"
],
"CVE-2003-0213": [
"16",
"19",
"9952",
"16845",
"22479"
],
"CVE-2003-0209": [
"18"
],
"CVE-2008-4037": [
"20",
"7125",
"16360"
],
"CVE-2002-1643": [
"23",
"9937",
"16286"
],
"CVE-2003-0190": [
"25",
"26",
"3303"
],
"CVE-2003-1481": [
"27"
],
"CVE-2004-2720": [
"30"
],
"CVE-2003-0339": [
"33"
],
"CVE-2003-0344": [
"37",
"16581",
"22726"
],
"CVE-2003-0380": [
"39"
],
"CVE-2003-0437": [
"41"
],
"CVE-2003-0391": [
"42"
],
"CVE-2003-0500": [
"43"
],
"CVE-2002-0031": [
"45",
"21484"
],
"CVE-2003-0349": [
"48",
"16355",
"22837"
],
"CVE-2003-0558": [
"54",
"16708"
],
"CVE-2003-0227": [
"56"
],
"CVE-2001-0797": [
"57",
"346",
"716",
"9917",
"10036",
"16327",
"16928",
"21179"
],
"CVE-2003-0651": [
"67"
],
"CVE-2003-0466": [
"74",
"78",
"22974",
"22975",
"22976"
],
"CVE-2003-0647": [
"77"
],
"CVE-2003-0727": [
"80",
"1365",
"16714",
"16731",
"16809",
"42780"
],
"CVE-2003-0701": [
"83"
],
"CVE-2003-0725": [
"86"
],
"CVE-2003-0755": [
"88"
],
"CVE-2003-0686": [
"89"
],
"CVE-2003-0767": [
"95"
],
"CVE-2003-0720": [
"99"
],
"CVE-2003-0352": [
"100",
"16749",
"22917"
],
"CVE-2003-0722": [
"101",
"16324"
],
"CVE-2005-0491": [
"102",
"828",
"9930",
"16466",
"16865"
],
"CVE-2003-0849": [
"105",
"23182",
"23183"
],
"CVE-2003-1336": [
"112",
"16530"
],
"CVE-2003-1142": [
"116"
],
"CVE-2003-0812": [
"119",
"123",
"130",
"16378"
],
"CVE-2003-0822": [
"121",
"16356"
],
"CVE-2003-1192": [
"124",
"16767",
"23334"
],
"CVE-2003-0842": [
"126"
],
"CVE-2003-1339": [
"133",
"136"
],
"CVE-2003-0963": [
"143"
],
"CVE-2004-2111": [
"149",
"822",
"18190",
"23591",
"23592"
],
"CVE-2003-1026": [
"151"
],
"CVE-2004-0326": [
"155",
"16692",
"23741"
],
"CVE-2004-0297": [
"157",
"16824"
],
"CVE-2004-0340": [
"159"
],
"CVE-2004-1521": [
"163"
],
"CVE-2004-2719": [
"164"
],
"CVE-2004-1883": [
"165"
],
"CVE-2004-1868": [
"166"
],
"CVE-2004-0362": [
"168",
"16464"
],
"CVE-2004-0184": [
"171"
],
"CVE-2003-1083": [
"173",
"23397"
],
"CVE-2004-1897": [
"174"
],
"CVE-2004-1892": [
"175"
],
"CVE-2000-0884": [
"189",
"190",
"191",
"192",
"20301",
"20299",
"20300",
"20298",
"20302"
],
"CVE-2000-0573": [
"201",
"239",
"269",
"16311",
"20030",
"20031",
"20032"
],
"CVE-2000-1186": [
"211"
],
"CVE-1999-0977": [
"213",
"19668",
"19669",
"19670",
"19672"
],
"CVE-2000-0967": [
"220",
"20286"
],
"CVE-2000-0917": [
"226",
"227",
"230",
"16842"
],
"CVE-2001-0029": [
"228"
],
"CVE-2001-0053": [
"234",
"20512"
],
"CVE-2000-0284": [
"253",
"284",
"397",
"10025",
"16846",
"19847",
"19848",
"19849"
],
"CVE-2001-0241": [
"266",
"268",
"16469",
"20815",
"20816",
"20817",
"20818"
],
"CVE-2003-0719": [
"275",
"16334"
],
"CVE-2001-0010": [
"277",
"279",
"280",
"282"
],
"CVE-2003-0533": [
"293",
"295",
"16368"
],
"CVE-2004-0409": [
"296"
],
"CVE-2004-0396": [
"300",
"301"
],
"CVE-2004-2043": [
"303",
"24165"
],
"CVE-2004-0393": [
"307",
"24223"
],
"CVE-2004-0659": [
"308"
],
"CVE-2004-2291": [
"310"
],
"CVE-2004-0627": [
"311"
],
"CVE-2004-0549": [
"316"
],
"CVE-1999-0042": [
"340"
],
"CVE-2002-0163": [
"347"
],
"CVE-2001-0550": [
"348",
"21161"
],
"CVE-2001-0144": [
"349",
"20617"
],
"CVE-2004-1783": [
"361"
],
"CVE-2004-0600": [
"364"
],
"CVE-2004-2523": [
"372",
"373"
],
"CVE-2004-1439": [
"378",
"439"
],
"CVE-2004-1456": [
"379"
],
"CVE-2004-1437": [
"380"
],
"CVE-2002-1351": [
"382"
],
"CVE-2004-1475": [
"386"
],
"CVE-2004-1717": [
"390",
"400"
],
"CVE-2004-0430": [
"391",
"9931",
"16863"
],
"CVE-2004-0416": [
"392"
],
"CVE-2002-0048": [
"398",
"399",
"21242"
],
"CVE-2004-2263": [
"404"
],
"CVE-2004-0691": [
"408"
],
"CVE-2001-0093": [
"409"
],
"CVE-2004-1741": [
"413"
],
"CVE-2004-0820": [
"418"
],
"CVE-2004-1752": [
"421"
],
"CVE-2004-1650": [
"425"
],
"CVE-2004-1641": [
"426"
],
"CVE-2004-0777": [
"432"
],
"CVE-2004-1666": [
"435"
],
"CVE-2004-1546": [
"473",
"24624"
],
"CVE-2004-0798": [
"566",
"16787"
],
"CVE-2004-1561": [
"568",
"573",
"16763"
],
"CVE-2004-1558": [
"577",
"582",
"16818"
],
"CVE-2004-1898": [
"580"
],
"CVE-2004-1602": [
"581"
],
"CVE-2004-1612": [
"583",
"24688"
],
"CVE-2004-0209": [
"584"
],
"CVE-2004-1626": [
"588",
"618"
],
"CVE-2004-1381": [
"589"
],
"CVE-2004-1380": [
"589"
],
"CVE-2004-1595": [
"590",
"16454"
],
"CVE-2004-1627": [
"592"
],
"CVE-2004-1638": [
"598",
"637",
"16822"
],
"CVE-2004-1636": [
"608"
],
"CVE-2004-1095": [
"609"
],
"CVE-2004-1050": [
"612"
],
"CVE-2004-2271": [
"616",
"636",
"16754"
],
"CVE-2004-2416": [
"619"
],
"CVE-2004-2677": [
"620"
],
"CVE-2004-2685": [
"621",
"4360"
],
"CVE-2004-2418": [
"623"
],
"CVE-2004-1520": [
"627",
"1151",
"16479"
],
"CVE-2003-0264": [
"638",
"16399",
"643",
"646"
],
"CVE-2001-0875": [
"641",
"21164"
],
"CVE-2004-1533": [
"644"
],
"CVE-2004-1120": [
"652"
],
"CVE-2004-1119": [
"654"
],
"CVE-2004-2501": [
"658"
],
"CVE-2004-0594": [
"660"
],
"CVE-2004-1217": [
"675"
],
"CVE-2004-1192": [
"681"
],
"CVE-2004-1327": [
"711"
],
"CVE-2004-1373": [
"712",
"830",
"16751"
],
"CVE-2004-1043": [
"719"
],
"CVE-2004-1317": [
"726",
"16436"
],
"CVE-2003-0172": [
"729"
],
"CVE-2004-0567": [
"733"
],
"CVE-2004-0206": [
"734",
"16371"
],
"CVE-2004-1172": [
"750",
"16331"
],
"CVE-2005-0185": [
"761"
],
"CVE-2002-0082": [
"764",
"21671",
"47080"
],
"CVE-2005-0416": [
"765",
"771"
],
"CVE-2005-0566": [
"767"
],
"CVE-2004-1388": [
"775",
"3099",
"10029",
"16853"
],
"CVE-2005-0338": [
"781",
"787",
"819"
],
"CVE-2005-0226": [
"784"
],
"CVE-2005-0419": [
"794"
],
"CVE-2005-0439": [
"805"
],
"CVE-2005-0523": [
"806"
],
"CVE-2004-2074": [
"823",
"16712"
],
"CVE-2005-0277": [
"825",
"827",
"16730"
],
"CVE-2005-0494": [
"829"
],
"CVE-2005-0595": [
"845",
"16761"
],
"CVE-2005-0635": [
"854"
],
"CVE-2005-0582": [
"859"
],
"CVE-2005-0581": [
"859",
"16414",
"16744",
"16745"
],
"CVE-2005-0353": [
"875",
"16746"
],
"CVE-2005-0788": [
"879"
],
"CVE-2005-0892": [
"900",
"25275"
],
"CVE-2005-0958": [
"902"
],
"CVE-2004-1080": [
"909",
"16359"
],
"CVE-2005-1100": [
"934"
],
"CVE-2005-1110": [
"940"
],
"CVE-2005-1173": [
"945",
"949"
],
"CVE-2005-0560": [
"947"
],
"CVE-2005-1348": [
"952",
"16781"
],
"CVE-2005-1163": [
"953"
],
"CVE-2005-1323": [
"955",
"16735"
],
"CVE-2005-0634": [
"967",
"968",
"969"
],
"CVE-2005-1246": [
"970"
],
"CVE-2005-1415": [
"975",
"16703"
],
"CVE-2005-1654": [
"979",
"987"
],
"CVE-2005-1476": [
"986"
],
"CVE-2005-1477": [
"986"
],
"CVE-2005-1547": [
"990"
],
"CVE-2005-1461": [
"1021"
],
"CVE-2005-1903": [
"1026"
],
"CVE-2005-1873": [
"1028"
],
"CVE-2005-1255": [
"1035",
"1124",
"3627"
],
"CVE-2005-2041": [
"1047"
],
"CVE-2005-1213": [
"1066",
"16379"
],
"CVE-2005-0059": [
"1075",
"16747"
],
"CVE-2005-2087": [
"1079"
],
"CVE-2005-2250": [
"1081"
],
"CVE-2005-2219": [
"1096"
],
"CVE-2005-2262": [
"1102"
],
"CVE-2001-0311": [
"1114",
"9942",
"16291"
],
"CVE-2005-1523": [
"1123"
],
"CVE-2005-1272": [
"1130",
"16403"
],
"CVE-2006-6379": [
"1132"
],
"CVE-2005-2409": [
"1138"
],
"CVE-2005-2367": [
"1139"
],
"CVE-2005-1990": [
"1144"
],
"CVE-2005-1989": [
"1144"
],
"CVE-2005-2611": [
"1147"
],
"CVE-2005-1543": [
"1150",
"16815"
],
"CVE-2005-2551": [
"1152",
"16769"
],
"CVE-2001-1583": [
"1167",
"9921",
"16322",
"21097"
],
"CVE-2005-2665": [
"1171"
],
"CVE-2002-1120": [
"1184",
"4280",
"10434",
"16770"
],
"CVE-2005-2773": [
"1188",
"16887"
],
"CVE-2005-2842": [
"1190",
"42703"
],
"CVE-2005-2857": [
"1193"
],
"CVE-2005-2878": [
"1209",
"1234",
"3787"
],
"CVE-2003-0471": [
"1210",
"16776",
"22833",
"22834"
],
"CVE-2006-5961": [
"1223"
],
"CVE-2005-2871": [
"1224"
],
"CVE-2005-3081": [
"1231",
"1292"
],
"CVE-2005-2710": [
"1232"
],
"CVE-2005-2961": [
"1238"
],
"CVE-2005-2967": [
"1242"
],
"CVE-2005-3190": [
"1243",
"16801"
],
"CVE-2005-3277": [
"1261"
],
"CVE-2005-2715": [
"1263",
"1264",
"1265"
],
"CVE-2005-3252": [
"1272",
"1313",
"1314",
"10026",
"16834"
],
"CVE-2005-3523": [
"1290",
"1291"
],
"CVE-2005-3524": [
"1295"
],
"CVE-2005-3684": [
"1330"
],
"CVE-2005-3683": [
"1330",
"16707"
],
"CVE-2005-3155": [
"1332",
"16480"
],
"CVE-2005-3757": [
"1333",
"16907"
],
"CVE-2005-1980": [
"1352"
],
"CVE-2005-1978": [
"1352"
],
"CVE-2005-3995": [
"1355"
],
"CVE-2005-4417": [
"1357"
],
"CVE-2005-4143": [
"1366"
],
"CVE-2005-4270": [
"1374"
],
"CVE-2005-4411": [
"1375",
"16419"
],
"CVE-2005-4456": [
"1378"
],
"CVE-2005-4402": [
"1378"
],
"CVE-2006-0637": [
"1380"
],
"CVE-2005-4267": [
"1380",
"16474"
],
"CVE-2005-4553": [
"1381"
],
"CVE-2005-4085": [
"1408",
"16691"
],
"CVE-2006-0189": [
"1413",
"1414"
],
"CVE-2006-0319": [
"1417"
],
"CVE-2005-3116": [
"1421"
],
"CVE-2006-0537": [
"1466"
],
"CVE-2006-0295": [
"1474",
"1480",
"16301"
],
"CVE-2006-0681": [
"1486"
],
"CVE-2005-4714": [
"1487"
],
"CVE-2006-0005": [
"1504",
"1505",
"1520"
],
"CVE-2006-1124": [
"1565"
],
"CVE-2006-1236": [
"1582",
"50216"
],
"CVE-2006-0396": [
"1583"
],
"CVE-2006-1255": [
"1592",
"2345",
"3133",
"3540",
"16476",
"16481"
],
"CVE-2006-0460": [
"1602",
"16433"
],
"CVE-2006-0230": [
"1703"
],
"CVE-2006-2022": [
"1717",
"3815"
],
"CVE-2006-1518": [
"1741"
],
"CVE-2006-1516": [
"1742"
],
"CVE-2006-2236": [
"1750"
],
"CVE-2006-2407": [
"1787",
"16461",
"16462"
],
"CVE-2002-1359": [
"1788",
"16463"
],
"CVE-2006-2369": [
"1791",
"1794",
"17719",
"36932"
],
"CVE-2006-2502": [
"1813",
"2185",
"16836"
],
"CVE-2006-2814": [
"1862"
],
"CVE-2006-2926": [
"1885",
"16690"
],
"CVE-2006-2901": [
"1889"
],
"CVE-2006-2370": [
"1940",
"1965",
"16364",
"16375"
],
"CVE-2006-3392": [
"1997",
"2017"
],
"CVE-2006-3670": [
"2014"
],
"CVE-2006-3561": [
"2034"
],
"CVE-2006-3734": [
"2048"
],
"CVE-2006-0003": [
"2052",
"2164",
"16561"
],
"CVE-2006-2372": [
"2054"
],
"CVE-2006-3838": [
"2074",
"2075",
"2080",
"2140",
"16438",
"16451"
],
"CVE-2006-3677": [
"2082",
"9946",
"16300"
],
"CVE-2006-4081": [
"2136",
"2145"
],
"CVE-2006-3439": [
"2162",
"2223",
"2265",
"2355",
"16367"
],
"CVE-2006-4318": [
"2233",
"16741"
],
"CVE-2006-3952": [
"2234",
"3579",
"16742",
"33538"
],
"CVE-2006-3747": [
"2237",
"3680",
"3996",
"16752"
],
"CVE-2006-3124": [
"2274",
"2277"
],
"CVE-2006-4681": [
"2320"
],
"CVE-2006-4723": [
"2328"
],
"CVE-2006-4777": [
"2358",
"16506"
],
"CVE-2006-4974": [
"2401"
],
"CVE-2006-4868": [
"2425",
"2426",
"16597"
],
"CVE-2006-3866": [
"2425",
"2426"
],
"CVE-2006-3730": [
"2440",
"2448",
"2458",
"2460",
"16564"
],
"CVE-2006-5112": [
"2445",
"3092",
"16808"
],
"CVE-2006-5156": [
"2467",
"16783"
],
"CVE-2006-5216": [
"2482",
"16759"
],
"CVE-2006-4379": [
"2601",
"3264",
"3265"
],
"CVE-2006-5725": [
"2637"
],
"CVE-2006-5596": [
"2637"
],
"CVE-2006-5597": [
"2651"
],
"CVE-2006-3252": [
"2680",
"16760"
],
"CVE-2006-5714": [
"2690"
],
"CVE-2006-5715": [
"2699"
],
"CVE-2006-5780": [
"2729",
"16389"
],
"CVE-2006-5745": [
"2743",
"2749",
"2753",
"16532"
],
"CVE-2006-5882": [
"2770"
],
"CVE-2006-6055": [
"2771"
],
"CVE-2006-5925": [
"2784",
"29033"
],
"CVE-2006-4691": [
"2789",
"2800",
"2809",
"16372"
],
"CVE-2006-5815": [
"2856",
"16852"
],
"CVE-2006-5864": [
"2858"
],
"CVE-2006-6121": [
"2866"
],
"CVE-2006-6493": [
"2933"
],
"CVE-2004-1364": [
"2951",
"24353"
],
"CVE-2006-7141": [
"2959"
],
"CVE-2006-6758": [
"2974"
],
"CVE-2006-6838": [
"3058"
],
"CVE-2007-0055": [
"3063"
],
"CVE-2007-0015": [
"3064",
"3072",
"16527"
],
"CVE-2007-0059": [
"3077"
],
"CVE-2007-0046": [
"3084"
],
"CVE-2006-6917": [
"3086"
],
"CVE-2006-3726": [
"3107",
"16733"
],
"CVE-2006-4948": [
"3132",
"7452",
"16346"
],
"CVE-2007-0024": [
"3137",
"3148"
],
"CVE-2007-0243": [
"3168"
],
"CVE-2007-0528": [
"3189"
],
"CVE-2007-0449": [
"3211",
"3218",
"3244",
"16400"
],
"CVE-2007-0827": [
"3279"
],
"CVE-2006-5784": [
"3291"
],
"CVE-2007-0882": [
"3293",
"9918",
"16328"
],
"CVE-2007-0883": [
"3294"
],
"CVE-2007-0927": [
"3296"
],
"CVE-2007-0977": [
"3302"
],
"CVE-2005-2428": [
"3302",
"39495"
],
"CVE-2006-5229": [
"3303"
],
"CVE-2006-6423": [
"3319",
"3320",
"16475"
],
"CVE-2006-4847": [
"3335",
"16717"
],
"CVE-2007-0981": [
"3340"
],
"CVE-2006-0549": [
"3363",
"3377"
],
"CVE-2005-4832": [
"3364",
"3378",
"25452",
"25453"
],
"CVE-2007-0888": [
"3380"
],
"CVE-2007-1225": [
"3381"
],
"CVE-2007-1224": [
"3381"
],
"CVE-2006-6332": [
"3389",
"10024",
"16835"
],
"CVE-2007-1260": [
"3395"
],
"CVE-2007-1301": [
"3397"
],
"CVE-2007-1287": [
"3405"
],
"CVE-2006-3890": [
"3420"
],
"CVE-2007-1359": [
"3425"
],
"CVE-2007-1452": [
"3452"
],
"CVE-2007-1568": [
"3462",
"3463"
],
"CVE-2007-1567": [
"3474",
"3482",
"3570"
],
"CVE-2006-5143": [
"3495",
"16401",
"28765",
"28766"
],
"CVE-2006-6026": [
"3531"
],
"CVE-2007-1579": [
"3537"
],
"CVE-2007-1645": [
"3541"
],
"CVE-2007-1644": [
"3544"
],
"CVE-2007-1465": [
"3554"
],
"CVE-2007-1511": [
"3575",
"3650"
],
"CVE-2006-7206": [
"3577"
],
"CVE-2007-1733": [
"3589"
],
"CVE-2007-1785": [
"3604"
],
"CVE-2007-1866": [
"3615"
],
"CVE-2007-1882": [
"3654"
],
"CVE-2007-1819": [
"3661",
"16580"
],
"CVE-2006-5820": [
"3662"
],
"CVE-2007-0919": [
"3708",
"5212"
],
"CVE-2007-2057": [
"3724"
],
"CVE-2007-0018": [
"3728",
"3808",
"16603"
],
"CVE-2007-1748": [
"3737",
"3740",
"3746",
"16366",
"16748"
],
"CVE-2007-2080": [
"3738"
],
"CVE-2007-2079": [
"3738"
],
"CVE-2007-1687": [
"3810"
],
"CVE-2007-2031": [
"3821",
"3822",
"3829"
],
"CVE-2007-2566": [
"3872"
],
"CVE-2007-2221": [
"3892"
],
"CVE-2007-2584": [
"3893"
],
"CVE-2007-2644": [
"3899"
],
"CVE-2007-2668": [
"3913",
"3922"
],
"CVE-2007-2667": [
"3916"
],
"CVE-2007-2711": [
"3925",
"16444"
],
"CVE-2007-2725": [
"3927"
],
"CVE-2007-2770": [
"3934"
],
"CVE-2007-2755": [
"3938"
],
"CVE-2007-2771": [
"3950"
],
"CVE-2007-2787": [
"3951",
"3952"
],
"CVE-2007-2783": [
"3954"
],
"CVE-2007-2851": [
"3961"
],
"CVE-2007-2814": [
"3966"
],
"CVE-2007-2853": [
"3967"
],
"CVE-2007-2820": [
"3968"
],
"CVE-2007-2856": [
"3982",
"3984"
],
"CVE-2007-2938": [
"3993"
],
"CVE-2007-3076": [
"4008"
],
"CVE-2007-3168": [
"4010"
],
"CVE-2007-3166": [
"4014"
],
"CVE-2007-3167": [
"4015"
],
"CVE-2007-2815": [
"4016"
],
"CVE-2007-2987": [
"4021",
"4214",
"16540"
],
"CVE-2007-3111": [
"4023"
],
"CVE-2007-2791": [
"4032"
],
"CVE-2007-3147": [
"4042",
"4053",
"16519"
],
"CVE-2007-3148": [
"4043",
"4052"
],
"CVE-2007-3233": [
"4060"
],
"CVE-2007-2222": [
"4065",
"4066"
],
"CVE-2007-3360": [
"4087"
],
"CVE-2007-3435": [
"4094",
"16565"
],
"CVE-2007-3400": [
"4101"
],
"CVE-2007-3493": [
"4109"
],
"CVE-2007-3459": [
"4110"
],
"CVE-2007-3487": [
"4119"
],
"CVE-2007-3536": [
"4123"
],
"CVE-2007-2239": [
"4143"
],
"CVE-2007-1770": [
"4146"
],
"CVE-2007-3612": [
"4152"
],
"CVE-2007-3649": [
"4155"
],
"CVE-2007-3614": [
"4157",
"16758",
"30278"
],
"CVE-2006-6707": [
"4158",
"16538"
],
"CVE-2007-3633": [
"4160"
],
"CVE-2007-0774": [
"4162",
"16798"
],
"CVE-2007-3703": [
"4170"
],
"CVE-2007-3785": [
"4176"
],
"CVE-2007-3883": [
"4190",
"5395"
],
"CVE-2007-3983": [
"4208"
],
"CVE-2007-3982": [
"4208"
],
"CVE-2007-3984": [
"4214"
],
"CVE-2007-3955": [
"4217"
],
"CVE-2007-4006": [
"4222",
"16427"
],
"CVE-2007-4005": [
"4222"
],
"CVE-2007-3925": [
"4223",
"16487"
],
"CVE-2007-4067": [
"4226"
],
"CVE-2007-3927": [
"4228"
],
"CVE-2007-4031": [
"4230",
"4237"
],
"CVE-2007-4062": [
"4237"
],
"CVE-2007-4061": [
"4237"
],
"CVE-2007-4059": [
"4240"
],
"CVE-2007-4060": [
"4243"
],
"CVE-2007-4058": [
"4244"
],
"CVE-2007-4155": [
"4245"
],
"CVE-2007-4034": [
"4250"
],
"CVE-2007-4252": [
"4255"
],
"CVE-2007-4254": [
"4259"
],
"CVE-2007-2926": [
"4266"
],
"CVE-2007-4336": [
"4279"
],
"CVE-2007-4370": [
"4283",
"8253",
"16694"
],
"CVE-2007-4377": [
"4287"
],
"CVE-2007-4420": [
"4290"
],
"CVE-2007-4375": [
"4292"
],
"CVE-2007-4489": [
"4299"
],
"CVE-2007-4566": [
"4315",
"9586",
"9592",
"9596"
],
"CVE-2007-4584": [
"4321"
],
"CVE-2007-4582": [
"4322"
],
"CVE-2007-4583": [
"4323",
"4324"
],
"CVE-2007-4607": [
"4328",
"16579"
],
"CVE-2007-2931": [
"4334",
"30537"
],
"CVE-2007-4748": [
"4348"
],
"CVE-2007-4515": [
"4351",
"16522"
],
"CVE-2007-4740": [
"4357"
],
"CVE-2007-4726": [
"4362"
],
"CVE-2007-4802": [
"4366",
"4372"
],
"CVE-2007-1070": [
"4367",
"16827"
],
"CVE-2007-4902": [
"4388"
],
"CVE-2007-4903": [
"4389"
],
"CVE-2007-4891": [
"4393"
],
"CVE-2007-4890": [
"4394"
],
"CVE-2007-4982": [
"4420"
],
"CVE-2007-4983": [
"4427"
],
"CVE-2007-5017": [
"4428"
],
"CVE-2007-5018": [
"4429"
],
"CVE-2007-5094": [
"4438"
],
"CVE-2007-5070": [
"4445"
],
"CVE-2007-5067": [
"4450",
"16753"
],
"CVE-2007-5108": [
"4452"
],
"CVE-2007-5107": [
"4452",
"16557"
],
"CVE-2007-5111": [
"4453"
],
"CVE-2007-5110": [
"4453"
],
"CVE-2008-1117": [
"4455",
"5238",
"16339"
],
"CVE-2007-4174": [
"4468",
"30447"
],
"CVE-2007-5184": [
"4478"
],
"CVE-2007-5320": [
"4488"
],
"CVE-2007-5322": [
"4506"
],
"CVE-2007-2807": [
"4514"
],
"CVE-2007-5450": [
"4522"
],
"CVE-2007-5446": [
"4526"
],
"CVE-2007-5461": [
"4530",
"4552"
],
"CVE-2007-5654": [
"4556"
],
"CVE-2007-5699": [
"4566"
],
"CVE-2007-5731": [
"4567"
],
"CVE-2007-4880": [
"4573",
"16764"
],
"CVE-2007-5779": [
"4579",
"16572"
],
"CVE-2007-5603": [
"4594",
"16616"
],
"CVE-2007-5826": [
"4598"
],
"CVE-2007-6189": [
"4663"
],
"CVE-2007-5775": [
"4663"
],
"CVE-2002-0252": [
"4673",
"21286"
],
"CVE-2007-6405": [
"4700"
],
"CVE-2007-6404": [
"4700"
],
"CVE-2007-6317": [
"4713"
],
"CVE-2007-6316": [
"4713"
],
"CVE-2007-6315": [
"4713"
],
"CVE-2007-6314": [
"4713"
],
"CVE-2007-6379": [
"4715"
],
"CVE-2007-6378": [
"4715"
],
"CVE-2007-6377": [
"4715",
"4784",
"16806"
],
"CVE-2007-6333": [
"4720"
],
"CVE-2007-6332": [
"4720"
],
"CVE-2007-6331": [
"4720"
],
"CVE-2007-6204": [
"4724",
"16805"
],
"CVE-2007-6702": [
"4744"
],
"CVE-2007-3039": [
"4745",
"4760",
"4934",
"16750"
],
"CVE-2007-6516": [
"4746"
],
"CVE-2007-6453": [
"4747"
],
"CVE-2007-4560": [
"4761",
"9913",
"16924"
],
"CVE-2007-6638": [
"4797"
],
"CVE-2007-6530": [
"4806",
"16588"
],
"CVE-2007-4474": [
"4818",
"4820",
"5111",
"16502"
],
"CVE-2007-6654": [
"4819"
],
"CVE-2007-6387": [
"4825"
],
"CVE-2007-6335": [
"4862"
],
"CVE-2007-5759": [
"4862"
],
"CVE-2007-3901": [
"4866",
"16442"
],
"CVE-2007-4722": [
"4868",
"30562"
],
"CVE-2008-0221": [
"4869"
],
"CVE-2008-0220": [
"4869",
"4982"
],
"CVE-2008-0236": [
"4873"
],
"CVE-2008-0237": [
"4874"
],
"CVE-2008-0244": [
"4877"
],
"CVE-2008-0248": [
"4894"
],
"CVE-2008-4547": [
"4903"
],
"CVE-2008-4587": [
"4909"
],
"CVE-2008-4586": [
"4913"
],
"CVE-2008-4548": [
"4918"
],
"CVE-2008-0338": [
"4923"
],
"CVE-2008-0337": [
"4923"
],
"CVE-2008-0380": [
"4932"
],
"CVE-2008-0403": [
"4941"
],
"CVE-2008-0399": [
"4946"
],
"CVE-2008-0434": [
"4947"
],
"CVE-2008-0394": [
"4949"
],
"CVE-2008-0437": [
"4959"
],
"CVE-2008-0443": [
"4967"
],
"CVE-2008-0470": [
"4974"
],
"CVE-2008-0477": [
"4979"
],
"CVE-2008-4549": [
"4981"
],
"CVE-2008-0551": [
"4986"
],
"CVE-2008-0492": [
"4987",
"16576"
],
"CVE-2008-0631": [
"4999"
],
"CVE-2008-4584": [
"5005",
"7594"
],
"CVE-2008-0659": [
"5025"
],
"CVE-2008-4583": [
"5028"
],
"CVE-2008-0634": [
"5045"
],
"CVE-2008-5711": [
"5049",
"5102",
"16505"
],
"CVE-2008-0660": [
"5049"
],
"CVE-2008-0625": [
"5052"
],
"CVE-2008-0457": [
"5078",
"31072"
],
"CVE-2008-0621": [
"5079",
"16338"
],
"CVE-2006-6334": [
"5106"
],
"CVE-2008-4876": [
"5113"
],
"CVE-2008-4875": [
"5113"
],
"CVE-2008-4874": [
"5113"
],
"CVE-2008-0804": [
"5150"
],
"CVE-2008-0647": [
"5153"
],
"CVE-2008-1116": [
"5188"
],
"CVE-2008-1044": [
"5190"
],
"CVE-2008-4771": [
"5193"
],
"CVE-2007-6016": [
"5205",
"16582"
],
"CVE-2008-1319": [
"5213"
],
"CVE-2008-1145": [
"5215"
],
"CVE-2008-1411": [
"5228"
],
"CVE-2008-1410": [
"5228"
],
"CVE-2008-1118": [
"5238"
],
"CVE-2008-1358": [
"5248",
"16482"
],
"CVE-2008-1276": [
"5249"
],
"CVE-2008-1218": [
"5257"
],
"CVE-2008-1498": [
"5259"
],
"CVE-2008-1472": [
"5264",
"16577"
],
"CVE-2008-1402": [
"5269"
],
"CVE-2008-1401": [
"5269"
],
"CVE-2008-1400": [
"5269"
],
"CVE-2008-1467": [
"5283"
],
"CVE-2008-1160": [
"5289"
],
"CVE-2008-1247": [
"5313"
],
"CVE-2008-1611": [
"5314",
"18345",
"18759"
],
"CVE-2008-1309": [
"5332",
"16584"
],
"CVE-2008-1647": [
"5338",
"7594"
],
"CVE-2008-1697": [
"5342",
"16774"
],
"CVE-1999-0209": [
"5366",
"16326",
"19040"
],
"CVE-2007-6258": [
"5386"
],
"CVE-2008-1886": [
"5397"
],
"CVE-2008-1885": [
"5397"
],
"CVE-2008-1724": [
"5398",
"16563"
],
"CVE-2008-1725": [
"5416"
],
"CVE-2008-1914": [
"5451",
"9673",
"9690",
"16430",
"16431"
],
"CVE-2008-1933": [
"5489"
],
"CVE-2008-2015": [
"5496"
],
"CVE-2008-2390": [
"5511"
],
"CVE-2007-6682": [
"5519"
],
"CVE-2008-2161": [
"5563"
],
"CVE-2008-2283": [
"5612"
],
"CVE-2008-2281": [
"5619"
],
"CVE-2008-0166": [
"5622",
"5632",
"5720"
],
"CVE-2008-0955": [
"5681",
"16539"
],
"CVE-2008-1491": [
"5694",
"16425"
],
"CVE-2008-0871": [
"5695",
"16779"
],
"CVE-2008-3280": [
"5720"
],
"CVE-2008-2551": [
"5732",
"18449"
],
"CVE-2008-1661": [
"5738",
"16450"
],
"CVE-2008-1770": [
"5741"
],
"CVE-2008-2693": [
"5746",
"5747"
],
"CVE-2008-2684": [
"5750"
],
"CVE-2008-2683": [
"5750",
"17415",
"17424"
],
"CVE-2008-2745": [
"5777",
"5778"
],
"CVE-2008-0960": [
"5790"
],
"CVE-2008-2910": [
"5793"
],
"CVE-2008-2841": [
"5795"
],
"CVE-2006-5202": [
"5926"
],
"CVE-2008-3156": [
"6004"
],
"CVE-2008-3155": [
"6004"
],
"CVE-2008-6922": [
"6012"
],
"CVE-2008-6825": [
"6045",
"6026",
"16904"
],
"CVE-2008-3257": [
"6089",
"18897"
],
"CVE-2008-3234": [
"6094"
],
"CVE-2008-3361": [
"6118",
"6227"
],
"CVE-2008-4194": [
"6122",
"6123",
"6130"
],
"CVE-2008-1447": [
"6122",
"6123",
"6130"
],
"CVE-2008-2463": [
"6124",
"16605"
],
"CVE-2008-7084": [
"6151"
],
"CVE-2008-3364": [
"6152"
],
"CVE-2007-2586": [
"6155"
],
"CVE-2008-3583": [
"6195"
],
"CVE-2008-3558": [
"6220",
"16604"
],
"CVE-2008-2737": [
"6220"
],
"CVE-2008-2938": [
"6229",
"14489"
],
"CVE-2008-3480": [
"6278"
],
"CVE-2008-7115": [
"6305"
],
"CVE-2008-1245": [
"6305"
],
"CVE-2008-1244": [
"6305"
],
"CVE-2008-1242": [
"6305"
],
"CVE-2008-3878": [
"6318",
"16513"
],
"CVE-2008-4048": [
"6323"
],
"CVE-2008-4049": [
"6324"
],
"CVE-2008-0964": [
"6328"
],
"CVE-2008-4050": [
"6334"
],
"CVE-2008-6996": [
"6355"
],
"CVE-2008-6976": [
"6366"
],
"CVE-2008-6994": [
"6367"
],
"CVE-2008-2639": [
"6387",
"16380"
],
"CVE-2008-4699": [
"6414"
],
"CVE-2008-3008": [
"6454",
"16521"
],
"CVE-2008-4128": [
"6476"
],
"CVE-2008-4342": [
"6491"
],
"CVE-2008-4243": [
"6506"
],
"CVE-2008-4343": [
"6537"
],
"CVE-2006-6488": [
"6570"
],
"CVE-2008-7022": [
"6600"
],
"CVE-2008-4472": [
"6630"
],
"CVE-2008-4471": [
"6630"
],
"CVE-2008-4453": [
"6638"
],
"CVE-2008-4501": [
"6661"
],
"CVE-2008-4421": [
"6686"
],
"CVE-2008-5697": [
"6690"
],
"CVE-2008-4493": [
"6699"
],
"CVE-2008-4728": [
"6773",
"6774",
"6776"
],
"CVE-2008-4556": [
"6786",
"9920",
"16325"
],
"CVE-2008-4652": [
"6793",
"6840"
],
"CVE-2008-4725": [
"6801"
],
"CVE-2008-4696": [
"6801",
"9944",
"16304"
],
"CVE-2008-4726": [
"6804"
],
"CVE-2008-4750": [
"6828"
],
"CVE-2008-4749": [
"6828"
],
"CVE-2008-4923": [
"6870"
],
"CVE-2008-4924": [
"6871"
],
"CVE-2008-4925": [
"6872"
],
"CVE-2008-4926": [
"6873"
],
"CVE-2008-4919": [
"6875"
],
"CVE-2008-4922": [
"6878",
"16638"
],
"CVE-2008-6824": [
"6899"
],
"CVE-2008-6823": [
"6899"
],
"CVE-2008-0175": [
"6921"
],
"CVE-2011-5289": [
"6963"
],
"CVE-2008-5002": [
"6963",
"16518"
],
"CVE-2008-6916": [
"7055"
],
"CVE-2008-6959": [
"7142"
],
"CVE-2008-6937": [
"7145",
"7167"
],
"CVE-2008-6936": [
"7145",
"7167"
],
"CVE-2008-6935": [
"7145",
"7167"
],
"CVE-2008-5297": [
"7151"
],
"CVE-2008-7070": [
"7181"
],
"CVE-2008-5706": [
"7183"
],
"CVE-2008-5705": [
"7183"
],
"CVE-2008-4033": [
"7196"
],
"CVE-2008-4029": [
"7196"
],
"CVE-2008-6534": [
"7355"
],
"CVE-2008-6499": [
"7384"
],
"CVE-2008-6498": [
"7384",
"10391"
],
"CVE-2008-6975": [
"7389",
"9209"
],
"CVE-2008-6974": [
"7389",
"9209"
],
"CVE-2008-4844": [
"7403",
"7410",
"16583"
],
"CVE-2008-6528": [
"7442"
],
"CVE-2010-1175": [
"7477"
],
"CVE-2008-1094": [
"7496"
],
"CVE-2008-5691": [
"7505"
],
"CVE-2008-5862": [
"7521"
],
"CVE-2008-5750": [
"7566"
],
"CVE-2008-5749": [
"7566"
],
"CVE-2008-6898": [
"7617",
"14195",
"16641"
],
"CVE-2008-6748": [
"7623",
"7630"
],
"CVE-2009-0134": [
"7779"
],
"CVE-2009-0253": [
"7842"
],
"CVE-2009-0301": [
"7868"
],
"CVE-2009-0351": [
"7875"
],
"CVE-2009-0374": [
"7903"
],
"CVE-2009-0389": [
"7910"
],
"CVE-2009-0369": [
"7912"
],
"CVE-2009-0393": [
"7915"
],
"CVE-2009-0392": [
"7915"
],
"CVE-2009-0468": [
"7919"
],
"CVE-2009-0467": [
"7919"
],
"CVE-2009-0465": [
"7928"
],
"CVE-2009-0545": [
"8023"
],
"CVE-2009-0543": [
"8037"
],
"CVE-2009-0542": [
"8037",
"32798"
],
"CVE-2009-5087": [
"8041"
],
"CVE-2009-0865": [
"8059"
],
"CVE-2009-0076": [
"8079",
"8080",
"8082",
"8152"
],
"CVE-2009-0753": [
"8097"
],
"CVE-2009-0187": [
"8118",
"16569"
],
"CVE-2009-0811": [
"8143"
],
"CVE-2009-0813": [
"8144"
],
"CVE-2009-4809": [
"8155"
],
"CVE-2009-5135": [
"8191"
],
"CVE-2009-1029": [
"8203",
"16441",
"16458"
],
"CVE-2009-1092": [
"8206"
],
"CVE-2009-1031": [
"8211"
],
"CVE-2009-1087": [
"8215"
],
"CVE-2009-4800": [
"8256"
],
"CVE-2009-4790": [
"8256"
],
"CVE-2009-1064": [
"8257"
],
"CVE-2008-6899": [
"8295"
],
"CVE-2009-1212": [
"8332"
],
"CVE-2008-5457": [
"8336",
"16762"
],
"CVE-2009-1354": [
"8428"
],
"CVE-2008-5518": [
"8458"
],
"CVE-2009-0065": [
"8556"
],
"CVE-2009-2570": [
"8562"
],
"CVE-2009-1492": [
"8569"
],
"CVE-2009-1493": [
"8570"
],
"CVE-2009-1612": [
"8579",
"16553"
],
"CVE-2009-1611": [
"8613",
"8621"
],
"CVE-2009-1675": [
"8623"
],
"CVE-2009-1676": [
"8704"
],
"CVE-2009-1535": [
"8704",
"8806"
],
"CVE-2008-5353": [
"8753",
"9948",
"16293",
"16302"
],
"CVE-2009-1807": [
"8757"
],
"CVE-2009-1800": [
"8758"
],
"CVE-2009-1122": [
"8806"
],
"CVE-2009-4841": [
"8824"
],
"CVE-2009-4840": [
"8835"
],
"CVE-2009-0950": [
"8861",
"8934",
"11138",
"16296"
],
"CVE-2009-2011": [
"8922",
"16515"
],
"CVE-2009-2258": [
"8963"
],
"CVE-2009-2257": [
"8963"
],
"CVE-2009-2169": [
"8986"
],
"CVE-2009-2227": [
"9002",
"9031",
"16445"
],
"CVE-2009-2275": [
"9039"
],
"CVE-2009-2306": [
"9066"
],
"CVE-2009-2544": [
"9093"
],
"CVE-2009-3760": [
"9106"
],
"CVE-2009-3759": [
"9106"
],
"CVE-2009-3758": [
"9106"
],
"CVE-2009-3757": [
"9106"
],
"CVE-2009-2478": [
"9137",
"9181"
],
"CVE-2009-2766": [
"9209"
],
"CVE-2009-2765": [
"9209",
"10030",
"16856"
],
"CVE-2009-4988": [
"9319",
"16423"
],
"CVE-2009-1873": [
"9443"
],
"CVE-2009-3976": [
"9508",
"16709"
],
"CVE-2009-3023": [
"9541",
"9559",
"16740"
],
"CVE-2009-3364": [
"9613"
],
"CVE-2009-2694": [
"9615"
],
"CVE-2009-1376": [
"9615"
],
"CVE-2009-3544": [
"9649"
],
"CVE-2009-3076": [
"9651"
],
"CVE-2009-1977": [
"9652"
],
"CVE-2009-1978": [
"9652"
],
"CVE-2007-2795": [
"9662"
],
"CVE-2008-0016": [
"9663"
],
"CVE-2009-4660": [
"9673",
"9690"
],
"CVE-2009-3646": [
"9694"
],
"CVE-2009-4663": [
"9705"
],
"CVE-2009-3562": [
"9718"
],
"CVE-2009-3561": [
"9718"
],
"CVE-2009-4873": [
"9800",
"9966"
],
"CVE-2009-3518": [
"9802"
],
"CVE-2009-3898": [
"9829"
],
"CVE-2009-3850": [
"9843"
],
"CVE-2009-3031": [
"9853",
"16613"
],
"CVE-2009-3710": [
"9858"
],
"CVE-2009-1547": [
"9893",
"33270"
],
"CVE-2009-1979": [
"9905",
"16342"
],
"CVE-2006-2447": [
"9914",
"16920"
],
"CVE-2004-2687": [
"9915"
],
"CVE-2001-0803": [
"9923",
"16323"
],
"CVE-2004-0695": [
"9928",
"16872"
],
"CVE-2006-0395": [
"9929",
"16870"
],
"CVE-2003-0085": [
"9936",
"16321",
"22356"
],
"CVE-2001-0414": [
"9940",
"16285",
"20727"
],
"CVE-2004-1389": [
"9941"
],
"CVE-2007-2175": [
"9943",
"16295",
"29884"
],
"CVE-2005-2265": [
"9947",
"16306"
],
"CVE-2007-2446": [
"9950",
"16329",
"16859",
"16875"
],
"CVE-2004-0541": [
"9951",
"16847"
],
"CVE-2008-0226": [
"9953",
"16701",
"16849"
],
"CVE-2007-5243": [
"9954",
"10020",
"10021",
"16420",
"16432",
"16437",
"16440",
"16447",
"16449",
"16839",
"16843",
"16844"
],
"CVE-2009-3838": [
"9957"
],
"CVE-2009-3658": [
"9992"
],
"CVE-2009-0796": [
"9993"
],
"CVE-2009-0795": [
"9993"
],
"CVE-2009-3457": [
"10000"
],
"CVE-2009-2820": [
"10001"
],
"CVE-2009-2684": [
"10011",
"10055"
],
"CVE-2007-5244": [
"10019",
"16840"
],
"CVE-2005-1099": [
"10023",
"16841",
"25392"
],
"CVE-2006-1148": [
"10027",
"16786",
"16855"
],
"CVE-2005-2799": [
"10028",
"16854"
],
"CVE-2004-0608": [
"10032",
"16693",
"16848"
],
"CVE-2001-0800": [
"10033"
],
"CVE-2002-1473": [
"10034",
"16927"
],
"CVE-2008-7232": [
"10035"
],
"CVE-2004-2221": [
"10037",
"16926"
],
"CVE-2009-3711": [
"10053",
"16799"
],
"CVE-2009-3691": [
"10070"
],
"CVE-2009-3555": [
"10071",
"10579"
],
"CVE-2009-2685": [
"10099",
"16785"
],
"CVE-2009-4053": [
"10162"
],
"CVE-2009-4194": [
"10258"
],
"CVE-2009-4219": [
"10269"
],
"CVE-2009-1429": [
"10340",
"17699"
],
"CVE-2009-4179": [
"10394",
"16797"
],
"CVE-2009-3844": [
"10715",
"16435"
],
"CVE-2010-0249": [
"11167",
"16599"
],
"CVE-2009-3958": [
"11172"
],
"CVE-2010-0013": [
"11203"
],
"CVE-2010-0679": [
"11422",
"16500"
],
"CVE-2008-5517": [
"11497"
],
"CVE-2010-0483": [
"11615",
"16541"
],
"CVE-2010-0425": [
"11650"
],
"CVE-2010-1132": [
"11662"
],
"CVE-2010-0806": [
"11683",
"16590"
],
"CVE-2010-1185": [
"11886"
],
"CVE-2009-4178": [
"11974",
"16792"
],
"CVE-2010-1147": [
"11986"
],
"CVE-2010-1465": [
"12152",
"16710"
],
"CVE-2007-6493": [
"12244",
"30897"
],
"CVE-2010-0432": [
"12263",
"12264",
"12330"
],
"CVE-2009-4535": [
"12309",
"9897"
],
"CVE-2010-0356": [
"12320",
"18134"
],
"CVE-2010-1157": [
"12343"
],
"CVE-2010-1939": [
"12573",
"12614"
],
"CVE-2010-1663": [
"12657"
],
"CVE-2010-2307": [
"12865"
],
"CVE-2010-2309": [
"13735",
"14254",
"16864",
"16874"
],
"CVE-2010-1885": [
"13808",
"16545"
],
"CVE-2010-2266": [
"13818"
],
"CVE-2010-2263": [
"13818",
"13822"
],
"CVE-2010-2305": [
"13834"
],
"CVE-2010-2333": [
"13850"
],
"CVE-2010-2075": [
"13853",
"16922"
],
"CVE-2010-2331": [
"13903"
],
"CVE-2010-2620": [
"13932",
"27401",
"27556"
],
"CVE-2010-1870": [
"14360",
"17691"
],
"CVE-2007-2983": [
"30100"
],
"CVE-2010-2731": [
"14179"
],
"CVE-2010-1553": [
"14180",
"17042"
],
"CVE-2010-1554": [
"14181",
"17040"
],
"CVE-2010-1555": [
"14182",
"17047"
],
"CVE-2010-0361": [
"14194",
"14287",
"16314"
],
"CVE-2010-2627": [
"14267"
],
"CVE-2010-2701": [
"14269",
"14539"
],
"CVE-2010-1039": [
"14407"
],
"CVE-2010-3187": [
"14409",
"14456"
],
"CVE-2010-2931": [
"14514"
],
"CVE-2010-2860": [
"14536"
],
"CVE-2010-2861": [
"14641",
"16985"
],
"CVE-2009-2532": [
"14674",
"40280"
],
"CVE-2009-2526": [
"14674",
"40280"
],
"CVE-2010-0265": [
"14886"
],
"CVE-2010-3306": [
"14925"
],
"CVE-2010-1527": [
"15042",
"15072"
],
"CVE-2010-3407": [
"15005",
"17151"
],
"CVE-2010-3486": [
"15048",
"15189",
"16955"
],
"CVE-2010-0838": [
"15056"
],
"CVE-2010-3106": [
"15073",
"16492"
],
"CVE-2010-3189": [
"15168"
],
"CVE-2010-3332": [
"15213",
"15265",
"15292"
],
"CVE-2010-3552": [
"15241",
"16587"
],
"CVE-2010-0231": [
"15266"
],
"CVE-2010-3573": [
"15288"
],
"CVE-2010-3653": [
"15296",
"16594"
],
"CVE-2010-4099": [
"15318",
"34932"
],
"CVE-2010-4181": [
"15371"
],
"CVE-2010-1807": [
"15423",
"15548"
],
"CVE-2010-4221": [
"15449",
"16851",
"16878"
],
"CVE-2010-4231": [
"15505"
],
"CVE-2010-4107": [
"15631",
"17635",
"17636",
"32990"
],
"CVE-2010-5194": [
"15658",
"18123"
],
"CVE-2010-5193": [
"15668",
"18123"
],
"CVE-2010-4297": [
"15717"
],
"CVE-2010-4344": [
"15725",
"16925"
],
"CVE-2010-2590": [
"15733",
"23472"
],
"CVE-2010-4598": [
"15802"
],
"CVE-2010-4566": [
"15806",
"16916"
],
"CVE-2010-4588": [
"15809"
],
"CVE-2010-3973": [
"15809",
"16516"
],
"CVE-2010-5301": [
"15834"
],
"CVE-2010-0219": [
"15869",
"16312",
"16315"
],
"CVE-2011-4779": [
"18245"
],
"CVE-2011-4644": [
"18245"
],
"CVE-2011-4643": [
"18245"
],
"CVE-2011-4642": [
"18245"
],
"CVE-2010-3749": [
"15991"
],
"CVE-2011-0406": [
"15957"
],
"CVE-2011-0404": [
"15937",
"16838"
],
"CVE-2011-0887": [
"16123"
],
"CVE-2011-0886": [
"16123"
],
"CVE-2011-0885": [
"16123"
],
"CVE-2010-2746": [
"15963"
],
"CVE-2011-0027": [
"15984"
],
"CVE-2010-4321": [
"16014",
"16956"
],
"CVE-2006-6576": [
"16036",
"17355",
"49629"
],
"CVE-2011-0902": [
"16041"
],
"CVE-2010-3599": [
"16052"
],
"CVE-2010-3591": [
"16053",
"16055"
],
"CVE-2010-3595": [
"16056"
],
"CVE-2011-0354": [
"16100"
],
"CVE-2011-0063": [
"16103"
],
"CVE-2011-0049": [
"16103"
],
"CVE-2010-4435": [
"16137"
],
"CVE-2009-3867": [
"16294",
"33315",
"33316"
],
"CVE-2010-0840": [
"16297"
],
"CVE-2009-3869": [
"16298"
],
"CVE-2010-0094": [
"16305"
],
"CVE-2010-0738": [
"16316",
"16319",
"16274",
"17924"
],
"CVE-2010-4094": [
"16317"
],
"CVE-2010-0557": [
"16317"
],
"CVE-2009-4189": [
"16317"
],
"CVE-2009-4188": [
"16317",
"33211"
],
"CVE-2009-3843": [
"16317"
],
"CVE-2009-3548": [
"16317",
"31433"
],
"CVE-2007-1036": [
"16318",
"21080"
],
"CVE-2007-2447": [
"16320"
],
"CVE-2005-0773": [
"16332"
],
"CVE-2010-0478": [
"16333"
],
"CVE-2008-5159": [
"16335",
"31106"
],
"CVE-2003-1141": [
"16336"
],
"CVE-2005-1815": [
"16337"
],
"CVE-2001-0499": [
"16340",
"20980"
],
"CVE-2002-0965": [
"16341"
],
"CVE-2008-5444": [
"16343"
],
"CVE-2007-1435": [
"16345",
"29735"
],
"CVE-2002-2226": [
"16349",
"22025"
],
"CVE-2004-1134": [
"16354"
],
"CVE-2000-1089": [
"16357",
"20460"
],
"CVE-2005-4734": [
"16358"
],
"CVE-2010-2729": [
"16361"
],
"CVE-2006-4688": [
"16369",
"16373"
],
"CVE-2009-1394": [
"16370"
],
"CVE-1999-0504": [
"16374"
],
"CVE-2009-1350": [
"16376"
],
"CVE-2010-4741": [
"16381"
],
"CVE-2008-4322": [
"16385"
],
"CVE-2006-5972": [
"16388"
],
"CVE-2010-0103": [
"16390"
],
"CVE-2008-2158": [
"16391"
],
"CVE-2002-0649": [
"16393",
"21652"
],
"CVE-2000-1209": [
"16394",
"16395"
],
"CVE-2000-0402": [
"16394",
"16395"
],
"CVE-2005-4145": [
"16397"
],
"CVE-2002-1123": [
"16398",
"21693"
],
"CVE-2008-4397": [
"16404"
],
"CVE-2005-1018": [
"16405"
],
"CVE-2005-0260": [
"16406"
],
"CVE-2006-6076": [
"16407"
],
"CVE-2007-3216": [
"16409",
"16415",
"16416"
],
"CVE-2007-4620": [
"16410"
],
"CVE-2007-5003": [
"16411"
],
"CVE-2007-2139": [
"16413"
],
"CVE-2007-0169": [
"16418"
],
"CVE-2009-3853": [
"16421"
],
"CVE-2008-4828": [
"16428"
],
"CVE-2007-3872": [
"16429"
],
"CVE-2008-0311": [
"16434"
],
"CVE-2007-3566": [
"16453"
],
"CVE-2007-2280": [
"16455"
],
"CVE-2007-1674": [
"16457",
"29853"
],
"CVE-2001-0333": [
"16467",
"20835",
"20836",
"20837",
"20838",
"20839",
"20840",
"20841",
"20842"
],
"CVE-1999-0874": [
"16468",
"19245",
"19246",
"19247",
"19248"
],
"CVE-2006-6761": [
"16478"
],
"CVE-2005-3314": [
"16483"
],
"CVE-2005-2278": [
"16485"
],
"CVE-2006-6425": [
"16488"
],
"CVE-2001-0167": [
"16489"
],
"CVE-2006-1652": [
"16490",
"27568",
"27569"
],
"CVE-2001-0168": [
"16491"
],
"CVE-2008-4830": [
"16493"
],
"CVE-2010-3563": [
"16495"
],
"CVE-2007-5217": [
"16496"
],
"CVE-2007-5601": [
"16497",
"30692"
],
"CVE-2008-2908": [
"16508"
],
"CVE-2006-3961": [
"16510"
],
"CVE-2007-2918": [
"16511"
],
"CVE-2008-4388": [
"16512"
],
"CVE-2008-0935": [
"16514"
],
"CVE-2009-0215": [
"16517"
],
"CVE-2009-1568": [
"16523"
],
"CVE-2009-3033": [
"16528"
],
"CVE-2007-0348": [
"16529"
],
"CVE-2007-0325": [
"16535"
],
"CVE-2009-1534": [
"16542"
],
"CVE-2009-1569": [
"16543"
],
"CVE-2009-3672": [
"16547"
],
"CVE-2006-1016": [
"16549"
],
"CVE-2008-4385": [
"16552"
],
"CVE-2006-5650": [
"16554",
"28916"
],
"CVE-2010-1799": [
"16558"
],
"CVE-2007-1559": [
"16559",
"29840"
],
"CVE-2006-4704": [
"16561"
],
"CVE-2006-2086": [
"16568"
],
"CVE-2009-4850": [
"16570"
],
"CVE-2008-4384": [
"16571"
],
"CVE-2007-5660": [
"16573",
"16602"
],
"CVE-2007-4475": [
"16575",
"32879"
],
"CVE-2007-1682": [
"16592"
],
"CVE-2004-0363": [
"16595"
],
"CVE-2009-3028": [
"16600"
],
"CVE-2007-2919": [
"16601"
],
"CVE-2006-5198": [
"16607"
],
"CVE-2007-2238": [
"16608"
],
"CVE-2007-4466": [
"16609"
],
"CVE-2007-1689": [
"16610"
],
"CVE-2008-0065": [
"16611"
],
"CVE-2005-4560": [
"16612"
],
"CVE-2009-4225": [
"16630"
],
"CVE-2016-6816": [
"41783",
"41783"
],
"CVE-2010-4742": [
"16685"
],
"CVE-2008-2499": [
"16696",
"31820"
],
"CVE-2008-2240": [
"16697"
],
"CVE-2010-0266": [
"16699",
"16700"
],
"CVE-2006-2212": [
"16702"
],
"CVE-1999-0256": [
"16706",
"16724"
],
"CVE-2006-5792": [
"16718",
"16722"
],
"CVE-2005-2373": [
"16729"
],
"CVE-2009-4769": [
"16732",
"16794"
],
"CVE-2006-0992": [
"16757"
],
"CVE-2006-4305": [
"16765"
],
"CVE-2005-2297": [
"16766"
],
"CVE-2006-5478": [
"16773",
"28835",
"28836",
"28837"
],
"CVE-2009-4006": [
"16775"
],
"CVE-2009-3849": [
"16780"
],
"CVE-2002-0392": [
"16782",
"21559",
"21560"
],
"CVE-2010-5324": [
"16784"
],
"CVE-2010-5323": [
"16784"
],
"CVE-2009-3068": [
"16789",
"33209"
],
"CVE-2005-0684": [
"16791"
],
"CVE-2008-0067": [
"16795"
],
"CVE-2008-4008": [
"16796"
],
"CVE-2008-0550": [
"16800"
],
"CVE-2002-2268": [
"16802",
"16970"
],
"CVE-2007-1868": [
"16810"
],
"CVE-2005-0478": [
"16811"
],
"CVE-2006-6424": [
"16813"
],
"CVE-2000-0665": [
"16816"
],
"CVE-2001-1320": [
"16823"
],
"CVE-2005-2668": [
"16825"
],
"CVE-2009-1430": [
"16826"
],
"CVE-2007-2508": [
"16828",
"16829",
"29964"
],
"CVE-2006-2630": [
"16830"
],
"CVE-2009-1943": [
"16831"
],
"CVE-2005-2852": [
"16832"
],
"CVE-2007-5208": [
"16837"
],
"CVE-2009-4484": [
"16850"
],
"CVE-2010-2063": [
"16860"
],
"CVE-2006-0848": [
"16866"
],
"CVE-2007-5863": [
"16867"
],
"CVE-2007-6165": [
"16870",
"30781"
],
"CVE-2007-2386": [
"16871"
],
"CVE-2003-0990": [
"16888"
],
"CVE-2009-4098": [
"16903"
],
"CVE-2010-3585": [
"16915"
],
"CVE-2009-4502": [
"16918",
"10431"
],
"CVE-2010-4345": [
"16925"
],
"CVE-2009-2727": [
"16930"
],
"CVE-2011-3142": [
"16936"
],
"CVE-2010-1119": [
"16974"
],
"CVE-2011-0276": [
"16984"
],
"CVE-2010-4452": [
"16990"
],
"CVE-2010-3747": [
"16998"
],
"CVE-2011-1568": [
"17024"
],
"CVE-2011-1567": [
"17024",
"17300",
"17374"
],
"CVE-2011-1566": [
"17024",
"29129"
],
"CVE-2011-1565": [
"17024"
],
"CVE-2011-0609": [
"17027"
],
"CVE-2011-0266": [
"17028"
],
"CVE-2010-2709": [
"17029",
"14547"
],
"CVE-2011-2963": [
"17034"
],
"CVE-2011-0267": [
"17038"
],
"CVE-2010-1552": [
"17039"
],
"CVE-2010-1960": [
"17043"
],
"CVE-2010-1961": [
"17044"
],
"CVE-2010-3275": [
"17048"
],
"CVE-2011-0364": [
"17155"
],
"CVE-2010-0620": [
"17219"
],
"CVE-2011-2089": [
"17240",
"17269"
],
"CVE-2011-1574": [
"17252"
],
"CVE-2011-0966": [
"17304",
"35781"
],
"CVE-2011-0962": [
"17304",
"35780"
],
"CVE-2011-0961": [
"17304",
"35779"
],
"CVE-2011-0960": [
"17304"
],
"CVE-2011-0959": [
"17304",
"35762",
"35763",
"35764",
"35765",
"35766"
],
"CVE-2011-0922": [
"17345",
"19288",
"27271"
],
"CVE-2011-0923": [
"17339",
"17614",
"17648",
"18521",
"27400"
],
"CVE-2013-0657": [
"17352",
"45218"
],
"CVE-2011-2039": [
"17366"
],
"CVE-2011-1220": [
"17392"
],
"CVE-2011-1260": [
"17409"
],
"CVE-2011-0073": [
"17419",
"17520"
],
"CVE-2011-4716": [
"17422",
"18079",
"36286"
],
"CVE-2011-1213": [
"17448"
],
"CVE-2011-5124": [
"17513"
],
"CVE-2011-0546": [
"17517"
],
"CVE-2011-3556": [
"17535"
],
"CVE-2009-0920": [
"17537"
],
"CVE-2011-0065": [
"17612",
"17650",
"17672",
"18377"
],
"CVE-1999-1510": [
"17649",
"17810",
"19219"
],
"CVE-2011-2404": [
"17697"
],
"CVE-2011-2882": [
"17762"
],
"CVE-2011-3322": [
"17827"
],
"CVE-2011-2950": [
"17849"
],
"CVE-2011-3976": [
"17876",
"17904",
"17948"
],
"CVE-2011-5127": [
"17883"
],
"CVE-2011-2628": [
"17936"
],
"CVE-2011-3368": [
"17969"
],
"CVE-2011-2371": [
"17974",
"17976",
"18531"
],
"CVE-2011-3230": [
"17986"
],
"CVE-2011-1774": [
"17993"
],
"CVE-2011-1425": [
"17993"
],
"CVE-2009-3999": [
"18015"
],
"CVE-2011-5167": [
"18092"
],
"CVE-2007-4517": [
"18093"
],
"CVE-2011-5164": [
"18102"
],
"CVE-2011-3360": [
"18125"
],
"CVE-2011-4404": [
"18138"
],
"CVE-2009-1523": [
"18138",
"36318"
],
"CVE-2011-3544": [
"18171"
],
"CVE-2011-5010": [
"18172"
],
"CVE-2011-1519": [
"18179"
],
"CVE-2011-0920": [
"18179"
],
"CVE-2011-4800": [
"18182"
],
"CVE-2011-5003": [
"18183"
],
"CVE-2011-5007": [
"18187",
"18240"
],
"CVE-2011-4722": [
"18189"
],
"CVE-2011-4717": [
"18235"
],
"CVE-2011-4862": [
"18280",
"18368",
"18369"
],
"CVE-2011-5052": [
"18283"
],
"CVE-2011-5053": [
"18291"
],
"CVE-2012-0391": [
"18984",
"18329"
],
"CVE-2005-1790": [
"18365"
],
"CVE-2011-4786": [
"18381"
],
"CVE-2012-6530": [
"18382",
"18420"
],
"CVE-2011-3167": [
"18388"
],
"CVE-2011-4789": [
"18423"
],
"CVE-2012-0003": [
"18426"
],
"CVE-2011-2140": [
"18437",
"18479"
],
"CVE-2012-0053": [
"18442"
],
"CVE-2010-2300": [
"18446"
],
"CVE-2010-1759": [
"18446"
],
"CVE-2010-0842": [
"18485"
],
"CVE-2012-0209": [
"18492"
],
"CVE-2012-0500": [
"18520"
],
"CVE-2011-5001": [
"18514"
],
"CVE-2012-4924": [
"18538"
],
"CVE-2012-0201": [
"18539"
],
"CVE-2012-1466": [
"18542"
],
"CVE-2012-1464": [
"18543"
],
"CVE-2012-4992": [
"18555"
],
"CVE-2012-0754": [
"18572"
],
"CVE-2012-5335": [
"18610"
],
"CVE-2012-1195": [
"18622",
"18714"
],
"CVE-2012-1196": [
"18623",
"18714"
],
"CVE-2012-1065": [
"18625"
],
"CVE-2010-0248": [
"18642"
],
"CVE-2008-0610": [
"18666"
],
"CVE-2012-5897": [
"18672"
],
"CVE-2012-5306": [
"18673"
],
"CVE-2012-5896": [
"18674",
"18735"
],
"CVE-2012-4876": [
"18675",
"18709"
],
"CVE-2012-0507": [
"18679"
],
"CVE-2012-0198": [
"18727"
],
"CVE-2011-4828": [
"18738"
],
"CVE-2008-5499": [
"18761"
],
"CVE-2012-0158": [
"18780"
],
"CVE-2012-2441": [
"18779"
],
"CVE-2012-1803": [
"18779"
],
"CVE-2012-4598": [
"18805",
"18812"
],
"CVE-2012-2576": [
"18818"
],
"CVE-2012-1775": [
"18825"
],
"CVE-2012-2336": [
"18834",
"18836",
"29290",
"29316"
],
"CVE-2012-2311": [
"18834",
"18836",
"29290",
"29316"
],
"CVE-2012-1823": [
"18834",
"18836",
"29290",
"29316"
],
"CVE-2011-3658": [
"18847"
],
"CVE-2011-3659": [
"18870"
],
"CVE-2012-4362": [
"18893",
"18901"
],
"CVE-2012-4361": [
"18893",
"18901"
],
"CVE-2012-2986": [
"18893",
"18901"
],
"CVE-2012-6554": [
"18898"
],
"CVE-2012-0297": [
"18942",
"18932",
"19065",
"19406"
],
"CVE-2002-1142": [
"19026"
],
"CVE-2011-3400": [
"19002"
],
"CVE-2011-2217": [
"19030"
],
"CVE-1999-0095": [
"19028"
],
"CVE-1999-1504": [
"19047"
],
"CVE-1999-1113": [
"19069"
],
"CVE-1999-1555": [
"19083"
],
"CVE-1999-0268": [
"19084"
],
"CVE-1999-0368": [
"19086",
"19087"
],
"CVE-2012-2122": [
"19092"
],
"CVE-1999-0477": [
"19093"
],
"CVE-1999-0455": [
"19093"
],
"CVE-1999-0487": [
"19094"
],
"CVE-1999-0002": [
"19096"
],
"CVE-1999-0003": [
"19101",
"19102"
],
"CVE-1999-0018": [
"19104"
],
"CVE-1999-0021": [
"19105"
],
"CVE-1999-0005": [
"19107"
],
"CVE-1999-0006": [
"19109",
"19110"
],
"CVE-1999-0009": [
"19111",
"19112"
],
"CVE-1999-0278": [
"19118"
],
"CVE-1999-1437": [
"19120"
],
"CVE-1999-1436": [
"19121"
],
"CVE-1999-1433": [
"19124"
],
"CVE-1999-0736": [
"19129"
],
"CVE-2012-1875": [
"19141"
],
"CVE-1999-1538": [
"19147"
],
"CVE-1999-0448": [
"19149"
],
"CVE-1999-0450": [
"19152"
],
"CVE-1999-0347": [
"19156"
],
"CVE-1999-1453": [
"19164"
],
"CVE-2012-1889": [
"19186"
],
"CVE-1999-0800": [
"19193"
],
"CVE-1999-1375": [
"19194"
],
"CVE-1999-1520": [
"19208"
],
"CVE-1999-0219": [
"19218"
],
"CVE-1999-0928": [
"19221"
],
"CVE-1999-0927": [
"19222"
],
"CVE-1999-0887": [
"19223"
],
"CVE-1999-0920": [
"19226"
],
"CVE-2012-2329": [
"19231"
],
"CVE-1999-1413": [
"19236"
],
"CVE-1999-1063": [
"19242"
],
"CVE-1999-1024": [
"19251"
],
"CVE-1999-0678": [
"19253"
],
"CVE-2011-2110": [
"19295"
],
"CVE-2008-4192": [
"19295"
],
"CVE-1999-1509": [
"19601"
],
"CVE-1999-1488": [
"19297"
],
"CVE-1999-0149": [
"19298"
],
"CVE-1999-0039": [
"19299"
],
"CVE-1999-0148": [
"19303"
],
"CVE-1999-1485": [
"19316"
],
"CVE-1999-0493": [
"19327"
],
"CVE-1999-0113": [
"19348"
],
"CVE-2011-3478": [
"19407",
"38599"
],
"CVE-1999-0725": [
"19361"
],
"CVE-1999-0239": [
"19363"
],
"CVE-1999-0470": [
"19364"
],
"CVE-1999-1020": [
"19365"
],
"CVE-2012-0779": [
"19369"
],
"CVE-1999-0696": [
"19420",
"19421"
],
"CVE-2000-0325": [
"19435"
],
"CVE-1999-1130": [
"19443"
],
"CVE-1999-0913": [
"19444"
],
"CVE-1999-0671": [
"19448"
],
"CVE-1999-0672": [
"19449"
],
"CVE-1999-0673": [
"19450"
],
"CVE-1999-0875": [
"19451"
],
"CVE-1999-0426": [
"19458"
],
"CVE-1999-0414": [
"19458"
],
"CVE-1999-0679": [
"19459"
],
"CVE-1999-0753": [
"19466"
],
"CVE-1999-0668": [
"19468"
],
"CVE-1999-0911": [
"19475",
"19476"
],
"CVE-1999-0704": [
"19478",
"19479"
],
"CVE-2012-0124": [
"19484"
],
"CVE-1999-0685": [
"19486"
],
"CVE-1999-0669": [
"19487"
],
"CVE-1999-0702": [
"19490"
],
"CVE-1999-0750": [
"19492"
],
"CVE-1999-0751": [
"19493"
],
"CVE-1999-1521": [
"19495"
],
"CVE-1999-0759": [
"19496"
],
"CVE-2000-0824": [
"19503"
],
"CVE-1999-1576": [
"19514"
],
"CVE-1999-1577": [
"19521"
],
"CVE-2004-0641": [
"19522"
],
"CVE-2002-1463": [
"19522"
],
"CVE-2001-1104": [
"19522"
],
"CVE-2001-0751": [
"19522"
],
"CVE-2001-0328": [
"19522"
],
"CVE-2001-0288": [
"19522"
],
"CVE-2001-0163": [
"19522"
],
"CVE-2001-0162": [
"19522"
],
"CVE-2000-0916": [
"19522"
],
"CVE-1999-0077": [
"19522"
],
"CVE-1999-0891": [
"19530"
],
"CVE-1999-0789": [
"19532"
],
"CVE-1999-0933": [
"19537"
],
"CVE-1999-0791": [
"19538"
],
"CVE-1999-0877": [
"19539"
],
"CVE-1999-1083": [
"19540"
],
"CVE-1999-1082": [
"19540"
],
"CVE-1999-0068": [
"19553"
],
"CVE-1999-0060": [
"19554",
"19555"
],
"CVE-1999-0066": [
"19557"
],
"CVE-1999-0943": [
"19558"
],
"CVE-1999-0793": [
"19559"
],
"CVE-1999-0879": [
"19560"
],
"CVE-2000-0016": [
"19561"
],
"CVE-1999-0951": [
"19566"
],
"CVE-1999-1481": [
"19567"
],
"CVE-1999-0915": [
"19568"
],
"CVE-2012-0708": [
"19576"
],
"CVE-1999-0873": [
"19584"
],
"CVE-1999-0947": [
"19587"
],
"CVE-1999-1531": [
"19588"
],
"CVE-1999-0981": [
"19591"
],
"CVE-1999-0896": [
"19592",
"19593"
],
"CVE-1999-0885": [
"19595"
],
"CVE-2000-0329": [
"19603"
],
"CVE-2010-3964": [
"20122"
],
"CVE-2000-0381": [
"19903"
],
"CVE-2000-0330": [
"19607",
"19608"
],
"CVE-2000-1116": [
"19611"
],
"CVE-2001-0679": [
"19612",
"19614"
],
"CVE-1999-1529": [
"19612",
"19614"
],
"CVE-1999-1110": [
"19618"
],
"CVE-1999-1050": [
"19620"
],
"CVE-1999-1190": [
"19621"
],
"CVE-1999-1508": [
"19632"
],
"CVE-2000-0165": [
"19634"
],
"CVE-1999-0842": [
"19644"
],
"CVE-1999-0822": [
"19645",
"19646"
],
"CVE-1999-0869": [
"19662"
],
"CVE-1999-0973": [
"19663"
],
"CVE-1999-0972": [
"19667"
],
"CVE-1999-0996": [
"19679"
],
"CVE-2000-0026": [
"19680"
],
"CVE-1999-1005": [
"19682"
],
"CVE-2000-0028": [
"19686"
],
"CVE-2000-0002": [
"19688",
"19689"
],
"CVE-2000-0038": [
"19690"
],
"CVE-2000-0010": [
"19691"
],
"CVE-2000-0039": [
"19694"
],
"CVE-2000-0012": [
"19696"
],
"CVE-2000-0059": [
"19708"
],
"CVE-2000-0057": [
"19712"
],
"CVE-2000-0054": [
"19713"
],
"CVE-2016-2098": [
"40086"
],
"CVE-2012-1723": [
"19717"
],
"CVE-2011-2657": [
"19718"
],
"CVE-2000-0156": [
"19719"
],
"CVE-2000-0061": [
"19719"
],
"CVE-2000-1221": [
"19722"
],
"CVE-2000-0046": [
"19724"
],
"CVE-2000-0096": [
"19729"
],
"CVE-2000-0065": [
"19730"
],
"CVE-2000-0097": [
"19731"
],
"CVE-2000-0116": [
"19732"
],
"CVE-2000-0132": [
"19734"
],
"CVE-2000-0347": [
"19889"
],
"CVE-2000-0133": [
"19737"
],
"CVE-2000-0653": [
"19738"
],
"CVE-2000-0105": [
"19738"
],
"CVE-2000-0125": [
"19741"
],
"CVE-2000-0126": [
"19742"
],
"CVE-2000-0129": [
"19743"
],
"CVE-2000-0128": [
"19745"
],
"CVE-2000-0149": [
"19747"
],
"CVE-1999-0386": [
"19753"
],
"CVE-2000-0213": [
"19761"
],
"CVE-2000-0187": [
"19781",
"659"
],
"CVE-2000-0191": [
"19784"
],
"CVE-2000-0208": [
"19785"
],
"CVE-2000-0177": [
"19786"
],
"CVE-2000-0207": [
"19788"
],
"CVE-2000-0302": [
"19830"
],
"CVE-2000-0192": [
"19795"
],
"CVE-2000-0174": [
"19797"
],
"CVE-2000-0183": [
"19801"
],
"CVE-2000-0185": [
"19805"
],
"CVE-2000-0180": [
"19808"
],
"CVE-2000-0169": [
"19809"
],
"CVE-2000-0236": [
"19814"
],
"CVE-2000-0240": [
"19815"
],
"CVE-2000-0242": [
"19819"
],
"CVE-2000-0245": [
"19822"
],
"CVE-2000-0246": [
"19824"
],
"CVE-2000-0234": [
"19828"
],
"CVE-2000-0282": [
"19842"
],
"CVE-2000-0287": [
"19844"
],
"CVE-2000-0260": [
"19845",
"19846"
],
"CVE-2000-0254": [
"19852"
],
"CVE-2000-0412": [
"19905"
],
"CVE-2000-0295": [
"19868"
],
"CVE-2000-0339": [
"19871"
],
"CVE-2000-0248": [
"19879",
"16858"
],
"CVE-2000-0429": [
"19881"
],
"CVE-2000-0380": [
"19882"
],
"CVE-2000-0343": [
"19886",
"19887",
"19888"
],
"CVE-2000-0332": [
"19890"
],
"CVE-2000-0333": [
"19891",
"19892"
],
"CVE-2000-0425": [
"19893"
],
"CVE-2000-0423": [
"19895"
],
"CVE-2000-0413": [
"19897"
],
"CVE-2000-0379": [
"19901"
],
"CVE-2000-0411": [
"19906"
],
"CVE-2000-0457": [
"19908"
],
"CVE-2001-0329": [
"19909"
],
"CVE-2000-0424": [
"19913"
],
"CVE-2000-0397": [
"19914"
],
"CVE-2000-0405": [
"19916",
"19917",
"19918"
],
"CVE-2000-0432": [
"19921"
],
"CVE-2000-0350": [
"19922"
],
"CVE-2000-0400": [
"19928"
],
"CVE-2000-0446": [
"19966"
],
"CVE-2000-0465": [
"19939"
],
"CVE-2000-0451": [
"19943"
],
"CVE-2000-1046": [
"19944"
],
"CVE-2000-0452": [
"19944"
],
"CVE-2000-0436": [
"19945"
],
"CVE-2000-0491": [
"19947",
"19948"
],
"CVE-2000-0437 ": [
"19949"
],
"CVE-2000-0136": [
"19951"
],
"CVE-2000-0443": [
"19956"
],
"CVE-2000-0396": [
"19957"
],
"CVE-2011-3176": [
"19958",
"19959"
],
"CVE-2011-3175": [
"19958",
"19959"
],
"CVE-2000-0505": [
"19975"
],
"CVE-2000-0507": [
"19976"
],
"CVE-2000-0493": [
"19978"
],
"CVE-2000-0490": [
"19983"
],
"CVE-2000-0521": [
"19995"
],
"CVE-2000-0523": [
"19997"
],
"CVE-2000-0472": [
"19998"
],
"CVE-2000-0527": [
"20007"
],
"CVE-2000-0526": [
"20008"
],
"CVE-2012-2593": [
"20009"
],
"CVE-2000-0430": [
"20019"
],
"CVE-2000-0500": [
"20027"
],
"CVE-2000-0592": [
"20040"
],
"CVE-2000-0588": [
"20041"
],
"CVE-2000-0586": [
"20043"
],
"CVE-2000-0577": [
"20046"
],
"CVE-2000-0580": [
"20048"
],
"CVE-2000-0590": [
"20059"
],
"CVE-2000-0594": [
"20060"
],
"CVE-2000-0584": [
"20061"
],
"CVE-2000-0640": [
"20065"
],
"CVE-2000-0641": [
"20066"
],
"CVE-2000-0613": [
"20067"
],
"CVE-2000-0638": [
"20068"
],
"CVE-2000-0660 ": [
"20070"
],
"CVE-2000-0675": [
"20074"
],
"CVE-2000-0666": [
"20075",
"20076",
"20077"
],
"CVE-2000-0567": [
"20078",
"20079"
],
"CVE-2000-0622": [
"20086"
],
"CVE-2012-2953": [
"20088",
"20113"
],
"CVE-2000-0630": [
"20089"
],
"CVE-2000-0634": [
"20091"
],
"CVE-2000-0649": [
"20096"
],
"CVE-2000-0652": [
"20097"
],
"CVE-2000-0664": [
"20103"
],
"CVE-2000-0671": [
"20104"
],
"CVE-2000-0668": [
"20105"
],
"CVE-2000-0673": [
"20106"
],
"CVE-2000-0757": [
"20145"
],
"CVE-2000-0685": [
"20125"
],
"CVE-2000-0759": [
"20131"
],
"CVE-2000-0760": [
"20132"
],
"CVE-2000-0740": [
"20134"
],
"CVE-2000-0739": [
"20135"
],
"CVE-2000-0741": [
"20136"
],
"CVE-2000-0711": [
"20139"
],
"CVE-2000-0676": [
"20140"
],
"CVE-2000-0705": [
"20143"
],
"CVE-2000-0696": [
"20144"
],
"CVE-2000-0697": [
"20146"
],
"CVE-2000-0776": [
"20148"
],
"CVE-2000-0733": [
"20149"
],
"CVE-2000-0706": [
"20150"
],
"CVE-2000-0778": [
"20151",
"20152"
],
"CVE-2000-0782": [
"20156"
],
"CVE-2000-0743": [
"20157"
],
"CVE-2000-0846": [
"20159"
],
"CVE-2000-0787": [
"20161"
],
"CVE-2000-0704": [
"20163"
],
"CVE-2000-0689": [
"20164",
"20165"
],
"CVE-2012-1876": [
"20174",
"24017",
"33944",
"34815",
"35273"
],
"CVE-2000-0688": [
"20176",
"20177"
],
"CVE-2000-0775": [
"20180"
],
"CVE-2000-0780": [
"20182"
],
"CVE-2000-0720": [
"20183"
],
"CVE-2000-0734": [
"20184"
],
"CVE-2000-0690": [
"20194"
],
"CVE-2012-2962": [
"20204",
"20033"
],
"CVE-2000-0903": [
"20206"
],
"CVE-2000-0904": [
"20207"
],
"CVE-2000-0869": [
"20210"
],
"CVE-2000-0828": [
"20211"
],
"CVE-2000-1037": [
"20215",
"20216"
],
"CVE-2000-0853": [
"20218"
],
"CVE-2000-0883": [
"20220"
],
"CVE-2000-0834": [
"20222"
],
"CVE-2000-0835": [
"20223"
],
"CVE-2000-0836": [
"20224"
],
"CVE-2000-1022": [
"20231"
],
"CVE-2000-1036": [
"20234"
],
"CVE-2000-1054": [
"20235"
],
"CVE-2000-1016": [
"20236"
],
"CVE-2000-0909": [
"20237"
],
"CVE-2000-1023": [
"20238"
],
"CVE-2000-0929": [
"20240"
],
"CVE-2000-1014": [
"20242"
],
"CVE-2001-0149": [
"20243"
],
"CVE-2000-0926": [
"20247"
],
"CVE-2000-0925": [
"20248"
],
"CVE-2000-0930": [
"20249"
],
"CVE-2000-0992": [
"20253"
],
"CVE-1999-0208": [
"20258",
"20259"
],
"CVE-2000-1061": [
"20266"
],
"CVE-2000-0951": [
"20269"
],
"CVE-2000-0906": [
"20273"
],
"CVE-2000-0924": [
"20277"
],
"CVE-2000-1005": [
"20279"
],
"CVE-2000-0922": [
"20280"
],
"CVE-2000-0921": [
"20281"
],
"CVE-2000-0979": [
"20283",
"20284"
],
"CVE-2000-0985": [
"20287"
],
"CVE-2000-0973": [
"20292",
"20293"
],
"CVE-2012-0549": [
"20297"
],
"CVE-2000-0977": [
"20303"
],
"CVE-1999-0360": [
"20305"
],
"CVE-1999-0182": [
"20308"
],
"CVE-1999-0191": [
"20309"
],
"CVE-2000-1050": [
"20313"
],
"CVE-2000-1053": [
"20314"
],
"CVE-2012-4177": [
"20321"
],
"CVE-2000-0958": [
"20322"
],
"CVE-2000-1075": [
"20324",
"20325"
],
"CVE-1999-0492": [
"20327"
],
"CVE-2000-0945": [
"20330"
],
"CVE-2000-1033": [
"20334"
],
"CVE-2000-0942": [
"20335"
],
"CVE-2000-1026": [
"20337"
],
"CVE-2000-0937": [
"20340"
],
"CVE-2012-3951": [
"20355"
],
"CVE-2000-1027": [
"20369"
],
"CVE-2000-0941": [
"20370"
],
"CVE-2000-0955": [
"20372"
],
"CVE-2000-1029": [
"20374"
],
"CVE-1999-0283": [
"20375"
],
"CVE-2000-0886": [
"20384"
],
"CVE-2000-1176": [
"20387"
],
"CVE-2009-1730": [
"20392"
],
"CVE-1999-0968": [
"20394",
"20395"
],
"CVE-2000-1105": [
"20399"
],
"CVE-2000-1154": [
"20404"
],
"CVE-2000-1132": [
"20405"
],
"CVE-2000-1181": [
"20406"
],
"CVE-2000-1171": [
"20408"
],
"CVE-2000-1114": [
"20412"
],
"CVE-2000-1177": [
"20413"
],
"CVE-2000-1174": [
"20414"
],
"CVE-2000-1112": [
"20424"
],
"CVE-1999-0146": [
"20423"
],
"CVE-2000-1173": [
"20425"
],
"CVE-2000-1113": [
"20427"
],
"CVE-2000-1224": [
"20429"
],
"CVE-1999-0266": [
"20430"
],
"CVE-1999-0985": [
"20433"
],
"CVE-1999-0264": [
"20434"
],
"CVE-1999-0070": [
"20435"
],
"CVE-2000-1110": [
"20441"
],
"CVE-1999-0935": [
"20442"
],
"CVE-1999-0934": [
"20444"
],
"CVE-1999-0233": [
"20445"
],
"CVE-1999-0467": [
"20446",
"20447"
],
"CVE-1999-0287": [
"20446",
"20447"
],
"CVE-1999-0175": [
"20448"
],
"CVE-1999-0147": [
"20449"
],
"CVE-2000-1100": [
"20450"
],
"CVE-2001-0089": [
"20459"
],
"CVE-2001-0054": [
"20461"
],
"CVE-1999-0262": [
"20462"
],
"CVE-1999-0176": [
"20463"
],
"CVE-1999-0710": [
"20465"
],
"CVE-2001-0042": [
"20466"
],
"CVE-2001-0021": [
"20469"
],
"CVE-2001-0051": [
"20472"
],
"CVE-1999-0154": [
"20481"
],
"CVE-1999-1081": [
"20482"
],
"CVE-1999-0196": [
"20483"
],
"CVE-1999-0173": [
"20486"
],
"CVE-2001-0038": [
"20488"
],
"CVE-2001-0037": [
"20489"
],
"CVE-2001-0050": [
"20490"
],
"CVE-2001-0034": [
"20491"
],
"CVE-2001-0032": [
"20492"
],
"CVE-2001-0028": [
"20495",
"20496"
],
"CVE-2001-0023": [
"20497"
],
"CVE-2011-2653": [
"20502"
],
"CVE-2001-0024": [
"20503"
],
"CVE-2001-0025": [
"20504"
],
"CVE-2001-0022": [
"20506"
],
"CVE-2000-1092": [
"20507"
],
"CVE-2000-1093": [
"20510"
],
"CVE-2000-1094": [
"20511"
],
"CVE-1999-1069": [
"20513"
],
"CVE-2001-0098": [
"20516"
],
"CVE-2001-0082": [
"20519"
],
"CVE-2001-0074": [
"20522"
],
"CVE-2001-0075": [
"20523"
],
"CVE-2001-0099": [
"20524"
],
"CVE-2001-0100": [
"20525"
],
"CVE-2001-0148": [
"20528"
],
"CVE-2001-0009": [
"20529",
"20530"
],
"CVE-2001-0123": [
"20533"
],
"CVE-2001-0008": [
"20537"
],
"CVE-2011-1255": [
"20547"
],
"CVE-2001-0137": [
"20553"
],
"CVE-2001-0114": [
"20557"
],
"CVE-2001-0113": [
"20557"
],
"CVE-2001-0129": [
"20559"
],
"CVE-1999-0997": [
"20563"
],
"CVE-1999-0238": [
"20567"
],
"CVE-1999-0174": [
"20568"
],
"CVE-2001-0233": [
"20569"
],
"CVE-2001-0202": [
"20612"
],
"CVE-2001-0197": [
"20582"
],
"CVE-1999-1479": [
"20583"
],
"CVE-2001-0255": [
"20584"
],
"CVE-2001-0250": [
"20591"
],
"CVE-2001-0183": [
"20593"
],
"CVE-2001-0187": [
"20594"
],
"CVE-1999-0236": [
"20595"
],
"CVE-1999-0207": [
"20597"
],
"CVE-1999-0204": [
"20599"
],
"CVE-1999-0404": [
"20600"
],
"CVE-2001-0253": [
"20601"
],
"CVE-1999-1588": [
"20602"
],
"CVE-2001-0198": [
"20605"
],
"CVE-2001-0173": [
"20606"
],
"CVE-2001-0228": [
"20607"
],
"CVE-2001-0199": [
"20608"
],
"CVE-2001-0200": [
"20609"
],
"CVE-2000-0975": [
"20611"
],
"CVE-2001-0205": [
"20614"
],
"CVE-2001-0471": [
"20615"
],
"CVE-2001-0206": [
"20616"
],
"CVE-2001-0319": [
"20618"
],
"CVE-2000-0017": [
"20619"
],
"CVE-2000-0306": [
"20620"
],
"CVE-2001-0192": [
"20622"
],
"CVE-2001-0210": [
"20623"
],
"CVE-2012-1535": [
"20624"
],
"CVE-2001-0211": [
"20625"
],
"CVE-2001-0212": [
"20628"
],
"CVE-2001-0214": [
"20629"
],
"CVE-2001-0215": [
"20630"
],
"CVE-2001-0217": [
"20631"
],
"CVE-2001-0216": [
"20632"
],
"CVE-2001-0224": [
"20633"
],
"CVE-2001-0304": [
"20635"
],
"CVE-2001-0305": [
"20636"
],
"CVE-2001-0306": [
"20637"
],
"CVE-2001-0308": [
"20638"
],
"CVE-2001-0307": [
"20639"
],
"CVE-2001-0276": [
"20640"
],
"CVE-2001-0425": [
"20642"
],
"CVE-2001-0440": [
"20646"
],
"CVE-2001-0280": [
"20647"
],
"CVE-2001-0236": [
"20648",
"20649"
],
"CVE-2001-0711": [
"20652"
],
"CVE-2001-0283": [
"20653"
],
"CVE-2001-0286": [
"20657"
],
"CVE-2001-0274": [
"20660"
],
"CVE-2001-0295": [
"20661"
],
"CVE-2001-0454": [
"20663",
"25933"
],
"CVE-2001-0150": [
"20680"
],
"CVE-2001-0360": [
"20683"
],
"CVE-2001-0461": [
"20686"
],
"CVE-2001-0626": [
"20687"
],
"CVE-2001-0365": [
"20688"
],
"CVE-2001-0476": [
"20689"
],
"CVE-2001-1501": [
"20690"
],
"CVE-2001-0925": [
"20692",
"20693",
"20694",
"20695"
],
"CVE-2001-0593": [
"20714"
],
"CVE-2001-0590": [
"20716"
],
"CVE-2001-0571": [
"20717"
],
"CVE-2001-0399": [
"20722"
],
"CVE-2001-0264": [
"20723"
],
"CVE-2001-0466": [
"20725"
],
"CVE-2001-0263": [
"20726"
],
"CVE-2001-0402": [
"20730"
],
"CVE-2001-0247": [
"20731",
"20732",
"20733"
],
"CVE-2001-0265": [
"20738"
],
"CVE-2001-0400": [
"20744"
],
"CVE-2001-0609": [
"20748",
"20749"
],
"CVE-2001-0418": [
"20752"
],
"CVE-2001-0421": [
"20764"
],
"CVE-2001-0405": [
"20765"
],
"CVE-2001-0643": [
"20774"
],
"CVE-2001-0262": [
"20775"
],
"CVE-2001-0464": [
"20780"
],
"CVE-2001-1325": [
"20782"
],
"CVE-2001-0596": [
"20791"
],
"CVE-2001-0467": [
"20793"
],
"CVE-2001-0296": [
"20794"
],
"CVE-2009-4498": [
"20796",
"10432"
],
"CVE-2001-0462": [
"20797"
],
"CVE-2000-0074": [
"20799",
"20800",
"20801"
],
"CVE-2001-0491": [
"20803"
],
"CVE-1999-0215": [
"20805"
],
"CVE-2001-0484": [
"20806"
],
"CVE-2001-0495": [
"20807"
],
"CVE-2001-0463": [
"20808"
],
"CVE-2001-0452": [
"20819"
],
"CVE-2001-0490": [
"20820"
],
"CVE-2001-0574": [
"20826"
],
"CVE-2001-0557": [
"20829"
],
"CVE-2001-0561": [
"20831",
"20832",
"20833"
],
"CVE-2001-0527": [
"20849"
],
"CVE-2001-0614": [
"20850"
],
"CVE-2012-4681": [
"20865"
],
"CVE-2012-3539": [
"20865"
],
"CVE-2012-0547": [
"20865"
],
"CVE-2001-0520": [
"20869"
],
"CVE-2001-0630": [
"20878"
],
"CVE-2001-0779": [
"20879"
],
"CVE-2001-1339": [
"20881"
],
"CVE-2001-0615": [
"20882"
],
"CVE-2001-1335": [
"20884"
],
"CVE-2001-0778": [
"20886"
],
"CVE-2001-0780": [
"20887"
],
"CVE-2001-1326": [
"20888"
],
"CVE-2001-0522": [
"20889"
],
"CVE-2001-0519": [
"20890"
],
"CVE-2001-0521": [
"20891"
],
"CVE-2001-0380": [
"20892"
],
"CVE-2001-0791": [
"20893"
],
"CVE-2001-0748": [
"20894"
],
"CVE-2001-0693": [
"20895"
],
"CVE-2001-0743": [
"20896"
],
"CVE-2001-1088": [
"20899"
],
"CVE-2001-0763": [
"20908"
],
"CVE-2001-0552": [
"20909"
],
"CVE-2001-0688": [
"20910"
],
"CVE-2001-0766": [
"20911"
],
"CVE-2001-1344": [
"20914"
],
"CVE-2001-1343": [
"20916"
],
"CVE-2001-0818": [
"20924"
],
"CVE-2002-1904": [
"20929"
],
"CVE-2001-0820": [
"20929",
"21937"
],
"CVE-2001-0788": [
"20934"
],
"CVE-2001-1160": [
"20935"
],
"CVE-2001-1163": [
"20936"
],
"CVE-2001-0821": [
"20938",
"20939"
],
"CVE-2001-0805": [
"20940"
],
"CVE-2001-0700": [
"20941"
],
"CVE-2001-0705": [
"20947"
],
"CVE-2001-0704": [
"20948"
],
"CVE-2001-0341": [
"20950",
"20951"
],
"CVE-2001-0554": [
"21018"
],
"CVE-2000-1196": [
"20966"
],
"CVE-2001-1162": [
"20968"
],
"CVE-2001-0784": [
"20972"
],
"CVE-2001-0537": [
"20975",
"20976",
"20977",
"20978"
],
"CVE-2001-1290": [
"20982"
],
"CVE-2001-1412": [
"20984"
],
"CVE-2001-1086": [
"20993"
],
"CVE-2001-1075": [
"20994"
],
"CVE-2001-0775": [
"20998"
],
"CVE-2001-0731": [
"21002"
],
"CVE-2001-0538": [
"21003",
"21004"
],
"CVE-2001-0804": [
"21008"
],
"CVE-2001-1142": [
"21009"
],
"CVE-2001-1291": [
"21011"
],
"CVE-2001-1303": [
"21015"
],
"CVE-2001-0553": [
"21021"
],
"CVE-2001-0987": [
"21023"
],
"CVE-2001-0991": [
"21025"
],
"CVE-2001-1010": [
"21026"
],
"CVE-2001-1106": [
"21027"
],
"CVE-2001-1108": [
"21030"
],
"CVE-2001-1107": [
"21035"
],
"CVE-2001-1022": [
"21037"
],
"CVE-2001-1586": [
"21039"
],
"CVE-1999-0267": [
"21049",
"21050"
],
"CVE-1999-0235": [
"21049",
"21050"
],
"CVE-2001-1009": [
"21064",
"21066"
],
"CVE-2001-1115": [
"21068"
],
"CVE-2001-1130": [
"21075"
],
"CVE-2001-1067": [
"21088",
"21089"
],
"CVE-1999-0745": [
"21093"
],
"CVE-2001-1002": [
"21095"
],
"CVE-2001-0669": [
"21100"
],
"CVE-2001-1138": [
"21102"
],
"CVE-2001-0985": [
"21104"
],
"CVE-2001-1112": [
"21109"
],
"CVE-2001-1109": [
"21110"
],
"CVE-2001-1013": [
"21112"
],
"CVE-2001-0986": [
"21113"
],
"CVE-2001-1170": [
"21115"
],
"CVE-2001-1528": [
"21116"
],
"CVE-2001-0664": [
"21118"
],
"CVE-2001-0836": [
"21121"
],
"CVE-2001-1502": [
"21125"
],
"CVE-2001-1410": [
"21127"
],
"CVE-2001-0838": [
"21128"
],
"CVE-2001-0839": [
"21129"
],
"CVE-2012-3579": [
"21136"
],
"CVE-2001-0722": [
"21144"
],
"CVE-2001-0857": [
"21151"
],
"CVE-2001-0815": [
"21152",
"21153",
"21154"
],
"CVE-2001-0899": [
"21155"
],
"CVE-2001-0898": [
"21156"
],
"CVE-2001-0924": [
"21160"
],
"CVE-2001-1549": [
"21169"
],
"CVE-2001-1188": [
"21178"
],
"CVE-2001-1195": [
"21182"
],
"CVE-2001-1196": [
"21183"
],
"CVE-2001-1487": [
"21185"
],
"CVE-2001-1194": [
"21186"
],
"CVE-2001-0876": [
"21188",
"21189"
],
"CVE-2002-0002": [
"21192"
],
"CVE-2001-1202": [
"21193"
],
"CVE-2001-1209": [
"21194"
],
"CVE-2002-0023": [
"21195"
],
"CVE-2002-0005": [
"21196"
],
"CVE-2002-0095": [
"21197"
],
"CVE-2002-2031": [
"21198",
"21199"
],
"CVE-2002-1570": [
"21200"
],
"CVE-2002-2026": [
"21201"
],
"CVE-2002-0236": [
"21203"
],
"CVE-2002-2029": [
"21204"
],
"CVE-2002-0098": [
"21205"
],
"CVE-2002-0207": [
"21207"
],
"CVE-2002-0006": [
"21210"
],
"CVE-2002-0112": [
"21211"
],
"CVE-2002-0107": [
"21212"
],
"CVE-2002-0142": [
"21225"
],
"CVE-2002-0502": [
"21235"
],
"CVE-2002-0153": [
"21238"
],
"CVE-2002-0209": [
"21243"
],
"CVE-2002-0215": [
"21249"
],
"CVE-2002-2073": [
"21260"
],
"CVE-2002-0230": [
"21263"
],
"CVE-2004-0327": [
"21264",
"21265",
"21266",
"23742"
],
"CVE-2002-0229": [
"21264",
"21265",
"21266"
],
"CVE-2002-0231": [
"21274"
],
"CVE-2002-0266": [
"21276"
],
"CVE-2002-0250": [
"21285"
],
"CVE-2002-0263": [
"21287"
],
"CVE-2002-0276": [
"21289"
],
"CVE-2002-0288": [
"21291",
"21292"
],
"CVE-2002-0300": [
"21295"
],
"CVE-2002-0068": [
"21297"
],
"CVE-2002-0313": [
"21298"
],
"CVE-2002-0325": [
"21303"
],
"CVE-2002-0332": [
"21309"
],
"CVE-2002-0333": [
"21310"
],
"CVE-2002-0331": [
"21311"
],
"CVE-2002-0419": [
"21313"
],
"CVE-2002-0083": [
"21314"
],
"CVE-2002-0430": [
"21334",
"21335"
],
"CVE-2002-0440": [
"21339"
],
"CVE-2002-0436": [
"21340"
],
"CVE-2002-0061": [
"21350"
],
"CVE-2002-0495": [
"21354"
],
"CVE-2002-0504": [
"21355"
],
"CVE-2002-0191": [
"21361"
],
"CVE-2002-0177": [
"21363"
],
"CVE-2002-0536": [
"21365"
],
"CVE-2002-0544": [
"21367"
],
"CVE-2002-0543": [
"21367"
],
"CVE-2002-0079": [
"21368",
"21369",
"21370",
"21371"
],
"CVE-2002-0148": [
"21372"
],
"CVE-2002-1688": [
"21376"
],
"CVE-2002-0540": [
"21378"
],
"CVE-2002-0539": [
"21384"
],
"CVE-2002-1744": [
"21385"
],
"CVE-2002-0591": [
"21386"
],
"CVE-2002-0737": [
"21390"
],
"CVE-2002-0575": [
"21402"
],
"CVE-2002-0608": [
"21410"
],
"CVE-2002-2006": [
"21412"
],
"CVE-2002-0749": [
"21415"
],
"CVE-2002-0733": [
"21422"
],
"CVE-2002-0033": [
"21437"
],
"CVE-2002-1741": [
"21438"
],
"CVE-2002-1740": [
"21439"
],
"CVE-2002-0702": [
"21440"
],
"CVE-2002-0769": [
"21441"
],
"CVE-2002-0379": [
"21442",
"21443"
],
"CVE-2002-0787": [
"21444"
],
"CVE-2002-0786": [
"21445"
],
"CVE-2002-0375": [
"21446"
],
"CVE-2002-0770": [
"21450"
],
"CVE-2002-0783": [
"21451"
],
"CVE-2002-0193": [
"21452"
],
"CVE-2002-0192": [
"21452"
],
"CVE-2002-2341": [
"21453"
],
"CVE-2002-0908": [
"21456"
],
"CVE-2002-0799": [
"21466",
"21467"
],
"CVE-2002-0895": [
"21468"
],
"CVE-2002-0892": [
"21469"
],
"CVE-2002-0893": [
"21470"
],
"CVE-2002-0897": [
"21475"
],
"CVE-2002-0898": [
"21483"
],
"CVE-2002-0823": [
"21485"
],
"CVE-2002-1634": [
"21488"
],
"CVE-2002-2007": [
"21490",
"21491",
"21492"
],
"CVE-2002-0644": [
"21650"
],
"CVE-2002-0371": [
"21510"
],
"CVE-2002-0907": [
"21511"
],
"CVE-2002-0949": [
"21513"
],
"CVE-2002-2062": [
"21515"
],
"CVE-2002-0946": [
"21530"
],
"CVE-2002-0187": [
"21541"
],
"CVE-2002-0968": [
"21542"
],
"CVE-2002-1700": [
"21548"
],
"CVE-2002-1965": [
"21554"
],
"CVE-2002-0938": [
"21555"
],
"CVE-2002-0652": [
"21571"
],
"CVE-2002-0928": [
"21574"
],
"CVE-2002-1685": [
"21576"
],
"CVE-2002-0640": [
"21578",
"21579"
],
"CVE-2002-1008": [
"21581"
],
"CVE-2002-0665": [
"21582"
],
"CVE-2002-2376": [
"21586"
],
"CVE-2002-1001": [
"21589"
],
"CVE-2002-1004": [
"21591"
],
"CVE-2002-2195": [
"21595"
],
"CVE-2002-0676": [
"21596"
],
"CVE-2002-1031": [
"21597"
],
"CVE-2002-1683": [
"21599"
],
"CVE-2002-1973": [
"21601"
],
"CVE-2002-1982": [
"21602"
],
"CVE-2002-1042": [
"21603"
],
"CVE-2002-0682": [
"21604"
],
"CVE-2002-0723": [
"21606"
],
"CVE-2002-0680": [
"21607"
],
"CVE-2002-0681": [
"21608"
],
"CVE-2002-1009": [
"21611"
],
"CVE-2002-1790": [
"21613"
],
"CVE-2002-1014": [
"21615"
],
"CVE-2002-1021": [
"21616"
],
"CVE-2002-2169": [
"21619"
],
"CVE-2002-0637": [
"21625"
],
"CVE-2002-1073": [
"21626"
],
"CVE-2002-1361": [
"22072"
],
"CVE-2002-1089": [
"21627"
],
"CVE-2002-2170": [
"21630"
],
"CVE-2002-1057": [
"21633"
],
"CVE-2002-2312": [
"21636"
],
"CVE-2002-2314": [
"21638"
],
"CVE-2002-0814": [
"21639"
],
"CVE-2002-0855": [
"21641",
"21642"
],
"CVE-2002-0280": [
"21643"
],
"CVE-2002-1075": [
"21648"
],
"CVE-2002-1060": [
"21649"
],
"CVE-2002-0982": [
"21651"
],
"CVE-2002-1076": [
"21654"
],
"CVE-2002-1792": [
"21663"
],
"CVE-2002-1847": [
"21670"
],
"CVE-2002-0656": [
"40347"
],
"CVE-2002-2425": [
"21677"
],
"CVE-2002-0833": [
"21680"
],
"CVE-2002-2358": [
"21681"
],
"CVE-2002-2359": [
"21682"
],
"CVE-2002-1183": [
"21692"
],
"CVE-2002-0862": [
"21692"
],
"CVE-2002-0828": [
"21692"
],
"CVE-2002-2351": [
"21695",
"21696"
],
"CVE-2002-0661": [
"21697"
],
"CVE-2002-2318": [
"21698"
],
"CVE-2002-0812": [
"21699"
],
"CVE-2002-1445": [
"21704"
],
"CVE-2002-0874": [
"21706"
],
"CVE-2002-1951": [
"21707"
],
"CVE-2002-1452": [
"21709"
],
"CVE-2002-1453": [
"21710"
],
"CVE-2002-0980": [
"21711"
],
"CVE-2002-0974": [
"21717"
],
"CVE-2002-0721": [
"21718"
],
"CVE-2002-0654": [
"21719"
],
"CVE-2002-1405": [
"21722"
],
"CVE-2002-1809": [
"21725"
],
"CVE-2002-1436": [
"21731"
],
"CVE-2002-1567": [
"21734"
],
"CVE-2002-1079": [
"21735"
],
"CVE-2002-0647": [
"21748"
],
"CVE-2002-0648": [
"21749"
],
"CVE-2002-0189": [
"21750"
],
"CVE-2002-1451": [
"21751",
"21752"
],
"CVE-2002-1455": [
"21753",
"21754"
],
"CVE-2002-1456": [
"21759"
],
"CVE-2002-1143": [
"21764",
"21812"
],
"CVE-2002-2360": [
"21765"
],
"CVE-2002-1497": [
"21767"
],
"CVE-2002-1187": [
"21777"
],
"CVE-2002-1566": [
"21784"
],
"CVE-2002-2145": [
"21794"
],
"CVE-2002-1483": [
"21800"
],
"CVE-2002-1484": [
"21801"
],
"CVE-2002-0866": [
"21808"
],
"CVE-2002-1496": [
"21818"
],
"CVE-2002-0840": [
"21885"
],
"CVE-2002-2422": [
"21827"
],
"CVE-2011-4051": [
"21837"
],
"CVE-2012-0267": [
"21839"
],
"CVE-2012-4969": [
"21840"
],
"CVE-2012-0266": [
"21841"
],
"CVE-2012-3811": [
"21847"
],
"CVE-2012-1182": [
"21850"
],
"CVE-2012-2982": [
"21851"
],
"CVE-2002-1148": [
"21853"
],
"CVE-2002-2154": [
"21857"
],
"CVE-2002-2171": [
"21858"
],
"CVE-2002-1943": [
"21876"
],
"CVE-2002-1852": [
"21880"
],
"CVE-2012-2516": [
"21888"
],
"CVE-2002-0708": [
"21897"
],
"CVE-2002-0709": [
"21898"
],
"CVE-2002-0693": [
"21902"
],
"CVE-1999-0661": [
"21919"
],
"CVE-2002-1179": [
"21932"
],
"CVE-2002-1224": [
"21934"
],
"CVE-2002-1816": [
"21936"
],
"CVE-2002-1217": [
"21940"
],
"CVE-2002-1910": [
"21942"
],
"CVE-2002-1222": [
"21944"
],
"CVE-2002-1167": [
"21947"
],
"CVE-2002-1168": [
"21948"
],
"CVE-2002-1930": [
"21955"
],
"CVE-2002-1813": [
"21958"
],
"CVE-2002-1254": [
"21959"
],
"CVE-2002-1209": [
"21964"
],
"CVE-2002-1275": [
"21974"
],
"CVE-2002-2191": [
"21996"
],
"CVE-2002-2192": [
"21997",
"21999"
],
"CVE-2002-1652": [
"21998"
],
"CVE-2002-1785": [
"22000"
],
"CVE-2002-1238": [
"22001"
],
"CVE-2012-3810": [
"22007"
],
"CVE-2012-3809": [
"22007"
],
"CVE-2012-3808": [
"22007"
],
"CVE-2012-3807": [
"22007"
],
"CVE-2002-1549": [
"22012",
"22013",
"24999"
],
"CVE-2002-2400": [
"22016"
],
"CVE-2002-2403": [
"22018"
],
"CVE-2002-1986": [
"22020"
],
"CVE-2002-1823": [
"22021"
],
"CVE-2002-2357": [
"22023"
],
"CVE-2002-2353": [
"22024"
],
"CVE-2002-1307": [
"22026"
],
"CVE-2003-0111": [
"22027"
],
"CVE-2002-2281": [
"22028"
],
"CVE-2002-2417": [
"22032"
],
"CVE-2002-1317": [
"22036"
],
"CVE-2002-2251": [
"22049"
],
"CVE-2002-2416": [
"22063",
"22064"
],
"CVE-2002-1349": [
"22082"
],
"CVE-2002-1374": [
"22084"
],
"CVE-2002-1375": [
"22085"
],
"CVE-2002-1368": [
"22106"
],
"CVE-2003-1271": [
"22130"
],
"CVE-2003-1236": [
"22135"
],
"CVE-2003-1341": [
"22171"
],
"CVE-2003-1344": [
"22173"
],
"CVE-2003-1343": [
"22174"
],
"CVE-2003-1260": [
"22184"
],
"CVE-2003-0015": [
"22187"
],
"CVE-2003-1350": [
"22201"
],
"CVE-2003-0042": [
"22205"
],
"CVE-2003-1430": [
"22224"
],
"CVE-2003-1328": [
"22226"
],
"CVE-2003-1090": [
"22229"
],
"CVE-2003-1427": [
"22236"
],
"CVE-2003-1442": [
"22244"
],
"CVE-1999-0101": [
"22251"
],
"CVE-2003-0078": [
"22264"
],
"CVE-2003-1242": [
"22269"
],
"CVE-2003-1243": [
"22270"
],
"CVE-2003-0100": [
"22271"
],
"CVE-2003-0101": [
"22275"
],
"CVE-2003-0203": [
"22278"
],
"CVE-2003-1378": [
"22280"
],
"CVE-2003-0009": [
"22289"
],
"CVE-2003-1381": [
"22291"
],
"CVE-2003-1386": [
"22296"
],
"CVE-2012-2020": [
"22305"
],
"CVE-2012-2019": [
"22306"
],
"CVE-2003-1414": [
"22312"
],
"CVE-2002-1048": [
"22319"
],
"CVE-2003-0121": [
"22338"
],
"CVE-2003-0143": [
"22342"
],
"CVE-2012-5106": [
"22351"
],
"CVE-2003-0129": [
"22369"
],
"CVE-2003-0130": [
"22371"
],
"CVE-2003-1553": [
"22381"
],
"CVE-2003-1540": [
"22388"
],
"CVE-2003-0400": [
"22472",
"22646"
],
"CVE-2003-0228": [
"22570"
],
"CVE-2012-2288": [
"22525"
],
"CVE-2003-0113": [
"22530"
],
"CVE-2003-1463": [
"22541",
"22542"
],
"CVE-2003-0309": [
"22575"
],
"CVE-2003-0282": [
"22584"
],
"CVE-2003-1129": [
"22593"
],
"CVE-2003-0312": [
"22609"
],
"CVE-1999-0269": [
"22611"
],
"CVE-2003-0332": [
"22620"
],
"CVE-2003-0338": [
"22623"
],
"CVE-2003-0240": [
"22626"
],
"CVE-2003-1091": [
"22630"
],
"CVE-2003-0317": [
"22631"
],
"CVE-2003-0404": [
"22648"
],
"CVE-2012-5076": [
"22657",
"24309"
],
"CVE-2012-5067": [
"22657"
],
"CVE-2003-0407": [
"22658",
"22659"
],
"CVE-2003-0411": [
"22664"
],
"CVE-2003-0413": [
"22665"
],
"CVE-2012-5692": [
"22686",
"22398",
"22547"
],
"CVE-2003-0442": [
"22696"
],
"CVE-2010-3600": [
"22714"
],
"CVE-2012-5931": [
"22737"
],
"CVE-2012-5930": [
"22737"
],
"CVE-2003-0436": [
"22753",
"22754"
],
"CVE-2003-0434": [
"22771"
],
"CVE-2003-0446": [
"22783"
],
"CVE-2003-0447": [
"22784"
],
"CVE-2012-4959": [
"22787",
"23323"
],
"CVE-2003-0469": [
"22824"
],
"CVE-2003-0510": [
"22848"
],
"CVE-2003-0561": [
"22871",
"22872",
"22891"
],
"CVE-2003-0805": [
"22893",
"22894"
],
"CVE-2012-5932": [
"22903"
],
"CVE-2012-3752": [
"22905"
],
"CVE-2003-0526": [
"22919"
],
"CVE-2012-3753": [
"22973"
],
"CVE-2003-0726": [
"23043"
],
"CVE-2003-0729": [
"23066"
],
"CVE-2003-0747": [
"23069"
],
"CVE-2003-0748": [
"23070"
],
"CVE-2003-0749": [
"23071"
],
"CVE-2012-5615": [
"23073",
"23081"
],
"CVE-2012-6066": [
"23079",
"23080",
"24133"
],
"CVE-2012-5975": [
"23082",
"23156"
],
"CVE-2003-0347": [
"23094"
],
"CVE-2003-0665": [
"23095"
],
"CVE-2003-0772": [
"23100"
],
"CVE-2003-0838": [
"23114"
],
"CVE-2003-0705": [
"23115"
],
"CVE-2003-0809": [
"23122"
],
"CVE-2003-0816": [
"23131",
"23790"
],
"CVE-2003-0802": [
"23147"
],
"CVE-2003-0803": [
"23148"
],
"CVE-2003-0801": [
"23149"
],
"CVE-2003-0681": [
"23154"
],
"CVE-2012-5357": [
"23155"
],
"CVE-2003-0826": [
"23161",
"23162"
],
"CVE-2003-0865": [
"23171"
],
"CVE-2003-0835": [
"23186"
],
"CVE-2003-0833": [
"23196"
],
"CVE-2002-0659": [
"23199"
],
"CVE-2003-1096": [
"23212"
],
"CVE-2003-0845": [
"23221"
],
"CVE-2003-0974": [
"23404",
"23405"
],
"CVE-2003-1511": [
"23257"
],
"CVE-2003-1516": [
"23265"
],
"CVE-2003-1521": [
"23270"
],
"CVE-2003-1522": [
"23271"
],
"CVE-2003-1172": [
"23282"
],
"CVE-2010-3007": [
"23290"
],
"CVE-2003-1137": [
"23295"
],
"CVE-2003-1138": [
"23296"
],
"CVE-2003-1017": [
"23298"
],
"CVE-2003-1149": [
"23304"
],
"CVE-2003-1151": [
"23307"
],
"CVE-2003-1173": [
"23309"
],
"CVE-2003-0621": [
"23312"
],
"CVE-2003-1157": [
"23316"
],
"CVE-2003-1160": [
"23317"
],
"CVE-2003-1164": [
"23320"
],
"CVE-2012-4958": [
"23323"
],
"CVE-2012-4957": [
"23323"
],
"CVE-2003-1174": [
"23328",
"23329"
],
"CVE-2003-0328": [
"23366"
],
"CVE-2003-0886": [
"23371"
],
"CVE-2004-0380": [
"23400",
"23401",
"23695"
],
"CVE-2003-1025": [
"23422",
"23423",
"23465"
],
"CVE-2002-1603": [
"23446"
],
"CVE-2003-1566": [
"23490"
],
"CVE-2011-0340": [
"23500"
],
"CVE-2004-1793": [
"23509"
],
"CVE-2004-1784": [
"23514"
],
"CVE-2004-1789": [
"23527"
],
"CVE-2004-1790": [
"23528"
],
"CVE-2004-0046": [
"23529"
],
"CVE-2004-0069": [
"23531"
],
"CVE-2004-0072": [
"23533"
],
"CVE-2004-2748": [
"23559"
],
"CVE-2004-2745": [
"23560"
],
"CVE-2004-2749": [
"23562"
],
"CVE-2004-2094": [
"23563"
],
"CVE-2004-2096": [
"23564"
],
"CVE-2004-1856": [
"23878"
],
"CVE-2004-2487": [
"23877"
],
"CVE-2012-6329": [
"23579",
"23580"
],
"CVE-2012-6330": [
"23580"
],
"CVE-2004-2102": [
"23582"
],
"CVE-2004-2107": [
"23585"
],
"CVE-2004-2104": [
"23586",
"23587",
"23588"
],
"CVE-2004-2115": [
"23593"
],
"CVE-2004-2116": [
"23594"
],
"CVE-2004-2119": [
"23596"
],
"CVE-2004-2121": [
"23597"
],
"CVE-2004-1442": [
"23598"
],
"CVE-2004-2113": [
"23600"
],
"CVE-2012-5691": [
"23694"
],
"CVE-2004-2112": [
"23603"
],
"CVE-2004-2171": [
"23605"
],
"CVE-2004-2114": [
"23608"
],
"CVE-2004-2128": [
"23612"
],
"CVE-2004-2309": [
"23632"
],
"CVE-2012-2174": [
"23650"
],
"CVE-2004-2090": [
"23668"
],
"CVE-2004-0281": [
"23671"
],
"CVE-2004-0474": [
"23675"
],
"CVE-2004-0290": [
"23707"
],
"CVE-2004-0292": [
"23714"
],
"CVE-2004-0312": [
"23721"
],
"CVE-2004-0104": [
"23728"
],
"CVE-2004-2373": [
"23730"
],
"CVE-2012-2175": [
"23736"
],
"CVE-2012-2176": [
"23737"
],
"CVE-2004-0159": [
"23740"
],
"CVE-2004-0173": [
"23751"
],
"CVE-2012-4792": [
"23754",
"23785"
],
"CVE-2004-0349": [
"23758"
],
"CVE-2004-0192": [
"23764"
],
"CVE-2004-2383": [
"23766"
],
"CVE-2004-0354": [
"23771"
],
"CVE-2004-0353": [
"23772"
],
"CVE-2004-0337": [
"23776"
],
"CVE-2004-0189": [
"23777"
],
"CVE-2004-1801": [
"23794"
],
"CVE-2004-0121": [
"23796"
],
"CVE-2003-0514": [
"23800"
],
"CVE-2003-1199": [
"23801"
],
"CVE-2004-2617": [
"23802"
],
"CVE-2004-2618": [
"23803"
],
"CVE-2004-1769": [
"23804"
],
"CVE-2004-2326": [
"23808"
],
"CVE-2003-1228": [
"23811"
],
"CVE-2004-2311": [
"23836"
],
"CVE-2004-2310": [
"23837"
],
"CVE-2004-1838": [
"23864"
],
"CVE-2004-1855": [
"23873"
],
"CVE-2004-1857": [
"23879",
"23880"
],
"CVE-2011-5227": [
"23887"
],
"CVE-2012-0202": [
"23969"
],
"CVE-2004-1872": [
"23893"
],
"CVE-2004-1887": [
"23905",
"23906"
],
"CVE-2004-2464": [
"23909"
],
"CVE-2004-1908": [
"23926"
],
"CVE-2004-1915": [
"23936"
],
"CVE-2008-7248": [
"33402"
],
"CVE-2004-2253": [
"23987"
],
"CVE-2013-0156": [
"24019",
"27527"
],
"CVE-2011-1996": [
"24020"
],
"CVE-2004-1947": [
"24024",
"24025"
],
"CVE-2004-1945": [
"24028"
],
"CVE-2004-1951": [
"24038"
],
"CVE-2004-1958": [
"24041"
],
"CVE-2013-0422": [
"24045"
],
"CVE-2004-2626": [
"24065"
],
"CVE-2005-0643": [
"24067"
],
"CVE-2004-0763": [
"24069",
"24312"
],
"CVE-2003-1286": [
"24076"
],
"CVE-2004-0204": [
"24077"
],
"CVE-2004-2026": [
"24079"
],
"CVE-2012-6096": [
"24084",
"24159"
],
"CVE-2004-0399": [
"24093"
],
"CVE-2004-2614": [
"24097"
],
"CVE-2004-2649": [
"24098"
],
"CVE-2004-0502": [
"24101"
],
"CVE-2004-0526": [
"24102"
],
"CVE-2004-2480": [
"24105"
],
"CVE-2004-0501": [
"24114"
],
"CVE-2004-0580": [
"24115"
],
"CVE-2004-0771": [
"24120"
],
"CVE-2004-0486": [
"24121"
],
"CVE-2004-2289": [
"24125"
],
"CVE-2004-2299": [
"24129"
],
"CVE-2004-0527": [
"24136"
],
"CVE-2004-0528": [
"24137"
],
"CVE-2004-2032": [
"24140"
],
"CVE-2004-0520": [
"24160"
],
"CVE-2004-2564": [
"24161",
"24162"
],
"CVE-2004-2565": [
"24163"
],
"CVE-2004-1444": [
"24179"
],
"CVE-2012-0432": [
"24205",
"24323"
],
"CVE-2004-0616": [
"24230"
],
"CVE-2004-1754": [
"24218"
],
"CVE-2004-0615": [
"24226"
],
"CVE-2004-0673": [
"24246"
],
"CVE-2004-0678": [
"24253"
],
"CVE-2004-0633": [
"24259"
],
"CVE-2004-0648": [
"24263"
],
"CVE-2004-0727": [
"24265"
],
"CVE-2004-0841": [
"24266"
],
"CVE-2004-2494": [
"24268"
],
"CVE-2004-0760": [
"24276"
],
"CVE-2004-0595": [
"24280"
],
"CVE-2004-2563": [
"24297"
],
"CVE-2012-5088": [
"24308"
],
"CVE-2013-0332": [
"24310",
"17593"
],
"CVE-2013-0232": [
"24310"
],
"CVE-2013-0209": [
"24321"
],
"CVE-2012-6315": [
"24321"
],
"CVE-2013-1359": [
"24322",
"24204"
],
"CVE-2004-2491": [
"24325"
],
"CVE-2004-2061": [
"24326",
"24327"
],
"CVE-2004-0842": [
"24328"
],
"CVE-2004-2528": [
"24342"
],
"CVE-2004-2526": [
"24345"
],
"CVE-2004-2628": [
"24350"
],
"CVE-2004-2530": [
"24404"
],
"CVE-2004-1645": [
"24417",
"24418"
],
"CVE-2004-1646": [
"24419"
],
"CVE-2012-3569": [
"24460",
"24461"
],
"CVE-2013-0333": [
"24434"
],
"CVE-2013-7387": [
"24444",
"24438"
],
"CVE-2013-1412": [
"24444",
"24438"
],
"CVE-2012-5965": [
"24455"
],
"CVE-2012-5964": [
"24455"
],
"CVE-2012-5963": [
"24455"
],
"CVE-2012-5962": [
"24455"
],
"CVE-2012-5961": [
"24455"
],
"CVE-2012-5960": [
"24455"
],
"CVE-2012-5959": [
"24455"
],
"CVE-2012-5958": [
"24455",
"49119"
],
"CVE-2012-5858": [
"24455"
],
"CVE-2012-0439": [
"24490"
],
"CVE-2013-0025": [
"24495",
"24538"
],
"CVE-2012-6275": [
"24527"
],
"CVE-2012-6274": [
"24528"
],
"CVE-2011-4275": [
"24529",
"29210",
"10532",
"24492",
"24969",
"29091"
],
"CVE-2009-4140": [
"24529",
"29210",
"10532",
"24492",
"24969",
"29091"
],
"CVE-2013-0431": [
"24539"
],
"CVE-2013-0803": [
"24549"
],
"CVE-2004-0637": [
"24567"
],
"CVE-2004-1470": [
"24598"
],
"CVE-2004-2516": [
"24600"
],
"CVE-2004-2475": [
"24607"
],
"CVE-2004-2167": [
"24622"
],
"CVE-2004-0552": [
"24623"
],
"CVE-2004-0958": [
"24656"
],
"CVE-2004-0835": [
"24669"
],
"CVE-2004-1596": [
"24681"
],
"CVE-2005-0053": [
"24693"
],
"CVE-2004-1267": [
"24977"
],
"CVE-2004-1300": [
"24978"
],
"CVE-2004-0989": [
"24704"
],
"CVE-2004-1392": [
"24711"
],
"CVE-2004-1104": [
"24714"
],
"CVE-2004-1121": [
"24716"
],
"CVE-2004-1500": [
"24724"
],
"CVE-2004-1003": [
"24725"
],
"CVE-2013-0108": [
"24745"
],
"CVE-2004-1540": [
"24760"
],
"CVE-2004-1127": [
"24774"
],
"CVE-2004-1304": [
"24784"
],
"CVE-2004-1488": [
"24813"
],
"CVE-2004-1161": [
"24795"
],
"CVE-2004-1166": [
"24800"
],
"CVE-2004-1165": [
"24801"
],
"CVE-2004-1223": [
"24811"
],
"CVE-2004-1284": [
"24852"
],
"CVE-2004-1264": [
"24848"
],
"CVE-2004-1286": [
"24856",
"24857"
],
"CVE-2011-3923": [
"24874"
],
"CVE-2013-3075": [
"24886"
],
"CVE-2012-4711": [
"24887"
],
"CVE-2012-3001": [
"24888"
],
"CVE-2012-5201": [
"24891"
],
"CVE-2013-1362": [
"24955"
],
"CVE-2013-1493": [
"24904"
],
"CVE-2012-5879": [
"24907"
],
"CVE-2013-1892": [
"24935",
"24947"
],
"CVE-2013-1080": [
"24938"
],
"CVE-2013-0632": [
"24946",
"30210",
"27755"
],
"CVE-2013-0629": [
"24946"
],
"CVE-2013-0625": [
"24946"
],
"CVE-2013-2423": [
"24976"
],
"CVE-2004-1301": [
"24979"
],
"CVE-2004-1303": [
"24980"
],
"CVE-2004-1299": [
"24983"
],
"CVE-2004-1020": [
"24985"
],
"CVE-2005-0671": [
"25190"
],
"CVE-2013-1347": [
"25294"
],
"CVE-2013-3502": [
"25001"
],
"CVE-2004-1287": [
"25005"
],
"CVE-2004-1293": [
"25006"
],
"CVE-2004-1282": [
"25008"
],
"CVE-2004-1410": [
"25009"
],
"CVE-2004-1288": [
"25010"
],
"CVE-2004-1292": [
"25015"
],
"CVE-2004-1261": [
"25016"
],
"CVE-2004-1256": [
"25019"
],
"CVE-2004-1298": [
"25020"
],
"CVE-2004-1259": [
"25021"
],
"CVE-2004-1260": [
"25027",
"25029"
],
"CVE-2004-1324": [
"25031"
],
"CVE-2004-1325": [
"25032"
],
"CVE-2004-1289": [
"25035",
"25036"
],
"CVE-2004-1306": [
"25049"
],
"CVE-2005-0129": [
"25054"
],
"CVE-2005-0316": [
"25066"
],
"CVE-2005-0229": [
"25072"
],
"CVE-2005-0153": [
"25080"
],
"CVE-2005-0344": [
"25092"
],
"CVE-2013-3238": [
"25136",
"25003"
],
"CVE-2013-2010": [
"25137"
],
"CVE-2005-0161": [
"25150"
],
"CVE-2005-0701": [
"25195"
],
"CVE-2005-0737": [
"25196"
],
"CVE-2005-0731": [
"25207"
],
"CVE-2005-0709": [
"25209"
],
"CVE-2005-0710": [
"25210"
],
"CVE-2005-0711": [
"25211"
],
"CVE-2005-4809": [
"25221"
],
"CVE-2005-0838": [
"25238"
],
"CVE-2005-0905": [
"25274"
],
"CVE-2005-0906": [
"25291"
],
"CVE-2005-0950": [
"25319"
],
"CVE-2005-0959": [
"25321"
],
"CVE-2005-0978": [
"25325"
],
"CVE-2005-1002": [
"25336"
],
"CVE-2005-1059": [
"25359"
],
"CVE-2005-1087": [
"25365"
],
"CVE-2005-0404": [
"25375"
],
"CVE-2005-0555": [
"25385"
],
"CVE-2005-0553": [
"25386"
],
"CVE-2005-1077": [
"25391"
],
"CVE-2005-1105": [
"25395"
],
"CVE-2004-1774": [
"25397"
],
"CVE-2005-1112": [
"25420"
],
"CVE-2005-1118": [
"25421"
],
"CVE-2005-1191": [
"25454"
],
"CVE-2005-1480": [
"25486"
],
"CVE-2013-0136": [
"25517"
],
"CVE-2005-1380": [
"25546"
],
"CVE-2005-1349": [
"25547"
],
"CVE-2005-1370": [
"25557"
],
"CVE-2005-1383": [
"25559"
],
"CVE-2005-1382": [
"25561"
],
"CVE-2005-1381": [
"25562",
"25563"
],
"CVE-2005-1401": [
"25574"
],
"CVE-2005-1333": [
"25598"
],
"CVE-2005-1493": [
"25600"
],
"CVE-2005-1306": [
"25822"
],
"CVE-2005-1423": [
"25621"
],
"CVE-2005-1344": [
"25624",
"25625"
],
"CVE-2005-1507": [
"25626"
],
"CVE-2005-1604": [
"25627"
],
"CVE-2005-1552": [
"25643"
],
"CVE-2005-1365": [
"25669"
],
"CVE-2005-1532": [
"25670"
],
"CVE-2005-1827": [
"25684"
],
"CVE-2005-1679": [
"25687"
],
"CVE-2005-1702": [
"25691"
],
"CVE-2005-1708": [
"25697"
],
"CVE-2005-1709": [
"25698"
],
"CVE-2005-1520": [
"25706"
],
"CVE-2009-4142": [
"33414",
"33415"
],
"CVE-2012-5946": [
"25814"
],
"CVE-2005-2006": [
"25842"
],
"CVE-2013-3563": [
"25851"
],
"CVE-2005-2968": [
"26288"
],
"CVE-2005-2176": [
"25948"
],
"CVE-2005-2175": [
"25944"
],
"CVE-2005-2277": [
"25966"
],
"CVE-2013-1559": [
"25979"
],
"CVE-2013-2115": [
"25980"
],
"CVE-2013-1966": [
"25980"
],
"CVE-2013-4878": [
"25986"
],
"CVE-2013-2571": [
"25987"
],
"CVE-2005-2310": [
"25989"
],
"CVE-2013-1311": [
"25999"
],
"CVE-2005-2453": [
"26071"
],
"CVE-2005-3204": [
"26332"
],
"CVE-2005-2357": [
"26101"
],
"CVE-2016-6707": [
"40874"
],
"CVE-2012-1533": [
"26123"
],
"CVE-2013-1488": [
"26135"
],
"CVE-2005-2644": [
"26151"
],
"CVE-2005-2523": [
"26152"
],
"CVE-2005-2127": [
"26167"
],
"CVE-2005-2640": [
"26168"
],
"CVE-2013-2551": [
"26175"
],
"CVE-2013-1298": [
"26175"
],
"CVE-2005-2729": [
"26198"
],
"CVE-2005-2791": [
"26210"
],
"CVE-2005-3202": [
"26330",
"26329"
],
"CVE-2005-3293": [
"26374",
"26375"
],
"CVE-2005-4774": [
"26376"
],
"CVE-2013-3576": [
"26420"
],
"CVE-2012-6495": [
"26422",
"25304"
],
"CVE-2012-6081": [
"26422",
"25304"
],
"CVE-2005-3330": [
"26424"
],
"CVE-2005-3390": [
"26443"
],
"CVE-2005-3489": [
"26460"
],
"CVE-2005-1939": [
"26464"
],
"CVE-2013-4730": [
"26471",
"26495",
"27007",
"27277",
"27703",
"28328",
"31254",
"31255",
"31789",
"36078",
"38013"
],
"CVE-2013-2460": [
"26529"
],
"CVE-2005-3189": [
"26536"
],
"CVE-2005-3737": [
"26540"
],
"CVE-2005-3745": [
"26542"
],
"CVE-2005-4080": [
"26741"
],
"CVE-2005-4202": [
"26773",
"26774",
"26775"
],
"CVE-2005-4667": [
"26913"
],
"CVE-2005-4502": [
"26966"
],
"CVE-2013-1017": [
"27012"
],
"CVE-2011-4166": [
"27013"
],
"CVE-2005-4622": [
"27024"
],
"CVE-2005-3539": [
"27032"
],
"CVE-2013-2121": [
"27045"
],
"CVE-2013-3520": [
"27046"
],
"CVE-2006-0187": [
"27072",
"27073"
],
"CVE-2006-0254": [
"27095",
"27096"
],
"CVE-2013-4659": [
"27133"
],
"CVE-2013-2251": [
"27135",
"44583"
],
"CVE-2006-0496": [
"27150"
],
"CVE-2006-0663": [
"27181",
"27182"
],
"CVE-2005-3058": [
"27203"
],
"CVE-2006-0731": [
"27233",
"27234",
"27235"
],
"CVE-2006-0787": [
"27244"
],
"CVE-2006-0947": [
"27319"
],
"CVE-2006-0971": [
"27325"
],
"CVE-2006-0903": [
"27326"
],
"CVE-2006-1161": [
"27378"
],
"CVE-2013-1690": [
"27429"
],
"CVE-2006-1357": [
"27452"
],
"CVE-2006-1490": [
"27508"
],
"CVE-2013-4211": [
"27529"
],
"CVE-2013-5036": [
"27530"
],
"CVE-2013-2343": [
"27555"
],
"CVE-2012-3282": [
"27555"
],
"CVE-2006-0996": [
"27564"
],
"CVE-2006-1654": [
"27565"
],
"CVE-2006-1626": [
"27577"
],
"CVE-2006-1494": [
"27595"
],
"CVE-2006-1608": [
"27596"
],
"CVE-2006-2233": [
"27806"
],
"CVE-2013-5576": [
"27610"
],
"CVE-2006-1771": [
"27627"
],
"CVE-2006-1711": [
"27630"
],
"CVE-2006-1786": [
"27636",
"27637"
],
"CVE-2013-2465": [
"27705"
],
"CVE-2013-0526": [
"27706"
],
"CVE-2006-2020": [
"27716"
],
"CVE-2006-2094": [
"27744"
],
"CVE-2006-2101": [
"27746"
],
"CVE-2013-5093": [
"27752"
],
"CVE-2006-2099": [
"27758"
],
"CVE-2006-2100": [
"27759"
],
"CVE-2006-2102": [
"27760"
],
"CVE-2006-2223": [
"27801"
],
"CVE-2006-2224": [
"27802"
],
"CVE-2006-1172": [
"27820"
],
"CVE-2006-0515": [
"27830"
],
"CVE-2009-1798": [
"33405"
],
"CVE-2006-2334": [
"27851"
],
"CVE-2006-2341": [
"27852"
],
"CVE-2006-2351": [
"27861",
"27862"
],
"CVE-2013-3763": [
"27877"
],
"CVE-2006-1039": [
"27887"
],
"CVE-2006-2531": [
"27891"
],
"CVE-2006-2490": [
"27892",
"27893",
"27894"
],
"CVE-2006-2548": [
"27902"
],
"CVE-2006-2653": [
"27923"
],
"CVE-2006-2769": [
"27931"
],
"CVE-2013-2370": [
"27939"
],
"CVE-2013-0753": [
"27940"
],
"CVE-2006-0747": [
"27992"
],
"CVE-2006-2383": [
"27984"
],
"CVE-2006-2894": [
"27986",
"27987"
],
"CVE-2006-1193": [
"28005"
],
"CVE-2006-3015": [
"28007"
],
"CVE-2006-3101": [
"28030"
],
"CVE-2012-3748": [
"28081"
],
"CVE-2013-3184": [
"28082"
],
"CVE-2013-4798": [
"28083"
],
"CVE-2006-3280": [
"28118"
],
"CVE-2006-3581": [
"28181"
],
"CVE-2006-3491": [
"28186"
],
"CVE-2013-4015": [
"28187"
],
"CVE-2013-3846": [
"28187"
],
"CVE-2013-3166": [
"28187"
],
"CVE-2013-3164": [
"28187"
],
"CVE-2013-3163": [
"28187"
],
"CVE-2013-3162": [
"28187"
],
"CVE-2013-3161": [
"28187"
],
"CVE-2013-3153": [
"28187"
],
"CVE-2013-3152": [
"28187"
],
"CVE-2013-3151": [
"28187"
],
"CVE-2013-3150": [
"28187"
],
"CVE-2013-3149": [
"28187"
],
"CVE-2013-3148": [
"28187"
],
"CVE-2013-3147": [
"28187"
],
"CVE-2013-3146": [
"28187"
],
"CVE-2013-3145": [
"28187"
],
"CVE-2013-3144": [
"28187"
],
"CVE-2013-3115": [
"28187"
],
"CVE-2013-2367": [
"28188"
],
"CVE-2006-3431": [
"28189"
],
"CVE-2006-2389": [
"28198"
],
"CVE-2006-3624": [
"28209",
"28210"
],
"CVE-2006-3655": [
"28224"
],
"CVE-2006-3660": [
"28225"
],
"CVE-2006-3656": [
"28226"
],
"CVE-2006-3845": [
"28235"
],
"CVE-2006-3733": [
"28245"
],
"CVE-2006-3835": [
"28254"
],
"CVE-2013-2817": [
"28284"
],
"CVE-2006-2481": [
"28312"
],
"CVE-2006-4006": [
"28314"
],
"CVE-2013-2472": [
"28331"
],
"CVE-2013-4983": [
"28334",
"28175"
],
"CVE-2013-4811": [
"28336"
],
"CVE-2013-4812": [
"28337"
],
"CVE-2006-4125": [
"28344"
],
"CVE-2006-3281": [
"28357"
],
"CVE-2006-4110": [
"28365"
],
"CVE-2006-4131": [
"28368"
],
"CVE-2006-4295": [
"28373"
],
"CVE-2006-4140": [
"28374"
],
"CVE-2005-4807": [
"28397"
],
"CVE-2006-4227": [
"28398"
],
"CVE-2006-4219": [
"28400"
],
"CVE-2006-3918": [
"28424"
],
"CVE-2006-4446": [
"28438"
],
"CVE-2013-3205": [
"28481"
],
"CVE-2013-0810": [
"28482"
],
"CVE-2013-5696": [
"28483",
"28685"
],
"CVE-2013-3568": [
"28484"
],
"CVE-2006-4654": [
"28489"
],
"CVE-2006-0032": [
"28500"
],
"CVE-2006-6919": [
"28501"
],
"CVE-2006-5034": [
"28512"
],
"CVE-2006-4965": [
"28639"
],
"CVE-2006-4899": [
"28640"
],
"CVE-2006-4900": [
"28641"
],
"CVE-2006-4901": [
"28642"
],
"CVE-2006-3507": [
"28643"
],
"CVE-2006-5114": [
"28725"
],
"CVE-2013-3893": [
"28682",
"49872"
],
"CVE-2006-5084": [
"28710"
],
"CVE-2013-4810": [
"28713"
],
"CVE-2006-4812": [
"28760"
],
"CVE-2013-4800": [
"28809"
],
"CVE-2006-5536": [
"28847"
],
"CVE-2006-5512": [
"28848",
"28842"
],
"CVE-2006-5571": [
"28850"
],
"CVE-2006-5653": [
"28887"
],
"CVE-2006-5711": [
"28888"
],
"CVE-2013-6366": [
"28962"
],
"CVE-2013-2333": [
"28973"
],
"CVE-2013-3897": [
"28974"
],
"CVE-2006-2431": [
"28981"
],
"CVE-2006-6124": [
"29045"
],
"CVE-2006-6059": [
"29096"
],
"CVE-2013-4822": [
"29130"
],
"CVE-2006-6097": [
"29160"
],
"CVE-2006-6125": [
"29167"
],
"CVE-2006-6133": [
"29171"
],
"CVE-2013-6021": [
"29273"
],
"CVE-2006-6597": [
"29281"
],
"CVE-2006-6104": [
"29302"
],
"CVE-2013-3591": [
"29319"
],
"CVE-2013-3631": [
"29320"
],
"CVE-2013-3628": [
"29321"
],
"CVE-2013-3629": [
"29322"
],
"CVE-2013-3632": [
"29323"
],
"CVE-2013-3630": [
"29324"
],
"CVE-2007-3181": [
"30186"
],
"CVE-2007-0044": [
"29383"
],
"CVE-2007-0297": [
"29475"
],
"CVE-2007-0110": [
"29400"
],
"CVE-2007-0183": [
"29439"
],
"CVE-2013-7382": [
"29513"
],
"CVE-2013-4467": [
"29513"
],
"CVE-2013-4468": [
"29513"
],
"CVE-2006-6899": [
"29471"
],
"CVE-2007-0357": [
"29490"
],
"CVE-2007-0389": [
"29496"
],
"CVE-2007-2441": [
"30037"
],
"CVE-2007-2440": [
"30038"
],
"CVE-2007-2788": [
"30043"
],
"CVE-2007-2763": [
"30049"
],
"CVE-2007-1355": [
"30052"
],
"CVE-2007-1280": [
"30016"
],
"CVE-2007-2052": [
"30018"
],
"CVE-2007-2523": [
"30019"
],
"CVE-2007-2639": [
"30026"
],
"CVE-2007-0641": [
"29538"
],
"CVE-2007-1229": [
"29685"
],
"CVE-2007-1199": [
"29686"
],
"CVE-2007-1192": [
"29687"
],
"CVE-2014-5007": [
"29812",
"29674",
"34518"
],
"CVE-2013-7390": [
"29812",
"29674",
"34518"
],
"CVE-2008-2286": [
"29552"
],
"CVE-2007-0896": [
"29573"
],
"CVE-2007-0872": [
"29575"
],
"CVE-2007-3406": [
"29619"
],
"CVE-2013-3623": [
"29666"
],
"CVE-2007-1190": [
"29688"
],
"CVE-2007-1263": [
"29689"
],
"CVE-2007-1264": [
"29690"
],
"CVE-2007-1266": [
"29691"
],
"CVE-2013-6796": [
"29706"
],
"CVE-2007-1365": [
"29725"
],
"CVE-2007-1453": [
"29732"
],
"CVE-2013-6831": [
"29734"
],
"CVE-2013-6830": [
"29734"
],
"CVE-2013-6829": [
"29734"
],
"CVE-2007-0450": [
"29739"
],
"CVE-2007-1499": [
"29741"
],
"CVE-2007-1506": [
"29749"
],
"CVE-2007-1583": [
"29752"
],
"CVE-2007-1536": [
"29753"
],
"CVE-2007-1562": [
"29768"
],
"CVE-2007-1563": [
"29769"
],
"CVE-2007-1564": [
"29770"
],
"CVE-2007-1658": [
"29771"
],
"CVE-2007-1718": [
"29784"
],
"CVE-2007-1717": [
"29784"
],
"CVE-2007-1773": [
"29785",
"29786"
],
"CVE-2007-1777": [
"29788"
],
"CVE-2007-2872": [
"30117"
],
"CVE-2007-3799": [
"30130"
],
"CVE-2007-3071": [
"30144",
"37319"
],
"CVE-2006-3974": [
"30164"
],
"CVE-2007-3201": [
"30169"
],
"CVE-2007-3186": [
"30176"
],
"CVE-2013-3346": [
"30394"
],
"CVE-2007-1825": [
"29807"
],
"CVE-2007-1890": [
"29808"
],
"CVE-2013-2751": [
"29815"
],
"CVE-2007-1947": [
"29820"
],
"CVE-2007-2048": [
"29843"
],
"CVE-2013-3918": [
"29857"
],
"CVE-2012-0016": [
"29858"
],
"CVE-2013-4212": [
"29859"
],
"CVE-2007-2191": [
"29873"
],
"CVE-2007-2353": [
"29930"
],
"CVE-2007-2429": [
"29931"
],
"CVE-2007-2581": [
"29951"
],
"CVE-2013-6162": [
"30373"
],
"CVE-2013-5486": [
"30008"
],
"CVE-2013-3906": [
"30011"
],
"CVE-2007-2747": [
"30067"
],
"CVE-2007-2519": [
"30074"
],
"CVE-2007-2843": [
"30078"
],
"CVE-2007-3227": [
"30089"
],
"CVE-2013-4837": [
"30209"
],
"CVE-2012-0874": [
"30211"
],
"CVE-2013-3522": [
"30212",
"24882"
],
"CVE-2007-3327": [
"30218"
],
"CVE-2007-3365": [
"30219"
],
"CVE-2007-3364": [
"30222"
],
"CVE-2007-2401": [
"30228"
],
"CVE-2007-3407": [
"30229"
],
"CVE-2007-3396": [
"30231"
],
"CVE-2007-3574": [
"30254"
],
"CVE-2007-3553": [
"30256"
],
"CVE-2007-3011": [
"30264"
],
"CVE-2007-3624": [
"30265"
],
"CVE-2007-3613": [
"30279"
],
"CVE-2007-0042": [
"30281"
],
"CVE-2007-3670": [
"30285"
],
"CVE-2007-3701": [
"30287"
],
"CVE-2007-3456": [
"30288"
],
"CVE-2007-3725": [
"30291"
],
"CVE-2007-3832": [
"30315"
],
"CVE-2007-3798": [
"30319"
],
"CVE-2007-3947": [
"30322"
],
"CVE-2007-3845": [
"30381"
],
"CVE-2013-2068": [
"30469"
],
"CVE-2008-6540": [
"31465"
],
"CVE-2007-4105": [
"30431"
],
"CVE-2007-3844": [
"30439"
],
"CVE-2007-4145": [
"30441"
],
"CVE-2007-4226": [
"30454"
],
"CVE-2007-6483": [
"30809",
"33428"
],
"CVE-2013-6955": [
"30470"
],
"CVE-2013-1349": [
"30471"
],
"CVE-2013-4835": [
"30473"
],
"CVE-2007-4318": [
"30485"
],
"CVE-2007-2216": [
"30490"
],
"CVE-2007-4385": [
"30491"
],
"CVE-2007-2223": [
"30493"
],
"CVE-2007-3386": [
"30495"
],
"CVE-2007-3382": [
"30496"
],
"CVE-2007-4381": [
"30502"
],
"CVE-2007-4444": [
"30507"
],
"CVE-2007-4446": [
"30508"
],
"CVE-2007-4545": [
"30521"
],
"CVE-2007-4537": [
"30523"
],
"CVE-2007-4220": [
"30532"
],
"CVE-2007-2930": [
"30535",
"30536"
],
"CVE-2007-4642": [
"30543"
],
"CVE-2008-0096": [
"30971"
],
"CVE-2008-6061": [
"30972"
],
"CVE-2008-6060": [
"30973"
],
"CVE-2008-0265": [
"31024"
],
"CVE-2007-6003": [
"30882"
],
"CVE-2007-4725": [
"30565"
],
"CVE-2007-3040": [
"30567"
],
"CVE-2007-4843": [
"30569"
],
"CVE-2014-1903": [
"32512",
"32214"
],
"CVE-2008-4247": [
"32399"
],
"CVE-2008-4131": [
"32393"
],
"CVE-2007-4909": [
"30582"
],
"CVE-2007-4962": [
"30589"
],
"CVE-2007-5064": [
"30600"
],
"CVE-2007-5158": [
"30622"
],
"CVE-2007-5248": [
"30630"
],
"CVE-2007-5255": [
"30631"
],
"CVE-2007-3898": [
"30635",
"30636"
],
"CVE-2007-5264": [
"30643"
],
"CVE-2007-3896": [
"30645"
],
"CVE-2007-5411": [
"30650"
],
"CVE-2007-5381": [
"30652"
],
"CVE-2007-5562": [
"30673"
],
"CVE-2007-5488": [
"30677"
],
"CVE-2007-5636": [
"30678"
],
"CVE-2007-5685": [
"30711"
],
"CVE-2007-5722": [
"30720"
],
"CVE-2007-5837": [
"30728"
],
"CVE-2007-5796": [
"30729"
],
"CVE-2007-5815": [
"30730"
],
"CVE-2007-5795": [
"30736"
],
"CVE-2007-5926": [
"30742"
],
"CVE-2007-5979": [
"30755"
],
"CVE-2007-5944": [
"30768"
],
"CVE-2007-6054": [
"30771"
],
"CVE-2007-6028": [
"30772"
],
"CVE-2008-7161": [
"31026"
],
"CVE-2013-3214": [
"30787",
"27279"
],
"CVE-2007-6593": [
"30816"
],
"CVE-2007-6704": [
"30833",
"30834"
],
"CVE-2007-6203": [
"30835"
],
"CVE-2007-6514": [
"30901"
],
"CVE-2007-6244": [
"30905",
"30907"
],
"CVE-2014-1202": [
"30908"
],
"CVE-2014-0659": [
"30915"
],
"CVE-2007-6513": [
"30920"
],
"CVE-2007-6561": [
"30928"
],
"CVE-2007-6533": [
"30933"
],
"CVE-2007-6630": [
"30944"
],
"CVE-2008-1136": [
"30998"
],
"CVE-2008-0339": [
"31010"
],
"CVE-2007-4389": [
"31013"
],
"CVE-2008-4664": [
"31023"
],
"CVE-2008-0372": [
"31031"
],
"CVE-2008-0364": [
"31032"
],
"CVE-2013-6343": [
"31033"
],
"CVE-2008-0396": [
"31039"
],
"CVE-2008-0438": [
"31047"
],
"CVE-2008-0387": [
"31050"
],
"CVE-2008-0418": [
"31051"
],
"CVE-2008-0455": [
"31052"
],
"CVE-2007-4850": [
"31053"
],
"CVE-2008-0406": [
"31056"
],
"CVE-2008-0485": [
"31076"
],
"CVE-2006-4220": [
"31095"
],
"CVE-2008-0671": [
"31119"
],
"CVE-2007-5333": [
"31130"
],
"CVE-2008-0767": [
"31132"
],
"CVE-2008-7032": [
"31133"
],
"CVE-2008-0760": [
"31149"
],
"CVE-2008-0790": [
"31163"
],
"CVE-2013-7246": [
"31179"
],
"CVE-2013-6194": [
"31181"
],
"CVE-2008-0838": [
"31204"
],
"CVE-2008-1169": [
"31231"
],
"CVE-2012-3153": [
"31253"
],
"CVE-2012-3152": [
"31253",
"31737"
],
"CVE-2008-1482": [
"31462"
],
"CVE-2008-1037": [
"31298"
],
"CVE-2008-0411": [
"31309"
],
"CVE-2008-1180": [
"31311"
],
"CVE-2008-1208": [
"31340"
],
"CVE-2008-1262": [
"31342"
],
"CVE-2008-1221": [
"31345"
],
"CVE-2008-1283": [
"31362"
],
"CVE-2008-0533": [
"31395"
],
"CVE-2008-1270": [
"31396"
],
"CVE-2008-2030": [
"31698"
],
"CVE-2008-1461": [
"31405"
],
"CVE-2008-1403": [
"31409"
],
"CVE-2008-1000": [
"31412"
],
"CVE-2014-1683": [
"31432",
"31183"
],
"CVE-2012-0394": [
"31434",
"18329"
],
"CVE-2008-6543": [
"31479",
"31480",
"31481",
"31482",
"31483",
"31484",
"31485",
"31486",
"31487",
"31488",
"31489",
"31490",
"31491",
"31492",
"31493",
"31494",
"31495",
"31496",
"31497",
"31498",
"31499",
"31500",
"31501",
"31502",
"31503",
"31504",
"31505",
"31506",
"31507",
"31508",
"31509",
"31510",
"31511",
"31512",
"31513",
"31514"
],
"CVE-2016-3861": [
"40354"
],
"CVE-2008-0926": [
"31533"
],
"CVE-2008-1605": [
"31534"
],
"CVE-2008-1564": [
"31536"
],
"CVE-2008-1488": [
"31540"
],
"CVE-2005-4703": [
"31551"
],
"CVE-2008-1620": [
"31562"
],
"CVE-2013-2827": [
"31575"
],
"CVE-2008-6195": [
"31591"
],
"CVE-2007-6019": [
"31630"
],
"CVE-2008-1888": [
"31632"
],
"CVE-2008-1721": [
"31634"
],
"CVE-2008-0068": [
"31638"
],
"CVE-2008-6563": [
"31639"
],
"CVE-2013-5014": [
"31917",
"31853"
],
"CVE-2013-5015": [
"31917",
"31853"
],
"CVE-2013-2347": [
"31689",
"32164"
],
"CVE-2014-10031": [
"31694"
],
"CVE-2008-1965": [
"31706"
],
"CVE-2008-2162": [
"31756"
],
"CVE-2008-2167": [
"31757"
],
"CVE-2008-2168": [
"31759"
],
"CVE-2014-1610": [
"31767",
"31329"
],
"CVE-2008-2138": [
"31770"
],
"CVE-2008-2333": [
"31828"
],
"CVE-2008-5225": [
"31862",
"31863",
"31864"
],
"CVE-2007-5604": [
"31873"
],
"CVE-2014-1912": [
"31875"
],
"CVE-2008-2637": [
"31885",
"31886"
],
"CVE-2008-2702": [
"31887"
],
"CVE-2008-7184": [
"31890"
],
"CVE-2008-5266": [
"31901"
],
"CVE-2008-2719": [
"31903"
],
"CVE-2008-7170": [
"31912"
],
"CVE-2008-6737": [
"31918"
],
"CVE-2008-2821": [
"31920"
],
"CVE-2008-2822": [
"31921"
],
"CVE-2008-2751": [
"31922",
"31923",
"31924",
"31925",
"31926",
"31927",
"31928"
],
"CVE-2008-2795": [
"31936"
],
"CVE-2008-2889": [
"31941"
],
"CVE-2008-2894": [
"31942"
],
"CVE-2008-2303": [
"32048"
],
"CVE-2008-2935": [
"32133"
],
"CVE-2008-7168": [
"31980"
],
"CVE-2014-0750": [
"31987"
],
"CVE-2008-2949": [
"31996"
],
"CVE-2008-2948": [
"31996"
],
"CVE-2008-5175": [
"31997"
],
"CVE-2008-3076": [
"32012"
],
"CVE-2014-2206": [
"32132"
],
"CVE-2008-6442": [
"32052"
],
"CVE-2008-3285": [
"32084"
],
"CVE-2008-3430": [
"32124"
],
"CVE-2008-2370": [
"32137"
],
"CVE-2008-1232": [
"32138"
],
"CVE-2008-3569": [
"32165",
"32166"
],
"CVE-2008-3494": [
"32167"
],
"CVE-2008-3667": [
"32197"
],
"CVE-2014-0783": [
"32209"
],
"CVE-2014-0784": [
"32210"
],
"CVE-2008-3657": [
"32223"
],
"CVE-2008-3655": [
"32223",
"32224"
],
"CVE-2008-3432": [
"32225"
],
"CVE-2008-4437": [
"32228"
],
"CVE-2008-3776": [
"32286"
],
"CVE-2008-4101": [
"32289"
],
"CVE-2008-7110": [
"32301"
],
"CVE-2008-3906": [
"32303"
],
"CVE-2008-4133": [
"32336"
],
"CVE-2008-3956": [
"32339"
],
"CVE-2008-3957": [
"32344",
"32345"
],
"CVE-2008-5191": [
"32359",
"32621",
"5960"
],
"CVE-2008-7012": [
"32382"
],
"CVE-2008-5073": [
"32429"
],
"CVE-2014-0307": [
"32438"
],
"CVE-2014-1691": [
"32439"
],
"CVE-2008-4456": [
"32445"
],
"CVE-2008-4508": [
"32465"
],
"CVE-2008-4582": [
"32466"
],
"CVE-2008-5869": [
"32469"
],
"CVE-2008-3641": [
"32470"
],
"CVE-2008-6065": [
"32475"
],
"CVE-2008-6504": [
"32564"
],
"CVE-2008-1547": [
"32489"
],
"CVE-2013-2143": [
"32515"
],
"CVE-2008-4910": [
"32529"
],
"CVE-2006-7234": [
"32530"
],
"CVE-2008-4795": [
"32548"
],
"CVE-2008-4918": [
"32552"
],
"CVE-2008-6505": [
"32565"
],
"CVE-2014-1216": [
"32568"
],
"CVE-2008-5177": [
"32578"
],
"CVE-2008-5112": [
"32586"
],
"CVE-2008-6280": [
"32599"
],
"CVE-2014-2560": [
"32643"
],
"CVE-2008-5551": [
"32654"
],
"CVE-2008-5659": [
"32673",
"32674"
],
"CVE-2006-7236": [
"32690"
],
"CVE-2008-5824": [
"32691"
],
"CVE-2009-0043": [
"32711"
],
"CVE-2008-3821": [
"32723"
],
"CVE-2014-2314": [
"32725"
],
"CVE-2014-0346": [
"32745",
"32764",
"32791",
"32998"
],
"CVE-2014-0160": [
"32745",
"32764",
"32791",
"32998"
],
"CVE-2009-0348": [
"32762"
],
"CVE-2009-0470": [
"32776"
],
"CVE-2009-0544": [
"32780"
],
"CVE-2014-2850": [
"32789"
],
"CVE-2014-2849": [
"32789"
],
"CVE-2014-2268": [
"32794"
],
"CVE-2009-0611": [
"32795"
],
"CVE-2009-0640": [
"32796"
],
"CVE-2009-0520": [
"32811"
],
"CVE-2014-0322": [
"32904",
"32851"
],
"CVE-2009-0858": [
"32825"
],
"CVE-2009-0849": [
"32832"
],
"CVE-2009-0037": [
"32834"
],
"CVE-2009-0367": [
"32837"
],
"CVE-2009-0855": [
"32839"
],
"CVE-2009-4795": [
"32877"
],
"CVE-2009-1220": [
"32878"
],
"CVE-2014-3139": [
"32885"
],
"CVE-2014-3008": [
"32885"
],
"CVE-2014-2994": [
"32997"
],
"CVE-2014-0984": [
"32919"
],
"CVE-2009-0038": [
"32920",
"32921"
],
"CVE-2009-0039": [
"32922"
],
"CVE-2014-2913": [
"32925",
"34461"
],
"CVE-2009-1349": [
"32929"
],
"CVE-2009-1561": [
"32931"
],
"CVE-2009-1312": [
"32942"
],
"CVE-2009-1558": [
"32954"
],
"CVE-2009-1557": [
"32955"
],
"CVE-2013-0634": [
"32959"
],
"CVE-2013-0633": [
"32959"
],
"CVE-2009-1416": [
"32965"
],
"CVE-2009-1595": [
"32967"
],
"CVE-2009-1553": [
"32971",
"32978",
"32974",
"32975",
"32977",
"32979",
"32980",
"32981"
],
"CVE-2014-3791": [
"33352"
],
"CVE-2009-1554": [
"32987"
],
"CVE-2009-0162": [
"32994"
],
"CVE-2009-1634": [
"33007"
],
"CVE-2009-0580": [
"33023"
],
"CVE-2009-1140": [
"33024"
],
"CVE-2014-4158": [
"33027",
"34059"
],
"CVE-2009-1391": [
"33032"
],
"CVE-2009-1684": [
"33033"
],
"CVE-2009-1699": [
"33034"
],
"CVE-2009-1834": [
"33039"
],
"CVE-2009-0961": [
"33044",
"33045",
"33046"
],
"CVE-2009-1724": [
"33047"
],
"CVE-2009-2288": [
"33051",
"9861",
"16908"
],
"CVE-2009-1886": [
"33053"
],
"CVE-2009-1203": [
"33054"
],
"CVE-2009-1201": [
"33055"
],
"CVE-2009-2350": [
"33063"
],
"CVE-2009-2352": [
"33064"
],
"CVE-2009-2377": [
"33066"
],
"CVE-2009-2386": [
"33067"
],
"CVE-2013-0140": [
"33071"
],
"CVE-2009-1422": [
"33078"
],
"CVE-2009-1975": [
"33079"
],
"CVE-2009-1019": [
"33081"
],
"CVE-2009-1968": [
"33082"
],
"CVE-2009-1020": [
"33084"
],
"CVE-2009-3860": [
"33089"
],
"CVE-2009-4653": [
"33351"
],
"CVE-2010-0470": [
"33580"
],
"CVE-2013-5331": [
"33095"
],
"CVE-2009-2654": [
"33103"
],
"CVE-2014-0113": [
"33142"
],
"CVE-2014-0112": [
"33142",
"41690"
],
"CVE-2014-0094": [
"33142",
"41690"
],
"CVE-2014-3220": [
"33143"
],
"CVE-2014-2937": [
"33143"
],
"CVE-2009-2195": [
"33164"
],
"CVE-2008-6992": [
"33203"
],
"CVE-2009-3099": [
"33210"
],
"CVE-2014-0497": [
"33212"
],
"CVE-2009-3485": [
"33257"
],
"CVE-2009-3486": [
"33258",
"33259"
],
"CVE-2009-3487": [
"33260",
"33261"
],
"CVE-2009-3573": [
"33263"
],
"CVE-2009-3577": [
"33272"
],
"CVE-2009-2511": [
"33264"
],
"CVE-2009-3733": [
"33310"
],
"CVE-2009-3373": [
"33313"
],
"CVE-2010-0239": [
"33594"
],
"CVE-2014-0782": [
"33331"
],
"CVE-2014-0515": [
"33333"
],
"CVE-2009-4227": [
"33388"
],
"CVE-2010-0936": [
"33471",
"11030"
],
"CVE-2009-4492": [
"33489"
],
"CVE-2009-4487": [
"33490"
],
"CVE-2009-4494": [
"33497"
],
"CVE-2009-4488": [
"33498"
],
"CVE-2009-4491": [
"33499"
],
"CVE-2009-4490": [
"33500"
],
"CVE-2009-4489": [
"33501"
],
"CVE-2009-4495": [
"33502"
],
"CVE-2009-4493": [
"33503"
],
"CVE-2009-4496": [
"33504"
],
"CVE-2014-1649": [
"33521"
],
"CVE-2009-4273": [
"33535"
],
"CVE-2010-0713": [
"33536"
],
"CVE-2010-0027": [
"33552"
],
"CVE-2010-0387": [
"33553"
],
"CVE-2014-0749": [
"33554"
],
"CVE-2010-0315": [
"33562"
],
"CVE-2010-0314": [
"33563"
],
"CVE-2010-0440": [
"33567"
],
"CVE-2014-3120": [
"33588",
"33370"
],
"CVE-2010-0926": [
"33598",
"33599"
],
"CVE-2010-0416": [
"33620"
],
"CVE-2009-4645": [
"33622"
],
"CVE-2010-0108": [
"33642"
],
"CVE-2010-0703": [
"33653"
],
"CVE-2010-0700": [
"33662"
],
"CVE-2010-0655": [
"33664"
],
"CVE-2013-5755": [
"33739"
],
"CVE-2013-5759": [
"33741",
"33742"
],
"CVE-2013-5758": [
"33741",
"33742"
],
"CVE-2010-0049": [
"33752"
],
"CVE-2009-4655": [
"33767"
],
"CVE-2015-3292": [
"33789"
],
"CVE-2010-0168": [
"33798"
],
"CVE-2014-3805": [
"33805",
"42709"
],
"CVE-2014-3914": [
"33807"
],
"CVE-2010-1180": [
"33810"
],
"CVE-2010-1177": [
"33811"
],
"CVE-2014-3913": [
"33817"
],
"CVE-2014-3789": [
"33880"
],
"CVE-2010-1587": [
"33868"
],
"CVE-2010-1320": [
"33855"
],
"CVE-2010-1932": [
"34143"
],
"CVE-2014-3804": [
"33865",
"42708"
],
"CVE-2010-1586": [
"33873"
],
"CVE-2013-6221": [
"33891"
],
"CVE-2010-1866": [
"33920"
],
"CVE-2010-2094": [
"33988"
],
"CVE-2014-2424": [
"33989"
],
"CVE-2014-5023": [
"33929"
],
"CVE-2014-4511": [
"33929",
"33990"
],
"CVE-2013-7392": [
"33929",
"33990"
],
"CVE-2010-0607": [
"33938"
],
"CVE-2010-1143": [
"33940",
"12610"
],
"CVE-2014-4725": [
"33991"
],
"CVE-2014-3888": [
"34009"
],
"CVE-2013-6765": [
"34026"
],
"CVE-2010-2025": [
"34033"
],
"CVE-2014-3936": [
"34064"
],
"CVE-2014-2623": [
"34066",
"35961",
"36304"
],
"CVE-2014-4968": [
"34088"
],
"CVE-2010-2265": [
"34126"
],
"CVE-2014-3085": [
"34132"
],
"CVE-2014-3081": [
"34132"
],
"CVE-2014-3080": [
"34132"
],
"CVE-2010-1748": [
"34152"
],
"CVE-2013-1670": [
"34363"
],
"CVE-2008-7257": [
"34200"
],
"CVE-2010-2246": [
"34201"
],
"CVE-2013-4490": [
"34362"
],
"CVE-2010-2370": [
"34310"
],
"CVE-2010-2375": [
"34312"
],
"CVE-2014-5073": [
"34335"
],
"CVE-2015-4523": [
"34334"
],
"CVE-2014-5005": [
"34594",
"34518"
],
"CVE-2014-5006": [
"34594",
"34518"
],
"CVE-2014-2927": [
"34465"
],
"CVE-2010-2785": [
"34385"
],
"CVE-2010-2809": [
"34426"
],
"CVE-2014-1511": [
"34448"
],
"CVE-2014-1510": [
"34448"
],
"CVE-2010-3324": [
"34478"
],
"CVE-2010-3202": [
"34500"
],
"CVE-2015-4107": [
"34517"
],
"CVE-2010-3171": [
"34621"
],
"CVE-2010-3460": [
"34622"
],
"CVE-2014-6287": [
"34668",
"34926",
"39161",
"49125"
],
"CVE-2014-5468": [
"34669"
],
"CVE-2014-6037": [
"34670",
"34519"
],
"CVE-2013-0928": [
"34756"
],
"CVE-2014-2364": [
"34757"
],
"CVE-2014-7910": [
"34765",
"34766",
"34777",
"34860",
"34862",
"34879",
"34896",
"35115",
"36503",
"36504",
"34839",
"34895",
"35146",
"36609"
],
"CVE-2014-7227": [
"34765",
"34766",
"34777",
"34860",
"34862",
"34879",
"34896",
"35115",
"36503",
"36504",
"34839",
"34895",
"35146",
"36609"
],
"CVE-2014-7196": [
"34765",
"34766",
"34777",
"34860",
"34862",
"34879",
"34896",
"35115",
"36503",
"36504",
"38849",
"34839",
"34895",
"35146",
"36609"
],
"CVE-2014-7169": [
"34765",
"34766",
"34777",
"34860",
"34862",
"34879",
"34896",
"35115",
"36503",
"36504",
"36933",
"34839",
"34895",
"35146",
"36609"
],
"CVE-2014-62771": [
"34765",
"34766",
"34777",
"34860",
"34862",
"34879",
"34896",
"35115",
"36503",
"36504",
"34839",
"34895",
"35146",
"36609"
],
"CVE-2014-3671": [
"34765",
"34766",
"34777",
"34860",
"34862",
"34879",
"34896",
"35115",
"36503",
"36504",
"34839",
"34895",
"35146",
"36609"
],
"CVE-2014-3659": [
"34765",
"34766",
"34777",
"34860",
"34862",
"34879",
"34896",
"35115",
"36503",
"36504",
"34839",
"34895",
"35146",
"36609"
],
"CVE-2009-5026": [
"34796"
],
"CVE-2009-4531": [
"34846"
],
"CVE-2014-5289": [
"34856"
],
"CVE-2014-7187": [
"34860",
"36933"
],
"CVE-2014-7186": [
"34860",
"36933"
],
"CVE-2014-6278": [
"34860",
"34900",
"36933",
"39568",
"39887"
],
"CVE-2014-2624": [
"34866"
],
"CVE-2014-6034": [
"34867",
"43896"
],
"CVE-2010-3179": [
"34881"
],
"CVE-2014-6446": [
"34925"
],
"CVE-2014-2928": [
"34927"
],
"CVE-2010-3870": [
"34950"
],
"CVE-2010-3863": [
"34952"
],
"CVE-2010-4156": [
"34979"
],
"CVE-2010-4246": [
"34985"
],
"CVE-2010-4647": [
"34998",
"34999"
],
"CVE-2010-3893": [
"35003"
],
"CVE-2010-3804": [
"35005",
"35006"
],
"CVE-2010-4172": [
"35011"
],
"CVE-2014-8322": [
"35018"
],
"CVE-2014-4872": [
"35032",
"34924"
],
"CVE-2014-7228": [
"35033"
],
"CVE-2010-4412": [
"35068",
"35069",
"35070",
"35071"
],
"CVE-2014-3828": [
"35078",
"41676"
],
"CVE-2010-3770": [
"35095"
],
"CVE-2014-7279": [
"35103"
],
"CVE-2014-7140": [
"35180"
],
"CVE-2014-8998": [
"35183"
],
"CVE-2014-1635": [
"35184"
],
"CVE-2014-8516": [
"35211"
],
"CVE-2014-6332": [
"35229",
"35230",
"35308",
"36516",
"37400",
"37668",
"37800",
"38500",
"38512"
],
"CVE-2011-0020": [
"35232"
],
"CVE-2008-7271": [
"35242",
"35243"
],
"CVE-2014-1806": [
"35280"
],
"CVE-2014-7146": [
"35283",
"41685"
],
"CVE-2011-0538": [
"35314"
],
"CVE-2011-3187": [
"35352"
],
"CVE-2014-4880": [
"35356"
],
"CVE-2011-1038": [
"35364"
],
"CVE-2011-1018": [
"35386"
],
"CVE-2014-8517": [
"35427",
"43112"
],
"CVE-2011-0167": [
"35434"
],
"CVE-2013-1428": [
"35441"
],
"CVE-2014-6324": [
"35474"
],
"CVE-2011-0751": [
"35466"
],
"CVE-2011-4041": [
"35495"
],
"CVE-2014-5470": [
"35549"
],
"CVE-2014-8791": [
"35545"
],
"CVE-2011-1487": [
"35554"
],
"CVE-2009-5065": [
"35570"
],
"CVE-2011-0104": [
"35573"
],
"CVE-2009-2936": [
"35581"
],
"CVE-2011-0285": [
"35606"
],
"CVE-2011-5155": [
"35614"
],
"CVE-2011-0836": [
"35638",
"35639",
"35640",
"35641",
"35642"
],
"CVE-2014-9567": [
"35660",
"35424"
],
"CVE-2014-9583": [
"35688",
"44524"
],
"CVE-2010-4279": [
"35731",
"15639"
],
"CVE-2011-1772": [
"35735"
],
"CVE-2011-1271": [
"35740"
],
"CVE-2014-8741": [
"35776"
],
"CVE-2014-10021": [
"35778",
"35543"
],
"CVE-2011-1939": [
"35784"
],
"CVE-2011-1930": [
"35785"
],
"CVE-2011-1944": [
"35810"
],
"CVE-2011-2179": [
"35818"
],
"CVE-2014-9265": [
"35822"
],
"CVE-2011-2201": [
"35836"
],
"CVE-2014-5301": [
"35845"
],
"CVE-2011-2202": [
"35855"
],
"CVE-2011-2960": [
"35864"
],
"CVE-2011-1656": [
"35919"
],
"CVE-2014-7288": [
"35949"
],
"CVE-2011-2357": [
"36006"
],
"CVE-2011-1976": [
"36020"
],
"CVE-2015-2342": [
"36101"
],
"CVE-2011-2732": [
"36130"
],
"CVE-2011-3575": [
"36145"
],
"CVE-2015-1497": [
"36169",
"36206",
"40491"
],
"CVE-2011-3597": [
"36199"
],
"CVE-2011-1999": [
"36209"
],
"CVE-2014-7285": [
"36263"
],
"CVE-2011-4273": [
"36217",
"36218",
"36219"
],
"CVE-2012-1239": [
"36238"
],
"CVE-2011-3315": [
"36256"
],
"CVE-2014-8686": [
"36264"
],
"CVE-2014-8684": [
"36264"
],
"CVE-2014-8687": [
"36264",
"36202"
],
"CVE-2015-1427": [
"36337",
"36415"
],
"CVE-2011-4317": [
"36352"
],
"CVE-2015-0311": [
"36360"
],
"CVE-2014-7884": [
"36370"
],
"CVE-2011-4712": [
"36376"
],
"CVE-2015-0925": [
"36412"
],
"CVE-2015-0318": [
"36420"
],
"CVE-2014-8636": [
"36480"
],
"CVE-2011-5057": [
"36426"
],
"CVE-2011-5261": [
"36428"
],
"CVE-2011-4836": [
"36429"
],
"CVE-2014-7236": [
"36438"
],
"CVE-2015-0313": [
"36491",
"36579"
],
"CVE-2012-5100": [
"36500"
],
"CVE-2015-2097": [
"36505",
"36602",
"36607"
],
"CVE-2012-0007": [
"36507"
],
"CVE-2012-5344": [
"36513"
],
"CVE-2012-5345": [
"36514"
],
"CVE-2015-2094": [
"36517",
"36604"
],
"CVE-2015-2099": [
"36518"
],
"CVE-2015-2098": [
"36519",
"36603",
"36606"
],
"CVE-2012-6041": [
"36546"
],
"CVE-2015-2797": [
"36577",
"37170"
],
"CVE-2010-1871": [
"36653"
],
"CVE-2011-3639": [
"36663"
],
"CVE-2015-2284": [
"36679"
],
"CVE-2011-4367": [
"36681"
],
"CVE-2015-3306": [
"36742",
"36803",
"37262",
"49908"
],
"CVE-2014-0569": [
"36744"
],
"CVE-2014-0556": [
"36808"
],
"CVE-2015-4133": [
"36809"
],
"CVE-2014-8739": [
"36811",
"35057"
],
"CVE-2012-1221": [
"36829"
],
"CVE-2012-4923": [
"36831",
"36832",
"36833"
],
"CVE-2014-8361": [
"37169"
],
"CVE-2012-5323": [
"36864"
],
"CVE-2012-5322": [
"36866",
"36865"
],
"CVE-2012-5319": [
"36877",
"18509"
],
"CVE-2014-8440": [
"36880"
],
"CVE-2012-1257": [
"36884"
],
"CVE-2015-0359": [
"36956"
],
"CVE-2014-9735": [
"36957"
],
"CVE-2015-0336": [
"36962"
],
"CVE-2015-0779": [
"36964",
"36678"
],
"CVE-2012-4685": [
"37037"
],
"CVE-2014-9195": [
"37066"
],
"CVE-2015-2051": [
"37171"
],
"CVE-2015-1158": [
"37336",
"41233"
],
"CVE-2015-3090": [
"37368"
],
"CVE-2012-1038": [
"37429"
],
"CVE-2015-5082": [
"37426",
"37428",
"38096"
],
"CVE-2015-3105": [
"37448"
],
"CVE-2012-2764": [
"37510"
],
"CVE-2012-4739": [
"37512",
"37513"
],
"CVE-2015-5119": [
"37523"
],
"CVE-2015-3113": [
"37536"
],
"CVE-2015-3043": [
"37536"
],
"CVE-2012-3456": [
"37576"
],
"CVE-2015-2857": [
"37597"
],
"CVE-2015-5122": [
"37599"
],
"CVE-2015-7709": [
"37600"
],
"CVE-2011-1398": [
"37688"
],
"CVE-2015-2995": [
"37667",
"43885"
],
"CVE-2012-2984": [
"37671"
],
"CVE-2012-4871": [
"37947"
],
"CVE-2012-4528": [
"37949"
],
"CVE-2012-4415": [
"37788"
],
"CVE-2012-4905": [
"37792"
],
"CVE-2012-4906": [
"37793"
],
"CVE-2012-4909": [
"37794"
],
"CVE-2012-4908": [
"37795"
],
"CVE-2012-2994": [
"37803"
],
"CVE-2015-1489": [
"37812"
],
"CVE-2015-1487": [
"37812"
],
"CVE-2015-1486": [
"37812"
],
"CVE-2015-3082": [
"37840"
],
"CVE-2015-3083": [
"37841"
],
"CVE-2015-3081": [
"37842"
],
"CVE-2015-5116": [
"37851"
],
"CVE-2015-0816": [
"37958"
],
"CVE-2015-0802": [
"37958"
],
"CVE-2012-4940": [
"37996"
],
"CVE-2012-4960": [
"38020"
],
"CVE-2012-5627": [
"38109"
],
"CVE-2015-1538": [
"38124"
],
"CVE-2015-2509": [
"38151",
"38195"
],
"CVE-2012-4366": [
"38164"
],
"CVE-2012-6272": [
"38179"
],
"CVE-2015-7309": [
"38196"
],
"CVE-2012-6429": [
"38206"
],
"CVE-2015-7766": [
"38221"
],
"CVE-2015-7765": [
"38221"
],
"CVE-2015-3864": [
"38226",
"39640",
"40436"
],
"CVE-2013-0177": [
"38230"
],
"CVE-2012-2997": [
"38233"
],
"CVE-2013-1391": [
"38248"
],
"CVE-2013-0804": [
"38250"
],
"CVE-2015-7768": [
"38254",
"39215"
],
"CVE-2015-7603": [
"38260"
],
"CVE-2011-1350": [
"38310"
],
"CVE-2015-7601": [
"38340"
],
"CVE-2015-7602": [
"38341"
],
"CVE-2015-5453": [
"38346"
],
"CVE-2015-5452": [
"38346",
"37440"
],
"CVE-2015-7387": [
"38352",
"38173"
],
"CVE-2013-2560": [
"38356"
],
"CVE-2015-6922": [
"38401",
"38351"
],
"CVE-2013-5094": [
"38368"
],
"CVE-2014-9118": [
"38453"
],
"CVE-2014-8357": [
"38453"
],
"CVE-2014-8356": [
"38453"
],
"CVE-2013-3095": [
"38481"
],
"CVE-2015-6967": [
"38489"
],
"CVE-2013-2645": [
"38492"
],
"CVE-2013-3083": [
"38495"
],
"CVE-2013-2679": [
"38501",
"24202",
"25292"
],
"CVE-2013-2097": [
"38505",
"25519"
],
"CVE-2013-2131": [
"38521"
],
"CVE-2015-7007": [
"38535"
],
"CVE-2013-2134": [
"38549"
],
"CVE-2015-7893": [
"38554"
],
"CVE-2013-3690": [
"38582"
],
"CVE-2013-3539": [
"38583"
],
"CVE-2013-3963": [
"38584"
],
"CVE-2013-2182": [
"38587"
],
"CVE-2013-5620": [
"38632"
],
"CVE-2013-4787": [
"38627"
],
"CVE-2013-4786": [
"38633"
],
"CVE-2013-2261": [
"38636"
],
"CVE-2013-4103": [
"38637"
],
"CVE-2013-2248": [
"38666"
],
"CVE-2013-2739": [
"38667"
],
"CVE-2013-3969": [
"38669"
],
"CVE-2013-1436": [
"38680"
],
"CVE-2013-6826": [
"38824"
],
"CVE-2013-5092": [
"38692"
],
"CVE-2013-4885": [
"38741"
],
"CVE-2013-4978": [
"38742"
],
"CVE-2015-3628": [
"38764"
],
"CVE-2013-1727": [
"38766"
],
"CVE-2015-7858": [
"38797"
],
"CVE-2015-7857": [
"38797"
],
"CVE-2015-7297": [
"38797"
],
"CVE-2013-3827": [
"38802"
],
"CVE-2013-6025": [
"38805"
],
"CVE-2013-6027": [
"38810"
],
"CVE-2013-6246": [
"38812"
],
"CVE-2013-4295": [
"38813"
],
"CVE-2013-3617": [
"38818"
],
"CVE-2013-6792": [
"38821"
],
"CVE-2013-4034": [
"38825"
],
"CVE-2013-4579": [
"38826"
],
"CVE-2013-6875": [
"38827"
],
"CVE-2015-1578": [
"36025"
],
"CVE-2015-1577": [
"36025",
"36026"
],
"CVE-2013-4547": [
"38846"
],
"CVE-2013-5912": [
"38850"
],
"CVE-2010-4417": [
"38859"
],
"CVE-2015-5603": [
"38905",
"38551"
],
"CVE-2013-7420": [
"38910"
],
"CVE-2015-6131": [
"38911"
],
"CVE-2015-6127": [
"38912"
],
"CVE-2013-6492": [
"39097"
],
"CVE-2015-8249": [
"38982"
],
"CVE-2015-8103": [
"38983"
],
"CVE-2013-5880": [
"39018"
],
"CVE-2013-7179": [
"39074"
],
"CVE-2014-2072": [
"39104"
],
"CVE-2013-6835": [
"39114"
],
"CVE-2015-7874": [
"39119"
],
"CVE-2014-2923": [
"39154"
],
"CVE-2014-3146": [
"39155"
],
"CVE-2014-1849": [
"39195"
],
"CVE-2014-0242": [
"39196"
],
"CVE-2014-3004": [
"39205"
],
"CVE-2014-2946": [
"39209"
],
"CVE-2016-3987": [
"39218"
],
"CVE-2014-0007": [
"39222"
],
"CVE-2014-9301": [
"39258"
],
"CVE-2014-9302": [
"39259"
],
"CVE-2015-2080": [
"39455"
],
"CVE-2014-2595": [
"39278"
],
"CVE-2014-5380": [
"39292"
],
"CVE-2014-5381": [
"39293"
],
"CVE-2014-1564": [
"39295"
],
"CVE-2014-6437": [
"39314"
],
"CVE-2014-6436": [
"39316"
],
"CVE-2016-2555": [
"39514"
],
"CVE-2016-1525": [
"39515",
"39412"
],
"CVE-2016-2278": [
"39522"
],
"CVE-2016-3115": [
"39569"
],
"CVE-2016-0710": [
"39643"
],
"CVE-2016-0709": [
"39643"
],
"CVE-2016-4071": [
"39645"
],
"CVE-2015-6086": [
"39698"
],
"CVE-2016-1593": [
"39708",
"39687"
],
"CVE-2016-0854": [
"39735"
],
"CVE-2016-3074": [
"39736"
],
"CVE-2016-3078": [
"39742"
],
"CVE-2016-3081": [
"39756"
],
"CVE-2016-0185": [
"39805"
],
"CVE-2016-1287": [
"39823"
],
"CVE-2014-4977": [
"39836"
],
"CVE-2016-0492": [
"39852",
"39691"
],
"CVE-2016-0491": [
"39852",
"39691"
],
"CVE-2016-2004": [
"39858",
"39874"
],
"CVE-2016-3087": [
"39919",
"43382"
],
"CVE-2015-2866": [
"40441"
],
"CVE-2015-0935": [
"39958"
],
"CVE-2015-6567": [
"40004",
"38000"
],
"CVE-2015-6568": [
"40004",
"38000"
],
"CVE-2016-4971": [
"40064",
"49815"
],
"CVE-2016-6210": [
"40113",
"40136"
],
"CVE-2016-3116": [
"40119"
],
"CVE-2016-3989": [
"40120"
],
"CVE-2016-3962": [
"40120"
],
"CVE-2016-6754": [
"40846"
],
"CVE-2016-5680": [
"40200"
],
"CVE-2016-5679": [
"40200"
],
"CVE-2016-5678": [
"40200"
],
"CVE-2016-5677": [
"40200"
],
"CVE-2016-5676": [
"40200"
],
"CVE-2016-5675": [
"40200"
],
"CVE-2016-5674": [
"40200"
],
"CVE-2016-6366": [
"40258"
],
"CVE-2013-2088": [
"40507"
],
"CVE-2018-5359": [
"43588"
],
"CVE-2018-5347": [
"43659"
],
"CVE-2018-5702": [
"43665"
],
"CVE-2018-5726": [
"43693"
],
"CVE-2018-5725": [
"43693"
],
"CVE-2018-5724": [
"43693"
],
"CVE-2018-5723": [
"43693"
],
"CVE-2018-6000": [
"43881",
"44176"
],
"CVE-2018-5999": [
"43881",
"44176"
],
"CVE-2018-5997": [
"43871"
],
"CVE-2017-14143": [
"43876",
"43028"
],
"CVE-2017-17562": [
"43877",
"43360"
],
"CVE-2016-0752": [
"40561"
],
"CVE-2013-4863": [
"40589",
"27286"
],
"CVE-2016-6255": [
"40589"
],
"CVE-2015-4624": [
"40609"
],
"CVE-2016-5764": [
"40651"
],
"CVE-2014-7205": [
"40689"
],
"CVE-2014-6363": [
"40721"
],
"CVE-2016-6563": [
"40805"
],
"CVE-2016-5639": [
"40813"
],
"CVE-2016-7098": [
"40824"
],
"CVE-2016-3088": [
"40857",
"42283"
],
"CVE-2015-1830": [
"40857",
"48181"
],
"CVE-2016-9796": [
"40862"
],
"CVE-2015-1730": [
"40881"
],
"CVE-2016-8025": [
"40911"
],
"CVE-2016-8024": [
"40911"
],
"CVE-2016-8023": [
"40911"
],
"CVE-2016-8022": [
"40911"
],
"CVE-2016-8021": [
"40911"
],
"CVE-2016-8020": [
"40911"
],
"CVE-2016-8019": [
"40911"
],
"CVE-2016-8018": [
"40911"
],
"CVE-2016-8017": [
"40911"
],
"CVE-2016-8016": [
"40911"
],
"CVE-2016-1252": [
"40916"
],
"CVE-2016-9565": [
"40920"
],
"CVE-2016-10176": [
"40949"
],
"CVE-2016-10175": [
"40949"
],
"CVE-2016-10174": [
"40949",
"41719"
],
"CVE-2016-10009": [
"40963"
],
"CVE-2016-9587": [
"41013"
],
"CVE-2016-6433": [
"41041",
"40463"
],
"CVE-2016-9079": [
"41151",
"42327"
],
"CVE-2017-11517": [
"41153"
],
"CVE-2016-8523": [
"41297"
],
"CVE-2016-9244": [
"41298",
"44446"
],
"CVE-2017-5586": [
"41366"
],
"CVE-2017-6187": [
"41436"
],
"CVE-2017-2361": [
"41443"
],
"CVE-2017-6351": [
"41480"
],
"CVE-2017-6465": [
"41511"
],
"CVE-2017-6506": [
"41545"
],
"CVE-2017-6805": [
"41592"
],
"CVE-2016-6277": [
"41598",
"40889"
],
"CVE-2015-7450": [
"41613"
],
"CVE-2017-5638": [
"41614",
"41570"
],
"CVE-2017-17560": [
"43356"
],
"CVE-2017-7411": [
"43374"
],
"CVE-2016-0792": [
"43375",
"42394"
],
"CVE-2017-17692": [
"43376"
],
"CVE-2016-6415": [
"43383"
],
"CVE-2017-5135": [
"43384"
],
"CVE-2017-5689": [
"43385"
],
"CVE-2016-1909": [
"43386"
],
"CVE-2017-14097": [
"43388"
],
"CVE-2017-14096": [
"43388"
],
"CVE-2017-14095": [
"43388"
],
"CVE-2017-14094": [
"43388"
],
"CVE-2017-11398": [
"43388"
],
"CVE-2017-10271": [
"43392",
"43458",
"43924"
],
"CVE-2017-17968": [
"43408"
],
"CVE-2010-1549": [
"43411"
],
"CVE-2017-5255": [
"43413"
],
"CVE-2018-7756": [
"44275"
],
"CVE-2017-17867": [
"43428"
],
"CVE-2017-17411": [
"43429",
"43363"
],
"CVE-2017-16666": [
"43430"
],
"CVE-2017-6736": [
"43450"
],
"CVE-2018-5262": [
"43478"
],
"CVE-2017-5817": [
"43492",
"43195"
],
"CVE-2017-5816": [
"43493",
"43198"
],
"CVE-2017-6090": [
"43519",
"42934"
],
"CVE-2016-1543": [
"43902",
"43939"
],
"CVE-2016-1542": [
"43902",
"43939"
],
"CVE-2016-5063": [
"43902",
"43934"
],
"CVE-2017-5792": [
"43927"
],
"CVE-2018-14847": [
"45578"
],
"CVE-2017-3066": [
"43993"
],
"CVE-2017-12542": [
"44005"
],
"CVE-2018-6871": [
"44022"
],
"CVE-2018-6892": [
"44027",
"44175",
"45197",
"46250"
],
"CVE-2018-6911": [
"44031"
],
"CVE-2017-18001": [
"44047"
],
"CVE-2017-17761": [
"44048"
],
"CVE-2017-12243": [
"44052"
],
"CVE-2017-15643": [
"44055"
],
"CVE-2017-3897": [
"44067"
],
"CVE-2017-11467": [
"44068"
],
"CVE-2017-12653": [
"44069"
],
"CVE-2017-5815": [
"44073"
],
"CVE-2015-0936": [
"41679"
],
"CVE-2016-1561": [
"41680"
],
"CVE-2016-1560": [
"41680"
],
"CVE-2015-3224": [
"41689"
],
"CVE-2014-0114": [
"41690"
],
"CVE-1999-0502": [
"41694"
],
"CVE-2011-4929": [
"41695"
],
"CVE-2017-6020": [
"42885"
],
"CVE-2016-4372": [
"42756"
],
"CVE-2017-8550": [
"42316"
],
"CVE-2017-11610": [
"42779"
],
"CVE-2017-7240": [
"41718"
],
"CVE-2017-7269": [
"41738",
"41992"
],
"CVE-2017-2619": [
"41740"
],
"CVE-2017-0569": [
"41808"
],
"CVE-2017-7237": [
"41825"
],
"CVE-2017-7455": [
"41850"
],
"CVE-2017-7457": [
"41852"
],
"CVE-2017-6554": [
"41861"
],
"CVE-2017-3881": [
"41872",
"42122"
],
"CVE-2017-8051": [
"41892"
],
"CVE-2017-0160": [
"41903"
],
"CVE-2017-7692": [
"41910"
],
"CVE-2017-2491": [
"41964"
],
"CVE-2017-0290": [
"41975"
],
"CVE-2016-10073": [
"41996"
],
"CVE-2016-10033": [
"41996",
"42024",
"40968",
"40970",
"40969",
"40974",
"40986",
"41962",
"42221"
],
"CVE-2017-6553": [
"42010"
],
"CVE-2017-7494": [
"42084",
"42060"
],
"CVE-2017-9024": [
"42041"
],
"CVE-2017-2536": [
"42125"
],
"CVE-2017-4914": [
"42152"
],
"CVE-2016-9651": [
"42175"
],
"CVE-2017-2741": [
"42176",
"45273"
],
"CVE-2017-6326": [
"42251"
],
"CVE-2017-6334": [
"42257",
"41459",
"41472"
],
"CVE-2017-8895": [
"42282"
],
"CVE-2015-2845": [
"42296",
"36807"
],
"CVE-2015-2843": [
"42296",
"36807"
],
"CVE-2017-10974": [
"42303"
],
"CVE-2017-5375": [
"42327",
"44293",
"44294"
],
"CVE-2016-1960": [
"42484",
"44294"
],
"CVE-2017-1092": [
"42541",
"42091"
],
"CVE-2017-11567": [
"42614"
],
"CVE-2017-9805": [
"42627"
],
"CVE-2017-5177": [
"42693"
],
"CVE-2014-4153": [
"42695"
],
"CVE-2014-5210": [
"42697"
],
"CVE-2015-7901": [
"42698",
"38338"
],
"CVE-2016-8377": [
"42700"
],
"CVE-2013-6810": [
"42701",
"42702"
],
"CVE-2017-8759": [
"42711"
],
"CVE-2013-0946": [
"42719"
],
"CVE-2014-0787": [
"42724"
],
"CVE-2017-6315": [
"42726"
],
"CVE-2017-12930": [
"42753",
"42754"
],
"CVE-2017-12929": [
"42753",
"42755"
],
"CVE-2017-11120": [
"42784"
],
"CVE-2015-4852": [
"42806",
"44552",
"46628"
],
"CVE-2017-6622": [
"42888"
],
"CVE-2017-14084": [
"42891"
],
"CVE-2017-12477": [
"42957",
"43031"
],
"CVE-2017-14702": [
"42952"
],
"CVE-2017-12478": [
"42958",
"43030",
"45559"
],
"CVE-2017-15220": [
"42973"
],
"CVE-2017-7115": [
"42996"
],
"CVE-2017-12617": [
"43008",
"42966"
],
"CVE-2016-2345": [
"43059"
],
"CVE-2016-10401": [
"43105"
],
"CVE-2017-11309": [
"43121"
],
"CVE-2017-8225": [
"43142"
],
"CVE-2017-8224": [
"43142"
],
"CVE-2017-8223": [
"43142"
],
"CVE-2017-8222": [
"43142"
],
"CVE-2017-8221": [
"43142"
],
"CVE-2017-16806": [
"43141"
],
"CVE-2017-11882": [
"43163"
],
"CVE-2017-16930": [
"43231"
],
"CVE-2017-16929": [
"43231"
],
"CVE-2017-15944": [
"43342",
"44597"
],
"CVE-2018-6481": [
"44156"
],
"CVE-2018-7466": [
"44226",
"44349"
],
"CVE-2018-5767": [
"44253"
],
"CVE-2018-7445": [
"44290"
],
"CVE-2018-2380": [
"44292"
],
"CVE-2016-2819": [
"44293"
],
"CVE-2018-6328": [
"44297",
"45559"
],
"CVE-2018-7719": [
"44345"
],
"CVE-2018-5955": [
"44356",
"44044"
],
"CVE-2017-14459": [
"44398"
],
"CVE-2017-0781": [
"44415",
"44554"
],
"CVE-2018-0886": [
"44453"
],
"CVE-2018-10110": [
"44473"
],
"CVE-2018-7600": [
"44482",
"44448",
"44449"
],
"CVE-2018-9059": [
"44485",
"44522"
],
"CVE-2018-2628": [
"44553",
"45193",
"46513"
],
"CVE-2017-0785": [
"44555"
],
"CVE-2017-12611": [
"44556"
],
"CVE-2018-6789": [
"44571",
"45671"
],
"CVE-2018-5234": [
"44574"
],
"CVE-2018-10562": [
"44576"
],
"CVE-2018-10561": [
"44576"
],
"CVE-2018-9995": [
"44577"
],
"CVE-2018-6065": [
"44584"
],
"CVE-2018-7573": [
"44596",
"44968"
],
"CVE-2017-9101": [
"44598",
"42044"
],
"CVE-2017-9080": [
"44599"
],
"CVE-2008-4687": [
"44611",
"6768"
],
"CVE-2017-11885": [
"44616"
],
"CVE-2018-10123": [
"44635"
],
"CVE-2016-9299": [
"44642"
],
"CVE-2017-9791": [
"44643",
"42324"
],
"CVE-2017-8982": [
"44648"
],
"CVE-2017-12500": [
"44648"
],
"CVE-2018-11220": [
"44779"
],
"CVE-2016-4656": [
"44836"
],
"CVE-2016-4655": [
"44836"
],
"CVE-2018-11138": [
"44950"
],
"CVE-2018-1111&": [
"44890"
],
"CVE-2018-8736": [
"44969",
"44560"
],
"CVE-2018-8735": [
"44969",
"44560"
],
"CVE-2018-8734": [
"44969",
"44560"
],
"CVE-2018-8733": [
"44969",
"44560"
],
"CVE-2018-12589": [
"44985"
],
"CVE-2018-10718": [
"44987"
],
"CVE-2018-1612": [
"45005"
],
"CVE-2018-1418": [
"45005"
],
"CVE-2016-9722": [
"45005"
],
"CVE-2017-12636": [
"45019",
"44913"
],
"CVE-2017-12635": [
"45019",
"44498"
],
"CVE-2018-12613": [
"45020",
"44924",
"44928",
"50457"
],
"CVE-2018-0707": [
"45043",
"45015"
],
"CVE-2018-0706": [
"45043",
"45015"
],
"CVE-2018-10662": [
"45100"
],
"CVE-2018-10661": [
"45100"
],
"CVE-2018-10660": [
"45100"
],
"CVE-2018-15473": [
"45210",
"45233",
"45939"
],
"CVE-2018-15576": [
"45227"
],
"CVE-2018-11776": [
"45260",
"45262",
"45367"
],
"CVE-2017-5941": [
"45265",
"49552"
],
"CVE-2018-15685": [
"45272"
],
"CVE-2018-15691": [
"45425"
],
"CVE-2018-8469": [
"45502"
],
"CVE-2018-8468": [
"45502"
],
"CVE-2018-8463": [
"45502"
],
"CVE-2018-15379": [
"45555"
],
"CVE-2018-17553": [
"45561"
],
"CVE-2018-17552": [
"45561"
],
"CVE-2018-17980": [
"45611"
],
"CVE-2018-10933": [
"45638",
"46307"
],
"CVE-2018-7750": [
"45712"
],
"CVE-2018-9206": [
"45790",
"45584",
"46182"
],
"CVE-2016-1555": [
"45909"
],
"CVE-2018-19518": [
"45914"
],
"CVE-2017-12557": [
"45952"
],
"CVE-2015-6396": [
"45986"
],
"CVE-2014-0683": [
"45986"
],
"CVE-2018-4404": [
"45998"
],
"CVE-2018-4233": [
"45998"
],
"CVE-2018-19862": [
"45999"
],
"CVE-2018-19861": [
"45999"
],
"CVE-2018-10021": [
"46052",
"46053"
],
"CVE-2019-9624": [
"46201"
],
"CVE-2019-6111": [
"46193",
"46516"
],
"CVE-2019-6110": [
"46193",
"46516"
],
"CVE-2019-6498": [
"46215"
],
"CVE-2019-6116": [
"46242"
],
"CVE-2016-4117": [
"46339"
],
"CVE-2018-14933": [
"46340"
],
"CVE-2019-6545": [
"46342"
],
"CVE-2019-6543": [
"46342"
],
"CVE-2019-6453": [
"46392"
],
"CVE-2019-3924": [
"46444"
],
"CVE-2018-18982": [
"46449"
],
"CVE-2019-3921": [
"46469"
],
"CVE-2019-6340": [
"46510",
"46452",
"46459"
],
"CVE-2018-3245": [
"46513"
],
"CVE-2019-9194": [
"46539",
"46481"
],
"CVE-2018-1335": [
"46540",
"47208"
],
"CVE-2018-1335 ": [
"46540"
],
"CVE-2019-9760": [
"46543"
],
"CVE-2018-20735": [
"46556"
],
"CVE-2019-10030": [
"46572",
"46427",
"46453",
"48904"
],
"CVE-2019-9692": [
"46627",
"46546"
],
"CVE-2019-10863": [
"46641"
],
"CVE-2019-1653": [
"46655",
"46262"
],
"CVE-2019-1652": [
"46655",
"46243"
],
"CVE-2019-8943": [
"46662",
"46511"
],
"CVE-2019-8942": [
"46662",
"46511"
],
"CVE-2019-6977": [
"46677"
],
"CVE-2019-6989": [
"46678"
],
"CVE-2019-0227": [
"46682"
],
"CVE-2019-9670": [
"46693"
],
"CVE-2019-9621": [
"46693",
"46967"
],
"CVE-2019-11447": [
"46698",
"48800"
],
"CVE-2019-1663": [
"46705",
"46961",
"47348"
],
"CVE-2019-11448": [
"46725"
],
"CVE-2019-3396": [
"46731",
"49465"
],
"CVE-2019-11469": [
"46740"
],
"CVE-2019-11631": [
"46775"
],
"CVE-2019-10123": [
"46782"
],
"CVE-2019-10867": [
"46783"
],
"CVE-2006-2667": [
"6"
],
"CVE-2003-0486": [
"44"
],
"CVE-2015-7259": [
"38772"
],
"CVE-2015-7258": [
"38772"
],
"CVE-2015-7257": [
"38772"
],
"CVE-2003-1216": [
"137"
],
"CVE-2000-1069": [
"177"
],
"CVE-2000-0944": [
"179"
],
"CVE-2001-0272": [
"289"
],
"CVE-2004-2631": [
"309"
],
"CVE-2004-2692": [
"384"
],
"CVE-2004-2218": [
"406"
],
"CVE-2004-1932": [
"465"
],
"CVE-2004-2158": [
"561"
],
"CVE-2004-1567": [
"565"
],
"CVE-2004-1584": [
"570"
],
"CVE-2004-1592": [
"574"
],
"CVE-2004-1515": [
"631"
],
"CVE-2004-2456": [
"635"
],
"CVE-2004-1037": [
"642",
"16894"
],
"CVE-2004-1315": [
"647",
"12510",
"16890",
"24274"
],
"CVE-2004-1531": [
"648"
],
"CVE-2004-2718": [
"703"
],
"CVE-2004-2262": [
"704"
],
"CVE-2005-0283": [
"737"
],
"CVE-2005-0116": [
"772",
"773",
"9912",
"16905"
],
"CVE-2005-0343": [
"790"
],
"CVE-2005-0413": [
"807"
],
"CVE-2005-0368": [
"808"
],
"CVE-2005-0414": [
"814"
],
"CVE-2005-0429": [
"818",
"820"
],
"CVE-2005-0511": [
"832",
"16896"
],
"CVE-2005-0438": [
"853"
],
"CVE-2005-0678": [
"857"
],
"CVE-2005-0700": [
"860"
],
"CVE-2005-0689": [
"862",
"922",
"923"
],
"CVE-2005-0698": [
"864"
],
"CVE-2005-0720": [
"865"
],
"CVE-2005-0647": [
"866"
],
"CVE-2005-0680": [
"870"
],
"CVE-2005-0614": [
"871",
"889",
"897"
],
"CVE-2005-0691": [
"872"
],
"CVE-2005-0792": [
"881"
],
"CVE-2005-0841": [
"892"
],
"CVE-2005-0999": [
"921"
],
"CVE-2007-5728": [
"30090"
],
"CVE-2005-1149": [
"925"
],
"CVE-2005-1051": [
"928"
],
"CVE-2005-1134": [
"939"
],
"CVE-2005-1289": [
"954"
],
"CVE-2004-2275": [
"980"
],
"CVE-2005-1629": [
"989"
],
"CVE-2005-1628": [
"1004",
"1005"
],
"CVE-2005-1779": [
"1010",
"1011",
"1012"
],
"CVE-2005-1598": [
"1013",
"1014",
"43824"
],
"CVE-2005-1784": [
"1015"
],
"CVE-2005-1787": [
"1016",
"1017",
"1018"
],
"CVE-2005-1820": [
"1020"
],
"CVE-2005-1833": [
"1022"
],
"CVE-2005-1500": [
"1023"
],
"CVE-2005-1777": [
"1030"
],
"CVE-2005-1701": [
"1031"
],
"CVE-2005-1950": [
"1039",
"1040",
"1041"
],
"CVE-2004-0734": [
"1048"
],
"CVE-2005-2002": [
"1049"
],
"CVE-2005-2000": [
"1050"
],
"CVE-2005-1375": [
"1052",
"1053",
"25552",
"25553"
],
"CVE-2005-4891": [
"1057"
],
"CVE-2005-2028": [
"1058"
],
"CVE-2005-2075": [
"1068"
],
"CVE-2005-2058": [
"1069",
"25897",
"25898",
"25899",
"25900",
"25901",
"25902",
"25903"
],
"CVE-2005-2067": [
"1070"
],
"CVE-2005-2066": [
"1071"
],
"CVE-2005-2108": [
"1077"
],
"CVE-2005-2116": [
"1078"
],
"CVE-2005-1921": [
"1078",
"1083",
"1084",
"16882",
"43829"
],
"CVE-2005-2113": [
"1082",
"43827"
],
"CVE-2005-2106": [
"1088"
],
"CVE-2005-2229": [
"1097"
],
"CVE-2005-2327": [
"1106"
],
"CVE-2005-2086": [
"1113",
"16890"
],
"CVE-2005-2420": [
"1120"
],
"CVE-2005-2468": [
"1134"
],
"CVE-2005-4208": [
"1140",
"1367"
],
"CVE-2005-2540": [
"1140"
],
"CVE-2005-2697": [
"1172"
],
"CVE-2005-2787": [
"1191"
],
"CVE-2005-2733": [
"1191",
"16883"
],
"CVE-2005-2192": [
"1191"
],
"CVE-2005-2812": [
"1194"
],
"CVE-2005-2323": [
"1208"
],
"CVE-2005-4724": [
"1211"
],
"CVE-2005-2951": [
"1214"
],
"CVE-2008-0092": [
"1217"
],
"CVE-2005-4792": [
"1217"
],
"CVE-2005-3010": [
"1221"
],
"CVE-2005-3045": [
"1225"
],
"CVE-2005-3048": [
"1226"
],
"CVE-2005-3063": [
"1227"
],
"CVE-2005-2848": [
"1236"
],
"CVE-2005-2847": [
"1236",
"16893"
],
"CVE-2005-3157": [
"1237"
],
"CVE-2005-3201": [
"1240"
],
"CVE-2005-3575": [
"1241",
"1321"
],
"CVE-2005-3299": [
"1244"
],
"CVE-2005-3259": [
"1245"
],
"CVE-2005-4656": [
"1273"
],
"CVE-2005-3423": [
"1278"
],
"CVE-2009-4115": [
"1289"
],
"CVE-2005-3545": [
"1296"
],
"CVE-2005-4155": [
"1298"
],
"CVE-2005-3649": [
"1312"
],
"CVE-2005-3681": [
"1315"
],
"CVE-2005-3686": [
"1319"
],
"CVE-2005-3696": [
"1320"
],
"CVE-2005-3682": [
"1322",
"26503",
"26504"
],
"CVE-2005-4226": [
"1324",
"1325"
],
"CVE-2005-4218": [
"1324",
"1325"
],
"CVE-2005-3792": [
"1326"
],
"CVE-2005-3738": [
"1337"
],
"CVE-2005-4171": [
"1340"
],
"CVE-2005-3926": [
"1342"
],
"CVE-2005-3996": [
"1354"
],
"CVE-2005-4095": [
"1356"
],
"CVE-2005-4087": [
"1359",
"1364"
],
"CVE-2005-4086": [
"1359",
"1364"
],
"CVE-2005-4135": [
"1361"
],
"CVE-2005-4140": [
"1363"
],
"CVE-2005-4449": [
"1367"
],
"CVE-2005-4213": [
"1370"
],
"CVE-2005-4318": [
"1373"
],
"CVE-2005-4468": [
"1379"
],
"CVE-2005-4467": [
"1379"
],
"CVE-2005-4517": [
"1385"
],
"CVE-2005-4554": [
"1387",
"26976",
"26977"
],
"CVE-2005-4593": [
"1395"
],
"CVE-2006-0064": [
"1398"
],
"CVE-2006-0099": [
"1401"
],
"CVE-2006-0157": [
"1410"
],
"CVE-2006-0199": [
"1418",
"1419"
],
"CVE-2006-0214": [
"1442"
],
"CVE-2006-0478": [
"1446"
],
"CVE-2006-0444": [
"1453"
],
"CVE-2006-0520": [
"1461"
],
"CVE-2006-0565": [
"1467"
],
"CVE-2006-0583": [
"1468"
],
"CVE-2006-0628": [
"1471"
],
"CVE-2006-0644": [
"1478"
],
"CVE-2006-0626": [
"1482"
],
"CVE-2006-0658": [
"1484",
"3702"
],
"CVE-2006-1793": [
"1485"
],
"CVE-2006-0659": [
"1485"
],
"CVE-2006-0687": [
"1491"
],
"CVE-2006-0750": [
"1492"
],
"CVE-2006-0714": [
"1494"
],
"CVE-2006-0728": [
"1498"
],
"CVE-2006-0786": [
"1501"
],
"CVE-2005-4633": [
"1509"
],
"CVE-2005-4619": [
"1509"
],
"CVE-2005-2564": [
"1510"
],
"CVE-2006-0852": [
"1512"
],
"CVE-2006-0821": [
"1513"
],
"CVE-2006-0870": [
"1514"
],
"CVE-2006-0851": [
"1516"
],
"CVE-2006-0891": [
"1522"
],
"CVE-2006-0973": [
"1525"
],
"CVE-2006-1001": [
"1526"
],
"CVE-2006-1031": [
"1527"
],
"CVE-2006-1000": [
"1528"
],
"CVE-2005-3363": [
"1530",
"26390"
],
"CVE-2006-0943": [
"1532"
],
"CVE-2006-0668": [
"1532"
],
"CVE-2006-0899": [
"1533"
],
"CVE-2006-0660": [
"1538",
"27183"
],
"CVE-2006-0959": [
"1539",
"1548"
],
"CVE-2006-1662": [
"1541",
"1563"
],
"CVE-2006-1032": [
"1542",
"43836"
],
"CVE-2006-0962": [
"1543"
],
"CVE-2006-1094": [
"1544"
],
"CVE-2006-1112": [
"1547"
],
"CVE-2006-1111": [
"1547"
],
"CVE-2006-1110": [
"1547"
],
"CVE-2006-1109": [
"1550"
],
"CVE-2006-1153": [
"1556"
],
"CVE-2006-1149": [
"1561"
],
"CVE-2006-0961": [
"1562"
],
"CVE-2006-1219": [
"1566"
],
"CVE-2006-1140": [
"1567"
],
"CVE-2006-1123": [
"1569"
],
"CVE-2006-1252": [
"1570"
],
"CVE-2006-0206": [
"1570"
],
"CVE-2006-1213": [
"1571"
],
"CVE-2006-1223": [
"1576"
],
"CVE-2006-1243": [
"1581"
],
"CVE-2006-1292": [
"1585"
],
"CVE-2006-1291": [
"1586"
],
"CVE-2006-1164": [
"1588"
],
"CVE-2006-1162": [
"1588"
],
"CVE-2006-1333": [
"1589"
],
"CVE-2006-0940": [
"1590"
],
"CVE-2006-1327": [
"1594"
],
"CVE-2006-1348": [
"1595"
],
"CVE-2006-1347": [
"1595"
],
"CVE-2006-1346": [
"1595"
],
"CVE-2006-1353": [
"1597"
],
"CVE-2006-1363": [
"1600"
],
"CVE-2006-1371": [
"1605"
],
"CVE-2006-1480": [
"1608"
],
"CVE-2006-1481": [
"1609"
],
"CVE-2006-1422": [
"1610",
"5696"
],
"CVE-2006-1412": [
"1611"
],
"CVE-2006-1495": [
"1617"
],
"CVE-2006-1688": [
"1629"
],
"CVE-2006-1610": [
"1629"
],
"CVE-2006-1645": [
"1631"
],
"CVE-2006-1668": [
"1645"
],
"CVE-2006-1667": [
"1645"
],
"CVE-2006-1710": [
"1653"
],
"CVE-2006-1694": [
"1655"
],
"CVE-2006-1491": [
"1660"
],
"CVE-2006-1708": [
"1662"
],
"CVE-2006-2029": [
"1663",
"1705"
],
"CVE-2006-1779": [
"1663"
],
"CVE-2006-1778": [
"1663"
],
"CVE-2006-1777": [
"1663"
],
"CVE-2006-1776": [
"1663"
],
"CVE-2006-0147": [
"1663"
],
"CVE-2006-0146": [
"1663"
],
"CVE-2006-1784": [
"1665"
],
"CVE-2006-1828": [
"1666"
],
"CVE-2006-1799": [
"1669"
],
"CVE-2006-1832": [
"1677"
],
"CVE-2006-1831": [
"1677"
],
"CVE-2006-0522": [
"1680"
],
"CVE-2006-1838": [
"1682"
],
"CVE-2006-1837": [
"1682"
],
"CVE-2006-1917": [
"1683"
],
"CVE-2006-1978": [
"1686"
],
"CVE-2006-1919": [
"1694"
],
"CVE-2006-1921": [
"1695"
],
"CVE-2006-2065": [
"1701"
],
"CVE-2006-2032": [
"1704"
],
"CVE-2006-1994": [
"1706"
],
"CVE-2006-2002": [
"1707"
],
"CVE-2006-2005": [
"1710"
],
"CVE-2006-2008": [
"1711"
],
"CVE-2006-2034": [
"1713"
],
"CVE-2005-1287": [
"1714"
],
"CVE-2006-2059": [
"1720"
],
"CVE-2006-2151": [
"1722",
"1724"
],
"CVE-2006-2152": [
"1723"
],
"CVE-2006-2137": [
"1727"
],
"CVE-2006-2134": [
"1728"
],
"CVE-2006-2142": [
"1729"
],
"CVE-2006-7026": [
"1730"
],
"CVE-2006-2149": [
"1732"
],
"CVE-2006-2097": [
"1733"
],
"CVE-2006-2156": [
"1738"
],
"CVE-2006-2175": [
"1740"
],
"CVE-2006-2182": [
"1744"
],
"CVE-2006-2245": [
"1747"
],
"CVE-2006-2363": [
"1751"
],
"CVE-2006-2253": [
"1752"
],
"CVE-2006-7055": [
"1753"
],
"CVE-2006-2237": [
"1755",
"9909",
"16886"
],
"CVE-2006-0759": [
"1756"
],
"CVE-2006-0757": [
"1756",
"27184",
"27185"
],
"CVE-2006-2263": [
"1759"
],
"CVE-2006-2331": [
"1760"
],
"CVE-2006-2330": [
"1760"
],
"CVE-2006-2270": [
"1761"
],
"CVE-2006-2261": [
"1763"
],
"CVE-2006-2256": [
"1764"
],
"CVE-2006-2285": [
"1765"
],
"CVE-2006-7048": [
"1766"
],
"CVE-2006-2284": [
"1766"
],
"CVE-2006-1959": [
"1767"
],
"CVE-2006-2323": [
"1769"
],
"CVE-2006-1749": [
"1769"
],
"CVE-2006-2361": [
"1774"
],
"CVE-2006-2406": [
"1777"
],
"CVE-2006-2405": [
"1777"
],
"CVE-2006-2507": [
"1778"
],
"CVE-2006-2392": [
"1779"
],
"CVE-2006-2460": [
"1785"
],
"CVE-2006-2557": [
"1789"
],
"CVE-2006-2483": [
"1790"
],
"CVE-2006-2503": [
"1793"
],
"CVE-2006-2424": [
"1795"
],
"CVE-2006-2459": [
"1796"
],
"CVE-2006-4558": [
"1797"
],
"CVE-2006-2485": [
"1798"
],
"CVE-2006-2487": [
"1800"
],
"CVE-2006-2528": [
"1804"
],
"CVE-2006-2527": [
"1804"
],
"CVE-2006-2523": [
"1805"
],
"CVE-2006-2541": [
"1807"
],
"CVE-2006-2521": [
"1808"
],
"CVE-2006-2570": [
"1809"
],
"CVE-2006-2569": [
"1810"
],
"CVE-2006-2516": [
"1811"
],
"CVE-2006-3387": [
"1812"
],
"CVE-2006-2568": [
"1814"
],
"CVE-2006-2583": [
"1816"
],
"CVE-2006-2577": [
"1817"
],
"CVE-2006-2576": [
"1817"
],
"CVE-2006-2798": [
"1818"
],
"CVE-2006-2797": [
"1818"
],
"CVE-2006-2743": [
"1821"
],
"CVE-2006-2685": [
"1823",
"9908",
"16897"
],
"CVE-2006-2683": [
"1824"
],
"CVE-2006-2682": [
"1825"
],
"CVE-2006-2681": [
"1826"
],
"CVE-2006-2666": [
"1827"
],
"CVE-2006-2665": [
"1827"
],
"CVE-2006-2668": [
"1828"
],
"CVE-2006-2686": [
"1829"
],
"CVE-2006-2645": [
"1832"
],
"CVE-2006-0725": [
"1832"
],
"CVE-2006-2638": [
"1833"
],
"CVE-2006-2697": [
"1834"
],
"CVE-2006-2696": [
"1834"
],
"CVE-2006-2730": [
"1835"
],
"CVE-2006-2740": [
"1839"
],
"CVE-2006-2739": [
"1839"
],
"CVE-2006-2731": [
"1840"
],
"CVE-2006-2746": [
"1841"
],
"CVE-2006-2745": [
"1841"
],
"CVE-2006-2744": [
"1841"
],
"CVE-2006-2725": [
"1842"
],
"CVE-2006-2755": [
"1843"
],
"CVE-2006-2675": [
"1843"
],
"CVE-2006-2735": [
"1844"
],
"CVE-2006-2794": [
"1845"
],
"CVE-2006-2793": [
"1845"
],
"CVE-2006-2736": [
"1846"
],
"CVE-2006-2650": [
"1847"
],
"CVE-2006-2726": [
"1848"
],
"CVE-2006-2807": [
"1849"
],
"CVE-2006-2737": [
"1850"
],
"CVE-2006-2834": [
"1851"
],
"CVE-2006-2770": [
"1853",
"6972"
],
"CVE-2006-2767": [
"1854"
],
"CVE-2006-2768": [
"1855"
],
"CVE-2006-7063": [
"1857"
],
"CVE-2006-2841": [
"1858"
],
"CVE-2006-2848": [
"1859"
],
"CVE-2006-2847": [
"1859"
],
"CVE-2006-2849": [
"1860"
],
"CVE-2006-2845": [
"1861"
],
"CVE-2006-2844": [
"1861"
],
"CVE-2006-2843": [
"1861"
],
"CVE-2006-2819": [
"1863"
],
"CVE-2003-1292": [
"1864"
],
"CVE-2006-2818": [
"1865"
],
"CVE-2006-2828": [
"1866"
],
"CVE-2006-2889": [
"1868"
],
"CVE-2006-2866": [
"1869"
],
"CVE-2006-2864": [
"1870"
],
"CVE-2006-2860": [
"1871"
],
"CVE-2006-2863": [
"1872"
],
"CVE-2006-2857": [
"1874"
],
"CVE-2006-2896": [
"1875"
],
"CVE-2006-7012": [
"1876"
],
"CVE-2006-2868": [
"1877"
],
"CVE-2006-2861": [
"1878"
],
"CVE-2006-2852": [
"1879"
],
"CVE-2006-2881": [
"1881"
],
"CVE-2006-2947": [
"1882"
],
"CVE-2006-2946": [
"1882"
],
"CVE-2006-2888": [
"1883"
],
"CVE-2006-2887": [
"1884",
"27979"
],
"CVE-2006-2929": [
"1886"
],
"CVE-2006-2928": [
"1890"
],
"CVE-2006-2982": [
"1891"
],
"CVE-2006-2962": [
"1895"
],
"CVE-2006-2996": [
"1896"
],
"CVE-2006-2995": [
"1898"
],
"CVE-2006-2998": [
"1899"
],
"CVE-2006-3172": [
"1903"
],
"CVE-2006-3065": [
"1904"
],
"CVE-2006-3028": [
"1908"
],
"CVE-2006-2908": [
"1909"
],
"CVE-2006-3177": [
"1912"
],
"CVE-2006-3076": [
"1913"
],
"CVE-2006-2914": [
"1916"
],
"CVE-2006-3105": [
"1918"
],
"CVE-2006-3104": [
"1918"
],
"CVE-2006-3103": [
"1918"
],
"CVE-2006-3102": [
"1918"
],
"CVE-2006-3186": [
"1919"
],
"CVE-2006-3262": [
"1920",
"1941"
],
"CVE-2006-7032": [
"1921"
],
"CVE-2006-7247": [
"1922"
],
"CVE-2006-3192": [
"1923"
],
"CVE-2006-7017": [
"1925"
],
"CVE-2006-1767": [
"1925",
"27625"
],
"CVE-2006-0688": [
"1925"
],
"CVE-2008-5199": [
"1928"
],
"CVE-2006-3144": [
"1929"
],
"CVE-2006-3213": [
"1930"
],
"CVE-2006-3580": [
"1931"
],
"CVE-2006-3184": [
"1931"
],
"CVE-2006-3193": [
"1933"
],
"CVE-2006-3421": [
"1936",
"1974"
],
"CVE-2006-3162": [
"1936"
],
"CVE-2006-3221": [
"1938",
"1939"
],
"CVE-2007-4127": [
"1942"
],
"CVE-2006-3210": [
"1942"
],
"CVE-2006-7024": [
"1943"
],
"CVE-2006-3292": [
"1946"
],
"CVE-2006-3300": [
"1948"
],
"CVE-2006-3266": [
"1951"
],
"CVE-2006-3269": [
"1952"
],
"CVE-2006-3304": [
"1953"
],
"CVE-2006-6232": [
"1954"
],
"CVE-2006-3294": [
"1955"
],
"CVE-2006-3340": [
"1956"
],
"CVE-2006-3309": [
"1957"
],
"CVE-2006-6962": [
"1959"
],
"CVE-2006-3364": [
"1960"
],
"CVE-2006-3341": [
"1961"
],
"CVE-2006-6225": [
"1963"
],
"CVE-2006-3362": [
"1964"
],
"CVE-2006-3347": [
"1968"
],
"CVE-2006-3361": [
"1969"
],
"CVE-2006-7021": [
"1970"
],
"CVE-2006-3375": [
"1971"
],
"CVE-2006-3394": [
"1975"
],
"CVE-2006-3396": [
"1981"
],
"CVE-2006-3422": [
"1982"
],
"CVE-2006-3478": [
"1983"
],
"CVE-2006-3147": [
"1987"
],
"CVE-2006-3533": [
"1991"
],
"CVE-2006-3532": [
"1991"
],
"CVE-2006-3531": [
"1991"
],
"CVE-2006-3572": [
"1993"
],
"CVE-2006-3571": [
"1993"
],
"CVE-2006-3528": [
"1994"
],
"CVE-2006-7208": [
"1995"
],
"CVE-2006-3520": [
"1996"
],
"CVE-2006-3611": [
"2008"
],
"CVE-2006-3685": [
"2009"
],
"CVE-2005-0859": [
"2009",
"25244"
],
"CVE-2006-7071": [
"2010",
"2033"
],
"CVE-2011-5035": [
"2012"
],
"CVE-2011-5034": [
"2012"
],
"CVE-2011-4858": [
"2012"
],
"CVE-2011-4084": [
"2012"
],
"CVE-2006-3775": [
"2012"
],
"CVE-2006-3755": [
"2018"
],
"CVE-2006-3754": [
"2018"
],
"CVE-2006-3735": [
"2019"
],
"CVE-2006-3736": [
"2020"
],
"CVE-2006-3773": [
"2021"
],
"CVE-2006-3748": [
"2023"
],
"CVE-2006-3530": [
"2024"
],
"CVE-2006-3774": [
"2025"
],
"CVE-2006-3750": [
"2026"
],
"CVE-2006-3751": [
"2027"
],
"CVE-2006-3749": [
"2028"
],
"CVE-2006-5045": [
"2029"
],
"CVE-2006-3690": [
"2030"
],
"CVE-2006-3727": [
"2032"
],
"CVE-2006-3772": [
"2036"
],
"CVE-2006-3771": [
"2046"
],
"CVE-2006-3793": [
"2049"
],
"CVE-2006-3832": [
"2050"
],
"CVE-2006-3917": [
"2058"
],
"CVE-2006-3911": [
"2060"
],
"CVE-2006-3847": [
"2062"
],
"CVE-2006-3951": [
"2064"
],
"CVE-2006-3846": [
"2066"
],
"CVE-2006-3851": [
"2068"
],
"CVE-2006-5044": [
"2069"
],
"CVE-2006-3904": [
"2071"
],
"CVE-2006-7070": [
"2072"
],
"CVE-2006-3928": [
"2077"
],
"CVE-2006-3930": [
"2078"
],
"CVE-2006-3922": [
"2081"
],
"CVE-2006-5048": [
"2083"
],
"CVE-2006-3980": [
"2084"
],
"CVE-2006-3969": [
"2085"
],
"CVE-2006-3947": [
"2086"
],
"CVE-2006-4004": [
"2087"
],
"CVE-2006-3996": [
"2088"
],
"CVE-2006-3995": [
"2089"
],
"CVE-2006-3962": [
"2090"
],
"CVE-2006-3970": [
"2092"
],
"CVE-2006-3983": [
"2095"
],
"CVE-2006-3966": [
"2096"
],
"CVE-2006-3986": [
"2097"
],
"CVE-2006-4085": [
"2098"
],
"CVE-2006-4055": [
"2098",
"2116"
],
"CVE-2006-3993": [
"2098"
],
"CVE-2006-3998": [
"2099"
],
"CVE-2006-3984": [
"2100"
],
"CVE-2006-3988": [
"2101"
],
"CVE-2006-3991": [
"2102"
],
"CVE-2006-3989": [
"2103"
],
"CVE-2006-3987": [
"2104"
],
"CVE-2006-3994": [
"2105"
],
"CVE-2006-4012": [
"2113"
],
"CVE-2006-4011": [
"2115"
],
"CVE-2006-4042": [
"2118"
],
"CVE-2006-4052": [
"2119"
],
"CVE-2006-4051": [
"2120"
],
"CVE-2006-4045": [
"2121"
],
"CVE-2006-4053": [
"2122"
],
"CVE-2006-4102": [
"2123"
],
"CVE-2006-4074": [
"2125"
],
"CVE-2006-4034": [
"2127"
],
"CVE-2006-4063": [
"2128",
"2129",
"2130",
"2131"
],
"CVE-2006-4026": [
"2128"
],
"CVE-2006-4065": [
"2130"
],
"CVE-2006-4062": [
"2131"
],
"CVE-2006-4050": [
"2132"
],
"CVE-2006-4073": [
"2134"
],
"CVE-2006-4059": [
"2135"
],
"CVE-2006-4064": [
"2138"
],
"CVE-2006-4044": [
"2139"
],
"CVE-2006-4060": [
"2141"
],
"CVE-2006-4036": [
"2142"
],
"CVE-2006-3819": [
"2143"
],
"CVE-2006-4075": [
"2146"
],
"CVE-2006-4103": [
"2148"
],
"CVE-2006-4113": [
"2149"
],
"CVE-2006-4072": [
"2150"
],
"CVE-2006-4077": [
"2151"
],
"CVE-2006-4123": [
"2153"
],
"CVE-2006-4115": [
"2154"
],
"CVE-2006-4121": [
"2155"
],
"CVE-2006-4437": [
"2157"
],
"CVE-2006-4166": [
"2158"
],
"CVE-2006-4114": [
"2159"
],
"CVE-2006-4158": [
"2165"
],
"CVE-2006-4213": [
"2166"
],
"CVE-2002-2298": [
"2166"
],
"CVE-2006-4164": [
"2168"
],
"CVE-2006-4216": [
"2169"
],
"CVE-2006-4159": [
"2169"
],
"CVE-2007-2312": [
"2170"
],
"CVE-2006-4142": [
"2170"
],
"CVE-2006-4209": [
"2171"
],
"CVE-2006-4130": [
"2172"
],
"CVE-2006-4160": [
"2173"
],
"CVE-2006-4198": [
"2174"
],
"CVE-2006-4196": [
"2175"
],
"CVE-2006-4129": [
"2177"
],
"CVE-2006-4191": [
"2178"
],
"CVE-2006-4210": [
"2181"
],
"CVE-2006-4203": [
"2182"
],
"CVE-2006-4205": [
"2183"
],
"CVE-2006-4195": [
"2184"
],
"CVE-2006-4202": [
"2186",
"2421"
],
"CVE-2006-4207": [
"2188"
],
"CVE-2006-4217": [
"2189"
],
"CVE-2006-4204": [
"2190"
],
"CVE-2006-4234": [
"2191"
],
"CVE-2006-4239": [
"2192"
],
"CVE-2006-4321": [
"2196"
],
"CVE-2006-4267": [
"2198"
],
"CVE-2006-4237": [
"2199"
],
"CVE-2006-4238": [
"2200"
],
"CVE-2006-4236": [
"2201"
],
"CVE-2006-4270": [
"2202"
],
"CVE-2006-4242": [
"2203"
],
"CVE-2006-3990": [
"2205",
"28273"
],
"CVE-2006-4288": [
"2207"
],
"CVE-2006-3949": [
"2209"
],
"CVE-2006-4291": [
"2211"
],
"CVE-2006-4282": [
"2213"
],
"CVE-2006-4348": [
"2215"
],
"CVE-2006-4311": [
"2216"
],
"CVE-2006-4363": [
"2217"
],
"CVE-2006-4448": [
"2218"
],
"CVE-2006-4277": [
"2220"
],
"CVE-2006-4276": [
"2220"
],
"CVE-2006-4285": [
"2221"
],
"CVE-2006-4372": [
"2222"
],
"CVE-2006-4296": [
"2225"
],
"CVE-2006-4287": [
"2226"
],
"CVE-2006-4278": [
"2227",
"18018"
],
"CVE-2006-4300": [
"2228",
"2232"
],
"CVE-2006-4329": [
"2229"
],
"CVE-2006-4284": [
"2230"
],
"CVE-2006-4354": [
"2239"
],
"CVE-2006-4367": [
"2248"
],
"CVE-2006-4373": [
"2249"
],
"CVE-2006-4369": [
"2250"
],
"CVE-2006-4368": [
"2250"
],
"CVE-2006-4365": [
"2251"
],
"CVE-2006-4418": [
"2252"
],
"CVE-2006-4420": [
"2253"
],
"CVE-2006-4425": [
"2254"
],
"CVE-2006-4424": [
"2254"
],
"CVE-2006-4427": [
"2255"
],
"CVE-2006-7068": [
"2257"
],
"CVE-2006-4419": [
"2259"
],
"CVE-2006-4426": [
"2260"
],
"CVE-2006-4536": [
"2262"
],
"CVE-2006-4441": [
"2263"
],
"CVE-2006-4440": [
"2263"
],
"CVE-2006-4490": [
"2266"
],
"CVE-2006-4444": [
"2267"
],
"CVE-2006-4452": [
"2269"
],
"CVE-2006-4458": [
"2270"
],
"CVE-2006-4498": [
"2271"
],
"CVE-2006-4489": [
"2272"
],
"CVE-2006-4488": [
"2273"
],
"CVE-2006-4456": [
"2275"
],
"CVE-2006-4749": [
"2279"
],
"CVE-2006-4594": [
"2279"
],
"CVE-2006-4604": [
"2280"
],
"CVE-2006-4531": [
"2281"
],
"CVE-2006-4559": [
"2282"
],
"CVE-2006-4532": [
"2282"
],
"CVE-2006-4596": [
"2285"
],
"CVE-2006-4597": [
"2287"
],
"CVE-2006-4602": [
"2288",
"16885"
],
"CVE-2006-4601": [
"2289"
],
"CVE-2006-4589": [
"2290"
],
"CVE-2005-1312": [
"2292"
],
"CVE-2006-4583": [
"2293"
],
"CVE-2006-4641": [
"2294"
],
"CVE-2006-4592": [
"2296"
],
"CVE-2006-4586": [
"2297"
],
"CVE-2006-4584": [
"2297",
"12385"
],
"CVE-2006-4633": [
"2300"
],
"CVE-2006-4632": [
"2300"
],
"CVE-2006-4630": [
"2301"
],
"CVE-2006-4610": [
"2304"
],
"CVE-2006-4622": [
"2305"
],
"CVE-2006-4612": [
"2306",
"2382"
],
"CVE-2006-4638": [
"2307"
],
"CVE-2006-4629": [
"2308"
],
"CVE-2006-4647": [
"2309"
],
"CVE-2006-4636": [
"2310"
],
"CVE-2006-4664": [
"2311"
],
"CVE-2006-4649": [
"2312"
],
"CVE-2006-4648": [
"2312"
],
"CVE-2006-4644": [
"2313"
],
"CVE-2006-4645": [
"2315"
],
"CVE-2006-4672": [
"2316"
],
"CVE-2006-5291": [
"2317",
"2521"
],
"CVE-2006-4656": [
"2317",
"2521"
],
"CVE-2006-4746": [
"2318"
],
"CVE-2006-4716": [
"2319"
],
"CVE-2006-7081": [
"2323"
],
"CVE-2006-4637": [
"2324"
],
"CVE-2006-4678": [
"2325"
],
"CVE-2006-4666": [
"2326",
"28493"
],
"CVE-2006-4670": [
"2327"
],
"CVE-2007-0704": [
"2329"
],
"CVE-2006-4669": [
"2329"
],
"CVE-2006-4721": [
"2333"
],
"CVE-2006-4719": [
"2335"
],
"CVE-2006-7069": [
"2336"
],
"CVE-2006-4715": [
"2337",
"6789"
],
"CVE-2006-4714": [
"2339",
"6789"
],
"CVE-2006-4713": [
"2340"
],
"CVE-2006-4722": [
"2341"
],
"CVE-2006-4720": [
"2342"
],
"CVE-2006-4770": [
"2343"
],
"CVE-2006-4750": [
"2344"
],
"CVE-2006-4764": [
"2346"
],
"CVE-2006-4742": [
"2347"
],
"CVE-2006-4741": [
"2347"
],
"CVE-2006-4780": [
"2349"
],
"CVE-2006-4769": [
"2350"
],
"CVE-2006-4782": [
"2352"
],
"CVE-2006-4779": [
"2353"
],
"CVE-2006-4889": [
"2354",
"28522",
"28523",
"28524",
"28525",
"28526",
"28527",
"28528",
"28529",
"28530",
"28531",
"28532",
"28533",
"28534",
"28535",
"28536",
"28537",
"28538",
"28539",
"28540",
"28541"
],
"CVE-2006-4788": [
"2354"
],
"CVE-2006-4824": [
"2356"
],
"CVE-2006-4869": [
"2357"
],
"CVE-2006-4827": [
"2359"
],
"CVE-2006-4885": [
"2361"
],
"CVE-2006-4826": [
"2361"
],
"CVE-2006-4793": [
"2362"
],
"CVE-2006-4823": [
"2363"
],
"CVE-2006-5919": [
"2364"
],
"CVE-2006-4766": [
"2365"
],
"CVE-2006-4834": [
"2366"
],
"CVE-2006-4858": [
"2367"
],
"CVE-2006-4845": [
"2368"
],
"CVE-2006-4828": [
"2369"
],
"CVE-2006-4859": [
"2370"
],
"CVE-2006-4853": [
"2371"
],
"CVE-2006-4850": [
"2372"
],
"CVE-2006-4912": [
"2373"
],
"CVE-2006-4922": [
"2374"
],
"CVE-2006-4921": [
"2374"
],
"CVE-2006-4920": [
"2374"
],
"CVE-2006-4979": [
"2376"
],
"CVE-2006-4978": [
"2376"
],
"CVE-2006-4977": [
"2376"
],
"CVE-2006-4865": [
"2376"
],
"CVE-2006-4870": [
"2377"
],
"CVE-2006-4867": [
"2378"
],
"CVE-2006-5254": [
"2379"
],
"CVE-2006-4890": [
"2380"
],
"CVE-2006-4898": [
"2381"
],
"CVE-2006-4849": [
"2383"
],
"CVE-2006-4852": [
"2384"
],
"CVE-2006-4892": [
"2385"
],
"CVE-2006-4891": [
"2386"
],
"CVE-2006-4882": [
"2387"
],
"CVE-2006-4897": [
"2388"
],
"CVE-2006-4913": [
"2389"
],
"CVE-2006-4968": [
"2390"
],
"CVE-2006-4963": [
"2391"
],
"CVE-2006-4970": [
"2392"
],
"CVE-2006-4969": [
"2393"
],
"CVE-2006-4906": [
"2394"
],
"CVE-2006-4916": [
"2395"
],
"CVE-2006-4918": [
"2396"
],
"CVE-2006-4957": [
"2397"
],
"CVE-2006-4945": [
"2398"
],
"CVE-2006-4946": [
"2399"
],
"CVE-2006-4962": [
"2402",
"4277"
],
"CVE-2006-4961": [
"2402"
],
"CVE-2006-4960": [
"2402"
],
"CVE-2006-4993": [
"2405"
],
"CVE-2006-5030": [
"2406"
],
"CVE-2006-5022": [
"2407"
],
"CVE-2006-5032": [
"2409"
],
"CVE-2006-4966": [
"2410"
],
"CVE-2006-4944": [
"2411"
],
"CVE-2006-5020": [
"2413"
],
"CVE-2006-4989": [
"2414"
],
"CVE-2006-4988": [
"2414"
],
"CVE-2006-4987": [
"2414"
],
"CVE-2006-7080": [
"2415"
],
"CVE-2006-7079": [
"2415"
],
"CVE-2006-5023": [
"2416"
],
"CVE-2006-5017": [
"2418"
],
"CVE-2006-5053": [
"2419"
],
"CVE-2006-5065": [
"2420"
],
"CVE-2006-5061": [
"2422"
],
"CVE-2006-5054": [
"2423"
],
"CVE-2006-5055": [
"2424"
],
"CVE-2006-5078": [
"2427"
],
"CVE-2006-5062": [
"2428"
],
"CVE-2006-5077": [
"2429"
],
"CVE-2006-5087": [
"2431"
],
"CVE-2006-5068": [
"2432",
"2433"
],
"CVE-2006-5070": [
"2434"
],
"CVE-2006-5100": [
"2435"
],
"CVE-2006-5092": [
"2436"
],
"CVE-2006-5079": [
"2437"
],
"CVE-2006-5102": [
"2439"
],
"CVE-2006-5086": [
"2441"
],
"CVE-2006-5085": [
"2441"
],
"CVE-2006-5135": [
"2442"
],
"CVE-2006-5180": [
"2443"
],
"CVE-2006-5165": [
"2446"
],
"CVE-2006-5115": [
"2447"
],
"CVE-2006-5093": [
"2450"
],
"CVE-2006-5125": [
"2451",
"2462"
],
"CVE-2006-5124": [
"2451",
"2462"
],
"CVE-2006-5094": [
"2453"
],
"CVE-2006-5126": [
"2454"
],
"CVE-2006-5155": [
"2455"
],
"CVE-2006-5140": [
"2456"
],
"CVE-2006-5137": [
"2457"
],
"CVE-2006-5148": [
"2459"
],
"CVE-2006-5147": [
"2461"
],
"CVE-2006-5181": [
"2462"
],
"CVE-2006-5167": [
"2465"
],
"CVE-2006-5187": [
"2468"
],
"CVE-2008-1609": [
"2469",
"2474",
"5317"
],
"CVE-2006-7128": [
"2469",
"5317"
],
"CVE-2006-5186": [
"2470"
],
"CVE-2006-5182": [
"2471"
],
"CVE-2006-5189": [
"2472"
],
"CVE-2006-5206": [
"2473"
],
"CVE-2006-5205": [
"2473"
],
"CVE-2006-7127": [
"2474",
"5317"
],
"CVE-2006-5209": [
"2475"
],
"CVE-2006-5192": [
"2476"
],
"CVE-2006-5191": [
"2477"
],
"CVE-2006-5207": [
"2478"
],
"CVE-2006-5208": [
"2479"
],
"CVE-2006-5224": [
"2480"
],
"CVE-2006-5222": [
"2481"
],
"CVE-2006-5223": [
"2483"
],
"CVE-2006-5230": [
"2484"
],
"CVE-2006-5221": [
"2485"
],
"CVE-2006-5236": [
"2487",
"10572"
],
"CVE-2006-5261": [
"2488"
],
"CVE-2006-5257": [
"2489"
],
"CVE-2006-5226": [
"2490"
],
"CVE-2006-7135": [
"2491"
],
"CVE-2006-5240": [
"2493"
],
"CVE-2006-5244": [
"2494",
"2495"
],
"CVE-2006-5243": [
"2494"
],
"CVE-2006-5220": [
"2496"
],
"CVE-2006-5241": [
"2497"
],
"CVE-2006-5263": [
"2500"
],
"CVE-2006-5314": [
"2501"
],
"CVE-2006-5316": [
"2502"
],
"CVE-2006-5315": [
"2502"
],
"CVE-2006-5259": [
"2503"
],
"CVE-2006-5317": [
"2504"
],
"CVE-2006-5318": [
"2505"
],
"CVE-2006-5319": [
"2506"
],
"CVE-2006-5320": [
"2507"
],
"CVE-2006-5289": [
"2508"
],
"CVE-2006-5292": [
"2509"
],
"CVE-2006-5256": [
"2510"
],
"CVE-2006-5471": [
"2511"
],
"CVE-2006-7130": [
"2512"
],
"CVE-2006-5281": [
"2514"
],
"CVE-2006-5739": [
"2516"
],
"CVE-2006-5284": [
"2517"
],
"CVE-2006-5282": [
"2518"
],
"CVE-2006-5283": [
"2519"
],
"CVE-2006-5472": [
"2520"
],
"CVE-2006-5306": [
"2522"
],
"CVE-2006-7100": [
"2525"
],
"CVE-2006-5458": [
"2526"
],
"CVE-2006-7156": [
"2528"
],
"CVE-2006-5307": [
"2529"
],
"CVE-2006-7147": [
"2531"
],
"CVE-2006-5312": [
"2532"
],
"CVE-2006-5301": [
"2533"
],
"CVE-2006-5302": [
"2534"
],
"CVE-2006-5310": [
"2535"
],
"CVE-2006-5308": [
"2536"
],
"CVE-2006-7148": [
"2537"
],
"CVE-2006-5387": [
"2538"
],
"CVE-2006-6632": [
"2539"
],
"CVE-2006-5384": [
"2540"
],
"CVE-2006-6593": [
"2544"
],
"CVE-2006-5415": [
"2545"
],
"CVE-2006-5305": [
"2546"
],
"CVE-2006-5385": [
"2547"
],
"CVE-2006-5418": [
"2549"
],
"CVE-2006-5309": [
"2550"
],
"CVE-2006-5390": [
"2551"
],
"CVE-2006-5413": [
"2553"
],
"CVE-2006-6976": [
"2555"
],
"CVE-2006-6694": [
"2556"
],
"CVE-2006-5304": [
"2557"
],
"CVE-2006-7131": [
"2558"
],
"CVE-2006-5400": [
"2559"
],
"CVE-2006-5910": [
"2560"
],
"CVE-2006-5386": [
"2561"
],
"CVE-2006-5401": [
"2562"
],
"CVE-2006-7102": [
"2563"
],
"CVE-2006-5493": [
"2566"
],
"CVE-2006-5383": [
"2567"
],
"CVE-2006-5388": [
"2568"
],
"CVE-2006-5392": [
"2570"
],
"CVE-2006-6631": [
"2572"
],
"CVE-2006-6045": [
"2573"
],
"CVE-2006-5398": [
"2574"
],
"CVE-2008-7152": [
"2576",
"31358"
],
"CVE-2006-5419": [
"2576"
],
"CVE-2006-5434": [
"2577"
],
"CVE-2006-6760": [
"2578"
],
"CVE-2006-5509": [
"2579"
],
"CVE-2006-5508": [
"2579"
],
"CVE-2006-5433": [
"2582"
],
"CVE-2006-5421": [
"2583"
],
"CVE-2006-5399": [
"2584"
],
"CVE-2006-5402": [
"2585"
],
"CVE-2006-5412": [
"2588"
],
"CVE-2006-5429": [
"2589"
],
"CVE-2006-5432": [
"2590"
],
"CVE-2006-5427": [
"2591"
],
"CVE-2006-6633": [
"2594"
],
"CVE-2006-5426": [
"2595"
],
"CVE-2006-5555": [
"2596"
],
"CVE-2006-5510": [
"2598"
],
"CVE-2006-5494": [
"2599"
],
"CVE-2006-5722": [
"2600"
],
"CVE-2006-5497": [
"2600"
],
"CVE-2006-7106": [
"2602"
],
"CVE-2002-1885": [
"2602"
],
"CVE-2006-5423": [
"2603"
],
"CVE-2006-5514": [
"2604"
],
"CVE-2006-5518": [
"2605"
],
"CVE-2006-5480": [
"2606"
],
"CVE-2006-5522": [
"2607"
],
"CVE-2006-5517": [
"2609"
],
"CVE-2006-5495": [
"2611"
],
"CVE-2006-5543": [
"2612"
],
"CVE-2006-5519": [
"2613"
],
"CVE-2006-5521": [
"2614"
],
"CVE-2006-5485": [
"2615"
],
"CVE-2006-5511": [
"2616"
],
"CVE-2006-5525": [
"2617"
],
"CVE-2006-5523": [
"2620"
],
"CVE-2006-5526": [
"2621"
],
"CVE-2006-5548": [
"2622"
],
"CVE-2006-5547": [
"2622"
],
"CVE-2006-5546": [
"2622"
],
"CVE-2006-5562": [
"2623"
],
"CVE-2006-5506": [
"2624"
],
"CVE-2006-5587": [
"2626"
],
"CVE-2006-6635": [
"2628"
],
"CVE-2006-5527": [
"2630"
],
"CVE-2006-5531": [
"2631"
],
"CVE-2006-5588": [
"2632"
],
"CVE-2006-5539": [
"2640"
],
"CVE-2006-5561": [
"2644"
],
"CVE-2006-5590": [
"2645"
],
"CVE-2006-5615": [
"2646"
],
"CVE-2006-5554": [
"2647"
],
"CVE-2006-5624": [
"2653"
],
"CVE-2006-5621": [
"2654"
],
"CVE-2006-5673": [
"2655"
],
"CVE-2006-5620": [
"2656"
],
"CVE-2006-5625": [
"2659"
],
"CVE-2006-5622": [
"2660"
],
"CVE-2006-5676": [
"2661"
],
"CVE-2006-5629": [
"2662"
],
"CVE-2006-7132": [
"2664"
],
"CVE-2006-7107": [
"2665"
],
"CVE-2006-5613": [
"2666"
],
"CVE-2006-5623": [
"2667"
],
"CVE-2006-5670": [
"2669"
],
"CVE-2006-5762": [
"2670"
],
"CVE-2006-5636": [
"2673"
],
"CVE-2006-5672": [
"2674"
],
"CVE-2006-5707": [
"2675"
],
"CVE-2006-5618": [
"2677"
],
"CVE-2006-5637": [
"2678"
],
"CVE-2006-5638": [
"2679"
],
"CVE-2006-5627": [
"2681"
],
"CVE-2006-5641": [
"2683"
],
"CVE-2006-5640": [
"2684"
],
"CVE-2006-6938": [
"2685"
],
"CVE-2006-5665": [
"2686"
],
"CVE-2006-5666": [
"2687"
],
"CVE-2006-5634": [
"2688"
],
"CVE-2006-5667": [
"2691"
],
"CVE-2006-5669": [
"2692"
],
"CVE-2006-5732": [
"2694"
],
"CVE-2006-5505": [
"2698"
],
"CVE-2006-5703": [
"2701"
],
"CVE-2006-5702": [
"2701"
],
"CVE-2006-5731": [
"2702"
],
"CVE-2006-5766": [
"2703"
],
"CVE-2006-6941": [
"2704"
],
"CVE-2006-5773": [
"2704"
],
"CVE-2006-5772": [
"2704"
],
"CVE-2006-5730": [
"2706"
],
"CVE-2006-5733": [
"2707"
],
"CVE-2006-5777": [
"2709"
],
"CVE-2006-5786": [
"2711"
],
"CVE-2006-7112": [
"2712"
],
"CVE-2006-5767": [
"2713"
],
"CVE-2006-5760": [
"2717"
],
"CVE-2006-5727": [
"2718"
],
"CVE-2006-5834": [
"2719"
],
"CVE-2006-5828": [
"2720"
],
"CVE-2006-7169": [
"2721"
],
"CVE-2006-5802": [
"2722"
],
"CVE-2006-5796": [
"2724"
],
"CVE-2006-5768": [
"2725"
],
"CVE-2006-7194": [
"2726"
],
"CVE-2006-5811": [
"2727"
],
"CVE-2006-5795": [
"2727"
],
"CVE-2006-5765": [
"2728"
],
"CVE-2006-5787": [
"2731"
],
"CVE-2006-7119": [
"2732"
],
"CVE-2006-5837": [
"2733"
],
"CVE-2006-5839": [
"2736"
],
"CVE-2006-5788": [
"2739"
],
"CVE-2006-6586": [
"2740"
],
"CVE-2006-5849": [
"2741"
],
"CVE-2006-5841": [
"2742"
],
"CVE-2006-5863": [
"2744"
],
"CVE-2006-5923": [
"2745"
],
"CVE-2006-5892": [
"2746"
],
"CVE-2006-5865": [
"2747"
],
"CVE-2006-5866": [
"2748"
],
"CVE-2006-5895": [
"2750"
],
"CVE-2006-5889": [
"2751"
],
"CVE-2006-6041": [
"2752"
],
"CVE-2006-5881": [
"2754"
],
"CVE-2006-5886": [
"2755"
],
"CVE-2006-5885": [
"2756"
],
"CVE-2006-5887": [
"2757"
],
"CVE-2006-7101": [
"2759"
],
"CVE-2006-5894": [
"2760"
],
"CVE-2006-5880": [
"2761"
],
"CVE-2006-5879": [
"2762"
],
"CVE-2006-5891": [
"2763"
],
"CVE-2006-5890": [
"2764"
],
"CVE-2006-5888": [
"2765"
],
"CVE-2006-7185": [
"2766"
],
"CVE-2006-5893": [
"2767"
],
"CVE-2006-6391": [
"2769"
],
"CVE-2006-5934": [
"2773"
],
"CVE-2006-6029": [
"2774"
],
"CVE-2006-5928": [
"2775"
],
"CVE-2006-5930": [
"2777"
],
"CVE-2006-5948": [
"2778"
],
"CVE-2006-5952": [
"2779"
],
"CVE-2007-1566": [
"2780",
"3520"
],
"CVE-2006-5954": [
"2780",
"3520"
],
"CVE-2006-5976": [
"2781"
],
"CVE-2006-5975": [
"2781"
],
"CVE-2006-5962": [
"2782"
],
"CVE-2006-6330": [
"2786"
],
"CVE-2006-6329": [
"2786"
],
"CVE-2006-6328": [
"2786"
],
"CVE-2006-6047": [
"2790"
],
"CVE-2006-7134": [
"2791"
],
"CVE-2006-6341": [
"2794"
],
"CVE-2006-6028": [
"2795"
],
"CVE-2006-6038": [
"2797"
],
"CVE-2006-6039": [
"2798"
],
"CVE-2006-6065": [
"2799"
],
"CVE-2006-6051": [
"2807"
],
"CVE-2006-6281": [
"2808"
],
"CVE-2006-6280": [
"2810"
],
"CVE-2007-3141": [
"2811"
],
"CVE-2006-6042": [
"2811"
],
"CVE-2006-6070": [
"2813"
],
"CVE-2006-6044": [
"2814"
],
"CVE-2006-6093": [
"2817"
],
"CVE-2006-6086": [
"2818"
],
"CVE-2006-6577": [
"2819",
"2871"
],
"CVE-2006-6177": [
"2820"
],
"CVE-2006-6157": [
"2822"
],
"CVE-2006-6084": [
"2823"
],
"CVE-2006-7136": [
"2827"
],
"CVE-2006-6115": [
"2828"
],
"CVE-2006-6117": [
"2829"
],
"CVE-2006-6116": [
"2830"
],
"CVE-2006-6078": [
"2831"
],
"CVE-2006-6151": [
"2832"
],
"CVE-2006-6212": [
"2833"
],
"CVE-2006-6220": [
"2834"
],
"CVE-2006-6214": [
"2835"
],
"CVE-2006-6149": [
"2836"
],
"CVE-2006-6154": [
"2838"
],
"CVE-2006-6150": [
"2839"
],
"CVE-2006-6213": [
"2840"
],
"CVE-2006-6237": [
"2841"
],
"CVE-2006-6289": [
"2842"
],
"CVE-2006-6255": [
"2843"
],
"CVE-2006-6202": [
"2843"
],
"CVE-2006-6254": [
"2844"
],
"CVE-2006-6160": [
"2846"
],
"CVE-2006-6140": [
"2847"
],
"CVE-2006-6138": [
"2847"
],
"CVE-2006-6137": [
"2847"
],
"CVE-2006-6193": [
"2848"
],
"CVE-2006-7152": [
"2849"
],
"CVE-2006-7183": [
"2850"
],
"CVE-2006-6216": [
"2851"
],
"CVE-2006-6203": [
"2852"
],
"CVE-2006-6191": [
"2853"
],
"CVE-2006-7114": [
"2862"
],
"CVE-2006-7117": [
"2863"
],
"CVE-2006-7116": [
"2863"
],
"CVE-2006-6417": [
"2864"
],
"CVE-2006-6966": [
"2867"
],
"CVE-2006-6242": [
"2869"
],
"CVE-2006-6338": [
"2876"
],
"CVE-2006-6369": [
"2877"
],
"CVE-2006-6277": [
"2878"
],
"CVE-2006-6381": [
"2881"
],
"CVE-2006-6380": [
"2881"
],
"CVE-2006-6376": [
"2883"
],
"CVE-2006-6368": [
"2884"
],
"CVE-2006-6295": [
"2885"
],
"CVE-2006-6360": [
"2886"
],
"CVE-2006-6445": [
"2888"
],
"CVE-2006-6390": [
"2889"
],
"CVE-2006-4605": [
"2890",
"8425"
],
"CVE-2006-6546": [
"2891"
],
"CVE-2006-6550": [
"2894"
],
"CVE-2006-6453": [
"2895"
],
"CVE-2006-6551": [
"2896"
],
"CVE-2006-6544": [
"2897"
],
"CVE-2006-6462": [
"2897"
],
"CVE-2006-6426": [
"2898"
],
"CVE-2006-6604": [
"2902"
],
"CVE-2006-6598": [
"2902"
],
"CVE-2006-6599": [
"2903"
],
"CVE-2006-6566": [
"2904"
],
"CVE-2006-6526": [
"2905"
],
"CVE-2006-6542": [
"2906"
],
"CVE-2006-6543": [
"2907"
],
"CVE-2006-6559": [
"2908"
],
"CVE-2006-6525": [
"2909"
],
"CVE-2006-6524": [
"2909"
],
"CVE-2006-6613": [
"2913"
],
"CVE-2006-6545": [
"2917"
],
"CVE-2006-6615": [
"2919"
],
"CVE-2006-6611": [
"2920"
],
"CVE-2006-6560": [
"2921"
],
"CVE-2006-6552": [
"2923"
],
"CVE-2006-6568": [
"2924"
],
"CVE-2006-6567": [
"2924"
],
"CVE-2006-6553": [
"2925"
],
"CVE-2006-6612": [
"2927"
],
"CVE-2006-6575": [
"2930"
],
"CVE-2006-6590": [
"2931"
],
"CVE-2006-6722": [
"2938"
],
"CVE-2006-6645": [
"2939"
],
"CVE-2006-6650": [
"2940"
],
"CVE-2006-6644": [
"2941"
],
"CVE-2006-6720": [
"2943"
],
"CVE-2006-6666": [
"2944"
],
"CVE-2006-6716": [
"2945"
],
"CVE-2006-6648": [
"2948"
],
"CVE-2006-6661": [
"2953"
],
"CVE-2006-6739": [
"2955"
],
"CVE-2006-6740": [
"2956"
],
"CVE-2006-6732": [
"2958"
],
"CVE-2006-6738": [
"2960"
],
"CVE-2006-6671": [
"2962"
],
"CVE-2006-6757": [
"2963"
],
"CVE-2006-6691": [
"2964"
],
"CVE-2006-6686": [
"2965"
],
"CVE-2006-1209": [
"2968"
],
"CVE-2006-6711": [
"2970"
],
"CVE-2006-6710": [
"2971"
],
"CVE-2006-6715": [
"2973"
],
"CVE-2006-6756": [
"2975"
],
"CVE-2006-6755": [
"2975"
],
"CVE-2006-6726": [
"2976"
],
"CVE-2006-6741": [
"2977"
],
"CVE-2008-1635": [
"2979",
"5324"
],
"CVE-2006-6764": [
"2979"
],
"CVE-2006-6763": [
"2979"
],
"CVE-2003-1314": [
"2980"
],
"CVE-2006-6786": [
"2981"
],
"CVE-2006-6785": [
"2981"
],
"CVE-2006-6877": [
"2982"
],
"CVE-2006-6830": [
"2983"
],
"CVE-2006-6801": [
"2984"
],
"CVE-2006-3027": [
"2986"
],
"CVE-2006-6204": [
"2987",
"29121",
"29122",
"29123"
],
"CVE-2006-6805": [
"2988"
],
"CVE-2006-6803": [
"2989"
],
"CVE-2006-6806": [
"2990"
],
"CVE-2006-6802": [
"2991"
],
"CVE-2006-6804": [
"2992"
],
"CVE-2006-6792": [
"2993"
],
"CVE-2006-6822": [
"2994"
],
"CVE-2006-6820": [
"2995"
],
"CVE-2006-6821": [
"2996"
],
"CVE-2006-6813": [
"2997"
],
"CVE-2006-6787": [
"2998"
],
"CVE-2006-6790": [
"2999"
],
"CVE-2006-6765": [
"3000"
],
"CVE-2010-4782": [
"3001",
"15661"
],
"CVE-2006-6807": [
"3001",
"15661"
],
"CVE-2006-6781": [
"3002"
],
"CVE-2006-6780": [
"3002"
],
"CVE-2006-6770": [
"3003"
],
"CVE-2006-6873": [
"3004"
],
"CVE-2006-6872": [
"3004"
],
"CVE-2006-6871": [
"3004"
],
"CVE-2006-6796": [
"3005"
],
"CVE-2006-6789": [
"3006"
],
"CVE-2006-6771": [
"3007",
"32823"
],
"CVE-2006-6774": [
"3008"
],
"CVE-2006-6850": [
"3009"
],
"CVE-2006-6795": [
"3010"
],
"CVE-2006-6773": [
"3011"
],
"CVE-2006-6793": [
"3012"
],
"CVE-2006-6887": [
"3014"
],
"CVE-2006-6349": [
"3015"
],
"CVE-2006-6849": [
"3016"
],
"CVE-2006-6880": [
"3017"
],
"CVE-2006-6879": [
"3017",
"3020"
],
"CVE-2006-6812": [
"3019"
],
"CVE-2006-6878": [
"3020"
],
"CVE-2006-6823": [
"3025"
],
"CVE-2006-6809": [
"3026"
],
"CVE-2006-4671": [
"3027"
],
"CVE-2006-6800": [
"3028"
],
"CVE-2006-6831": [
"3031"
],
"CVE-2006-6846": [
"3032"
],
"CVE-2006-6842": [
"3033"
],
"CVE-2006-6848": [
"3035"
],
"CVE-2006-6856": [
"3036"
],
"CVE-2006-6866": [
"3039"
],
"CVE-2002-1656": [
"3043"
],
"CVE-2006-6890": [
"3044"
],
"CVE-2006-6865": [
"3046"
],
"CVE-2006-6889": [
"3047"
],
"CVE-2006-6859": [
"3048"
],
"CVE-2007-0082": [
"3049"
],
"CVE-2006-6864": [
"3050"
],
"CVE-2006-6863": [
"3051"
],
"CVE-2006-6891": [
"3053"
],
"CVE-2006-6888": [
"3054"
],
"CVE-2006-6869": [
"3057"
],
"CVE-2006-6867": [
"3059"
],
"CVE-2007-0052": [
"3061"
],
"CVE-2007-0053": [
"3062",
"12462"
],
"CVE-1999-0953": [
"3065"
],
"CVE-2007-0091": [
"3066"
],
"CVE-2007-0049": [
"3068"
],
"CVE-2007-0129": [
"3073"
],
"CVE-2007-0092": [
"3074"
],
"CVE-2007-0098": [
"3075"
],
"CVE-2007-0093": [
"3076"
],
"CVE-2007-0135": [
"3079"
],
"CVE-2007-0128": [
"3081"
],
"CVE-2007-0130": [
"3082"
],
"CVE-2007-0134": [
"3083"
],
"CVE-2007-0133": [
"3083"
],
"CVE-2007-0132": [
"3083"
],
"CVE-2007-3558": [
"3085"
],
"CVE-2007-0144": [
"3089"
],
"CVE-2006-6911": [
"3089"
],
"CVE-2007-0143": [
"3090"
],
"CVE-2007-0173": [
"3091"
],
"CVE-2007-0172": [
"3093"
],
"CVE-2007-0107": [
"3095"
],
"CVE-2007-0171": [
"3096"
],
"CVE-2007-0170": [
"3097"
],
"CVE-2007-0181": [
"3100"
],
"CVE-2007-0205": [
"3103"
],
"CVE-2007-0202": [
"3103"
],
"CVE-2007-0167": [
"3104"
],
"CVE-2007-0196": [
"3105"
],
"CVE-2007-0226": [
"3106"
],
"CVE-2007-0200": [
"3108"
],
"CVE-2007-0233": [
"3109"
],
"CVE-2007-0232": [
"3113"
],
"CVE-2007-0314": [
"3114"
],
"CVE-2007-0225": [
"3115"
],
"CVE-2007-0224": [
"3115"
],
"CVE-2007-0261": [
"3116"
],
"CVE-2007-0298": [
"3117"
],
"CVE-2007-0300": [
"3118"
],
"CVE-2007-0304": [
"3120"
],
"CVE-2007-0307": [
"3121"
],
"CVE-2007-0306": [
"3122"
],
"CVE-2007-0301": [
"3123"
],
"CVE-2007-0340": [
"3124"
],
"CVE-2007-0329": [
"3125"
],
"CVE-2007-0337": [
"3134"
],
"CVE-2007-0305": [
"3135"
],
"CVE-2007-0354": [
"3141"
],
"CVE-2007-0388": [
"3143",
"3144",
"3146"
],
"CVE-2007-0361": [
"3145"
],
"CVE-2007-0359": [
"3147"
],
"CVE-2007-0360": [
"3150"
],
"CVE-2007-0395": [
"3152"
],
"CVE-2007-0370": [
"3153"
],
"CVE-2007-0369": [
"3153"
],
"CVE-2007-0495": [
"3161"
],
"CVE-2007-0500": [
"3162"
],
"CVE-2007-0496": [
"3163"
],
"CVE-2007-0499": [
"3164"
],
"CVE-2007-0498": [
"3165"
],
"CVE-2007-0491": [
"3165"
],
"CVE-2007-0485": [
"3169"
],
"CVE-2007-0501": [
"3171"
],
"CVE-2007-0502": [
"3172"
],
"CVE-2007-0497": [
"3174"
],
"CVE-2007-0489": [
"3175"
],
"CVE-2007-0535": [
"3180"
],
"CVE-2007-0504": [
"3180"
],
"CVE-2007-0508": [
"3183"
],
"CVE-2007-0511": [
"3184"
],
"CVE-2007-0559": [
"3185"
],
"CVE-2007-0560": [
"3186"
],
"CVE-2007-0566": [
"3187"
],
"CVE-2007-0558": [
"3191"
],
"CVE-2007-0561": [
"3192"
],
"CVE-2007-0600": [
"3194"
],
"CVE-2007-0554": [
"3195"
],
"CVE-2007-0598": [
"3196"
],
"CVE-2007-0590": [
"3197"
],
"CVE-2007-0589": [
"3197"
],
"CVE-2007-0591": [
"3198"
],
"CVE-2007-0568": [
"3201"
],
"CVE-2007-0570": [
"3202"
],
"CVE-2007-0620": [
"3203",
"29530"
],
"CVE-2007-0573": [
"3205"
],
"CVE-2007-0577": [
"3206"
],
"CVE-2007-0572": [
"3207"
],
"CVE-2007-0697": [
"3208"
],
"CVE-2007-0576": [
"3209"
],
"CVE-2007-0582": [
"3210"
],
"CVE-2007-0571": [
"3212"
],
"CVE-2007-0581": [
"3214"
],
"CVE-2007-0580": [
"3215"
],
"CVE-2007-0569": [
"3216"
],
"CVE-2007-0584": [
"3217"
],
"CVE-2007-5845": [
"3221",
"4602"
],
"CVE-2007-0639": [
"3221"
],
"CVE-2007-0585": [
"3222"
],
"CVE-2007-0637": [
"3225"
],
"CVE-2007-0638": [
"3226"
],
"CVE-2007-0663": [
"3227"
],
"CVE-2007-0631": [
"3227"
],
"CVE-2007-0633": [
"3228"
],
"CVE-2007-0656": [
"3231"
],
"CVE-2007-0687": [
"3232"
],
"CVE-2007-0678": [
"3233"
],
"CVE-2007-0676": [
"3234"
],
"CVE-2007-0680": [
"3235"
],
"CVE-2007-0662": [
"3236"
],
"CVE-2007-0677": [
"3237"
],
"CVE-2007-0679": [
"3238"
],
"CVE-2007-0681": [
"3239"
],
"CVE-2007-0682": [
"3240"
],
"CVE-2007-0688": [
"3241"
],
"CVE-2007-0683": [
"3242"
],
"CVE-2007-0684": [
"3243"
],
"CVE-2006-4733": [
"3245"
],
"CVE-2007-0702": [
"3246"
],
"CVE-2007-0701": [
"3247"
],
"CVE-2007-0703": [
"3249"
],
"CVE-2007-0699": [
"3250"
],
"CVE-2007-0757": [
"3251"
],
"CVE-2007-0760": [
"3252"
],
"CVE-2006-3683": [
"3253"
],
"CVE-2007-0764": [
"3255"
],
"CVE-2007-0763": [
"3255"
],
"CVE-2007-0765": [
"3256"
],
"CVE-2007-0761": [
"3258"
],
"CVE-2007-0762": [
"3259"
],
"CVE-2007-0786": [
"3261"
],
"CVE-2007-0812": [
"3262"
],
"CVE-2006-6517": [
"3263",
"29254",
"29255"
],
"CVE-2006-6516": [
"3263"
],
"CVE-2007-0785": [
"3266"
],
"CVE-2007-0810": [
"3267"
],
"CVE-2007-0797": [
"3268"
],
"CVE-2007-0809": [
"3270"
],
"CVE-2007-0804": [
"3271"
],
"CVE-2007-0824": [
"3275"
],
"CVE-2007-0826": [
"3278"
],
"CVE-2007-0837": [
"3280"
],
"CVE-2007-0839": [
"3281"
],
"CVE-2007-0845": [
"3282"
],
"CVE-2007-0847": [
"3283"
],
"CVE-2007-0846": [
"3283"
],
"CVE-2007-0848": [
"3284"
],
"CVE-2007-0867": [
"3285"
],
"CVE-2007-0904": [
"3286"
],
"CVE-2007-0865": [
"3287"
],
"CVE-2007-0864": [
"3288"
],
"CVE-2007-0881": [
"3292"
],
"CVE-2007-0920": [
"3295"
],
"CVE-2007-0983": [
"3297"
],
"CVE-2006-3176": [
"3298"
],
"CVE-2007-0985": [
"3299"
],
"CVE-2007-0984": [
"3301"
],
"CVE-2007-0873": [
"3305"
],
"CVE-2007-0987": [
"3309"
],
"CVE-2007-0986": [
"3309"
],
"CVE-2007-0971": [
"3310"
],
"CVE-2007-0972": [
"3311"
],
"CVE-2007-1010": [
"3314"
],
"CVE-2005-2157": [
"3315"
],
"CVE-2007-1021": [
"3317"
],
"CVE-2007-1016": [
"3318"
],
"CVE-2007-1015": [
"3318"
],
"CVE-2007-1023": [
"3321"
],
"CVE-2007-1017": [
"3322"
],
"CVE-2007-1025": [
"3323"
],
"CVE-2007-1013": [
"3324"
],
"CVE-2007-1019": [
"3325"
],
"CVE-2007-1031": [
"3326"
],
"CVE-2007-1026": [
"3327"
],
"CVE-2007-1011": [
"3328"
],
"CVE-2007-1040": [
"3332"
],
"CVE-2007-1034": [
"3334",
"10615"
],
"CVE-2007-1059": [
"3336"
],
"CVE-2007-5125": [
"3337"
],
"CVE-2007-1171": [
"3337"
],
"CVE-2007-1493": [
"3338",
"3450"
],
"CVE-2007-1172": [
"3338"
],
"CVE-2007-1058": [
"3339"
],
"CVE-2007-1061": [
"3344",
"3345",
"3346"
],
"CVE-2007-1060": [
"3348"
],
"CVE-2007-1163": [
"3351"
],
"CVE-2007-1255": [
"3352"
],
"CVE-2007-1254": [
"3352"
],
"CVE-2007-1164": [
"3353"
],
"CVE-2007-1165": [
"3354"
],
"CVE-2007-1166": [
"3355"
],
"CVE-2007-1167": [
"3357"
],
"CVE-2007-1078": [
"3360"
],
"CVE-2007-1118": [
"3361"
],
"CVE-2007-1133": [
"3365"
],
"CVE-2007-1130": [
"3366"
],
"CVE-2007-1131": [
"3367"
],
"CVE-2007-1105": [
"3370"
],
"CVE-2007-1107": [
"3371"
],
"CVE-2007-1108": [
"3372"
],
"CVE-2007-1106": [
"3373"
],
"CVE-2007-1104": [
"3374"
],
"CVE-2007-1233": [
"3379"
],
"CVE-2007-1219": [
"3382"
],
"CVE-2007-1292": [
"3387"
],
"CVE-2007-1250": [
"3390"
],
"CVE-2006-6912": [
"3393"
],
"CVE-2007-1299": [
"3398"
],
"CVE-2007-1293": [
"3403"
],
"CVE-2007-1340": [
"3406"
],
"CVE-2007-1298": [
"3408"
],
"CVE-2007-1297": [
"3409"
],
"CVE-2007-1296": [
"3410"
],
"CVE-2007-1295": [
"3411"
],
"CVE-2007-1303": [
"3412"
],
"CVE-2007-1339": [
"3416"
],
"CVE-2007-1372": [
"3423"
],
"CVE-2007-1394": [
"3428"
],
"CVE-2007-1392": [
"3435"
],
"CVE-2007-1391": [
"3436"
],
"CVE-2007-1410": [
"3437"
],
"CVE-2007-1393": [
"3438"
],
"CVE-2007-1415": [
"3443"
],
"CVE-2007-1434": [
"3447"
],
"CVE-2007-1433": [
"3447"
],
"CVE-2007-1432": [
"3447"
],
"CVE-2007-1423": [
"3448"
],
"CVE-2007-1417": [
"3449"
],
"CVE-2006-0164": [
"3454"
],
"CVE-2007-1428": [
"3455"
],
"CVE-2005-3952": [
"3456"
],
"CVE-2007-1425": [
"3457"
],
"CVE-2007-1427": [
"3458"
],
"CVE-2007-1455": [
"3459"
],
"CVE-2007-1446": [
"3465"
],
"CVE-2007-1445": [
"3466"
],
"CVE-2006-5612": [
"3467"
],
"CVE-2007-1439": [
"3468"
],
"CVE-2007-1570": [
"3469"
],
"CVE-2007-1438": [
"3469"
],
"CVE-2007-1572": [
"3470"
],
"CVE-2007-1440": [
"3470"
],
"CVE-2007-1571": [
"3471"
],
"CVE-2007-1458": [
"3472"
],
"CVE-2007-1459": [
"3473"
],
"CVE-2007-1524": [
"3476"
],
"CVE-2007-1517": [
"3477"
],
"CVE-2007-1525": [
"3478"
],
"CVE-2007-1471": [
"3481"
],
"CVE-2007-1518": [
"3483"
],
"CVE-2007-1487": [
"3484"
],
"CVE-2007-1513": [
"3485"
],
"CVE-2007-1472": [
"3486"
],
"CVE-2007-1516": [
"3487"
],
"CVE-2007-1480": [
"3489"
],
"CVE-2007-1479": [
"3489"
],
"CVE-2007-1482": [
"3490"
],
"CVE-2007-1481": [
"3490"
],
"CVE-2007-1483": [
"3492"
],
"CVE-2007-1469": [
"3493"
],
"CVE-2007-1478": [
"3494"
],
"CVE-2006-7172": [
"3496",
"3497"
],
"CVE-2007-1556": [
"3498"
],
"CVE-2007-1510": [
"3500"
],
"CVE-2007-1620": [
"3501"
],
"CVE-2006-7173": [
"3502"
],
"CVE-2007-1613": [
"3503"
],
"CVE-2007-1621": [
"3504"
],
"CVE-2007-1635": [
"3505"
],
"CVE-2007-1634": [
"3505"
],
"CVE-2007-1553": [
"3506"
],
"CVE-2007-1618": [
"3507"
],
"CVE-2007-1647": [
"3508"
],
"CVE-2007-1615": [
"3509"
],
"CVE-2007-1617": [
"3510"
],
"CVE-2007-1619": [
"3511"
],
"CVE-2007-1626": [
"3512"
],
"CVE-2007-1612": [
"3513"
],
"CVE-2007-1616": [
"3515"
],
"CVE-2007-1552": [
"3516"
],
"CVE-2007-1633": [
"3518"
],
"CVE-2007-1555": [
"3519"
],
"CVE-2007-1539": [
"3521"
],
"CVE-2007-1577": [
"3522"
],
"CVE-2006-0308": [
"3524"
],
"CVE-2006-3317": [
"3528"
],
"CVE-2006-1781": [
"3530",
"27660"
],
"CVE-2007-1628": [
"3532"
],
"CVE-2007-1600": [
"3533"
],
"CVE-2007-1630": [
"3534"
],
"CVE-2007-1629": [
"3536"
],
"CVE-2006-4606": [
"3538",
"8425"
],
"CVE-2007-1596": [
"3539"
],
"CVE-2007-1640": [
"3542"
],
"CVE-2007-1641": [
"3543"
],
"CVE-2007-1643": [
"3545"
],
"CVE-2004-1552": [
"3546",
"7242"
],
"CVE-2007-1636": [
"3548"
],
"CVE-2007-1705": [
"3549"
],
"CVE-2005-2062": [
"3550",
"10526"
],
"CVE-2007-1712": [
"3551"
],
"CVE-2007-1698": [
"3552"
],
"CVE-2007-1697": [
"3552"
],
"CVE-2007-1696": [
"3556"
],
"CVE-2007-1699": [
"3557"
],
"CVE-2010-2359": [
"3558"
],
"CVE-2007-1706": [
"3558"
],
"CVE-2006-5043": [
"3560"
],
"CVE-2007-1707": [
"3562"
],
"CVE-2007-1708": [
"3563"
],
"CVE-2007-1704": [
"3564"
],
"CVE-2007-1703": [
"3565"
],
"CVE-2007-1702": [
"3567"
],
"CVE-2007-1715": [
"3568"
],
"CVE-2007-1725": [
"3580",
"3581"
],
"CVE-2007-1726": [
"3581"
],
"CVE-2007-1720": [
"3582"
],
"CVE-2007-1721": [
"3583"
],
"CVE-2007-3311": [
"3588",
"3594"
],
"CVE-2007-1776": [
"3590"
],
"CVE-2007-1778": [
"3591"
],
"CVE-2007-1771": [
"3592"
],
"CVE-2005-2246": [
"3596"
],
"CVE-2007-1838": [
"3597"
],
"CVE-2007-1837": [
"3598"
],
"CVE-2007-1839": [
"3599"
],
"CVE-2007-1787": [
"3600"
],
"CVE-2007-1801": [
"3601"
],
"CVE-2007-1791": [
"3605"
],
"CVE-2007-1790": [
"3607"
],
"CVE-2007-1766": [
"3608"
],
"CVE-2007-1795": [
"3611"
],
"CVE-2007-1847": [
"3612"
],
"CVE-2007-1818": [
"3613"
],
"CVE-2007-1842": [
"3614"
],
"CVE-2007-1817": [
"3618"
],
"CVE-2007-1815": [
"3619"
],
"CVE-2007-1814": [
"3620"
],
"CVE-2007-1816": [
"3621"
],
"CVE-2005-3811": [
"3622"
],
"CVE-2007-1813": [
"3623"
],
"CVE-2007-1812": [
"3624"
],
"CVE-2007-1811": [
"3625"
],
"CVE-2007-1810": [
"3626"
],
"CVE-2007-1809": [
"3628"
],
"CVE-2007-1808": [
"3629"
],
"CVE-2007-1805": [
"3630"
],
"CVE-2005-1237": [
"3631"
],
"CVE-2007-1807": [
"3632"
],
"CVE-2007-1806": [
"3633"
],
"CVE-2007-1843": [
"3638"
],
"CVE-2007-1980": [
"3639"
],
"CVE-2007-1978": [
"3640"
],
"CVE-2007-1982": [
"3641"
],
"CVE-2007-1851": [
"3641"
],
"CVE-2007-1974": [
"3644",
"3645",
"3646"
],
"CVE-2005-0725": [
"3644",
"3645",
"3646"
],
"CVE-2007-1963": [
"3653"
],
"CVE-2007-1979": [
"3655"
],
"CVE-2007-1897": [
"3656"
],
"CVE-2007-1896": [
"3657"
],
"CVE-2007-1895": [
"3657"
],
"CVE-2002-1887": [
"3658",
"21905"
],
"CVE-2007-1986": [
"3659"
],
"CVE-2007-1983": [
"3660"
],
"CVE-2007-1962": [
"3663"
],
"CVE-2007-1961": [
"3665"
],
"CVE-2007-1960": [
"3666"
],
"CVE-2007-2347": [
"3667"
],
"CVE-2007-2345": [
"3668"
],
"CVE-2007-2346": [
"3669"
],
"CVE-2007-2373": [
"3670"
],
"CVE-2007-2372": [
"3671"
],
"CVE-2007-2371": [
"3671"
],
"CVE-2007-2370": [
"3672"
],
"CVE-2007-2369": [
"3673"
],
"CVE-2007-2368": [
"3673"
],
"CVE-2007-1929": [
"3676"
],
"CVE-2007-1930": [
"3677"
],
"CVE-2007-1920": [
"3678"
],
"CVE-2007-1931": [
"3679"
],
"CVE-2007-1937": [
"3681"
],
"CVE-2007-1934": [
"3683"
],
"CVE-2007-1968": [
"3685"
],
"CVE-2007-1928": [
"3686"
],
"CVE-2007-1932": [
"3687"
],
"CVE-2007-1933": [
"3689"
],
"CVE-2007-1909": [
"3691"
],
"CVE-2007-1908": [
"3694"
],
"CVE-2007-1907": [
"3696"
],
"CVE-2007-1998": [
"3697"
],
"CVE-2007-2019": [
"3699"
],
"CVE-2007-1999": [
"3700"
],
"CVE-2007-2001": [
"3701"
],
"CVE-2007-2000": [
"3701"
],
"CVE-2007-2004": [
"3702"
],
"CVE-2007-2003": [
"3702"
],
"CVE-2007-2002": [
"3702"
],
"CVE-2005-0613": [
"3702",
"6783"
],
"CVE-2007-2005": [
"3703"
],
"CVE-2007-2008": [
"3704"
],
"CVE-2007-2007": [
"3704"
],
"CVE-2007-2006": [
"3704"
],
"CVE-2007-2009": [
"3705"
],
"CVE-2007-1992": [
"3706"
],
"CVE-2007-2317": [
"3707"
],
"CVE-2007-1996": [
"3711"
],
"CVE-2007-2044": [
"3712"
],
"CVE-2007-2049": [
"3713"
],
"CVE-2007-2043": [
"3714"
],
"CVE-2007-2313": [
"3716"
],
"CVE-2007-2307": [
"3717"
],
"CVE-2007-2050": [
"3718"
],
"CVE-2007-2302": [
"3722"
],
"CVE-2007-2015": [
"3723"
],
"CVE-2007-2149": [
"3725"
],
"CVE-2007-2148": [
"3725"
],
"CVE-2007-2147": [
"3725"
],
"CVE-2007-2305": [
"3729"
],
"CVE-2007-2304": [
"3729",
"4603"
],
"CVE-2007-2299": [
"3731"
],
"CVE-2007-2298": [
"3732"
],
"CVE-2007-2458": [
"3733"
],
"CVE-2007-2457": [
"3733"
],
"CVE-2007-2319": [
"3734"
],
"CVE-2007-2093": [
"3735"
],
"CVE-2007-2092": [
"3735"
],
"CVE-2007-2089": [
"3736"
],
"CVE-2007-2320": [
"3739"
],
"CVE-2007-2087": [
"3741"
],
"CVE-2007-2086": [
"3741"
],
"CVE-2007-2303": [
"3742"
],
"CVE-2007-2301": [
"3744"
],
"CVE-2007-2067": [
"3745"
],
"CVE-2007-2069": [
"3747"
],
"CVE-2007-2070": [
"3748"
],
"CVE-2007-2068": [
"3749"
],
"CVE-2007-2091": [
"3750"
],
"CVE-2007-2094": [
"3751"
],
"CVE-2007-2142": [
"3752"
],
"CVE-2007-2144": [
"3753"
],
"CVE-2007-2146": [
"3754"
],
"CVE-2007-2145": [
"3754"
],
"CVE-2007-2154": [
"3756"
],
"CVE-2007-2141": [
"3758"
],
"CVE-2007-2143": [
"3759"
],
"CVE-2007-2158": [
"3760"
],
"CVE-2007-2169": [
"3761"
],
"CVE-2007-2168": [
"3762"
],
"CVE-2007-2167": [
"3762"
],
"CVE-2007-2156": [
"3763"
],
"CVE-2007-2157": [
"3764"
],
"CVE-2007-2166": [
"3765"
],
"CVE-2007-2189": [
"3766"
],
"CVE-2007-2342": [
"3767"
],
"CVE-2007-2185": [
"3771"
],
"CVE-2007-2184": [
"3773"
],
"CVE-2007-2183": [
"3774"
],
"CVE-2007-2182": [
"3775"
],
"CVE-2007-2181": [
"3778"
],
"CVE-2007-2212": [
"3780"
],
"CVE-2007-2211": [
"3780"
],
"CVE-2007-2199": [
"3781",
"3915",
"4111"
],
"CVE-2007-2200": [
"3783"
],
"CVE-2007-2201": [
"3785"
],
"CVE-2007-2204": [
"3786"
],
"CVE-2007-2271": [
"3794"
],
"CVE-2007-2272": [
"3795"
],
"CVE-2007-2273": [
"3796"
],
"CVE-2007-2324": [
"3799"
],
"CVE-2007-2285": [
"3800"
],
"CVE-2007-2341": [
"3802"
],
"CVE-2007-2340": [
"3803"
],
"CVE-2007-2456": [
"3805"
],
"CVE-2007-2259": [
"3806"
],
"CVE-2007-2364": [
"3809"
],
"CVE-2007-2427": [
"3813"
],
"CVE-2007-2426": [
"3814"
],
"CVE-2007-2431": [
"3816"
],
"CVE-2007-2430": [
"3816"
],
"CVE-2007-2425": [
"3817"
],
"CVE-2007-2424": [
"3818"
],
"CVE-2007-2484": [
"3824"
],
"CVE-2007-2483": [
"3824"
],
"CVE-2007-2482": [
"3825"
],
"CVE-2007-2481": [
"3825"
],
"CVE-2007-2471": [
"3827"
],
"CVE-2007-2485": [
"3828"
],
"CVE-2007-2486": [
"3831"
],
"CVE-2007-2507": [
"3832"
],
"CVE-2007-2493": [
"3833"
],
"CVE-2007-2492": [
"3835"
],
"CVE-2007-2677": [
"3837"
],
"CVE-2007-2676": [
"3838"
],
"CVE-2007-2672": [
"3839"
],
"CVE-2007-2675": [
"3840",
"18613"
],
"CVE-2006-2763": [
"3841",
"5803"
],
"CVE-2007-2674": [
"3842"
],
"CVE-2007-2673": [
"3843"
],
"CVE-2007-2521": [
"3846"
],
"CVE-2007-2541": [
"3847"
],
"CVE-2007-2542": [
"3848"
],
"CVE-2007-2543": [
"3849"
],
"CVE-2007-2539": [
"3850"
],
"CVE-2007-2538": [
"3850"
],
"CVE-2007-2540": [
"3852"
],
"CVE-2007-2545": [
"3853"
],
"CVE-2007-2544": [
"3854"
],
"CVE-2007-2537": [
"3855"
],
"CVE-2007-2575": [
"3857"
],
"CVE-2007-2556": [
"3858",
"6749"
],
"CVE-2007-2574": [
"3859"
],
"CVE-2007-2573": [
"3860"
],
"CVE-2007-2572": [
"3861"
],
"CVE-2007-2571": [
"3862"
],
"CVE-2007-2570": [
"3863"
],
"CVE-2007-2569": [
"3864"
],
"CVE-2007-2530": [
"3865"
],
"CVE-2007-2560": [
"3867"
],
"CVE-2007-2527": [
"3868"
],
"CVE-2007-2531": [
"3869"
],
"CVE-2007-2607": [
"3870"
],
"CVE-2007-2611": [
"3874"
],
"CVE-2007-2615": [
"3875"
],
"CVE-2007-2609": [
"3876"
],
"CVE-2007-2608": [
"3878"
],
"CVE-2007-2594": [
"3879"
],
"CVE-2007-2634": [
"3884"
],
"CVE-2007-2596": [
"3884"
],
"CVE-2007-2597": [
"3885"
],
"CVE-2007-2598": [
"3886"
],
"CVE-2007-2600": [
"3887"
],
"CVE-2007-2599": [
"3887"
],
"CVE-2007-2620": [
"3894"
],
"CVE-2007-2621": [
"3895"
],
"CVE-2007-2622": [
"3896"
],
"CVE-2007-2715": [
"3900"
],
"CVE-2007-2643": [
"3901"
],
"CVE-2007-2642": [
"3902"
],
"CVE-2007-2647": [
"3903"
],
"CVE-2007-2641": [
"3905"
],
"CVE-2007-2665": [
"3906"
],
"CVE-2005-2412": [
"3906"
],
"CVE-2007-2717": [
"3907"
],
"CVE-2007-2664": [
"3908"
],
"CVE-2007-2663": [
"3909"
],
"CVE-2007-2662": [
"3911"
],
"CVE-2007-2661": [
"3914"
],
"CVE-2007-2660": [
"3915"
],
"CVE-2007-2659": [
"3918"
],
"CVE-2007-2710": [
"3919"
],
"CVE-2007-2709": [
"3919"
],
"CVE-2007-2708": [
"3920"
],
"CVE-2007-2707": [
"3923"
],
"CVE-2007-2706": [
"3924"
],
"CVE-2007-2736": [
"3928"
],
"CVE-2007-2735": [
"3931"
],
"CVE-2007-2738": [
"3932"
],
"CVE-2007-2737": [
"3933"
],
"CVE-2007-2743": [
"3935"
],
"CVE-2007-2753": [
"3936"
],
"CVE-2007-2752": [
"3936"
],
"CVE-2007-2751": [
"3941"
],
"CVE-2007-2750": [
"3942"
],
"CVE-2007-2749": [
"3943"
],
"CVE-2007-2792": [
"3944",
"11603"
],
"CVE-2007-2793": [
"3946"
],
"CVE-2007-2762": [
"3947"
],
"CVE-2007-2779": [
"3948"
],
"CVE-2007-2778": [
"3949"
],
"CVE-2007-2774": [
"3953"
],
"CVE-2007-2773": [
"3955"
],
"CVE-2007-2824": [
"3956"
],
"CVE-2007-2775": [
"3957"
],
"CVE-2007-2776": [
"3958"
],
"CVE-2007-2777": [
"3959"
],
"CVE-2007-2821": [
"3960"
],
"CVE-2008-6409": [
"3962",
"3964",
"6547"
],
"CVE-2007-6518": [
"3962"
],
"CVE-2007-2817": [
"3962",
"3964"
],
"CVE-2007-2816": [
"3962",
"3964"
],
"CVE-2007-2822": [
"3963"
],
"CVE-2007-2854": [
"3970"
],
"CVE-2007-2899": [
"3971"
],
"CVE-2007-2900": [
"3972"
],
"CVE-2007-2902": [
"3974"
],
"CVE-2007-2901": [
"3974"
],
"CVE-2007-2889": [
"3980"
],
"CVE-2007-2890": [
"3981"
],
"CVE-2007-2891": [
"3983"
],
"CVE-2007-2943": [
"3987"
],
"CVE-2007-2971": [
"3988"
],
"CVE-2007-2942": [
"3989"
],
"CVE-2007-2941": [
"3990"
],
"CVE-2007-2947": [
"3991"
],
"CVE-2007-2940": [
"3992"
],
"CVE-2007-2939": [
"3994"
],
"CVE-2007-2937": [
"3995"
],
"CVE-2007-2936": [
"3997"
],
"CVE-2007-2935": [
"3998"
],
"CVE-2007-2934": [
"3999"
],
"CVE-2007-2969": [
"4000"
],
"CVE-2007-2933": [
"4003"
],
"CVE-2007-2988": [
"4004"
],
"CVE-2007-2986": [
"4005"
],
"CVE-2007-2985": [
"4006"
],
"CVE-2007-2803": [
"4007"
],
"CVE-2007-3065": [
"4019"
],
"CVE-2007-3051": [
"4020"
],
"CVE-2007-3057": [
"4022"
],
"CVE-2007-3139": [
"4025"
],
"CVE-2007-3138": [
"4025"
],
"CVE-2007-3052": [
"4026"
],
"CVE-2007-3082": [
"4029"
],
"CVE-2007-3077": [
"4030"
],
"CVE-2007-2826": [
"4031",
"12369"
],
"CVE-2007-3118": [
"4034"
],
"CVE-2007-3088": [
"4035",
"4037"
],
"CVE-2007-3096": [
"4036"
],
"CVE-2007-3140": [
"4039"
],
"CVE-2007-3119": [
"4040"
],
"CVE-2007-3136": [
"4041"
],
"CVE-2007-3251": [
"4054"
],
"CVE-2007-3214": [
"4054"
],
"CVE-2007-3160": [
"4055"
],
"CVE-2007-3188": [
"4057"
],
"CVE-2007-3199": [
"4059"
],
"CVE-2007-3235": [
"4062"
],
"CVE-2007-3234": [
"4062"
],
"CVE-2007-3237": [
"4063"
],
"CVE-2007-3236": [
"4064"
],
"CVE-2007-3222": [
"4068"
],
"CVE-2007-3221": [
"4069"
],
"CVE-2007-3220": [
"4070"
],
"CVE-2007-3228": [
"4071"
],
"CVE-2007-3230": [
"4072"
],
"CVE-2007-3270": [
"4074"
],
"CVE-2007-3315": [
"4075"
],
"CVE-2007-3271": [
"4075"
],
"CVE-2007-3272": [
"4076"
],
"CVE-2007-3307": [
"4078"
],
"CVE-2007-3306": [
"4079"
],
"CVE-2007-3313": [
"4081"
],
"CVE-2007-3312": [
"4081"
],
"CVE-2007-3293": [
"4082"
],
"CVE-2007-3292": [
"4082"
],
"CVE-2007-3291": [
"4082"
],
"CVE-2007-3290": [
"4082"
],
"CVE-2007-3133": [
"4083"
],
"CVE-2007-3289": [
"4084"
],
"CVE-2007-3297": [
"4085"
],
"CVE-2007-3325": [
"4086"
],
"CVE-2007-3358": [
"4089"
],
"CVE-2007-3371": [
"4090"
],
"CVE-2007-3370": [
"4091"
],
"CVE-2005-3978": [
"4092",
"26698",
"26699"
],
"CVE-2007-3434": [
"4095"
],
"CVE-2007-3433": [
"4095"
],
"CVE-2007-3542": [
"4096"
],
"CVE-2007-3432": [
"4096"
],
"CVE-2007-3431": [
"4097"
],
"CVE-2007-3430": [
"4098"
],
"CVE-2007-3429": [
"4099"
],
"CVE-2007-3427": [
"4100"
],
"CVE-2007-3426": [
"4100"
],
"CVE-2007-3425": [
"4100"
],
"CVE-2007-3401": [
"4102"
],
"CVE-2007-3448": [
"4103"
],
"CVE-2007-3447": [
"4103"
],
"CVE-2007-3446": [
"4103"
],
"CVE-2007-3451": [
"4104"
],
"CVE-2007-3450": [
"4104"
],
"CVE-2007-3449": [
"4104"
],
"CVE-2007-3404": [
"4105"
],
"CVE-2007-3403": [
"4106"
],
"CVE-2007-3402": [
"4107"
],
"CVE-2007-3452": [
"4108"
],
"CVE-2007-3460": [
"4112"
],
"CVE-2007-3461": [
"4114"
],
"CVE-2007-3505": [
"4115"
],
"CVE-2007-3547": [
"4116"
],
"CVE-2007-3590": [
"4122"
],
"CVE-2007-3589": [
"4122"
],
"CVE-2007-3535": [
"4124",
"5870"
],
"CVE-2007-3534": [
"4125"
],
"CVE-2007-3549": [
"4127"
],
"CVE-2007-3526": [
"4128"
],
"CVE-2007-3524": [
"4129"
],
"CVE-2007-3515": [
"4130"
],
"CVE-2007-3523": [
"4131"
],
"CVE-2007-3522": [
"4132"
],
"CVE-2007-3521": [
"4133"
],
"CVE-2007-3520": [
"4134"
],
"CVE-2007-3519": [
"4135",
"26408"
],
"CVE-2007-3518": [
"4136"
],
"CVE-2007-3563": [
"4138"
],
"CVE-2007-3562": [
"4139"
],
"CVE-2007-3530": [
"4139"
],
"CVE-2007-3529": [
"4139"
],
"CVE-2006-3142": [
"4140",
"28033"
],
"CVE-2007-3582": [
"4141"
],
"CVE-2007-3583": [
"4142"
],
"CVE-2007-3586": [
"4144"
],
"CVE-2007-3585": [
"4144"
],
"CVE-2007-3587": [
"4145"
],
"CVE-2007-3584": [
"4147"
],
"CVE-2007-3611": [
"4150"
],
"CVE-2007-3621": [
"4151"
],
"CVE-2007-3610": [
"4153"
],
"CVE-2007-3609": [
"4154"
],
"CVE-2007-3632": [
"4156"
],
"CVE-2007-3631": [
"4159"
],
"CVE-2007-3646": [
"4161"
],
"CVE-2007-3630": [
"4163"
],
"CVE-2007-3683": [
"4164"
],
"CVE-2007-3687": [
"4166"
],
"CVE-2007-3682": [
"4167"
],
"CVE-2007-3697": [
"4169"
],
"CVE-2007-3702": [
"4171"
],
"CVE-2005-1924": [
"4173",
"4718"
],
"CVE-2007-3772": [
"4174"
],
"CVE-2007-3814": [
"4179"
],
"CVE-2007-3813": [
"4180"
],
"CVE-2007-3812": [
"4182"
],
"CVE-2007-3811": [
"4183"
],
"CVE-2007-3810": [
"4184"
],
"CVE-2007-3809": [
"4185"
],
"CVE-2007-3808": [
"4186"
],
"CVE-2007-3840": [
"4187"
],
"CVE-2007-3882": [
"4189"
],
"CVE-2007-3881": [
"4191"
],
"CVE-2007-3939": [
"4192",
"6789"
],
"CVE-2007-3933": [
"4193"
],
"CVE-2007-3932": [
"4194"
],
"CVE-2007-3934": [
"4195"
],
"CVE-2007-3935": [
"4197"
],
"CVE-2007-3937": [
"4198"
],
"CVE-2007-3936": [
"4198"
],
"CVE-2007-3938": [
"4199"
],
"CVE-2007-4046": [
"4201"
],
"CVE-2007-3979": [
"4206"
],
"CVE-2007-3981": [
"4209"
],
"CVE-2007-3980": [
"4210"
],
"CVE-2007-4919": [
"4211",
"4408"
],
"CVE-2007-3974": [
"4211",
"4408"
],
"CVE-2007-3973": [
"4211",
"4408"
],
"CVE-2007-3978": [
"4213"
],
"CVE-2007-3977": [
"4213"
],
"CVE-2007-3976": [
"4213"
],
"CVE-2007-4009": [
"4219"
],
"CVE-2007-4008": [
"4220"
],
"CVE-2007-4007": [
"4221"
],
"CVE-2007-4068": [
"4224"
],
"CVE-2007-4069": [
"4225"
],
"CVE-2007-4057": [
"4235"
],
"CVE-2007-4056": [
"4238"
],
"CVE-2007-4055": [
"4239"
],
"CVE-2007-4054": [
"4241"
],
"CVE-2007-4053": [
"4242"
],
"CVE-2007-4156": [
"4246"
],
"CVE-2007-4128": [
"4248"
],
"CVE-2007-4183": [
"4253"
],
"CVE-2007-4171": [
"4254"
],
"CVE-2007-4253": [
"4256"
],
"CVE-2007-4210": [
"4258",
"30448",
"30449",
"30450"
],
"CVE-2007-4256": [
"4261"
],
"CVE-2006-2046": [
"4264",
"27853"
],
"CVE-2007-4258": [
"4265"
],
"CVE-2007-4231": [
"4267"
],
"CVE-2007-4232": [
"4268"
],
"CVE-2007-4279": [
"4269"
],
"CVE-2007-4287": [
"4271"
],
"CVE-2007-4320": [
"4273"
],
"CVE-2007-4312": [
"4275"
],
"CVE-2007-4313": [
"4276"
],
"CVE-2007-4314": [
"4278"
],
"CVE-2007-4369": [
"4282"
],
"CVE-2007-4362": [
"4284"
],
"CVE-2007-4368": [
"4286"
],
"CVE-2007-4386": [
"4291"
],
"CVE-2007-4439": [
"4295"
],
"CVE-2007-4456": [
"4296"
],
"CVE-2005-1032": [
"4300"
],
"CVE-2007-4506": [
"4305"
],
"CVE-2007-4505": [
"4306"
],
"CVE-2007-4504": [
"4307"
],
"CVE-2007-4503": [
"4308"
],
"CVE-2007-4509": [
"4309"
],
"CVE-2007-4502": [
"4310"
],
"CVE-2007-4597": [
"4313"
],
"CVE-2007-4585": [
"4317"
],
"CVE-2007-4551": [
"4326",
"30525"
],
"CVE-2007-4552": [
"4326"
],
"CVE-2007-4581": [
"4327"
],
"CVE-2007-4602": [
"4329"
],
"CVE-2007-4603": [
"4330",
"30539"
],
"CVE-2007-4604": [
"4331"
],
"CVE-2007-4605": [
"4332"
],
"CVE-2007-4606": [
"4333"
],
"CVE-2007-4637": [
"4336"
],
"CVE-2007-4627": [
"4338"
],
"CVE-2007-4628": [
"4339"
],
"CVE-2007-4636": [
"4340"
],
"CVE-2007-4641": [
"4341"
],
"CVE-2007-4640": [
"4341"
],
"CVE-2007-4645": [
"4342"
],
"CVE-2007-4647": [
"4343"
],
"CVE-2007-4653": [
"4346"
],
"CVE-2007-4736": [
"4349"
],
"CVE-2007-4781": [
"4350"
],
"CVE-2007-4715": [
"4352"
],
"CVE-2007-4714": [
"4353"
],
"CVE-2007-4712": [
"4356"
],
"CVE-2007-4738": [
"4358"
],
"CVE-2007-4737": [
"4358"
],
"CVE-2007-4763": [
"4363"
],
"CVE-2007-4744": [
"4365"
],
"CVE-2007-4757": [
"4368"
],
"CVE-2007-4846": [
"4370"
],
"CVE-2007-4845": [
"4371"
],
"CVE-2007-4809": [
"4374"
],
"CVE-2007-4808": [
"4376"
],
"CVE-2007-4942": [
"4377"
],
"CVE-2007-4807": [
"4377"
],
"CVE-2007-4806": [
"4377"
],
"CVE-2007-4805": [
"4378"
],
"CVE-2007-4820": [
"4380"
],
"CVE-2007-4819": [
"4381"
],
"CVE-2007-4818": [
"4381"
],
"CVE-2007-4524": [
"4382"
],
"CVE-2007-4817": [
"4383"
],
"CVE-2007-4815": [
"4384"
],
"CVE-2007-4804": [
"4385"
],
"CVE-2007-4895": [
"4386"
],
"CVE-2007-4834": [
"4387"
],
"CVE-2007-4908": [
"4390"
],
"CVE-2007-4905": [
"4390"
],
"CVE-2007-4886": [
"4390"
],
"CVE-2007-4906": [
"4395"
],
"CVE-2007-4907": [
"4396"
],
"CVE-2007-4922": [
"4400"
],
"CVE-2007-4923": [
"4401"
],
"CVE-2007-4966": [
"4404"
],
"CVE-2007-3913": [
"4404"
],
"CVE-2007-4921": [
"4405"
],
"CVE-2007-4934": [
"4406"
],
"CVE-2007-4920": [
"4407"
],
"CVE-2007-4918": [
"4410"
],
"CVE-2007-4957": [
"4411"
],
"CVE-2007-4956": [
"4412",
"4413",
"4414"
],
"CVE-2007-4955": [
"4415"
],
"CVE-2007-4954": [
"4416"
],
"CVE-2007-4953": [
"4417"
],
"CVE-2007-4952": [
"4418"
],
"CVE-2007-4933": [
"4419"
],
"CVE-2007-4932": [
"4419"
],
"CVE-2007-4978": [
"4421"
],
"CVE-2007-4979": [
"4422"
],
"CVE-2007-4984": [
"4425"
],
"CVE-2007-5015": [
"4430"
],
"CVE-2007-5016": [
"4433"
],
"CVE-2007-5009": [
"4434"
],
"CVE-2007-5062": [
"4435"
],
"CVE-2007-5063": [
"4436"
],
"CVE-2007-5050": [
"4439"
],
"CVE-2007-5065": [
"4440"
],
"CVE-2007-5055": [
"4441"
],
"CVE-2007-5054": [
"4441"
],
"CVE-2007-5053": [
"4441"
],
"CVE-2005-4600": [
"4441"
],
"CVE-2007-5056": [
"4442",
"5090",
"5091",
"5097",
"5098"
],
"CVE-2007-5061": [
"4443"
],
"CVE-2007-5102": [
"4446"
],
"CVE-2007-5069": [
"4447"
],
"CVE-2007-5099": [
"4448"
],
"CVE-2007-5068": [
"4449"
],
"CVE-2007-5098": [
"4451"
],
"CVE-2007-5089": [
"4454"
],
"CVE-2007-5117": [
"4456"
],
"CVE-2007-5122": [
"4457"
],
"CVE-2007-5123": [
"4458"
],
"CVE-2007-5131": [
"4459"
],
"CVE-2007-5138": [
"4461"
],
"CVE-2007-5139": [
"4462"
],
"CVE-2007-5140": [
"4463"
],
"CVE-2007-5157": [
"4464"
],
"CVE-2007-5149": [
"4465"
],
"CVE-2007-5278": [
"4466"
],
"CVE-2007-5231": [
"4466"
],
"CVE-2007-5230": [
"4466"
],
"CVE-2007-5222": [
"4467",
"30623"
],
"CVE-2007-5177": [
"4469"
],
"CVE-2007-5178": [
"4470"
],
"CVE-2007-5173": [
"4471"
],
"CVE-2007-5174": [
"4472"
],
"CVE-2007-5175": [
"4473"
],
"CVE-2007-5187": [
"4475"
],
"CVE-2007-5186": [
"4476"
],
"CVE-2007-5185": [
"4477"
],
"CVE-2007-5261": [
"4480"
],
"CVE-2007-5221": [
"4481"
],
"CVE-2007-5233": [
"4482"
],
"CVE-2007-5234": [
"4483"
],
"CVE-2007-5271": [
"4485"
],
"CVE-2007-5272": [
"4486"
],
"CVE-2007-5363": [
"4489"
],
"CVE-2007-5307": [
"4490"
],
"CVE-2007-5306": [
"4490"
],
"CVE-2007-5305": [
"4490"
],
"CVE-2007-5304": [
"4490"
],
"CVE-2007-5298": [
"4491"
],
"CVE-2007-5313": [
"4492"
],
"CVE-2007-5299": [
"4493"
],
"CVE-2007-5321": [
"4494"
],
"CVE-2007-5294": [
"4495"
],
"CVE-2007-5293": [
"4495"
],
"CVE-2007-5309": [
"4496"
],
"CVE-2007-5310": [
"4497"
],
"CVE-2007-5362": [
"4499"
],
"CVE-2007-5312": [
"4500"
],
"CVE-2007-5311": [
"4500"
],
"CVE-2007-5308": [
"4501"
],
"CVE-2007-5314": [
"4502"
],
"CVE-2007-5315": [
"4503"
],
"CVE-2007-5316": [
"4504"
],
"CVE-2007-5374": [
"4505"
],
"CVE-2007-5412": [
"4507"
],
"CVE-2007-5407": [
"4508"
],
"CVE-2007-5423": [
"4509",
"16911"
],
"CVE-2007-5416": [
"4510"
],
"CVE-2007-5408": [
"4511"
],
"CVE-2007-5409": [
"4512"
],
"CVE-2007-5453": [
"4513"
],
"CVE-2007-5452": [
"4513"
],
"CVE-2007-5388": [
"4518"
],
"CVE-2007-5387": [
"4519"
],
"CVE-2007-5390": [
"4520"
],
"CVE-2007-5457": [
"4521"
],
"CVE-2007-5458": [
"4523"
],
"CVE-2007-5451": [
"4524"
],
"CVE-2007-5449": [
"4527"
],
"CVE-2007-5485": [
"4528"
],
"CVE-2007-5484": [
"4529"
],
"CVE-2007-5455": [
"4529"
],
"CVE-2007-5465": [
"4536"
],
"CVE-2007-5600": [
"4538"
],
"CVE-2007-5489": [
"4538"
],
"CVE-2007-5490": [
"4539"
],
"CVE-2007-5574": [
"4543"
],
"CVE-2007-5573": [
"4544"
],
"CVE-2007-5592": [
"4545"
],
"CVE-2007-5620": [
"4546"
],
"CVE-2007-5646": [
"4547"
],
"CVE-2007-5644": [
"4548"
],
"CVE-2007-5643": [
"4548"
],
"CVE-2007-5642": [
"4549"
],
"CVE-2007-5641": [
"4549"
],
"CVE-2007-5630": [
"4550"
],
"CVE-2007-5631": [
"4551"
],
"CVE-2007-5627": [
"4554"
],
"CVE-2007-5628": [
"4555"
],
"CVE-2007-5674": [
"4558"
],
"CVE-2007-5774": [
"4561"
],
"CVE-2007-5773": [
"4561"
],
"CVE-2007-5772": [
"4562"
],
"CVE-2007-5771": [
"4562"
],
"CVE-2007-5676": [
"4563"
],
"CVE-2007-5697": [
"4565"
],
"CVE-2007-5684": [
"4568"
],
"CVE-2007-5786": [
"4575"
],
"CVE-2007-5785": [
"4576"
],
"CVE-2007-5784": [
"4577"
],
"CVE-2007-5783": [
"4578"
],
"CVE-2007-5782": [
"4580"
],
"CVE-2007-5781": [
"4581"
],
"CVE-2007-5780": [
"4582"
],
"CVE-2007-5721": [
"4585"
],
"CVE-2007-5720": [
"4586"
],
"CVE-2007-5719": [
"4587"
],
"CVE-2007-5754": [
"4588"
],
"CVE-2007-5752": [
"4589",
"5649"
],
"CVE-2007-5812": [
"4591"
],
"CVE-2007-5813": [
"4592"
],
"CVE-2007-5800": [
"4593"
],
"CVE-2007-5802": [
"4595",
"30731"
],
"CVE-2007-5823": [
"4596"
],
"CVE-2007-5822": [
"4596"
],
"CVE-2007-5821": [
"4597"
],
"CVE-2007-5820": [
"4599"
],
"CVE-2007-5844": [
"4602"
],
"CVE-2007-5843": [
"4604"
],
"CVE-2007-5842": [
"4605"
],
"CVE-2007-5841": [
"4606"
],
"CVE-2007-5840": [
"4607"
],
"CVE-2007-5914": [
"4608"
],
"CVE-2007-5913": [
"4608"
],
"CVE-2007-5887": [
"4609"
],
"CVE-2007-5974": [
"4611"
],
"CVE-2007-5912": [
"4611"
],
"CVE-2007-5973": [
"4614"
],
"CVE-2007-5999": [
"4617"
],
"CVE-2007-5998": [
"4618"
],
"CVE-2007-5997": [
"4619"
],
"CVE-2007-5996": [
"4620"
],
"CVE-2007-5995": [
"4621"
],
"CVE-2007-5992": [
"4622"
],
"CVE-2007-6004": [
"4623"
],
"CVE-2007-6027": [
"4626"
],
"CVE-2007-6058": [
"4627"
],
"CVE-2007-6057": [
"4628"
],
"CVE-2007-6089": [
"4630"
],
"CVE-2007-6088": [
"4631"
],
"CVE-2007-6087": [
"4632"
],
"CVE-2007-6086": [
"4632"
],
"CVE-2007-6085": [
"4632"
],
"CVE-2007-6084": [
"4633"
],
"CVE-2007-6083": [
"4634"
],
"CVE-2007-6082": [
"4635"
],
"CVE-2007-6038": [
"4636"
],
"CVE-2007-6080": [
"4637",
"32536"
],
"CVE-2007-6079": [
"4637"
],
"CVE-2007-6078": [
"4638"
],
"CVE-2007-6105": [
"4640"
],
"CVE-2007-6106": [
"4641"
],
"CVE-2007-6133": [
"4642"
],
"CVE-2007-6137": [
"4645"
],
"CVE-2007-6134": [
"4646"
],
"CVE-2007-6176": [
"4647"
],
"CVE-2007-6217": [
"4649"
],
"CVE-2007-6139": [
"4650"
],
"CVE-2007-6129": [
"4652"
],
"CVE-2007-6128": [
"4653"
],
"CVE-2007-6127": [
"4655"
],
"CVE-2007-6126": [
"4655"
],
"CVE-2007-6147": [
"4659"
],
"CVE-2007-6125": [
"4660"
],
"CVE-2007-6124": [
"4660"
],
"CVE-2007-6237": [
"4661"
],
"CVE-2007-6159": [
"4662"
],
"CVE-2007-6164": [
"4665"
],
"CVE-2007-6185": [
"4666"
],
"CVE-2007-6172": [
"4668"
],
"CVE-2007-6184": [
"4669"
],
"CVE-2007-6177": [
"4670"
],
"CVE-2007-6178": [
"4671"
],
"CVE-2007-6179": [
"4672"
],
"CVE-2007-6221": [
"4674"
],
"CVE-2007-6188": [
"4674"
],
"CVE-2007-6187": [
"4675"
],
"CVE-2007-6215": [
"4676"
],
"CVE-2007-6213": [
"4677"
],
"CVE-2007-6202": [
"4678"
],
"CVE-2007-6212": [
"4679"
],
"CVE-2007-6214": [
"4680"
],
"CVE-2007-6234": [
"4681"
],
"CVE-2007-6233": [
"4681"
],
"CVE-2007-6232": [
"4681",
"4684"
],
"CVE-2007-6231": [
"4684"
],
"CVE-2007-6230": [
"4685"
],
"CVE-2007-6229": [
"4685"
],
"CVE-2007-6223": [
"4686"
],
"CVE-2007-6240": [
"4687"
],
"CVE-2007-6362": [
"4691"
],
"CVE-2007-6367": [
"4693"
],
"CVE-2007-6366": [
"4693"
],
"CVE-2007-6368": [
"4694"
],
"CVE-2007-6369": [
"4695"
],
"CVE-2007-6290": [
"4696"
],
"CVE-2007-6289": [
"4696"
],
"CVE-2007-6292": [
"4697"
],
"CVE-2007-6400": [
"4704"
],
"CVE-2007-6399": [
"4705"
],
"CVE-2007-6398": [
"4705"
],
"CVE-2007-6397": [
"4705"
],
"CVE-2007-6396": [
"4705"
],
"CVE-2007-6395": [
"4705"
],
"CVE-2007-6394": [
"4706"
],
"CVE-2007-6393": [
"4707"
],
"CVE-2007-6392": [
"4708"
],
"CVE-2007-6391": [
"4709"
],
"CVE-2007-6311": [
"4711"
],
"CVE-2007-6310": [
"4711"
],
"CVE-2007-6490": [
"4712"
],
"CVE-2007-6489": [
"4712"
],
"CVE-2007-6488": [
"4712"
],
"CVE-2007-6344": [
"4719"
],
"CVE-2007-6318": [
"4721"
],
"CVE-2007-6347": [
"4722"
],
"CVE-2007-6325": [
"4725"
],
"CVE-2007-6324": [
"4726"
],
"CVE-2007-6323": [
"4728"
],
"CVE-2007-6322": [
"4729"
],
"CVE-2007-6504": [
"4730"
],
"CVE-2007-6503": [
"4730"
],
"CVE-2007-6502": [
"4730"
],
"CVE-2007-6501": [
"4730"
],
"CVE-2007-6500": [
"4730"
],
"CVE-2007-6499": [
"4730"
],
"CVE-2007-6498": [
"4730"
],
"CVE-2007-6497": [
"4730"
],
"CVE-2007-6496": [
"4730"
],
"CVE-2007-6495": [
"4730"
],
"CVE-2007-6494": [
"4730"
],
"CVE-2007-6414": [
"4731"
],
"CVE-2007-6458": [
"4733"
],
"CVE-2007-6459": [
"4734"
],
"CVE-2007-6485": [
"4735"
],
"CVE-2007-6464": [
"4736"
],
"CVE-2007-6462": [
"4737"
],
"CVE-2007-6476": [
"4738"
],
"CVE-2007-6475": [
"4738"
],
"CVE-2007-6474": [
"4738"
],
"CVE-2007-6466": [
"4739",
"4740"
],
"CVE-2007-6668": [
"4741"
],
"CVE-2007-6472": [
"4750"
],
"CVE-2007-6479": [
"4753"
],
"CVE-2007-6508": [
"4758"
],
"CVE-2007-6586": [
"4762",
"6979"
],
"CVE-2007-6585": [
"4763"
],
"CVE-2007-6542": [
"4764"
],
"CVE-2007-6584": [
"4765"
],
"CVE-2007-6583": [
"4765"
],
"CVE-2007-6582": [
"4766"
],
"CVE-2007-6581": [
"4767"
],
"CVE-2007-6580": [
"4770"
],
"CVE-2007-6579": [
"4771"
],
"CVE-2007-6577": [
"4772"
],
"CVE-2007-6578": [
"4774"
],
"CVE-2007-6576": [
"4775"
],
"CVE-2007-6575": [
"4776"
],
"CVE-2007-6556": [
"4777"
],
"CVE-2007-6557": [
"4778"
],
"CVE-2007-6615": [
"4782"
],
"CVE-2007-6614": [
"4782"
],
"CVE-2007-6555": [
"4783"
],
"CVE-2007-6554": [
"4785"
],
"CVE-2007-6553": [
"4785"
],
"CVE-2007-6552": [
"4786"
],
"CVE-2007-6544": [
"4787",
"4792"
],
"CVE-2007-6551": [
"4788"
],
"CVE-2007-6550": [
"4789"
],
"CVE-2007-6548": [
"4790"
],
"CVE-2007-6547": [
"4790"
],
"CVE-2007-6546": [
"4790"
],
"CVE-2007-6545": [
"4790"
],
"CVE-2007-6543": [
"4791"
],
"CVE-2007-6565": [
"4793"
],
"CVE-2007-6567": [
"4794"
],
"CVE-2007-6566": [
"4794"
],
"CVE-2007-6568": [
"4795"
],
"CVE-2007-6624": [
"4796"
],
"CVE-2007-6623": [
"4798"
],
"CVE-2007-6622": [
"4798"
],
"CVE-2007-6621": [
"4799"
],
"CVE-2007-6620": [
"4799"
],
"CVE-2007-6632": [
"4800"
],
"CVE-2007-6604": [
"4802"
],
"CVE-2007-6603": [
"4804"
],
"CVE-2007-6602": [
"4805"
],
"CVE-2007-6657": [
"4808"
],
"CVE-2007-6658": [
"4809"
],
"CVE-2007-6656": [
"4810"
],
"CVE-2007-6655": [
"4811"
],
"CVE-2007-6653": [
"4812"
],
"CVE-2007-6652": [
"4813"
],
"CVE-2007-6651": [
"4814"
],
"CVE-2007-6650": [
"4814"
],
"CVE-2007-6649": [
"4815"
],
"CVE-2007-6648": [
"4816"
],
"CVE-2007-6647": [
"4817"
],
"CVE-2007-6639": [
"4821"
],
"CVE-2007-6667": [
"4822"
],
"CVE-2007-6666": [
"4823"
],
"CVE-2007-6665": [
"4824"
],
"CVE-2007-6664": [
"4826"
],
"CVE-2007-6663": [
"4827"
],
"CVE-2008-0091": [
"4828"
],
"CVE-2008-0089": [
"4830",
"24894"
],
"CVE-2008-0099": [
"4831"
],
"CVE-2008-0129": [
"4832"
],
"CVE-2008-0144": [
"4833"
],
"CVE-2008-0143": [
"4834"
],
"CVE-2008-0142": [
"4835"
],
"CVE-2008-0141": [
"4835"
],
"CVE-2008-0187": [
"4836"
],
"CVE-2008-7188": [
"4837"
],
"CVE-2008-0137": [
"4838"
],
"CVE-2008-0133": [
"4840"
],
"CVE-2008-7155": [
"4842"
],
"CVE-2008-0222": [
"4844"
],
"CVE-2008-0224": [
"4845"
],
"CVE-2008-0210": [
"4846"
],
"CVE-2008-0140": [
"4846"
],
"CVE-2008-0138": [
"4847"
],
"CVE-2008-4614": [
"4848"
],
"CVE-2008-4613": [
"4848"
],
"CVE-2008-4612": [
"4848"
],
"CVE-2008-0139": [
"4849"
],
"CVE-2006-1260": [
"4850"
],
"CVE-2008-4557": [
"4851"
],
"CVE-2008-0186": [
"4852"
],
"CVE-2008-0185": [
"4852"
],
"CVE-2008-7163": [
"4854"
],
"CVE-2008-0158": [
"4855"
],
"CVE-2008-7209": [
"4857"
],
"CVE-2008-7208": [
"4857"
],
"CVE-2008-0157": [
"4858"
],
"CVE-2008-7157": [
"4859"
],
"CVE-2008-7156": [
"4859"
],
"CVE-2008-0159": [
"4860"
],
"CVE-2008-0149": [
"4861"
],
"CVE-2008-0148": [
"4861"
],
"CVE-2008-0147": [
"4863"
],
"CVE-2008-0233": [
"4864"
],
"CVE-2008-0232": [
"4864"
],
"CVE-2008-0155": [
"4865"
],
"CVE-2008-0154": [
"4865"
],
"CVE-2008-0219": [
"4867"
],
"CVE-2008-0230": [
"4870"
],
"CVE-2008-0246": [
"4871"
],
"CVE-2008-0245": [
"4871"
],
"CVE-2008-0249": [
"4872"
],
"CVE-2008-0231": [
"4876"
],
"CVE-2008-7154": [
"4879"
],
"CVE-2008-7153": [
"4879",
"4891"
],
"CVE-2008-0282": [
"4880"
],
"CVE-2008-0280": [
"4882"
],
"CVE-2008-0283": [
"4883"
],
"CVE-2008-0351": [
"4884"
],
"CVE-2008-0350": [
"4884"
],
"CVE-2008-0255": [
"4886"
],
"CVE-2008-0290": [
"4887"
],
"CVE-2008-6064": [
"4888"
],
"CVE-2008-0287": [
"4889"
],
"CVE-2008-7210": [
"4890"
],
"CVE-2008-0288": [
"4895"
],
"CVE-2008-0297": [
"4897"
],
"CVE-2008-0262": [
"4898",
"4905"
],
"CVE-2008-0270": [
"4899"
],
"CVE-2008-0256": [
"4900"
],
"CVE-2008-0254": [
"4901"
],
"CVE-2008-0260": [
"4902"
],
"CVE-2008-0259": [
"4902"
],
"CVE-2008-0253": [
"4904"
],
"CVE-2008-0278": [
"4907"
],
"CVE-2008-0279": [
"4908"
],
"CVE-2008-0291": [
"4910"
],
"CVE-2008-0329": [
"4912"
],
"CVE-2008-0327": [
"4914"
],
"CVE-2008-0328": [
"4915"
],
"CVE-2008-0325": [
"4916"
],
"CVE-2008-0326": [
"4917"
],
"CVE-2008-0360": [
"4919"
],
"CVE-2008-0359": [
"4919"
],
"CVE-2008-0332": [
"4920"
],
"CVE-2008-0333": [
"4921"
],
"CVE-2008-0391": [
"4922"
],
"CVE-2008-0371": [
"4922"
],
"CVE-2008-0358": [
"4924"
],
"CVE-2008-0353": [
"4925"
],
"CVE-2008-0361": [
"4926"
],
"CVE-2008-0382": [
"4927",
"4928"
],
"CVE-2008-0355": [
"4929"
],
"CVE-2008-0357": [
"4930",
"4940"
],
"CVE-2008-0390": [
"4933"
],
"CVE-2008-0393": [
"4936"
],
"CVE-2008-0442": [
"4937"
],
"CVE-2008-0376": [
"4937"
],
"CVE-2008-0388": [
"4939"
],
"CVE-2007-6528": [
"4942"
],
"CVE-2008-0425": [
"4943"
],
"CVE-2008-0430": [
"4944"
],
"CVE-2008-0428": [
"4945"
],
"CVE-2008-0427": [
"4945"
],
"CVE-2008-0504": [
"4950"
],
"CVE-2008-0424": [
"4951"
],
"CVE-2008-0422": [
"4952"
],
"CVE-2008-0435": [
"4953"
],
"CVE-2008-0431": [
"4954"
],
"CVE-2008-0423": [
"4955"
],
"CVE-2008-0440": [
"4956"
],
"CVE-2008-0429": [
"4956"
],
"CVE-2008-0782": [
"4957"
],
"CVE-2008-0398": [
"4958"
],
"CVE-2008-0397": [
"4958"
],
"CVE-2008-0453": [
"4960"
],
"CVE-2008-0478": [
"4962"
],
"CVE-2008-0461": [
"4965"
],
"CVE-2008-0421": [
"4966"
],
"CVE-2008-0447": [
"4968"
],
"CVE-2008-0446": [
"4969"
],
"CVE-2008-0480": [
"4970"
],
"CVE-2008-0466": [
"4970",
"4971"
],
"CVE-2008-0481": [
"4971"
],
"CVE-2008-0473": [
"4971"
],
"CVE-2008-0479": [
"4972"
],
"CVE-2008-0452": [
"4973"
],
"CVE-2008-0458": [
"4975"
],
"CVE-2008-0459": [
"4976"
],
"CVE-2008-0464": [
"4977"
],
"CVE-2008-0465": [
"4980"
],
"CVE-2008-0469": [
"4984"
],
"CVE-2008-0468": [
"4985"
],
"CVE-2008-0739": [
"4988"
],
"CVE-2008-0738": [
"4988"
],
"CVE-2008-0737": [
"4988"
],
"CVE-2008-0736": [
"4988"
],
"CVE-2008-0547": [
"4988"
],
"CVE-2008-0546": [
"4988"
],
"CVE-2008-0542": [
"4989"
],
"CVE-2008-0541": [
"4989"
],
"CVE-2008-0538": [
"4990"
],
"CVE-2008-0545": [
"4991"
],
"CVE-2008-0490": [
"4992"
],
"CVE-2008-0491": [
"4993"
],
"CVE-2008-0501": [
"5000"
],
"CVE-2008-0521": [
"5001"
],
"CVE-2008-0498": [
"5002"
],
"CVE-2008-0503": [
"5003"
],
"CVE-2008-0513": [
"5006"
],
"CVE-2008-0510": [
"5007"
],
"CVE-2008-0512": [
"5008"
],
"CVE-2008-0511": [
"5009"
],
"CVE-2008-0514": [
"5010"
],
"CVE-2008-0579": [
"5011"
],
"CVE-2008-0515": [
"5011"
],
"CVE-2008-0502": [
"5012"
],
"CVE-2008-0507": [
"5013"
],
"CVE-2008-0518": [
"5014"
],
"CVE-2008-0519": [
"5015"
],
"CVE-2008-0517": [
"5016"
],
"CVE-2008-0520": [
"5017"
],
"CVE-2008-0770": [
"5018"
],
"CVE-2008-0567": [
"5020"
],
"CVE-2008-0565": [
"5021",
"37786"
],
"CVE-2008-0566": [
"5022"
],
"CVE-2008-0572": [
"5026"
],
"CVE-2008-0703": [
"5027"
],
"CVE-2008-0561": [
"5029"
],
"CVE-2008-0557": [
"5030"
],
"CVE-2008-0562": [
"5031"
],
"CVE-2008-0632": [
"5033"
],
"CVE-2008-0686": [
"5034"
],
"CVE-2008-0616": [
"5035"
],
"CVE-2008-0724": [
"5037"
],
"CVE-2008-0675": [
"5037"
],
"CVE-2008-0682": [
"5039"
],
"CVE-2008-0695": [
"5040"
],
"CVE-2008-0681": [
"5041",
"24108"
],
"CVE-2008-0679": [
"5042"
],
"CVE-2008-0678": [
"5042"
],
"CVE-2008-0690": [
"5047"
],
"CVE-2008-0677": [
"5050"
],
"CVE-2008-0676": [
"5050"
],
"CVE-2008-0683": [
"5053"
],
"CVE-2008-0689": [
"5055",
"7097"
],
"CVE-2008-0692": [
"5056"
],
"CVE-2008-0613": [
"5057"
],
"CVE-2008-0612": [
"5057"
],
"CVE-2008-0603": [
"5058"
],
"CVE-2008-0606": [
"5059"
],
"CVE-2008-0609": [
"5060"
],
"CVE-2008-0602": [
"5061"
],
"CVE-2008-0611": [
"5062"
],
"CVE-2008-0601": [
"5064"
],
"CVE-2008-0614": [
"5065"
],
"CVE-2008-5695": [
"5066"
],
"CVE-2008-0648": [
"5068"
],
"CVE-2008-0787": [
"5070"
],
"CVE-2008-0649": [
"5071"
],
"CVE-2008-0653": [
"5072"
],
"CVE-2008-0652": [
"5073"
],
"CVE-2008-0714": [
"5074"
],
"CVE-2008-0719": [
"5075"
],
"CVE-2008-0721": [
"5076"
],
"CVE-2008-0772": [
"5080"
],
"CVE-2008-0670": [
"5081"
],
"CVE-2008-0742": [
"5082"
],
"CVE-2008-0752": [
"5083"
],
"CVE-2008-0746": [
"5084"
],
"CVE-2008-0734": [
"5088"
],
"CVE-2008-0745": [
"5089"
],
"CVE-2008-0773": [
"5094"
],
"CVE-2008-0776": [
"5096"
],
"CVE-2008-0831": [
"5103"
],
"CVE-2008-0754": [
"5103"
],
"CVE-2008-0761": [
"5104"
],
"CVE-2008-0735": [
"5105"
],
"CVE-2008-0794": [
"5108"
],
"CVE-2008-0795": [
"5109"
],
"CVE-2008-1231": [
"5112"
],
"CVE-2008-1230": [
"5112"
],
"CVE-2008-1229": [
"5112"
],
"CVE-2008-1177": [
"5114"
],
"CVE-2008-1176": [
"5114"
],
"CVE-2008-0796": [
"5115"
],
"CVE-2008-0798": [
"5116"
],
"CVE-2008-0801": [
"5117"
],
"CVE-2008-0800": [
"5118"
],
"CVE-2008-0799": [
"5119"
],
"CVE-2008-0802": [
"5120"
],
"CVE-2008-0803": [
"5121"
],
"CVE-2008-0822": [
"5123"
],
"CVE-2008-0818": [
"5124"
],
"CVE-2008-0821": [
"5125",
"9254"
],
"CVE-2008-0832": [
"5128"
],
"CVE-2008-0814": [
"5129"
],
"CVE-2008-0811": [
"5130"
],
"CVE-2008-0835": [
"5131"
],
"CVE-2008-0829": [
"5132"
],
"CVE-2008-0841": [
"5133"
],
"CVE-2008-0833": [
"5134"
],
"CVE-2008-0939": [
"5135"
],
"CVE-2008-0805": [
"5136"
],
"CVE-2008-0813": [
"5137"
],
"CVE-2008-0918": [
"5138"
],
"CVE-2008-0839": [
"5138"
],
"CVE-2008-0840": [
"5140"
],
"CVE-2008-0844": [
"5145"
],
"CVE-2008-0842": [
"5146"
],
"CVE-2008-0827": [
"5147"
],
"CVE-2008-0847": [
"5148"
],
"CVE-2008-5578": [
"5149"
],
"CVE-2008-5577": [
"5149"
],
"CVE-2008-5576": [
"5149"
],
"CVE-2008-0880": [
"5155"
],
"CVE-2008-0878": [
"5156"
],
"CVE-2008-0874": [
"5157"
],
"CVE-2008-0873": [
"5158"
],
"CVE-2008-0881": [
"5159"
],
"CVE-2008-0916": [
"5160"
],
"CVE-2008-0906": [
"5161"
],
"CVE-2008-0905": [
"5162"
],
"CVE-2008-0907": [
"5163"
],
"CVE-2008-0857": [
"5164"
],
"CVE-2008-1484": [
"5165"
],
"CVE-2008-0911": [
"5166"
],
"CVE-2008-0922": [
"5168"
],
"CVE-2008-0921": [
"5170"
],
"CVE-2008-0920": [
"5171"
],
"CVE-2008-0919": [
"5171"
],
"CVE-2008-0934": [
"5172"
],
"CVE-2008-1067": [
"5173"
],
"CVE-2008-0167": [
"5173"
],
"CVE-2008-1069": [
"5174"
],
"CVE-2008-1051": [
"5175"
],
"CVE-2008-1046": [
"5176"
],
"CVE-2008-1137": [
"5178"
],
"CVE-2008-7240": [
"5179"
],
"CVE-2008-1043": [
"5180"
],
"CVE-2008-1068": [
"5182"
],
"CVE-2008-1042": [
"5183"
],
"CVE-2008-1039": [
"5185"
],
"CVE-2008-1053": [
"5186"
],
"CVE-2008-3888": [
"5187"
],
"CVE-2008-1038": [
"5189"
],
"CVE-2008-5582": [
"5192"
],
"CVE-2008-1061": [
"5194"
],
"CVE-2008-1060": [
"5194"
],
"CVE-2008-1059": [
"5194"
],
"CVE-2008-1077": [
"5195"
],
"CVE-2008-1121": [
"5196"
],
"CVE-2008-1074": [
"5197"
],
"CVE-2008-1122": [
"5198"
],
"CVE-2008-1123": [
"5199"
],
"CVE-2008-1125": [
"5200"
],
"CVE-2008-1124": [
"5200"
],
"CVE-2008-1126": [
"5202"
],
"CVE-2008-7038": [
"5203",
"5242"
],
"CVE-2008-1119": [
"5204"
],
"CVE-2008-1336": [
"5206"
],
"CVE-2008-6234": [
"5207"
],
"CVE-2008-1163": [
"5208"
],
"CVE-2008-1164": [
"5209"
],
"CVE-2008-1162": [
"5211"
],
"CVE-2008-7124": [
"5219",
"5220"
],
"CVE-2008-7123": [
"5220"
],
"CVE-2007-3539": [
"5222"
],
"CVE-2008-1272": [
"5223"
],
"CVE-2008-1297": [
"5226"
],
"CVE-2008-1295": [
"5231"
],
"CVE-2008-0300": [
"5232"
],
"CVE-2008-0301": [
"5233"
],
"CVE-2008-1313": [
"5234"
],
"CVE-2008-1305": [
"5236"
],
"CVE-2008-1513": [
"5239"
],
"CVE-2008-1316": [
"5240"
],
"CVE-2008-1350": [
"5243"
],
"CVE-2008-1349": [
"5244"
],
"CVE-2008-1351": [
"5245"
],
"CVE-2008-1345": [
"5246"
],
"CVE-2008-1344": [
"5246"
],
"CVE-2008-1347": [
"5247"
],
"CVE-2008-1346": [
"5247"
],
"CVE-2008-1406": [
"5252"
],
"CVE-2008-1404": [
"5254"
],
"CVE-2008-1407": [
"5255"
],
"CVE-2008-1398": [
"5256"
],
"CVE-2008-1405": [
"5260"
],
"CVE-2008-1415": [
"5262"
],
"CVE-2008-1414": [
"5262"
],
"CVE-2008-1408": [
"5263"
],
"CVE-2008-1409": [
"5265"
],
"CVE-2008-1416": [
"5266"
],
"CVE-2008-1427": [
"5273"
],
"CVE-2008-1426": [
"5274"
],
"CVE-2008-1425": [
"5275",
"11964"
],
"CVE-2008-1430": [
"5276",
"5286"
],
"CVE-2008-1460": [
"5277"
],
"CVE-2008-1459": [
"5278"
],
"CVE-2008-1465": [
"5280"
],
"CVE-2008-1507": [
"5281"
],
"CVE-2008-1506": [
"5281"
],
"CVE-2008-1496": [
"5281"
],
"CVE-2008-1495": [
"5281"
],
"CVE-2008-1462": [
"5285"
],
"CVE-2008-1492": [
"5288"
],
"CVE-2008-1551": [
"5290"
],
"CVE-2008-1591": [
"5292"
],
"CVE-2008-1509": [
"5293"
],
"CVE-2008-1505": [
"5294"
],
"CVE-2008-1680": [
"5295"
],
"CVE-2008-1539": [
"5295"
],
"CVE-2008-1493": [
"5296"
],
"CVE-2008-1535": [
"5297"
],
"CVE-2008-6538": [
"5298"
],
"CVE-2008-1512": [
"5301"
],
"CVE-2008-1537": [
"5302"
],
"CVE-2008-1534": [
"5303"
],
"CVE-2008-1541": [
"5304"
],
"CVE-2008-6539": [
"5305"
],
"CVE-2008-1702": [
"5308"
],
"CVE-2008-1557": [
"5309"
],
"CVE-2008-1556": [
"5309"
],
"CVE-2008-1555": [
"5309"
],
"CVE-2008-1559": [
"5310",
"5512"
],
"CVE-2008-1554": [
"5311"
],
"CVE-2008-1553": [
"5312"
],
"CVE-2008-6489": [
"5318"
],
"CVE-2008-1715": [
"5319"
],
"CVE-2008-1623": [
"5322"
],
"CVE-2008-1712": [
"5323"
],
"CVE-2008-1624": [
"5325"
],
"CVE-2008-1646": [
"5326"
],
"CVE-2008-1645": [
"5328"
],
"CVE-2008-1640": [
"5329"
],
"CVE-2008-1639": [
"5331"
],
"CVE-2008-1651": [
"5333"
],
"CVE-2008-1650": [
"5333"
],
"CVE-2008-1649": [
"5333"
],
"CVE-2008-1714": [
"5334"
],
"CVE-2008-4617": [
"5337"
],
"CVE-2008-1682": [
"5345"
],
"CVE-2008-1696": [
"5347"
],
"CVE-2008-1776": [
"5348"
],
"CVE-2008-6197": [
"5350"
],
"CVE-2008-1759": [
"5352"
],
"CVE-2008-1758": [
"5353"
],
"CVE-2008-1874": [
"5358"
],
"CVE-2008-6209": [
"5359"
],
"CVE-2008-1799": [
"5360"
],
"CVE-2008-1872": [
"5362"
],
"CVE-2008-1875": [
"5364"
],
"CVE-2008-1711": [
"5364"
],
"CVE-2008-1760": [
"5365"
],
"CVE-2008-1870": [
"5367"
],
"CVE-2008-1763": [
"5368"
],
"CVE-2008-1798": [
"5369"
],
"CVE-2008-6473": [
"5370"
],
"CVE-2008-1788": [
"5371"
],
"CVE-2008-6202": [
"5373"
],
"CVE-2008-1876": [
"5375"
],
"CVE-2008-1871": [
"5377"
],
"CVE-2008-6198": [
"5379"
],
"CVE-2008-1868": [
"5380"
],
"CVE-2008-1866": [
"5380"
],
"CVE-2008-1867": [
"5382"
],
"CVE-2008-1869": [
"5383"
],
"CVE-2008-1785": [
"5384"
],
"CVE-2008-1789": [
"5385"
],
"CVE-2008-1783": [
"5387"
],
"CVE-2008-1784": [
"5388"
],
"CVE-2008-1863": [
"5389"
],
"CVE-2008-1864": [
"5390"
],
"CVE-2008-6475": [
"5391"
],
"CVE-2008-1856": [
"5392"
],
"CVE-2008-1773": [
"5393"
],
"CVE-2008-1857": [
"5394"
],
"CVE-2008-1782": [
"5399"
],
"CVE-2008-1858": [
"5400",
"12560"
],
"CVE-2008-1791": [
"5401"
],
"CVE-2008-1859": [
"5402"
],
"CVE-2008-1790": [
"5402"
],
"CVE-2008-1772": [
"5402"
],
"CVE-2008-1862": [
"5405"
],
"CVE-2008-1861": [
"5405"
],
"CVE-2008-1774": [
"5406"
],
"CVE-2008-6490": [
"5407"
],
"CVE-2008-1860": [
"5408"
],
"CVE-2008-6204": [
"5409"
],
"CVE-2008-1732": [
"5410"
],
"CVE-2008-4778": [
"5414",
"5447"
],
"CVE-2008-6210": [
"5415",
"10751"
],
"CVE-2008-1727": [
"5418"
],
"CVE-2008-1730": [
"5419"
],
"CVE-2008-1755": [
"5420"
],
"CVE-2008-1726": [
"5421"
],
"CVE-2008-1750": [
"5422"
],
"CVE-2008-1751": [
"5423"
],
"CVE-2008-6537": [
"5425"
],
"CVE-2008-4912": [
"5426"
],
"CVE-2008-1909": [
"5428",
"12561"
],
"CVE-2008-1903": [
"5429"
],
"CVE-2008-1849": [
"5431"
],
"CVE-2008-1848": [
"5431"
],
"CVE-2008-1847": [
"5432"
],
"CVE-2008-1904": [
"5433"
],
"CVE-2008-1911": [
"5434"
],
"CVE-2008-4764": [
"5435"
],
"CVE-2008-4765": [
"5436",
"31640"
],
"CVE-2008-1908": [
"5437"
],
"CVE-2008-1907": [
"5437"
],
"CVE-2008-1906": [
"5437"
],
"CVE-2008-6477": [
"5440"
],
"CVE-2008-1838": [
"5444"
],
"CVE-2008-4703": [
"5446"
],
"CVE-2008-2036": [
"5448"
],
"CVE-2008-6201": [
"5449"
],
"CVE-2008-1936": [
"5450"
],
"CVE-2008-6593": [
"5452"
],
"CVE-2008-6592": [
"5452"
],
"CVE-2008-6590": [
"5452"
],
"CVE-2008-1913": [
"5454"
],
"CVE-2008-1896": [
"5456"
],
"CVE-2008-1895": [
"5456"
],
"CVE-2008-1889": [
"5457"
],
"CVE-2008-1989": [
"5459"
],
"CVE-2008-1963": [
"5463"
],
"CVE-2008-1921": [
"5464"
],
"CVE-2008-6199": [
"5465"
],
"CVE-2008-6524": [
"5466"
],
"CVE-2008-6523": [
"5466"
],
"CVE-2008-1971": [
"5467"
],
"CVE-2008-6081": [
"5468"
],
"CVE-2008-1961": [
"5469"
],
"CVE-2008-1918": [
"5470",
"7576"
],
"CVE-2008-1919": [
"5471"
],
"CVE-2008-1962": [
"5474"
],
"CVE-2008-1939": [
"5475"
],
"CVE-2008-2091": [
"5477"
],
"CVE-2008-1993": [
"5478"
],
"CVE-2008-1992": [
"5478"
],
"CVE-2008-1991": [
"5478"
],
"CVE-2008-1990": [
"5478"
],
"CVE-2008-1915": [
"5480"
],
"CVE-2008-1934": [
"5481"
],
"CVE-2008-1613": [
"5482"
],
"CVE-2008-1958": [
"5483"
],
"CVE-2008-1957": [
"5483"
],
"CVE-2008-2095": [
"5484"
],
"CVE-2008-1954": [
"5485"
],
"CVE-2008-1982": [
"5486"
],
"CVE-2008-1975": [
"5487"
],
"CVE-2008-1935": [
"5488"
],
"CVE-2008-2093": [
"5491"
],
"CVE-2008-4715": [
"5493"
],
"CVE-2008-2029": [
"5494"
],
"CVE-2008-2028": [
"5494"
],
"CVE-2008-2024": [
"5494"
],
"CVE-2008-2012": [
"5495"
],
"CVE-2008-2082": [
"5499",
"31709"
],
"CVE-2008-2081": [
"5499"
],
"CVE-2008-2013": [
"5500"
],
"CVE-2008-2048": [
"5503"
],
"CVE-2008-2047": [
"5503"
],
"CVE-2008-2088": [
"5504"
],
"CVE-2008-2084": [
"5505"
],
"CVE-2008-2018": [
"5506"
],
"CVE-2008-2023": [
"5507"
],
"CVE-2008-2022": [
"5507"
],
"CVE-2008-2065": [
"5508"
],
"CVE-2008-6642": [
"5509"
],
"CVE-2008-2217": [
"5510"
],
"CVE-2008-2083": [
"5516"
],
"CVE-2008-2087": [
"5517"
],
"CVE-2008-2063": [
"5520"
],
"CVE-2008-2045": [
"5521"
],
"CVE-2008-4913": [
"5522"
],
"CVE-2008-2216": [
"5523"
],
"CVE-2008-2215": [
"5523"
],
"CVE-2008-6651": [
"5524"
],
"CVE-2008-2074": [
"5525"
],
"CVE-2008-2220": [
"5526"
],
"CVE-2008-6653": [
"5527"
],
"CVE-2008-2076": [
"5528"
],
"CVE-2008-2073": [
"5529"
],
"CVE-2008-2072": [
"5529"
],
"CVE-2008-6656": [
"5531"
],
"CVE-2008-2192": [
"5532"
],
"CVE-2008-2175": [
"5533"
],
"CVE-2008-2185": [
"5535"
],
"CVE-2008-2184": [
"5535"
],
"CVE-2008-2183": [
"5535"
],
"CVE-2008-2177": [
"5537"
],
"CVE-2008-2181": [
"5538"
],
"CVE-2008-2180": [
"5538"
],
"CVE-2008-2193": [
"5539"
],
"CVE-2005-4195": [
"5540",
"26783"
],
"CVE-2008-2191": [
"5541"
],
"CVE-2008-2190": [
"5542"
],
"CVE-2008-2189": [
"5543"
],
"CVE-2008-2198": [
"5544"
],
"CVE-2008-2199": [
"5545"
],
"CVE-2008-2096": [
"5546"
],
"CVE-2008-6582": [
"5548",
"7586"
],
"CVE-2008-2197": [
"5548",
"7586"
],
"CVE-2008-2116": [
"5549"
],
"CVE-2008-2115": [
"5549"
],
"CVE-2008-2195": [
"5550"
],
"CVE-2008-2194": [
"5550"
],
"CVE-2008-2114": [
"5551"
],
"CVE-2008-2113": [
"5552"
],
"CVE-2008-2124": [
"5553"
],
"CVE-2008-2129": [
"5554"
],
"CVE-2008-2225": [
"5555"
],
"CVE-2008-2132": [
"5556"
],
"CVE-2008-6652": [
"5557"
],
"CVE-2008-2128": [
"5558"
],
"CVE-2008-2127": [
"5558"
],
"CVE-2008-2135": [
"5559"
],
"CVE-2008-2125": [
"5560",
"7152"
],
"CVE-2008-6641": [
"5564"
],
"CVE-2008-2223": [
"5565"
],
"CVE-2008-2224": [
"5566"
],
"CVE-2008-2228": [
"5567"
],
"CVE-2008-6650": [
"5568"
],
"CVE-2008-5209": [
"5575"
],
"CVE-2008-2411": [
"5576"
],
"CVE-2008-2537": [
"5577"
],
"CVE-2008-2535": [
"5578"
],
"CVE-2008-2534": [
"5578"
],
"CVE-2008-2533": [
"5578"
],
"CVE-2008-5217": [
"5579"
],
"CVE-2008-6649": [
"5580",
"5582"
],
"CVE-2008-6648": [
"5580",
"5582"
],
"CVE-2008-6647": [
"5580",
"5582"
],
"CVE-2008-2529": [
"5581"
],
"CVE-2008-5208": [
"5583"
],
"CVE-2008-5210": [
"5586"
],
"CVE-2008-2454": [
"5587"
],
"CVE-2008-2530": [
"5588"
],
"CVE-2008-5213": [
"5590"
],
"CVE-2008-5212": [
"5591"
],
"CVE-2008-5216": [
"5594"
],
"CVE-2008-5215": [
"5595"
],
"CVE-2008-5214": [
"5595"
],
"CVE-2008-2520": [
"5596"
],
"CVE-2008-2522": [
"5597"
],
"CVE-2008-2521": [
"5598"
],
"CVE-2008-2453": [
"5599"
],
"CVE-2008-2267": [
"5600"
],
"CVE-2008-2536": [
"5601"
],
"CVE-2008-2532": [
"5602"
],
"CVE-2008-2222": [
"5603"
],
"CVE-2008-2455": [
"5604"
],
"CVE-2008-2447": [
"5605"
],
"CVE-2008-2446": [
"5606"
],
"CVE-2008-2445": [
"5606"
],
"CVE-2008-2444": [
"5607"
],
"CVE-2008-2448": [
"5608"
],
"CVE-2008-2265": [
"5609"
],
"CVE-2008-2443": [
"5610"
],
"CVE-2008-2263": [
"5611"
],
"CVE-2008-2279": [
"5613"
],
"CVE-2008-2278": [
"5613"
],
"CVE-2008-2277": [
"5614"
],
"CVE-2008-2269": [
"5615"
],
"CVE-2008-2338": [
"5616"
],
"CVE-2008-2282": [
"5617"
],
"CVE-2007-5156": [
"5618",
"5688"
],
"CVE-2008-2296": [
"5620"
],
"CVE-2008-2295": [
"5620"
],
"CVE-2008-2270": [
"5621"
],
"CVE-2008-2301": [
"5623"
],
"CVE-2008-2343": [
"5624"
],
"CVE-2008-2342": [
"5624"
],
"CVE-2008-2341": [
"5624"
],
"CVE-2008-2340": [
"5624"
],
"CVE-2008-2336": [
"5626"
],
"CVE-2008-2294": [
"5627"
],
"CVE-2008-2297": [
"5628"
],
"CVE-2008-2298": [
"5629"
],
"CVE-2008-2293": [
"5630"
],
"CVE-2008-2337": [
"5631"
],
"CVE-2008-2349": [
"5634"
],
"CVE-2008-2356": [
"5635"
],
"CVE-2008-2355": [
"5637"
],
"CVE-2008-2417": [
"5638"
],
"CVE-2008-2425": [
"5639"
],
"CVE-2008-2416": [
"5639"
],
"CVE-2008-2352": [
"5640"
],
"CVE-2008-2351": [
"5641"
],
"CVE-2008-2394": [
"5642"
],
"CVE-2008-2346": [
"5645"
],
"CVE-2008-2353": [
"5647"
],
"CVE-2008-2348": [
"5648"
],
"CVE-2008-2347": [
"5650"
],
"CVE-2008-2396": [
"5651"
],
"CVE-2008-2395": [
"5652"
],
"CVE-2008-6632": [
"5653"
],
"CVE-2008-2393": [
"5654"
],
"CVE-2008-2459": [
"5655"
],
"CVE-2008-3332": [
"5657"
],
"CVE-2008-3331": [
"5657"
],
"CVE-2008-2276": [
"5657"
],
"CVE-2008-2456": [
"5658"
],
"CVE-2008-2477": [
"5659"
],
"CVE-2008-2457": [
"5660"
],
"CVE-2008-2461": [
"5661"
],
"CVE-2008-1331": [
"5662"
],
"CVE-2008-2506": [
"5664"
],
"CVE-2008-2505": [
"5664"
],
"CVE-2008-2504": [
"5665"
],
"CVE-2008-6438": [
"5666",
"6158",
"6346",
"6856"
],
"CVE-2008-2496": [
"5668"
],
"CVE-2008-2482": [
"5669"
],
"CVE-2008-6633": [
"5670"
],
"CVE-2008-2481": [
"5671"
],
"CVE-2008-2480": [
"5672"
],
"CVE-2008-2484": [
"5673"
],
"CVE-2008-2483": [
"5673"
],
"CVE-2008-2488": [
"5674"
],
"CVE-2008-6634": [
"5675"
],
"CVE-2008-2487": [
"5676"
],
"CVE-2008-2778": [
"5677"
],
"CVE-2008-2774": [
"5678"
],
"CVE-2008-2782": [
"5680"
],
"CVE-2008-2501": [
"5683",
"10590"
],
"CVE-2008-2572": [
"5685"
],
"CVE-2008-5223": [
"5689"
],
"CVE-2008-6604": [
"5690"
],
"CVE-2008-5226": [
"5692"
],
"CVE-2008-6427": [
"5698",
"5928"
],
"CVE-2008-6422": [
"5699"
],
"CVE-2008-2650": [
"5700"
],
"CVE-2008-6421": [
"5701",
"5707"
],
"CVE-2008-6420": [
"5701",
"5711"
],
"CVE-2008-6419": [
"5701"
],
"CVE-2008-2556": [
"5703"
],
"CVE-2008-6423": [
"5704"
],
"CVE-2008-2554": [
"5705"
],
"CVE-2008-2555": [
"5706"
],
"CVE-2008-6429": [
"5708"
],
"CVE-2008-2643": [
"5710"
],
"CVE-2008-6425": [
"5713"
],
"CVE-2008-6430": [
"5714"
],
"CVE-2008-2649": [
"5715"
],
"CVE-2008-2648": [
"5716"
],
"CVE-2008-2647": [
"5716"
],
"CVE-2008-2646": [
"5716"
],
"CVE-2008-2634": [
"5717"
],
"CVE-2008-2651": [
"5719"
],
"CVE-2008-2632": [
"5721"
],
"CVE-2008-2645": [
"5722"
],
"CVE-2008-2628": [
"5723"
],
"CVE-2008-2629": [
"5724"
],
"CVE-2008-2652": [
"5725"
],
"CVE-2008-2644": [
"5725"
],
"CVE-2008-2574": [
"5728"
],
"CVE-2008-2633": [
"5729",
"12400"
],
"CVE-2008-2627": [
"5730"
],
"CVE-2008-2626": [
"5731"
],
"CVE-2008-6678": [
"5733"
],
"CVE-2008-6677": [
"5733"
],
"CVE-2008-6676": [
"5733"
],
"CVE-2008-6675": [
"5733"
],
"CVE-2008-6674": [
"5733"
],
"CVE-2008-6673": [
"5733"
],
"CVE-2008-5051": [
"5734",
"7078"
],
"CVE-2008-2630": [
"5734",
"7078"
],
"CVE-2008-2638": [
"5736"
],
"CVE-2008-2564": [
"5737"
],
"CVE-2013-1748": [
"5739"
],
"CVE-2008-2566": [
"5739",
"18578"
],
"CVE-2008-2565": [
"5739",
"9023",
"18578"
],
"CVE-2008-2569": [
"5740"
],
"CVE-2008-2561": [
"5742"
],
"CVE-2008-2560": [
"5742"
],
"CVE-2008-2568": [
"5743",
"5833"
],
"CVE-2008-2562": [
"5744"
],
"CVE-2008-5269": [
"5745"
],
"CVE-2008-6068": [
"5748"
],
"CVE-2008-2701": [
"5752"
],
"CVE-2008-2691": [
"5753"
],
"CVE-2008-2695": [
"5754"
],
"CVE-2008-2694": [
"5754"
],
"CVE-2008-2692": [
"5755"
],
"CVE-2008-7178": [
"5756"
],
"CVE-2008-2690": [
"5757"
],
"CVE-2008-2689": [
"5757"
],
"CVE-2008-2699": [
"5758"
],
"CVE-2008-2697": [
"5759"
],
"CVE-2008-2700": [
"5760"
],
"CVE-2008-2676": [
"5761"
],
"CVE-2008-2687": [
"5762"
],
"CVE-2008-2678": [
"5764"
],
"CVE-2008-2677": [
"5764"
],
"CVE-2008-2688": [
"5765",
"15448"
],
"CVE-2008-2682": [
"5766"
],
"CVE-2008-2681": [
"5766"
],
"CVE-2008-2680": [
"5766"
],
"CVE-2008-2679": [
"5766"
],
"CVE-2008-2686": [
"5767"
],
"CVE-2008-2673": [
"5768"
],
"CVE-2008-7180": [
"5769"
],
"CVE-2008-2742": [
"5770"
],
"CVE-2008-2672": [
"5771"
],
"CVE-2008-2671": [
"5772"
],
"CVE-2008-2669": [
"5773"
],
"CVE-2008-2668": [
"5773"
],
"CVE-2008-2670": [
"5774"
],
"CVE-2008-5268": [
"5775"
],
"CVE-2008-5267": [
"5776"
],
"CVE-2008-5272": [
"5779"
],
"CVE-2008-5271": [
"5779"
],
"CVE-2008-6739": [
"5780"
],
"CVE-2008-5274": [
"5781"
],
"CVE-2008-5273": [
"5781"
],
"CVE-2008-5265": [
"5782"
],
"CVE-2008-5270": [
"5783"
],
"CVE-2008-2993": [
"5784"
],
"CVE-2008-2754": [
"5785"
],
"CVE-2008-2770": [
"5787"
],
"CVE-2008-2753": [
"5788"
],
"CVE-2008-2755": [
"5789"
],
"CVE-2009-1277": [
"5791",
"8350"
],
"CVE-2008-2997": [
"5791"
],
"CVE-2008-2996": [
"5791",
"8350"
],
"CVE-2008-7176": [
"5792",
"12061"
],
"CVE-2008-2909": [
"5794"
],
"CVE-2008-2746": [
"5796"
],
"CVE-2008-6700": [
"5797"
],
"CVE-2008-6328": [
"5797",
"7411"
],
"CVE-2008-6311": [
"5797",
"7411"
],
"CVE-2008-2907": [
"5798"
],
"CVE-2008-7181": [
"5800"
],
"CVE-2008-2818": [
"5801"
],
"CVE-2008-2906": [
"5802"
],
"CVE-2008-2858": [
"5802"
],
"CVE-2008-2916": [
"5804"
],
"CVE-2008-2917": [
"5805"
],
"CVE-2008-2919": [
"5806"
],
"CVE-2008-2914": [
"5807"
],
"CVE-2008-2905": [
"5808",
"9906",
"16912"
],
"CVE-2008-2915": [
"5809"
],
"CVE-2008-2912": [
"5810"
],
"CVE-2008-2911": [
"5810"
],
"CVE-2008-2901": [
"5811"
],
"CVE-2008-2904": [
"5812"
],
"CVE-2008-2814": [
"5813"
],
"CVE-2008-2813": [
"5813"
],
"CVE-2008-2918": [
"5815"
],
"CVE-2008-6714": [
"5818"
],
"CVE-2008-2921": [
"5819"
],
"CVE-2008-2920": [
"5819"
],
"CVE-2008-2823": [
"5820"
],
"CVE-2008-2902": [
"5821"
],
"CVE-2008-2857": [
"5821"
],
"CVE-2008-2913": [
"5822"
],
"CVE-2008-2903": [
"5823"
],
"CVE-2008-6665": [
"5824"
],
"CVE-2008-6741": [
"5826"
],
"CVE-2008-2816": [
"5828"
],
"CVE-2008-6664": [
"5829"
],
"CVE-2008-2817": [
"5830"
],
"CVE-2008-2820": [
"5831"
],
"CVE-2008-2815": [
"5832"
],
"CVE-2008-2791": [
"5834"
],
"CVE-2008-2789": [
"5836"
],
"CVE-2008-2796": [
"5838"
],
"CVE-2008-2793": [
"5839"
],
"CVE-2008-2790": [
"5840"
],
"CVE-2008-6735": [
"5841"
],
"CVE-2008-2865": [
"5842"
],
"CVE-2008-6738": [
"5845"
],
"CVE-2008-2792": [
"5846"
],
"CVE-2008-2836": [
"5847"
],
"CVE-2008-2839": [
"5848"
],
"CVE-2008-2838": [
"5848"
],
"CVE-2008-2843": [
"5849"
],
"CVE-2008-2842": [
"5849"
],
"CVE-2008-2832": [
"5850"
],
"CVE-2008-2847": [
"5853"
],
"CVE-2008-2845": [
"5854"
],
"CVE-2008-2853": [
"5855"
],
"CVE-2008-6669": [
"5856"
],
"CVE-2008-6668": [
"5856"
],
"CVE-2008-2844": [
"5857"
],
"CVE-2008-2846": [
"5858"
],
"CVE-2008-2864": [
"5859"
],
"CVE-2008-2863": [
"5859"
],
"CVE-2008-2862": [
"5859"
],
"CVE-2008-2861": [
"5859"
],
"CVE-2008-2856": [
"5860"
],
"CVE-2008-2855": [
"5860"
],
"CVE-2008-2970": [
"5861"
],
"CVE-2008-2969": [
"5861"
],
"CVE-2008-2968": [
"5861"
],
"CVE-2008-2967": [
"5861"
],
"CVE-2008-2878": [
"5861"
],
"CVE-2008-2837": [
"5863"
],
"CVE-2008-2854": [
"5864"
],
"CVE-2008-2866": [
"5865"
],
"CVE-2008-2860": [
"5867"
],
"CVE-2008-2896": [
"5871"
],
"CVE-2008-2887": [
"5872"
],
"CVE-2008-7172": [
"5873"
],
"CVE-2008-7171": [
"5873"
],
"CVE-2008-2971": [
"5875"
],
"CVE-2008-2886": [
"5876"
],
"CVE-2008-2883": [
"5876"
],
"CVE-2008-2966": [
"5877"
],
"CVE-2008-2965": [
"5877"
],
"CVE-2008-2891": [
"5878"
],
"CVE-2008-6663": [
"5879"
],
"CVE-2008-2046": [
"5880"
],
"CVE-2008-2972": [
"5883"
],
"CVE-2008-2895": [
"5884"
],
"CVE-2008-2834": [
"5885"
],
"CVE-2008-2833": [
"5887"
],
"CVE-2008-5125": [
"5888"
],
"CVE-2008-5123": [
"5888"
],
"CVE-2008-2890": [
"5889"
],
"CVE-2008-2893": [
"5890"
],
"CVE-2008-2900": [
"5892"
],
"CVE-2008-2892": [
"5893"
],
"CVE-2008-2882": [
"5895"
],
"CVE-2008-2873": [
"5895"
],
"CVE-2008-2872": [
"5895"
],
"CVE-2008-2961": [
"5896"
],
"CVE-2008-2986": [
"5897"
],
"CVE-2008-2835": [
"5898"
],
"CVE-2008-2897": [
"5899"
],
"CVE-2008-2884": [
"5900"
],
"CVE-2008-2888": [
"5901"
],
"CVE-2008-6740": [
"5902"
],
"CVE-2008-2982": [
"5903"
],
"CVE-2008-2981": [
"5903"
],
"CVE-2008-2980": [
"5903"
],
"CVE-2008-2898": [
"5904"
],
"CVE-2008-2985": [
"5905"
],
"CVE-2008-2984": [
"5905"
],
"CVE-2008-2885": [
"5906"
],
"CVE-2008-2989": [
"5908"
],
"CVE-2008-6745": [
"5909"
],
"CVE-2008-2964": [
"5911"
],
"CVE-2008-6193": [
"5913"
],
"CVE-2008-2963": [
"5913"
],
"CVE-2008-2962": [
"5913"
],
"CVE-2008-2983": [
"5914"
],
"CVE-2008-2990": [
"5915"
],
"CVE-2008-6636": [
"5916"
],
"CVE-2008-6635": [
"5916"
],
"CVE-2008-2976": [
"5917"
],
"CVE-2008-2975": [
"5917"
],
"CVE-2008-2974": [
"5919"
],
"CVE-2008-2973": [
"5919"
],
"CVE-2008-2979": [
"5920"
],
"CVE-2008-2978": [
"5920"
],
"CVE-2008-2977": [
"5920"
],
"CVE-2008-2877": [
"5921"
],
"CVE-2008-3185": [
"5924"
],
"CVE-2008-2881": [
"5924"
],
"CVE-2008-2870": [
"5925"
],
"CVE-2008-2868": [
"5927"
],
"CVE-2008-2867": [
"5929"
],
"CVE-2008-2869": [
"5930"
],
"CVE-2008-2875": [
"5932"
],
"CVE-2008-2876": [
"5933"
],
"CVE-2008-2874": [
"5934"
],
"CVE-2008-7167": [
"5936"
],
"CVE-2008-3497": [
"5937"
],
"CVE-2008-3118": [
"5938"
],
"CVE-2008-3117": [
"5938"
],
"CVE-2008-3498": [
"5939"
],
"CVE-2008-6734": [
"5940",
"5956"
],
"CVE-2008-3506": [
"5941"
],
"CVE-2008-3505": [
"5941"
],
"CVE-2008-5196": [
"5942"
],
"CVE-2008-5166": [
"5946"
],
"CVE-2008-5168": [
"5947"
],
"CVE-2008-5174": [
"5948"
],
"CVE-2008-5169": [
"5949"
],
"CVE-2008-5170": [
"5950"
],
"CVE-2008-5171": [
"5952"
],
"CVE-2008-6667": [
"5954"
],
"CVE-2008-5167": [
"5955"
],
"CVE-2008-5202": [
"5957"
],
"CVE-2008-5201": [
"5957"
],
"CVE-2008-5193": [
"5958"
],
"CVE-2008-5192": [
"5958"
],
"CVE-2008-7179": [
"5959"
],
"CVE-2008-5197": [
"5961"
],
"CVE-2008-5204": [
"5962"
],
"CVE-2008-5203": [
"5962"
],
"CVE-2008-7169": [
"5963"
],
"CVE-2008-5194": [
"5964"
],
"CVE-2008-3132": [
"5965"
],
"CVE-2008-5200": [
"5966"
],
"CVE-2008-5195": [
"5967"
],
"CVE-2008-5198": [
"5969"
],
"CVE-2008-5190": [
"5970"
],
"CVE-2008-3133": [
"5971"
],
"CVE-2008-3128": [
"5973"
],
"CVE-2008-3129": [
"5974"
],
"CVE-2008-3080": [
"5975"
],
"CVE-2007-1899": [
"5975"
],
"CVE-2008-3136": [
"5976"
],
"CVE-2008-3131": [
"5977"
],
"CVE-2008-3127": [
"5981"
],
"CVE-2008-3031": [
"5982"
],
"CVE-2008-3026": [
"5984"
],
"CVE-2008-3027": [
"5985"
],
"CVE-2008-3030": [
"5987"
],
"CVE-2008-3025": [
"5988"
],
"CVE-2008-6481": [
"5989"
],
"CVE-2008-3035": [
"5991"
],
"CVE-2008-3036": [
"5992"
],
"CVE-2008-3083": [
"5993"
],
"CVE-2008-3022": [
"5996"
],
"CVE-2008-3154": [
"5997"
],
"CVE-2008-6813": [
"5998"
],
"CVE-2008-6812": [
"5999"
],
"CVE-2008-6841": [
"6003"
],
"CVE-2008-3088": [
"6007"
],
"CVE-2008-3087": [
"6007"
],
"CVE-2008-3093": [
"6008"
],
"CVE-2008-3165": [
"6009"
],
"CVE-2008-3089": [
"6010"
],
"CVE-2008-3181": [
"6011"
],
"CVE-2008-3180": [
"6011"
],
"CVE-2008-3152": [
"6014",
"6019"
],
"CVE-2008-3178": [
"6015"
],
"CVE-2008-6834": [
"6016"
],
"CVE-2008-3153": [
"6017"
],
"CVE-2008-3150": [
"6018"
],
"CVE-2008-3124": [
"6021"
],
"CVE-2008-3123": [
"6022"
],
"CVE-2008-6911": [
"6023"
],
"CVE-2008-3167": [
"6024"
],
"CVE-2008-3166": [
"6024",
"6028"
],
"CVE-2008-6923": [
"6025"
],
"CVE-2008-3125": [
"6027"
],
"CVE-2008-3203": [
"6033"
],
"CVE-2008-3119": [
"6034"
],
"CVE-2008-3189": [
"6035"
],
"CVE-2008-3183": [
"6036"
],
"CVE-2008-3179": [
"6037"
],
"CVE-2006-1278": [
"6040"
],
"CVE-2008-5323": [
"6042"
],
"CVE-2008-5322": [
"6042"
],
"CVE-2008-3205": [
"6042"
],
"CVE-2008-4055": [
"6044"
],
"CVE-2008-3204": [
"6044"
],
"CVE-2008-7086": [
"6050"
],
"CVE-2008-3213": [
"6056"
],
"CVE-2008-7301": [
"6057"
],
"CVE-2008-3193": [
"6057"
],
"CVE-2008-3192": [
"6057"
],
"CVE-2008-3200": [
"6058"
],
"CVE-2008-6833": [
"6060"
],
"CVE-2008-3320": [
"6061"
],
"CVE-2008-3319": [
"6062"
],
"CVE-2008-3322": [
"6063"
],
"CVE-2008-3318": [
"6064"
],
"CVE-2008-3321": [
"6065"
],
"CVE-2008-3317": [
"6066"
],
"CVE-2008-3241": [
"6067"
],
"CVE-2008-3191": [
"6068"
],
"CVE-2008-3238": [
"6069"
],
"CVE-2008-3237": [
"6069"
],
"CVE-2008-3212": [
"6070"
],
"CVE-2008-3211": [
"6070"
],
"CVE-2008-3190": [
"6071"
],
"CVE-2008-3304": [
"6073"
],
"CVE-2008-3303": [
"6073"
],
"CVE-2008-3302": [
"6073"
],
"CVE-2008-3301": [
"6073"
],
"CVE-2008-3194": [
"6074"
],
"CVE-2008-6249": [
"6075"
],
"CVE-2008-6248": [
"6075"
],
"CVE-2008-3207": [
"6078"
],
"CVE-2008-6250": [
"6079"
],
"CVE-2008-3385": [
"6080"
],
"CVE-2008-6300": [
"6081"
],
"CVE-2008-7088": [
"6082"
],
"CVE-2008-0251": [
"6082"
],
"CVE-2008-7085": [
"6084"
],
"CVE-2008-3239": [
"6085"
],
"CVE-2008-3265": [
"6086"
],
"CVE-2008-3240": [
"6087"
],
"CVE-2008-3251": [
"6088"
],
"CVE-2008-3245": [
"6091"
],
"CVE-2008-3386": [
"6092"
],
"CVE-2008-3254": [
"6096"
],
"CVE-2008-3250": [
"6097",
"6113"
],
"CVE-2008-3291": [
"6098"
],
"CVE-2008-3256": [
"6099"
],
"CVE-2008-3387": [
"6102"
],
"CVE-2008-3309": [
"6104"
],
"CVE-2008-3266": [
"6105"
],
"CVE-2008-3384": [
"6107"
],
"CVE-2008-3382": [
"6108"
],
"CVE-2008-3403": [
"6109"
],
"CVE-2008-3267": [
"6110"
],
"CVE-2008-3383": [
"6111"
],
"CVE-2008-3293": [
"6112"
],
"CVE-2008-3346": [
"6114"
],
"CVE-2008-3292": [
"6115"
],
"CVE-2008-3308": [
"6117"
],
"CVE-2008-3307": [
"6117"
],
"CVE-2008-3306": [
"6117"
],
"CVE-2008-3305": [
"6117"
],
"CVE-2008-3310": [
"6119",
"32111"
],
"CVE-2008-3351": [
"6125",
"32114"
],
"CVE-2008-6288": [
"6126"
],
"CVE-2008-3362": [
"6127"
],
"CVE-2008-3352": [
"6128"
],
"CVE-2008-3400": [
"6131"
],
"CVE-2008-3399": [
"6131"
],
"CVE-2008-3398": [
"6131"
],
"CVE-2008-3355": [
"6132"
],
"CVE-2008-3378": [
"6133"
],
"CVE-2008-3377": [
"6134"
],
"CVE-2008-3417": [
"6135"
],
"CVE-2008-3416": [
"6137"
],
"CVE-2008-3420": [
"6138"
],
"CVE-2008-3412": [
"6139"
],
"CVE-2008-3407": [
"6140"
],
"CVE-2008-3406": [
"6140"
],
"CVE-2008-3418": [
"6141"
],
"CVE-2008-3415": [
"6142"
],
"CVE-2008-3372": [
"6143"
],
"CVE-2008-3413": [
"6144"
],
"CVE-2008-3414": [
"6145"
],
"CVE-2008-3366": [
"6146"
],
"CVE-2008-3419": [
"6147"
],
"CVE-2008-3371": [
"6148"
],
"CVE-2008-3363": [
"6149"
],
"CVE-2008-3365": [
"6150"
],
"CVE-2008-3368": [
"6153"
],
"CVE-2008-3369": [
"6154"
],
"CVE-2008-3390": [
"6156"
],
"CVE-2008-3374": [
"6159"
],
"CVE-2008-3455": [
"6160"
],
"CVE-2008-3401": [
"6161"
],
"CVE-2008-3402": [
"6162"
],
"CVE-2008-3454": [
"6163"
],
"CVE-2008-3405": [
"6164"
],
"CVE-2008-3669": [
"6165"
],
"CVE-2008-3670": [
"6167"
],
"CVE-2008-3649": [
"6167"
],
"CVE-2008-3673": [
"6169"
],
"CVE-2008-3672": [
"6169"
],
"CVE-2008-3674": [
"6170"
],
"CVE-2008-3452": [
"6171"
],
"CVE-2008-7091": [
"6172",
"6173"
],
"CVE-2008-7090": [
"6173"
],
"CVE-2008-7089": [
"6173"
],
"CVE-2008-6968": [
"6173"
],
"CVE-2008-3489": [
"6176"
],
"CVE-2008-3592": [
"6177"
],
"CVE-2008-3591": [
"6177"
],
"CVE-2008-3486": [
"6178"
],
"CVE-2008-3481": [
"6178"
],
"CVE-2008-3446": [
"6179"
],
"CVE-2008-3445": [
"6180"
],
"CVE-2008-3487": [
"6182"
],
"CVE-2008-3570": [
"6183"
],
"CVE-2008-3490": [
"6184"
],
"CVE-2008-3491": [
"6185",
"6186"
],
"CVE-2008-3484": [
"6187"
],
"CVE-2008-3585": [
"6189"
],
"CVE-2008-3588": [
"6190"
],
"CVE-2008-0856": [
"6191"
],
"CVE-2006-5016": [
"6191"
],
"CVE-2008-3581": [
"6192"
],
"CVE-2008-3580": [
"6192"
],
"CVE-2008-3594": [
"6193"
],
"CVE-2008-3589": [
"6194"
],
"CVE-2008-3586": [
"6199"
],
"CVE-2008-3593": [
"6200"
],
"CVE-2008-3564": [
"6203"
],
"CVE-2008-3563": [
"6204"
],
"CVE-2008-3508": [
"6206"
],
"CVE-2008-3507": [
"6207"
],
"CVE-2008-3555": [
"6208"
],
"CVE-2008-3509": [
"6209",
"6210"
],
"CVE-2008-3557": [
"6213"
],
"CVE-2008-3554": [
"6214"
],
"CVE-2008-4528": [
"6215",
"6231",
"6667",
"8105"
],
"CVE-2008-4428": [
"6215",
"6231",
"8105"
],
"CVE-2008-4427": [
"6215",
"6231",
"8105"
],
"CVE-2008-4426": [
"6215",
"6231",
"8105"
],
"CVE-2008-4425": [
"6215",
"6231",
"8105"
],
"CVE-2008-3603": [
"6221"
],
"CVE-2008-3601": [
"6223"
],
"CVE-2008-3595": [
"6224"
],
"CVE-2008-3602": [
"6225"
],
"CVE-2008-3598": [
"6226"
],
"CVE-2008-3599": [
"6228"
],
"CVE-2008-3604": [
"6230"
],
"CVE-2008-4423": [
"6232",
"27771"
],
"CVE-2008-3918": [
"6232",
"27771"
],
"CVE-2008-4436": [
"6233"
],
"CVE-2008-3681": [
"6234"
],
"CVE-2008-3675": [
"6235"
],
"CVE-2008-3708": [
"6247"
],
"CVE-2008-3706": [
"6249"
],
"CVE-2008-3721": [
"6250"
],
"CVE-2008-3720": [
"6250"
],
"CVE-2008-6023": [
"6254"
],
"CVE-2008-6022": [
"6254"
],
"CVE-2008-3711": [
"6255"
],
"CVE-2008-3713": [
"6258"
],
"CVE-2008-6518": [
"6259"
],
"CVE-2008-3718": [
"6260"
],
"CVE-2008-3764": [
"6261"
],
"CVE-2008-3763": [
"6261"
],
"CVE-2008-3762": [
"6261"
],
"CVE-2008-4112": [
"6269",
"6509"
],
"CVE-2008-3195": [
"6269",
"6509"
],
"CVE-2008-3719": [
"6270"
],
"CVE-2008-3725": [
"6271"
],
"CVE-2008-3768": [
"6273"
],
"CVE-2008-3749": [
"6276"
],
"CVE-2008-3748": [
"6277",
"10597"
],
"CVE-2008-3772": [
"6279"
],
"CVE-2008-3771": [
"6279"
],
"CVE-2008-3767": [
"6280"
],
"CVE-2008-4154": [
"6281"
],
"CVE-2008-4156": [
"6284"
],
"CVE-2008-3788": [
"6285"
],
"CVE-2008-7058": [
"6286"
],
"CVE-2008-7057": [
"6286"
],
"CVE-2008-7056": [
"6286"
],
"CVE-2008-4740": [
"6287"
],
"CVE-2008-4155": [
"6288"
],
"CVE-2008-7059": [
"6292",
"32293"
],
"CVE-2008-3780": [
"6294"
],
"CVE-2008-3779": [
"6294"
],
"CVE-2008-3785": [
"6295"
],
"CVE-2008-3784": [
"6296"
],
"CVE-2008-3783": [
"6297"
],
"CVE-2008-3787": [
"6298"
],
"CVE-2008-3851": [
"6300"
],
"CVE-2008-7055": [
"6301"
],
"CVE-2008-7054": [
"6301"
],
"CVE-2008-3845": [
"6307"
],
"CVE-2008-3848": [
"6309"
],
"CVE-2008-4054": [
"6310"
],
"CVE-2008-7099": [
"6312"
],
"CVE-2008-7098": [
"6312"
],
"CVE-2008-7097": [
"6312"
],
"CVE-2008-3926": [
"6313"
],
"CVE-2008-3925": [
"6313"
],
"CVE-2008-3924": [
"6313"
],
"CVE-2008-3923": [
"6313"
],
"CVE-2008-3859": [
"6314"
],
"CVE-2008-7114": [
"6315"
],
"CVE-2008-3861": [
"6320"
],
"CVE-2008-4093": [
"6321"
],
"CVE-2008-4083": [
"6332"
],
"CVE-2008-4082": [
"6332"
],
"CVE-2008-4091": [
"6335"
],
"CVE-2008-3945": [
"6336"
],
"CVE-2008-4089": [
"6338"
],
"CVE-2008-4088": [
"6338"
],
"CVE-2008-7118": [
"6339"
],
"CVE-2008-7117": [
"6339"
],
"CVE-2008-7116": [
"6339"
],
"CVE-2008-7119": [
"6341"
],
"CVE-2008-4084": [
"6342"
],
"CVE-2008-6991": [
"6343"
],
"CVE-2008-4092": [
"6347"
],
"CVE-2008-4090": [
"6348"
],
"CVE-2008-4086": [
"6349"
],
"CVE-2008-4043": [
"6350"
],
"CVE-2008-4044": [
"6351"
],
"CVE-2008-6394": [
"6352"
],
"CVE-2008-4039": [
"6354"
],
"CVE-2008-6978": [
"6357",
"6420"
],
"CVE-2008-6977": [
"6357",
"6420"
],
"CVE-2004-1553": [
"6357",
"6420"
],
"CVE-2008-3943": [
"6361"
],
"CVE-2008-3944": [
"6362"
],
"CVE-2008-4144": [
"6364"
],
"CVE-2008-3922": [
"6368",
"17324"
],
"CVE-2008-6983": [
"6369"
],
"CVE-2008-6982": [
"6369"
],
"CVE-2008-4186": [
"6370"
],
"CVE-2008-4185": [
"6370"
],
"CVE-2008-3951": [
"6371"
],
"CVE-2008-4462": [
"6373"
],
"CVE-2008-4467": [
"6374"
],
"CVE-2008-4468": [
"6375"
],
"CVE-2008-4465": [
"6376"
],
"CVE-2008-4463": [
"6378"
],
"CVE-2008-4460": [
"6379"
],
"CVE-2008-4464": [
"6380"
],
"CVE-2008-4469": [
"6381"
],
"CVE-2008-4466": [
"6382"
],
"CVE-2008-6016": [
"6383"
],
"CVE-2008-3952": [
"6383"
],
"CVE-2008-3953": [
"6385"
],
"CVE-2008-4461": [
"6388"
],
"CVE-2008-4183": [
"6390"
],
"CVE-2008-6971": [
"6392"
],
"CVE-2008-4457": [
"6393"
],
"CVE-2008-4164": [
"6393"
],
"CVE-2008-3955": [
"6395"
],
"CVE-2008-3954": [
"6396",
"6401"
],
"CVE-2009-2762": [
"6397",
"6421",
"9410"
],
"CVE-2008-5838": [
"6398"
],
"CVE-2008-4080": [
"6402"
],
"CVE-2008-4379": [
"6403"
],
"CVE-2008-4378": [
"6403"
],
"CVE-2008-4376": [
"6404"
],
"CVE-2008-7001": [
"6405"
],
"CVE-2008-4377": [
"6405"
],
"CVE-2008-4081": [
"6406"
],
"CVE-2008-4374": [
"6408"
],
"CVE-2008-4372": [
"6409"
],
"CVE-2008-4371": [
"6409"
],
"CVE-2008-4370": [
"6411"
],
"CVE-2008-4369": [
"6411"
],
"CVE-2008-4375": [
"6412"
],
"CVE-2008-4158": [
"6413"
],
"CVE-2008-4701": [
"6416"
],
"CVE-2008-4700": [
"6416"
],
"CVE-2008-4373": [
"6417"
],
"CVE-2008-4157": [
"6422",
"27519"
],
"CVE-2008-4159": [
"6423"
],
"CVE-2008-4702": [
"6425"
],
"CVE-2008-4591": [
"6425"
],
"CVE-2008-4074": [
"6426",
"6433"
],
"CVE-2008-4073": [
"6426",
"6433"
],
"CVE-2008-4592": [
"6427",
"6435"
],
"CVE-2008-6990": [
"6428"
],
"CVE-2008-6989": [
"6428"
],
"CVE-2008-6988": [
"6428"
],
"CVE-2008-4075": [
"6430"
],
"CVE-2008-4072": [
"6431"
],
"CVE-2008-7005": [
"6432"
],
"CVE-2008-4167": [
"6437"
],
"CVE-2008-4492": [
"6438",
"6693"
],
"CVE-2008-4355": [
"6442"
],
"CVE-2008-4345": [
"6443"
],
"CVE-2008-4354": [
"6444"
],
"CVE-2008-7010": [
"6445"
],
"CVE-2008-4350": [
"6446"
],
"CVE-2008-4347": [
"6447"
],
"CVE-2008-4357": [
"6449"
],
"CVE-2008-4346": [
"6451"
],
"CVE-2008-4115": [
"6451"
],
"CVE-2008-4352": [
"6452"
],
"CVE-2008-4351": [
"6452"
],
"CVE-2008-4176": [
"6453"
],
"CVE-2008-4353": [
"6455"
],
"CVE-2008-7006": [
"6456"
],
"CVE-2008-7007": [
"6457"
],
"CVE-2008-4356": [
"6460"
],
"CVE-2008-4181": [
"6461"
],
"CVE-2008-4203": [
"6462",
"6464"
],
"CVE-2008-4177": [
"6465"
],
"CVE-2008-4175": [
"6466"
],
"CVE-2008-4169": [
"6467"
],
"CVE-2008-4207": [
"6468"
],
"CVE-2008-4206": [
"6468"
],
"CVE-2008-4205": [
"6468"
],
"CVE-2008-4202": [
"6469"
],
"CVE-2008-4204": [
"6470"
],
"CVE-2008-4134": [
"6473"
],
"CVE-2008-4137": [
"6475"
],
"CVE-2008-4138": [
"6478"
],
"CVE-2008-4141": [
"6480"
],
"CVE-2008-4146": [
"6482"
],
"CVE-2008-4142": [
"6483"
],
"CVE-2008-4145": [
"6485"
],
"CVE-2008-4173": [
"6486"
],
"CVE-2008-4151": [
"6487"
],
"CVE-2008-4150": [
"6488"
],
"CVE-2008-4187": [
"6489"
],
"CVE-2008-4161": [
"6490"
],
"CVE-2008-6471": [
"6494"
],
"CVE-2008-5090": [
"6499"
],
"CVE-2008-6411": [
"6500"
],
"CVE-2008-5097": [
"6501"
],
"CVE-2008-6468": [
"6502"
],
"CVE-2008-6469": [
"6503"
],
"CVE-2008-6452": [
"6504"
],
"CVE-2008-6451": [
"6505"
],
"CVE-2008-6464": [
"6508"
],
"CVE-2008-5088": [
"6510",
"12561"
],
"CVE-2008-6454": [
"6511"
],
"CVE-2008-6467": [
"6512"
],
"CVE-2008-4245": [
"6513"
],
"CVE-2008-7021": [
"6514"
],
"CVE-2008-6466": [
"6516"
],
"CVE-2008-6030": [
"6517"
],
"CVE-2008-6042": [
"6518"
],
"CVE-2008-5968": [
"6519"
],
"CVE-2008-5967": [
"6519"
],
"CVE-2008-6453": [
"6520"
],
"CVE-2008-4244": [
"6521",
"6546"
],
"CVE-2008-6037": [
"6522"
],
"CVE-2008-6031": [
"6524"
],
"CVE-2008-6033": [
"6525"
],
"CVE-2008-5840": [
"6526"
],
"CVE-2008-6029": [
"6527"
],
"CVE-2008-6032": [
"6529"
],
"CVE-2008-6025": [
"6530"
],
"CVE-2008-4341": [
"6531"
],
"CVE-2008-6036": [
"6533"
],
"CVE-2008-6028": [
"6535"
],
"CVE-2008-4241": [
"6536"
],
"CVE-2008-6403": [
"6538"
],
"CVE-2008-6402": [
"6539"
],
"CVE-2008-5841": [
"6540",
"14820"
],
"CVE-2008-6401": [
"6542"
],
"CVE-2008-6410": [
"6543"
],
"CVE-2008-6405": [
"6545"
],
"CVE-2008-6408": [
"6547"
],
"CVE-2008-6407": [
"6547"
],
"CVE-2008-5992": [
"6549"
],
"CVE-2008-6414": [
"6550"
],
"CVE-2008-5990": [
"6551"
],
"CVE-2008-5991": [
"6552"
],
"CVE-2008-5989": [
"6553"
],
"CVE-2008-5988": [
"6555"
],
"CVE-2008-6002": [
"6556"
],
"CVE-2008-6001": [
"6557"
],
"CVE-2008-5993": [
"6558"
],
"CVE-2008-4318": [
"6559"
],
"CVE-2008-6004": [
"6561"
],
"CVE-2008-6003": [
"6561"
],
"CVE-2008-4330": [
"6562"
],
"CVE-2008-4331": [
"6563"
],
"CVE-2008-4333": [
"6566"
],
"CVE-2008-4332": [
"6566"
],
"CVE-2008-4319": [
"6567"
],
"CVE-2008-4334": [
"6568"
],
"CVE-2008-4329": [
"6571"
],
"CVE-2008-4336": [
"6572"
],
"CVE-2008-4335": [
"6572",
"6574"
],
"CVE-2008-4666": [
"6576"
],
"CVE-2008-5069": [
"6577"
],
"CVE-2008-4713": [
"6578"
],
"CVE-2008-7027": [
"6579"
],
"CVE-2008-4714": [
"6580"
],
"CVE-2008-7019": [
"6583"
],
"CVE-2008-7024": [
"6584"
],
"CVE-2008-4719": [
"6585"
],
"CVE-2008-4484": [
"6586"
],
"CVE-2008-4720": [
"6587"
],
"CVE-2008-4736": [
"6589"
],
"CVE-2008-7028": [
"6591"
],
"CVE-2008-4718": [
"6592",
"6607"
],
"CVE-2008-4706": [
"6593"
],
"CVE-2008-4366": [
"6594"
],
"CVE-2008-4711": [
"6595"
],
"CVE-2008-5075": [
"6596"
],
"CVE-2008-4735": [
"6598"
],
"CVE-2008-4674": [
"6599"
],
"CVE-2008-4712": [
"6601"
],
"CVE-2008-4739": [
"6602"
],
"CVE-2008-4738": [
"6603"
],
"CVE-2008-4361": [
"6604"
],
"CVE-2008-4716": [
"6605"
],
"CVE-2008-5071": [
"6606"
],
"CVE-2008-4717": [
"6608"
],
"CVE-2008-4364": [
"6610"
],
"CVE-2008-4675": [
"6611"
],
"CVE-2008-5070": [
"6612"
],
"CVE-2008-4709": [
"6613"
],
"CVE-2008-4707": [
"6617"
],
"CVE-2008-4668": [
"6618"
],
"CVE-2008-5074": [
"6620"
],
"CVE-2008-4708": [
"6621"
],
"CVE-2008-4673": [
"6623"
],
"CVE-2008-4721": [
"6625"
],
"CVE-2008-4665": [
"6626"
],
"CVE-2008-4667": [
"6628"
],
"CVE-2008-4743": [
"6629"
],
"CVE-2008-6011": [
"6631",
"6634"
],
"CVE-2008-6010": [
"6631"
],
"CVE-2008-6006": [
"6632"
],
"CVE-2008-7026": [
"6633"
],
"CVE-2008-6009": [
"6635"
],
"CVE-2008-6014": [
"6636"
],
"CVE-2008-6007": [
"6637"
],
"CVE-2008-6012": [
"6639"
],
"CVE-2006-0123": [
"6640"
],
"CVE-2008-4455": [
"6641"
],
"CVE-2008-4454": [
"6641",
"7020"
],
"CVE-2008-6091": [
"6642"
],
"CVE-2008-6100": [
"6643"
],
"CVE-2008-6093": [
"6644"
],
"CVE-2008-4483": [
"6645"
],
"CVE-2009-0820": [
"6646"
],
"CVE-2008-6132": [
"6646",
"18037"
],
"CVE-2008-6099": [
"6648"
],
"CVE-2008-6092": [
"6649"
],
"CVE-2008-6102": [
"6650"
],
"CVE-2008-6162": [
"6652"
],
"CVE-2008-5678": [
"6653"
],
"CVE-2008-6163": [
"6655"
],
"CVE-2008-4523": [
"6657"
],
"CVE-2008-6133": [
"6659"
],
"CVE-2008-4524": [
"6662"
],
"CVE-2008-4526": [
"6663"
],
"CVE-2008-5677": [
"6664"
],
"CVE-2008-4522": [
"6669"
],
"CVE-2008-4509": [
"6670",
"6674",
"6680"
],
"CVE-2008-4516": [
"6675"
],
"CVE-2008-4517": [
"6677"
],
"CVE-2008-4519": [
"6678"
],
"CVE-2008-4518": [
"6678"
],
"CVE-2008-4490": [
"6679"
],
"CVE-2008-4521": [
"6682"
],
"CVE-2008-4527": [
"6683"
],
"CVE-2008-4529": [
"6685"
],
"CVE-2008-4486": [
"6687",
"6691"
],
"CVE-2008-5873": [
"6691"
],
"CVE-2008-4496": [
"6694"
],
"CVE-2008-4495": [
"6695"
],
"CVE-2008-4498": [
"6696"
],
"CVE-2008-4497": [
"6697"
],
"CVE-2008-4494": [
"6698"
],
"CVE-2008-4502": [
"6700"
],
"CVE-2008-6155": [
"6701"
],
"CVE-2008-6154": [
"6701"
],
"CVE-2008-6156": [
"6702"
],
"CVE-2008-6139": [
"6703"
],
"CVE-2008-6138": [
"6703"
],
"CVE-2008-5663": [
"6706",
"6711"
],
"CVE-2008-6189": [
"6707"
],
"CVE-2008-6187": [
"6707"
],
"CVE-2008-6188": [
"6708"
],
"CVE-2008-6088": [
"6709"
],
"CVE-2008-6087": [
"6710"
],
"CVE-2008-6086": [
"6710"
],
"CVE-2008-6090": [
"6713"
],
"CVE-2008-4590": [
"6714"
],
"CVE-2008-6089": [
"6715"
],
"CVE-2008-4574": [
"6720"
],
"CVE-2008-6182": [
"6723"
],
"CVE-2008-6181": [
"6724"
],
"CVE-2008-4573": [
"6725"
],
"CVE-2008-5708": [
"6729"
],
"CVE-2008-6184": [
"6730"
],
"CVE-2008-4569": [
"6731"
],
"CVE-2008-5581": [
"6733"
],
"CVE-2008-5580": [
"6733"
],
"CVE-2008-5579": [
"6733"
],
"CVE-2008-5936": [
"6734"
],
"CVE-2008-5883": [
"6734"
],
"CVE-2008-5966": [
"6735"
],
"CVE-2008-4570": [
"6736"
],
"CVE-2008-5965": [
"6737"
],
"CVE-2008-6180": [
"6739"
],
"CVE-2008-6183": [
"6740"
],
"CVE-2008-6643": [
"6743"
],
"CVE-2008-4662": [
"6744"
],
"CVE-2008-6179": [
"6746"
],
"CVE-2008-4732": [
"6747"
],
"CVE-2008-5665": [
"6748"
],
"CVE-2008-4704": [
"6751"
],
"CVE-2008-4705": [
"6754"
],
"CVE-2008-4645": [
"6755"
],
"CVE-2008-4642": [
"6758"
],
"CVE-2008-4644": [
"6759"
],
"CVE-2008-4643": [
"6759"
],
"CVE-2008-4650": [
"6760"
],
"CVE-2008-4605": [
"6762"
],
"CVE-2008-4604": [
"6762"
],
"CVE-2008-4599": [
"6763"
],
"CVE-2008-6805": [
"6764"
],
"CVE-2008-4606": [
"6765"
],
"CVE-2008-4600": [
"6766"
],
"CVE-2008-4632": [
"6767"
],
"CVE-2008-4603": [
"6769"
],
"CVE-2008-4602": [
"6772"
],
"CVE-2008-4625": [
"6777"
],
"CVE-2008-5321": [
"6778"
],
"CVE-2008-4622": [
"6779"
],
"CVE-2008-4621": [
"6780"
],
"CVE-2008-4620": [
"6781"
],
"CVE-2008-4628": [
"6782"
],
"CVE-2008-6178": [
"6783",
"8060"
],
"CVE-2008-4624": [
"6785"
],
"CVE-2008-4626": [
"6788"
],
"CVE-2008-4627": [
"6790"
],
"CVE-2008-5320": [
"6791"
],
"CVE-2008-4623": [
"6792"
],
"CVE-2008-4653": [
"6795"
],
"CVE-2008-6078": [
"6796"
],
"CVE-2008-6177": [
"6797"
],
"CVE-2008-6076": [
"6802"
],
"CVE-2008-6084": [
"6803"
],
"CVE-2008-6074": [
"6806"
],
"CVE-2008-6077": [
"6808"
],
"CVE-2008-6080": [
"6809"
],
"CVE-2008-6165": [
"6814"
],
"CVE-2008-6083": [
"6816"
],
"CVE-2008-6172": [
"6817"
],
"CVE-2008-4784": [
"6818"
],
"CVE-2008-6789": [
"6819",
"6820"
],
"CVE-2008-6788": [
"6819",
"6820"
],
"CVE-2008-6790": [
"6820"
],
"CVE-2008-6168": [
"6821"
],
"CVE-2008-6167": [
"6821"
],
"CVE-2008-5920": [
"6822"
],
"CVE-2008-5919": [
"6822"
],
"CVE-2008-5918": [
"6822"
],
"CVE-2008-7267": [
"6823",
"32524"
],
"CVE-2008-6166": [
"6827"
],
"CVE-2008-4753": [
"6829"
],
"CVE-2008-6822": [
"6830"
],
"CVE-2008-4758": [
"6833"
],
"CVE-2008-4757": [
"6833"
],
"CVE-2008-4756": [
"6833"
],
"CVE-2008-4759": [
"6835"
],
"CVE-2008-4752": [
"6836"
],
"CVE-2008-4755": [
"6839"
],
"CVE-2008-4754": [
"6843"
],
"CVE-2008-4760": [
"6844"
],
"CVE-2008-6826": [
"6845"
],
"CVE-2008-4780": [
"6846"
],
"CVE-2008-4783": [
"6848"
],
"CVE-2008-4785": [
"6849"
],
"CVE-2008-4781": [
"6850"
],
"CVE-2008-4786": [
"6852"
],
"CVE-2008-4774": [
"6853"
],
"CVE-2008-4773": [
"6853"
],
"CVE-2008-4772": [
"6853"
],
"CVE-2008-4782": [
"6854",
"32537"
],
"CVE-2008-6815": [
"6855"
],
"CVE-2008-5040": [
"6857"
],
"CVE-2008-5066": [
"6859"
],
"CVE-2008-5065": [
"6860"
],
"CVE-2008-4873": [
"6864"
],
"CVE-2008-6806": [
"6866"
],
"CVE-2008-6811": [
"6867"
],
"CVE-2008-6814": [
"6868"
],
"CVE-2008-4878": [
"6869"
],
"CVE-2008-4877": [
"6869"
],
"CVE-2008-6213": [
"6874"
],
"CVE-2008-6216": [
"6876"
],
"CVE-2008-6215": [
"6876"
],
"CVE-2008-6214": [
"6877"
],
"CVE-2008-6777": [
"6879"
],
"CVE-2008-6857": [
"6882"
],
"CVE-2008-6860": [
"6883"
],
"CVE-2008-4906": [
"6885"
],
"CVE-2008-6804": [
"6886"
],
"CVE-2008-4894": [
"6888"
],
"CVE-2008-4893": [
"6888"
],
"CVE-2008-6862": [
"6889"
],
"CVE-2008-6858": [
"6890"
],
"CVE-2008-6863": [
"6891"
],
"CVE-2008-6864": [
"6892"
],
"CVE-2008-6859": [
"6893"
],
"CVE-2008-6781": [
"6894",
"6906"
],
"CVE-2008-6784": [
"6895"
],
"CVE-2008-4897": [
"6896"
],
"CVE-2008-4896": [
"6896"
],
"CVE-2008-6927": [
"6897"
],
"CVE-2008-6926": [
"6897"
],
"CVE-2008-4932": [
"6898"
],
"CVE-2008-6856": [
"6900"
],
"CVE-2008-6855": [
"6901"
],
"CVE-2008-6854": [
"6902"
],
"CVE-2008-6243": [
"6903"
],
"CVE-2008-6861": [
"6904"
],
"CVE-2008-6782": [
"6905"
],
"CVE-2008-6783": [
"6907"
],
"CVE-2008-6808": [
"6908"
],
"CVE-2008-6101": [
"6909"
],
"CVE-2008-6245": [
"6910"
],
"CVE-2008-6780": [
"6911"
],
"CVE-2008-4901": [
"6912"
],
"CVE-2008-6246": [
"6913"
],
"CVE-2008-6776": [
"6914"
],
"CVE-2008-6237": [
"6915"
],
"CVE-2008-5060": [
"6916"
],
"CVE-2008-5059": [
"6916"
],
"CVE-2008-4902": [
"6917"
],
"CVE-2008-6778": [
"6918"
],
"CVE-2008-6867": [
"6919"
],
"CVE-2008-6247": [
"6920"
],
"CVE-2008-6242": [
"6922",
"10384"
],
"CVE-2008-6794": [
"6923"
],
"CVE-2008-6244": [
"6924"
],
"CVE-2008-5004": [
"6925"
],
"CVE-2008-6482": [
"6928"
],
"CVE-2009-4808": [
"6929",
"8133"
],
"CVE-2008-6527": [
"6930"
],
"CVE-2008-6721": [
"6932"
],
"CVE-2008-6553": [
"6933"
],
"CVE-2008-5003": [
"6934"
],
"CVE-2008-4895": [
"6935",
"6936",
"32563"
],
"CVE-2008-4900": [
"6936",
"6944"
],
"CVE-2008-4884": [
"6936",
"6948"
],
"CVE-2008-4883": [
"6936",
"6937"
],
"CVE-2008-4882": [
"6936",
"6938"
],
"CVE-2008-4881": [
"6936",
"6943"
],
"CVE-2008-4885": [
"6940",
"6942"
],
"CVE-2008-3756": [
"6941"
],
"CVE-2008-3755": [
"6945"
],
"CVE-2008-4178": [
"6946",
"6947",
"6950",
"6951"
],
"CVE-2008-3750": [
"6949"
],
"CVE-2008-4886": [
"6952"
],
"CVE-2008-4879": [
"6953"
],
"CVE-2008-6296": [
"6954"
],
"CVE-2008-6269": [
"6955"
],
"CVE-2008-6683": [
"6956"
],
"CVE-2008-4888": [
"6957"
],
"CVE-2008-4887": [
"6957"
],
"CVE-2008-4880": [
"6958"
],
"CVE-2008-4890": [
"6960"
],
"CVE-2008-4889": [
"6961"
],
"CVE-2008-6526": [
"6962"
],
"CVE-2008-6294": [
"6964",
"6965",
"6968"
],
"CVE-2008-6293": [
"6964",
"6965",
"6968"
],
"CVE-2008-6292": [
"6964",
"6965",
"6968"
],
"CVE-2008-6291": [
"6966"
],
"CVE-2008-6606": [
"6967",
"6971"
],
"CVE-2008-6272": [
"6969"
],
"CVE-2008-6270": [
"6969"
],
"CVE-2008-6607": [
"6971"
],
"CVE-2008-6271": [
"6973"
],
"CVE-2008-6629": [
"6974"
],
"CVE-2008-6628": [
"6974"
],
"CVE-2008-6268": [
"6974"
],
"CVE-2008-6267": [
"6974"
],
"CVE-2008-6483": [
"6975"
],
"CVE-2008-6347": [
"6976"
],
"CVE-2008-6622": [
"6977"
],
"CVE-2008-6795": [
"6978",
"6981"
],
"CVE-2008-6222": [
"6980",
"15460"
],
"CVE-2008-6624": [
"6983"
],
"CVE-2008-6625": [
"6984"
],
"CVE-2008-6626": [
"6985"
],
"CVE-2008-6627": [
"6986"
],
"CVE-2008-6236": [
"6987"
],
"CVE-2008-6220": [
"6987"
],
"CVE-2008-6289": [
"6988"
],
"CVE-2008-6623": [
"6989"
],
"CVE-2008-6290": [
"6990"
],
"CVE-2008-6224": [
"6992"
],
"CVE-2008-6223": [
"6992"
],
"CVE-2008-6658": [
"6993"
],
"CVE-2008-6657": [
"6993"
],
"CVE-2008-6301": [
"6995"
],
"CVE-2008-5000": [
"6996"
],
"CVE-2008-6230": [
"6997"
],
"CVE-2008-6232": [
"6998",
"7000"
],
"CVE-2008-6231": [
"6998",
"7000"
],
"CVE-2008-6228": [
"6999"
],
"CVE-2008-6227": [
"6999"
],
"CVE-2008-6793": [
"7001"
],
"CVE-2008-6221": [
"7002"
],
"CVE-2008-6226": [
"7003"
],
"CVE-2008-5058": [
"7004"
],
"CVE-2008-6233": [
"7007"
],
"CVE-2008-6796": [
"7008"
],
"CVE-2008-6225": [
"7009"
],
"CVE-2008-6484": [
"7010"
],
"CVE-2008-6659": [
"7011"
],
"CVE-2008-6608": [
"7013"
],
"CVE-2008-5131": [
"7014"
],
"CVE-2008-5054": [
"7015"
],
"CVE-2008-6348": [
"7016"
],
"CVE-2008-6716": [
"7017"
],
"CVE-2008-6715": [
"7017"
],
"CVE-2008-6525": [
"7018"
],
"CVE-2008-5787": [
"7019"
],
"CVE-2008-6488": [
"7021",
"7026"
],
"CVE-2008-6485": [
"7021",
"7026"
],
"CVE-2008-5794": [
"7022"
],
"CVE-2008-5806": [
"7023"
],
"CVE-2008-6720": [
"7024",
"37786"
],
"CVE-2008-5648": [
"7025"
],
"CVE-2008-6723": [
"7028"
],
"CVE-2008-6349": [
"7029"
],
"CVE-2008-5046": [
"7030"
],
"CVE-2008-6551": [
"7031"
],
"CVE-2008-6717": [
"7032"
],
"CVE-2008-6718": [
"7033"
],
"CVE-2008-6719": [
"7034"
],
"CVE-2008-6351": [
"7035"
],
"CVE-2008-6350": [
"7035"
],
"CVE-2008-5793": [
"7038"
],
"CVE-2008-5790": [
"7039"
],
"CVE-2008-5789": [
"7040"
],
"CVE-2008-5803": [
"7041"
],
"CVE-2008-5047": [
"7043"
],
"CVE-2008-5653": [
"7044"
],
"CVE-2008-5655": [
"7045",
"7053"
],
"CVE-2008-5652": [
"7045"
],
"CVE-2008-5654": [
"7046"
],
"CVE-2008-5805": [
"7047"
],
"CVE-2008-5802": [
"7048"
],
"CVE-2008-5062": [
"7049"
],
"CVE-2008-5061": [
"7049"
],
"CVE-2008-5804": [
"7050"
],
"CVE-2008-5788": [
"7052"
],
"CVE-2008-5651": [
"7053"
],
"CVE-2008-6915": [
"7058"
],
"CVE-2008-6914": [
"7058"
],
"CVE-2008-5792": [
"7059"
],
"CVE-2008-5785": [
"7061"
],
"CVE-2008-6913": [
"7062"
],
"CVE-2008-5784": [
"7063",
"7069"
],
"CVE-2008-5783": [
"7063",
"7069"
],
"CVE-2008-6265": [
"7065"
],
"CVE-2008-6912": [
"7066",
"32575"
],
"CVE-2008-6487": [
"7067"
],
"CVE-2008-5042": [
"7070"
],
"CVE-2008-6917": [
"7071"
],
"CVE-2008-5782": [
"7072"
],
"CVE-2008-6960": [
"7074"
],
"CVE-2008-6511": [
"7075"
],
"CVE-2008-6510": [
"7075"
],
"CVE-2008-6509": [
"7075"
],
"CVE-2008-6508": [
"7075",
"19432"
],
"CVE-2008-6949": [
"7076"
],
"CVE-2008-6948": [
"7076"
],
"CVE-2008-6947": [
"7076"
],
"CVE-2008-6946": [
"7076"
],
"CVE-2008-5063": [
"7077"
],
"CVE-2008-6934": [
"7079"
],
"CVE-2008-7043": [
"7080"
],
"CVE-2008-7042": [
"7080"
],
"CVE-2008-7051": [
"7081"
],
"CVE-2008-6929": [
"7082"
],
"CVE-2008-6931": [
"7083"
],
"CVE-2008-6928": [
"7084"
],
"CVE-2008-6930": [
"7085"
],
"CVE-2008-7046": [
"7086"
],
"CVE-2008-7045": [
"7086"
],
"CVE-2008-7044": [
"7086"
],
"CVE-2008-6966": [
"7087"
],
"CVE-2008-6965": [
"7087"
],
"CVE-2008-7041": [
"7089"
],
"CVE-2008-5643": [
"7092"
],
"CVE-2008-5494": [
"7093"
],
"CVE-2008-7052": [
"7094"
],
"CVE-2008-6798": [
"7094"
],
"CVE-2008-5053": [
"7096"
],
"CVE-2008-5496": [
"7098"
],
"CVE-2008-6932": [
"7101"
],
"CVE-2008-5649": [
"7102"
],
"CVE-2008-5650": [
"7103",
"7116"
],
"CVE-2008-3765": [
"7105"
],
"CVE-2008-6302": [
"7106"
],
"CVE-2008-6941": [
"7107"
],
"CVE-2008-6940": [
"7107"
],
"CVE-2008-6939": [
"7107"
],
"CVE-2008-6944": [
"7110",
"7111",
"7112"
],
"CVE-2008-6943": [
"7110",
"7111",
"7112"
],
"CVE-2008-6942": [
"7110",
"7111",
"7112"
],
"CVE-2008-5497": [
"7113"
],
"CVE-2008-5132": [
"7114"
],
"CVE-2006-6819": [
"7116"
],
"CVE-2008-6963": [
"7118"
],
"CVE-2008-6958": [
"7119"
],
"CVE-2008-6950": [
"7120"
],
"CVE-2008-5491": [
"7121"
],
"CVE-2008-6964": [
"7123"
],
"CVE-2008-5487": [
"7124"
],
"CVE-2008-5486": [
"7124"
],
"CVE-2008-5489": [
"7128",
"24894"
],
"CVE-2008-6933": [
"7130"
],
"CVE-2008-5490": [
"7131"
],
"CVE-2008-5493": [
"7134"
],
"CVE-2008-6956": [
"7136"
],
"CVE-2008-6955": [
"7136"
],
"CVE-2008-6257": [
"7137"
],
"CVE-2008-6261": [
"7138"
],
"CVE-2008-5218": [
"7140"
],
"CVE-2008-6259": [
"7141"
],
"CVE-2008-6258": [
"7141"
],
"CVE-2008-6251": [
"7143"
],
"CVE-2008-6254": [
"7144"
],
"CVE-2008-6332": [
"7146"
],
"CVE-2008-6326": [
"7146"
],
"CVE-2008-6263": [
"7147"
],
"CVE-2008-6262": [
"7147"
],
"CVE-2008-6260": [
"7148"
],
"CVE-2008-5219": [
"7149"
],
"CVE-2008-6253": [
"7153"
],
"CVE-2008-6305": [
"7155"
],
"CVE-2008-6307": [
"7156"
],
"CVE-2008-6308": [
"7159"
],
"CVE-2008-6330": [
"7160"
],
"CVE-2008-6952": [
"7162"
],
"CVE-2008-6310": [
"7163",
"7166"
],
"CVE-2008-6309": [
"7163",
"7166"
],
"CVE-2008-6329": [
"7164"
],
"CVE-2008-5220": [
"7165"
],
"CVE-2008-5418": [
"7168"
],
"CVE-2008-5221": [
"7170"
],
"CVE-2008-7049": [
"7172",
"7175"
],
"CVE-2008-5335": [
"7173"
],
"CVE-2008-6303": [
"7176"
],
"CVE-2008-7047": [
"7179"
],
"CVE-2008-6116": [
"7182"
],
"CVE-2008-6114": [
"7184"
],
"CVE-2008-6957": [
"7185"
],
"CVE-2008-6111": [
"7186"
],
"CVE-2008-6112": [
"7190"
],
"CVE-2008-5308": [
"7191"
],
"CVE-2008-6115": [
"7195"
],
"CVE-2008-5310": [
"7198"
],
"CVE-2008-5311": [
"7199"
],
"CVE-2008-5306": [
"7200"
],
"CVE-2008-5307": [
"7201",
"32597"
],
"CVE-2008-6117": [
"7202"
],
"CVE-2008-5939": [
"7204"
],
"CVE-2008-5938": [
"7204"
],
"CVE-2008-6119": [
"7205"
],
"CVE-2008-6118": [
"7205",
"7210"
],
"CVE-2008-7080": [
"7206"
],
"CVE-2008-5309": [
"7208"
],
"CVE-2008-5338": [
"7215"
],
"CVE-2008-5337": [
"7215"
],
"CVE-2008-5336": [
"7216"
],
"CVE-2008-7064": [
"7217"
],
"CVE-2008-5334": [
"7218"
],
"CVE-2008-5333": [
"7218"
],
"CVE-2008-5332": [
"7221"
],
"CVE-2008-5293": [
"7222"
],
"CVE-2008-5294": [
"7223"
],
"CVE-2008-5287": [
"7224"
],
"CVE-2008-7073": [
"7225"
],
"CVE-2008-7072": [
"7227"
],
"CVE-2008-7071": [
"7227"
],
"CVE-2008-5290": [
"7228"
],
"CVE-2008-5289": [
"7228",
"7230"
],
"CVE-2008-5288": [
"7229"
],
"CVE-2008-5291": [
"7231"
],
"CVE-2008-7062": [
"7233"
],
"CVE-2008-5292": [
"7234"
],
"CVE-2008-5295": [
"7235"
],
"CVE-2008-6282": [
"7237"
],
"CVE-2008-5630": [
"7238"
],
"CVE-2008-5637": [
"7239"
],
"CVE-2008-7075": [
"7240",
"7243"
],
"CVE-2008-5639": [
"7241"
],
"CVE-2008-6370": [
"7244"
],
"CVE-2008-6369": [
"7244"
],
"CVE-2008-6274": [
"7248"
],
"CVE-2008-6277": [
"7250"
],
"CVE-2008-7076": [
"7251"
],
"CVE-2008-6809": [
"7253",
"10528"
],
"CVE-2008-6390": [
"7254"
],
"CVE-2008-6371": [
"7254"
],
"CVE-2008-7067": [
"7255"
],
"CVE-2009-3973": [
"7256",
"9511"
],
"CVE-2008-5629": [
"7256",
"9511"
],
"CVE-2008-7063": [
"7258"
],
"CVE-2008-6810": [
"7263"
],
"CVE-2008-7069": [
"7266"
],
"CVE-2008-7077": [
"7267"
],
"CVE-2008-6281": [
"7268"
],
"CVE-2008-5628": [
"7269"
],
"CVE-2008-7083": [
"7270"
],
"CVE-2008-6372": [
"7271"
],
"CVE-2008-5634": [
"7273"
],
"CVE-2008-5632": [
"7273",
"7301"
],
"CVE-2008-6889": [
"7274"
],
"CVE-2008-5633": [
"7275"
],
"CVE-2008-5959": [
"7276"
],
"CVE-2008-5635": [
"7278"
],
"CVE-2008-5631": [
"7279"
],
"CVE-2008-6286": [
"7280"
],
"CVE-2008-5974": [
"7281",
"7283"
],
"CVE-2008-5973": [
"7281"
],
"CVE-2008-5627": [
"7282"
],
"CVE-2008-6285": [
"7284"
],
"CVE-2008-5642": [
"7285"
],
"CVE-2008-6869": [
"7286"
],
"CVE-2008-5365": [
"7287"
],
"CVE-2008-6873": [
"7288"
],
"CVE-2008-5975": [
"7289"
],
"CVE-2008-5638": [
"7289"
],
"CVE-2008-5640": [
"7290"
],
"CVE-2008-7066": [
"7291"
],
"CVE-2008-6872": [
"7292"
],
"CVE-2008-5636": [
"7294"
],
"CVE-2008-5958": [
"7295"
],
"CVE-2008-6380": [
"7298"
],
"CVE-2008-5641": [
"7299"
],
"CVE-2008-5972": [
"7302"
],
"CVE-2008-6387": [
"7303"
],
"CVE-2008-5953": [
"7304"
],
"CVE-2008-5954": [
"7305"
],
"CVE-2008-5952": [
"7305"
],
"CVE-2008-6613": [
"7306"
],
"CVE-2008-6612": [
"7306"
],
"CVE-2008-6611": [
"7306"
],
"CVE-2008-6287": [
"7310"
],
"CVE-2008-6284": [
"7311"
],
"CVE-2008-6513": [
"7312"
],
"CVE-2008-3590": [
"7315"
],
"CVE-2008-6382": [
"7316"
],
"CVE-2008-6381": [
"7317"
],
"CVE-2008-5981": [
"7318"
],
"CVE-2008-5980": [
"7319"
],
"CVE-2008-5979": [
"7319"
],
"CVE-2008-5978": [
"7319",
"32603"
],
"CVE-2008-6446": [
"7322"
],
"CVE-2008-5969": [
"7323"
],
"CVE-2008-6388": [
"7324"
],
"CVE-2008-6374": [
"7325"
],
"CVE-2008-6379": [
"7326"
],
"CVE-2008-6378": [
"7327"
],
"CVE-2008-5586": [
"7328"
],
"CVE-2008-5607": [
"7331"
],
"CVE-2008-6494": [
"7332"
],
"CVE-2008-6389": [
"7333"
],
"CVE-2008-6377": [
"7335"
],
"CVE-2008-5949": [
"7336",
"14560"
],
"CVE-2008-5956": [
"7337"
],
"CVE-2008-5955": [
"7337",
"32642"
],
"CVE-2008-5601": [
"7338"
],
"CVE-2008-5951": [
"7339"
],
"CVE-2008-5950": [
"7339"
],
"CVE-2008-6493": [
"7340"
],
"CVE-2008-5585": [
"7341"
],
"CVE-2008-5604": [
"7342"
],
"CVE-2008-5957": [
"7343"
],
"CVE-2008-5963": [
"7344"
],
"CVE-2008-5962": [
"7344"
],
"CVE-2008-5948": [
"7345"
],
"CVE-2008-6362": [
"7346"
],
"CVE-2008-6871": [
"7348"
],
"CVE-2008-6870": [
"7348"
],
"CVE-2008-5588": [
"7349"
],
"CVE-2008-5589": [
"7350"
],
"CVE-2008-5592": [
"7351"
],
"CVE-2008-5591": [
"7351"
],
"CVE-2008-5600": [
"7352"
],
"CVE-2008-5599": [
"7352"
],
"CVE-2008-5597": [
"7353"
],
"CVE-2008-6492": [
"7354"
],
"CVE-2008-5608": [
"7356",
"7360"
],
"CVE-2008-5595": [
"7356"
],
"CVE-2008-5605": [
"7357"
],
"CVE-2008-5603": [
"7359"
],
"CVE-2008-5562": [
"7361"
],
"CVE-2008-5587": [
"7363"
],
"CVE-2008-5568": [
"7364"
],
"CVE-2008-5565": [
"7365"
],
"CVE-2008-5567": [
"7366"
],
"CVE-2008-6535": [
"7367"
],
"CVE-2008-5590": [
"7368"
],
"CVE-2008-6158": [
"7369"
],
"CVE-2008-5602": [
"7370"
],
"CVE-2008-5572": [
"7371"
],
"CVE-2008-5596": [
"7372"
],
"CVE-2008-5594": [
"7374"
],
"CVE-2008-5593": [
"7375"
],
"CVE-2008-5606": [
"7376"
],
"CVE-2008-5598": [
"7377"
],
"CVE-2008-6884": [
"7380"
],
"CVE-2008-5621": [
"7382"
],
"CVE-2008-6314": [
"7386"
],
"CVE-2008-5571": [
"7390",
"32653"
],
"CVE-2008-5573": [
"7391"
],
"CVE-2008-6317": [
"7392",
"7399"
],
"CVE-2008-6316": [
"7392",
"7399"
],
"CVE-2008-6315": [
"7392"
],
"CVE-2008-6892": [
"7395"
],
"CVE-2008-5561": [
"7396"
],
"CVE-2008-6327": [
"7397"
],
"CVE-2008-6312": [
"7397"
],
"CVE-2008-5560": [
"7398"
],
"CVE-2008-5559": [
"7398"
],
"CVE-2008-6318": [
"7399"
],
"CVE-2008-5570": [
"7400"
],
"CVE-2008-5566": [
"7400"
],
"CVE-2008-6844": [
"7406"
],
"CVE-2008-5574": [
"7407"
],
"CVE-2008-6530": [
"7408"
],
"CVE-2008-6529": [
"7408"
],
"CVE-2008-6502": [
"7409"
],
"CVE-2008-6501": [
"7409"
],
"CVE-2008-6321": [
"7412"
],
"CVE-2008-6320": [
"7412"
],
"CVE-2008-6319": [
"7413"
],
"CVE-2008-6323": [
"7414"
],
"CVE-2008-6322": [
"7415"
],
"CVE-2008-6324": [
"7416"
],
"CVE-2008-6313": [
"7417"
],
"CVE-2008-6581": [
"7418"
],
"CVE-2008-6356": [
"7419"
],
"CVE-2008-6357": [
"7420"
],
"CVE-2008-6361": [
"7422"
],
"CVE-2008-6366": [
"7423",
"32655"
],
"CVE-2008-6365": [
"7424",
"32655"
],
"CVE-2008-6364": [
"7425"
],
"CVE-2008-6354": [
"7427"
],
"CVE-2008-6355": [
"7428"
],
"CVE-2008-6353": [
"7429"
],
"CVE-2008-6352": [
"7432"
],
"CVE-2008-6358": [
"7433"
],
"CVE-2008-6367": [
"7435"
],
"CVE-2008-5931": [
"7436"
],
"CVE-2008-5930": [
"7436"
],
"CVE-2008-5929": [
"7438"
],
"CVE-2008-5921": [
"7439"
],
"CVE-2008-6580": [
"7440"
],
"CVE-2008-6883": [
"7441"
],
"CVE-2008-6882": [
"7441"
],
"CVE-2008-6881": [
"7441"
],
"CVE-2008-5927": [
"7443"
],
"CVE-2008-5763": [
"7444"
],
"CVE-2008-5762": [
"7444"
],
"CVE-2008-5886": [
"7445"
],
"CVE-2008-5885": [
"7446"
],
"CVE-2008-5926": [
"7447"
],
"CVE-2008-5901": [
"7449"
],
"CVE-2008-5932": [
"7450"
],
"CVE-2008-5771": [
"7451"
],
"CVE-2008-5770": [
"7451"
],
"CVE-2008-5928": [
"7453"
],
"CVE-2008-5779": [
"7453",
"7474"
],
"CVE-2008-5778": [
"7453",
"7489"
],
"CVE-2008-6900": [
"7456"
],
"CVE-2008-5894": [
"7458"
],
"CVE-2008-5922": [
"7459"
],
"CVE-2008-5761": [
"7461"
],
"CVE-2008-5759": [
"7461"
],
"CVE-2008-5774": [
"7462"
],
"CVE-2008-6874": [
"7463"
],
"CVE-2008-5772": [
"7464"
],
"CVE-2008-5934": [
"7465"
],
"CVE-2008-5933": [
"7465"
],
"CVE-2008-5780": [
"7466"
],
"CVE-2008-5898": [
"7468"
],
"CVE-2008-5899": [
"7469"
],
"CVE-2008-5897": [
"7470"
],
"CVE-2008-5900": [
"7471"
],
"CVE-2008-5896": [
"7472"
],
"CVE-2008-6906": [
"7475"
],
"CVE-2008-6905": [
"7475"
],
"CVE-2008-5895": [
"7476"
],
"CVE-2008-7003": [
"7478"
],
"CVE-2008-5768": [
"7479"
],
"CVE-2008-5777": [
"7480"
],
"CVE-2008-5765": [
"7481"
],
"CVE-2008-5764": [
"7481"
],
"CVE-2008-5776": [
"7482"
],
"CVE-2008-5775": [
"7482"
],
"CVE-2008-5781": [
"7483",
"10561"
],
"CVE-2008-5893": [
"7485"
],
"CVE-2008-5892": [
"7485"
],
"CVE-2008-5889": [
"7486"
],
"CVE-2008-5888": [
"7486"
],
"CVE-2008-5766": [
"7487"
],
"CVE-2003-1571": [
"7488"
],
"CVE-2008-5773": [
"7491"
],
"CVE-2008-6057": [
"7493"
],
"CVE-2008-5767": [
"7495"
],
"CVE-2008-6743": [
"7497"
],
"CVE-2008-6768": [
"7500"
],
"CVE-2008-6050": [
"7504"
],
"CVE-2008-6049": [
"7506"
],
"CVE-2008-6787": [
"7507"
],
"CVE-2008-6785": [
"7509",
"10601"
],
"CVE-2008-6902": [
"7510"
],
"CVE-2008-6901": [
"7510"
],
"CVE-2008-6907": [
"7511"
],
"CVE-2008-5738": [
"7513"
],
"CVE-2008-6017": [
"7514"
],
"CVE-2008-5879": [
"7515"
],
"CVE-2008-5878": [
"7515"
],
"CVE-2008-5877": [
"7515"
],
"CVE-2008-5890": [
"7517"
],
"CVE-2008-5880": [
"7518"
],
"CVE-2008-6018": [
"7519"
],
"CVE-2008-5851": [
"7522"
],
"CVE-2008-6752": [
"7523"
],
"CVE-2008-6335": [
"7524"
],
"CVE-2008-6334": [
"7525"
],
"CVE-2008-5855": [
"7526"
],
"CVE-2008-5854": [
"7526"
],
"CVE-2008-5861": [
"7527"
],
"CVE-2008-5860": [
"7529"
],
"CVE-2008-5859": [
"7529"
],
"CVE-2008-5847": [
"7529"
],
"CVE-2008-5863": [
"7530"
],
"CVE-2008-6751": [
"7531"
],
"CVE-2008-5853": [
"7532"
],
"CVE-2008-5852": [
"7534"
],
"CVE-2008-5732": [
"7537"
],
"CVE-2008-5865": [
"7538",
"7539",
"7567",
"7575"
],
"CVE-2008-5864": [
"7538",
"7539",
"7567",
"7575"
],
"CVE-2008-6333": [
"7541"
],
"CVE-2008-6336": [
"7542"
],
"CVE-2008-5752": [
"7543"
],
"CVE-2008-5739": [
"7544"
],
"CVE-2008-6773": [
"7545"
],
"CVE-2008-6772": [
"7545"
],
"CVE-2008-6771": [
"7545"
],
"CVE-2008-6770": [
"7545"
],
"CVE-2008-6769": [
"7545"
],
"CVE-2008-6337": [
"7546"
],
"CVE-2008-6345": [
"7548"
],
"CVE-2008-5619": [
"7549",
"7553"
],
"CVE-2008-5737": [
"7551"
],
"CVE-2008-6729": [
"7557"
],
"CVE-2008-6851": [
"7558"
],
"CVE-2008-5727": [
"7559"
],
"CVE-2008-5742": [
"7560"
],
"CVE-2008-5730": [
"7560"
],
"CVE-2008-5729": [
"7560"
],
"CVE-2008-5728": [
"7560"
],
"CVE-2008-6849": [
"7561"
],
"CVE-2008-6848": [
"7561",
"12345"
],
"CVE-2008-6921": [
"7562"
],
"CVE-2008-6920": [
"7563"
],
"CVE-2008-5726": [
"7565"
],
"CVE-2008-5875": [
"7567",
"7568",
"7575"
],
"CVE-2008-5874": [
"7567",
"7568",
"7575"
],
"CVE-2008-5816": [
"7570"
],
"CVE-2008-6852": [
"7572"
],
"CVE-2008-6148": [
"7573"
],
"CVE-2008-6149": [
"7574",
"17464"
],
"CVE-2008-5856": [
"7579"
],
"CVE-2008-5748": [
"7580"
],
"CVE-2008-5811": [
"7587"
],
"CVE-2008-6146": [
"7593"
],
"CVE-2008-5751": [
"7596",
"15335"
],
"CVE-2008-6143": [
"7597"
],
"CVE-2008-5733": [
"7598"
],
"CVE-2008-6147": [
"7599"
],
"CVE-2008-6731": [
"7600"
],
"CVE-2008-6763": [
"7601"
],
"CVE-2008-5817": [
"7602"
],
"CVE-2008-5819": [
"7603"
],
"CVE-2008-5818": [
"7604"
],
"CVE-2008-6919": [
"7605"
],
"CVE-2008-6727": [
"7607"
],
"CVE-2008-6151": [
"7609"
],
"CVE-2008-6152": [
"7610"
],
"CVE-2008-6853": [
"7611"
],
"CVE-2008-6157": [
"7613"
],
"CVE-2008-6150": [
"7613"
],
"CVE-2008-6750": [
"7614"
],
"CVE-2008-6749": [
"7614"
],
"CVE-2008-6241": [
"7615"
],
"CVE-2008-6730": [
"7616"
],
"CVE-2008-5820": [
"7619"
],
"CVE-2008-6918": [
"7620"
],
"CVE-2008-5815": [
"7621"
],
"CVE-2008-6761": [
"7622"
],
"CVE-2008-6142": [
"7624"
],
"CVE-2008-6726": [
"7625"
],
"CVE-2008-6725": [
"7625"
],
"CVE-2008-6153": [
"7627"
],
"CVE-2008-6765": [
"7628"
],
"CVE-2008-6758": [
"7628"
],
"CVE-2009-0703": [
"7635"
],
"CVE-2009-0711": [
"7636"
],
"CVE-2009-0710": [
"7636"
],
"CVE-2009-0709": [
"7636"
],
"CVE-2009-0597": [
"7640"
],
"CVE-2009-0705": [
"7641"
],
"CVE-2009-0707": [
"7642"
],
"CVE-2009-0596": [
"7648"
],
"CVE-2009-0595": [
"7648"
],
"CVE-2009-0594": [
"7648"
],
"CVE-2009-0592": [
"7658"
],
"CVE-2009-0704": [
"7659"
],
"CVE-2009-0598": [
"7660"
],
"CVE-2009-0593": [
"7663"
],
"CVE-2009-0701": [
"7668"
],
"CVE-2009-0702": [
"7670"
],
"CVE-2009-0107": [
"7672"
],
"CVE-2009-0106": [
"7672"
],
"CVE-2009-0108": [
"7674"
],
"CVE-2009-0110": [
"7679"
],
"CVE-2009-0105": [
"7680"
],
"CVE-2009-0104": [
"7680"
],
"CVE-2009-0109": [
"7682"
],
"CVE-2009-0121": [
"7683"
],
"CVE-2009-0111": [
"7683"
],
"CVE-2009-0493": [
"7686"
],
"CVE-2009-0103": [
"7687"
],
"CVE-2008-5881": [
"7687"
],
"CVE-2009-0826": [
"7689"
],
"CVE-2009-0827": [
"7690"
],
"CVE-2009-0113": [
"7691"
],
"CVE-2009-0831": [
"7697"
],
"CVE-2009-0832": [
"7698"
],
"CVE-2009-0829": [
"7699"
],
"CVE-2009-0828": [
"7699"
],
"CVE-2009-0494": [
"7734"
],
"CVE-2009-0495": [
"7743"
],
"CVE-2009-0498": [
"7744"
],
"CVE-2009-0726": [
"7746"
],
"CVE-2009-0326": [
"7758",
"32724"
],
"CVE-2009-5103": [
"7761"
],
"CVE-2009-5102": [
"7761"
],
"CVE-2009-0428": [
"7767",
"7787"
],
"CVE-2009-0427": [
"7767",
"7773"
],
"CVE-2009-0426": [
"7767"
],
"CVE-2009-0422": [
"7778"
],
"CVE-2009-0275": [
"7780"
],
"CVE-2009-0251": [
"7780"
],
"CVE-2009-0250": [
"7780"
],
"CVE-2009-0423": [
"7786"
],
"CVE-2009-0290": [
"7792"
],
"CVE-2009-0421": [
"7793"
],
"CVE-2009-0420": [
"7795"
],
"CVE-2009-0425": [
"7797"
],
"CVE-2009-0327": [
"7798"
],
"CVE-2009-0252": [
"7801"
],
"CVE-2009-0281": [
"7802"
],
"CVE-2009-0249": [
"7805"
],
"CVE-2009-0248": [
"7805"
],
"CVE-2009-0337": [
"7806"
],
"CVE-2009-0336": [
"7806"
],
"CVE-2009-0335": [
"7806"
],
"CVE-2009-0334": [
"7806"
],
"CVE-2009-0340": [
"7813"
],
"CVE-2009-0324": [
"7814"
],
"CVE-2009-0730": [
"7815",
"32807"
],
"CVE-2009-0328": [
"7816"
],
"CVE-2009-0330": [
"7818"
],
"CVE-2009-0331": [
"7819"
],
"CVE-2009-0329": [
"7824"
],
"CVE-2009-0325": [
"7831"
],
"CVE-2009-0333": [
"7833"
],
"CVE-2009-0383": [
"7835"
],
"CVE-2009-0381": [
"7840"
],
"CVE-2009-0380": [
"7841"
],
"CVE-2009-0379": [
"7846"
],
"CVE-2009-0378": [
"7847"
],
"CVE-2009-0377": [
"7847"
],
"CVE-2009-0384": [
"7849"
],
"CVE-2009-0280": [
"7850"
],
"CVE-2009-0279": [
"7851"
],
"CVE-2009-0372": [
"7859"
],
"CVE-2009-0284": [
"7862"
],
"CVE-2009-0286": [
"7863"
],
"CVE-2009-0295": [
"7867"
],
"CVE-2009-0296": [
"7873"
],
"CVE-2009-0292": [
"7874"
],
"CVE-2009-0407": [
"7876"
],
"CVE-2009-0293": [
"7877"
],
"CVE-2009-0299": [
"7878",
"9236"
],
"CVE-2009-0371": [
"7879"
],
"CVE-2009-0297": [
"7880"
],
"CVE-2009-0373": [
"7881"
],
"CVE-2009-0291": [
"7883",
"32759"
],
"CVE-2009-0406": [
"7892"
],
"CVE-2009-0403": [
"7894"
],
"CVE-2009-0399": [
"7894"
],
"CVE-2009-3167": [
"7895",
"9425"
],
"CVE-2009-0409": [
"7899"
],
"CVE-2009-0400": [
"7900"
],
"CVE-2009-0405": [
"7901"
],
"CVE-2009-0395": [
"7916"
],
"CVE-2009-0394": [
"7917"
],
"CVE-2009-0451": [
"7932"
],
"CVE-2009-1451": [
"7936"
],
"CVE-2009-1450": [
"7936"
],
"CVE-2009-0457": [
"7939"
],
"CVE-2009-0459": [
"7940",
"7941"
],
"CVE-2009-0458": [
"7940",
"7941"
],
"CVE-2009-0456": [
"7946"
],
"CVE-2009-0517": [
"7948"
],
"CVE-2010-4804": [
"18164"
],
"CVE-2009-0461": [
"7951",
"7952"
],
"CVE-2009-0460": [
"7951",
"7952"
],
"CVE-2009-0462": [
"7953"
],
"CVE-2009-0463": [
"7954"
],
"CVE-2009-0464": [
"7955"
],
"CVE-2009-0479": [
"7956"
],
"CVE-2009-0453": [
"7956"
],
"CVE-2009-0452": [
"7956"
],
"CVE-2009-0446": [
"7961"
],
"CVE-2009-0447": [
"7963"
],
"CVE-2009-0646": [
"7964"
],
"CVE-2009-0441": [
"7965"
],
"CVE-2009-0445": [
"7968"
],
"CVE-2009-0572": [
"7969"
],
"CVE-2009-0645": [
"7976"
],
"CVE-2009-0448": [
"7977"
],
"CVE-2009-0444": [
"7979"
],
"CVE-2009-0442": [
"7980"
],
"CVE-2009-0761": [
"7982"
],
"CVE-2009-0760": [
"7982"
],
"CVE-2009-0768": [
"7984"
],
"CVE-2009-0767": [
"7993"
],
"CVE-2009-0766": [
"7993"
],
"CVE-2009-0765": [
"7993"
],
"CVE-2009-0764": [
"7993"
],
"CVE-2009-0763": [
"7993"
],
"CVE-2009-0602": [
"7998"
],
"CVE-2009-0643": [
"7999"
],
"CVE-2009-0610": [
"7999"
],
"CVE-2009-0571": [
"8001"
],
"CVE-2009-0570": [
"8001"
],
"CVE-2009-0574": [
"8002"
],
"CVE-2009-0639": [
"8005"
],
"CVE-2009-0528": [
"8007"
],
"CVE-2009-0516": [
"8011"
],
"CVE-2009-0531": [
"8012"
],
"CVE-2009-0604": [
"8014"
],
"CVE-2009-0527": [
"8016"
],
"CVE-2009-0526": [
"8016"
],
"CVE-2009-0530": [
"8017"
],
"CVE-2009-0529": [
"8017"
],
"CVE-2009-1256": [
"8018",
"8355"
],
"CVE-2009-0534": [
"8018",
"8355"
],
"CVE-2009-0515": [
"8020"
],
"CVE-2009-0514": [
"8025"
],
"CVE-2009-0513": [
"8025"
],
"CVE-2009-0294": [
"8026"
],
"CVE-2009-5093": [
"8027"
],
"CVE-2009-0535": [
"8029"
],
"CVE-2009-0735": [
"8030"
],
"CVE-2009-0722": [
"8032"
],
"CVE-2009-0738": [
"8033"
],
"CVE-2009-0739": [
"8034"
],
"CVE-2009-0740": [
"8035"
],
"CVE-2009-0815": [
"8038"
],
"CVE-2009-5090": [
"8043"
],
"CVE-2009-5089": [
"8049"
],
"CVE-2009-5088": [
"8049"
],
"CVE-2009-5091": [
"8050"
],
"CVE-2009-5095": [
"8052"
],
"CVE-2009-5094": [
"8054"
],
"CVE-2009-0678": [
"8068"
],
"CVE-2009-0677": [
"8068"
],
"CVE-2009-0674": [
"8068"
],
"CVE-2009-0673": [
"8068"
],
"CVE-2009-0672": [
"8068"
],
"CVE-2009-0864": [
"8071"
],
"CVE-2009-0863": [
"8071"
],
"CVE-2009-0866": [
"8073"
],
"CVE-2009-0750": [
"8076"
],
"CVE-2009-0807": [
"8092"
],
"CVE-2009-0731": [
"8094"
],
"CVE-2009-0727": [
"8098"
],
"CVE-2009-0728": [
"8100"
],
"CVE-2009-0810": [
"8101"
],
"CVE-2009-4805": [
"8128"
],
"CVE-2009-4801": [
"8128"
],
"CVE-2009-4806": [
"8130"
],
"CVE-2009-4807": [
"8133"
],
"CVE-2009-0853": [
"8161"
],
"CVE-2009-0852": [
"8161"
],
"CVE-2009-0851": [
"8161"
],
"CVE-2009-0883": [
"8165"
],
"CVE-2009-0881": [
"8167"
],
"CVE-2009-0886": [
"8168"
],
"CVE-2009-0882": [
"8170"
],
"CVE-2009-4883": [
"8182",
"8330"
],
"CVE-2008-7192": [
"8183"
],
"CVE-2009-4886": [
"8185"
],
"CVE-2009-4889": [
"8186"
],
"CVE-2009-4892": [
"8188"
],
"CVE-2009-1030": [
"8196"
],
"CVE-2010-1109": [
"8204"
],
"CVE-2009-1038": [
"8207",
"8217"
],
"CVE-2009-1026": [
"8209"
],
"CVE-2009-1025": [
"8216"
],
"CVE-2009-1024": [
"8216"
],
"CVE-2009-1023": [
"8220"
],
"CVE-2009-0964": [
"8226"
],
"CVE-2009-0963": [
"8226"
],
"CVE-2009-0965": [
"8228"
],
"CVE-2009-0968": [
"8229"
],
"CVE-2009-0966": [
"8230"
],
"CVE-2009-1032": [
"8238"
],
"CVE-2010-4151": [
"8240"
],
"CVE-2009-1033": [
"8240"
],
"CVE-2009-1050": [
"8243"
],
"CVE-2009-1049": [
"8243",
"8244"
],
"CVE-2009-1088": [
"8247"
],
"CVE-2009-1067": [
"8252"
],
"CVE-2009-1066": [
"8252"
],
"CVE-2009-2311": [
"8254"
],
"CVE-2009-2310": [
"8258"
],
"CVE-2008-6842": [
"8271"
],
"CVE-2009-2309": [
"8272"
],
"CVE-2009-2313": [
"8278"
],
"CVE-2009-1246": [
"8290"
],
"CVE-2009-1248": [
"8291"
],
"CVE-2009-1247": [
"8291"
],
"CVE-2009-1228": [
"8296"
],
"CVE-2009-1171": [
"8297"
],
"CVE-2009-4796": [
"8302"
],
"CVE-2009-1229": [
"8304"
],
"CVE-2006-6446": [
"8305"
],
"CVE-2009-4799": [
"8307"
],
"CVE-2009-4798": [
"8307"
],
"CVE-2009-4793": [
"8309"
],
"CVE-2009-4792": [
"8309"
],
"CVE-2009-1512": [
"8317"
],
"CVE-2009-1508": [
"8317"
],
"CVE-2009-4797": [
"8318"
],
"CVE-2009-4791": [
"8319"
],
"CVE-2009-4794": [
"8323"
],
"CVE-2009-1230": [
"8324"
],
"CVE-2009-1226": [
"8324"
],
"CVE-2009-1222": [
"8328"
],
"CVE-2009-1224": [
"8331"
],
"CVE-2009-1510": [
"8334"
],
"CVE-2009-1509": [
"8341"
],
"CVE-2009-4957": [
"8346"
],
"CVE-2009-1283": [
"8347"
],
"CVE-2009-1282": [
"8347"
],
"CVE-2009-1281": [
"8347"
],
"CVE-2009-1278": [
"8350"
],
"CVE-2009-1259": [
"8351"
],
"CVE-2009-1263": [
"8353"
],
"CVE-2009-1498": [
"8357"
],
"CVE-2009-1499": [
"8366"
],
"CVE-2009-1496": [
"8367"
],
"CVE-2009-1495": [
"8374"
],
"CVE-2009-1323": [
"8382"
],
"CVE-2009-1314": [
"8382"
],
"CVE-2009-4209": [
"8394"
],
"CVE-2009-1369": [
"8394"
],
"CVE-2009-1368": [
"8394"
],
"CVE-2009-1367": [
"8394"
],
"CVE-2008-6126": [
"8394"
],
"CVE-2009-2337": [
"8396"
],
"CVE-2009-1322": [
"8418"
],
"CVE-2009-1321": [
"8418"
],
"CVE-2009-1318": [
"8423"
],
"CVE-2009-1316": [
"8424"
],
"CVE-2009-1315": [
"8424"
],
"CVE-2006-4608": [
"8425"
],
"CVE-2006-4607": [
"8425"
],
"CVE-2009-1319": [
"8431"
],
"CVE-2009-1317": [
"8432"
],
"CVE-2009-2338": [
"8446"
],
"CVE-2009-1408": [
"8453"
],
"CVE-2009-1916": [
"8454"
],
"CVE-2009-1361": [
"8454"
],
"CVE-2009-1345": [
"8455"
],
"CVE-2009-1346": [
"8457"
],
"CVE-2009-1452": [
"8460"
],
"CVE-2009-1362": [
"8461",
"12456"
],
"CVE-2009-1347": [
"8461",
"12456"
],
"CVE-2009-1453": [
"8464"
],
"CVE-2009-1447": [
"8474"
],
"CVE-2010-4996": [
"8475",
"14204"
],
"CVE-2009-4935": [
"8475",
"14204"
],
"CVE-2009-1483": [
"8481"
],
"CVE-2009-1411": [
"8482"
],
"CVE-2009-4933": [
"8487"
],
"CVE-2009-4927": [
"8492"
],
"CVE-2009-1489": [
"8493"
],
"CVE-2009-1488": [
"8493"
],
"CVE-2009-1487": [
"8493"
],
"CVE-2009-1409": [
"8495"
],
"CVE-2009-4929": [
"8496"
],
"CVE-2009-4925": [
"8497"
],
"CVE-2009-1403": [
"8501"
],
"CVE-2009-1405": [
"8502"
],
"CVE-2009-1404": [
"8502"
],
"CVE-2009-1406": [
"8503"
],
"CVE-2009-1407": [
"8504"
],
"CVE-2009-1410": [
"8505"
],
"CVE-2009-3590": [
"8506"
],
"CVE-2009-1446": [
"8514"
],
"CVE-2009-1445": [
"8516"
],
"CVE-2009-1444": [
"8516"
],
"CVE-2009-1504": [
"8529"
],
"CVE-2009-1480": [
"8533"
],
"CVE-2009-1621": [
"8539"
],
"CVE-2009-1624": [
"8545"
],
"CVE-2009-1623": [
"8545"
],
"CVE-2009-1625": [
"8546"
],
"CVE-2009-1626": [
"8547"
],
"CVE-2009-1622": [
"8548"
],
"CVE-2009-1486": [
"8549"
],
"CVE-2009-1617": [
"8550"
],
"CVE-2009-1619": [
"8551"
],
"CVE-2009-1618": [
"8552"
],
"CVE-2009-1550": [
"8555"
],
"CVE-2009-2451": [
"8558"
],
"CVE-2009-1506": [
"8563"
],
"CVE-2009-1500": [
"8565"
],
"CVE-2009-1502": [
"8566"
],
"CVE-2009-1503": [
"8571"
],
"CVE-2009-1613": [
"8576",
"8577"
],
"CVE-2009-1615": [
"8577"
],
"CVE-2009-1614": [
"8577"
],
"CVE-2009-2573": [
"8586"
],
"CVE-2009-2574": [
"8587"
],
"CVE-2009-1519": [
"8593"
],
"CVE-2009-4760": [
"8596"
],
"CVE-2009-1549": [
"8599"
],
"CVE-2009-1548": [
"8600"
],
"CVE-2009-1551": [
"8602"
],
"CVE-2009-1659": [
"8603"
],
"CVE-2009-1587": [
"8604"
],
"CVE-2009-1582": [
"8605"
],
"CVE-2009-1585": [
"8615"
],
"CVE-2009-1584": [
"8615",
"8616"
],
"CVE-2009-1583": [
"8615"
],
"CVE-2009-1607": [
"8618"
],
"CVE-2009-2567": [
"8619"
],
"CVE-2009-1912": [
"8622"
],
"CVE-2009-1670": [
"8626"
],
"CVE-2009-1638": [
"8627"
],
"CVE-2009-1799": [
"8636"
],
"CVE-2009-1637": [
"8638"
],
"CVE-2009-1610": [
"8639"
],
"CVE-2009-1662": [
"8642"
],
"CVE-2009-1658": [
"8643"
],
"CVE-2009-1913": [
"8645"
],
"CVE-2009-1609": [
"8647"
],
"CVE-2009-1910": [
"8648"
],
"CVE-2009-1911": [
"8649"
],
"CVE-2009-1661": [
"8655"
],
"CVE-2009-1781": [
"8658"
],
"CVE-2009-1780": [
"8658"
],
"CVE-2009-1779": [
"8658"
],
"CVE-2009-1678": [
"8659"
],
"CVE-2009-1677": [
"8659"
],
"CVE-2009-1669": [
"8659"
],
"CVE-2009-1778": [
"8664"
],
"CVE-2009-1653": [
"8667"
],
"CVE-2009-2003": [
"8668",
"8675"
],
"CVE-2009-2010": [
"8671"
],
"CVE-2009-1818": [
"8672"
],
"CVE-2009-1816": [
"8676"
],
"CVE-2009-1650": [
"8679"
],
"CVE-2009-1649": [
"8680"
],
"CVE-2009-1774": [
"8681"
],
"CVE-2009-1813": [
"8683"
],
"CVE-2009-1652": [
"8689"
],
"CVE-2009-1651": [
"8689"
],
"CVE-2009-1665": [
"8690"
],
"CVE-2009-1664": [
"8690"
],
"CVE-2009-1663": [
"8690"
],
"CVE-2009-1655": [
"8690"
],
"CVE-2009-1654": [
"8690"
],
"CVE-2009-1767": [
"8691"
],
"CVE-2009-1822": [
"8697"
],
"CVE-2009-1768": [
"8700"
],
"CVE-2009-1820": [
"8702"
],
"CVE-2009-1819": [
"8702"
],
"CVE-2009-1821": [
"8705"
],
"CVE-2009-1814": [
"8706"
],
"CVE-2009-1825": [
"8707"
],
"CVE-2009-1810": [
"8707"
],
"CVE-2009-1809": [
"8707"
],
"CVE-2009-1826": [
"8708"
],
"CVE-2009-1812": [
"8708"
],
"CVE-2009-1811": [
"8708"
],
"CVE-2009-1742": [
"8709"
],
"CVE-2009-1787": [
"8710"
],
"CVE-2009-1771": [
"8714"
],
"CVE-2009-1770": [
"8714"
],
"CVE-2009-1765": [
"8715"
],
"CVE-2009-1766": [
"8724"
],
"CVE-2009-1764": [
"8726"
],
"CVE-2009-1746": [
"8727"
],
"CVE-2009-1750": [
"8730"
],
"CVE-2009-1736": [
"8731"
],
"CVE-2009-1739": [
"8735"
],
"CVE-2009-1735": [
"8737"
],
"CVE-2009-1734": [
"8737"
],
"CVE-2009-1741": [
"8741"
],
"CVE-2009-2239": [
"8743"
],
"CVE-2009-1752": [
"8744"
],
"CVE-2009-1749": [
"8745"
],
"CVE-2009-1748": [
"8745"
],
"CVE-2009-1751": [
"8748"
],
"CVE-2009-2238": [
"8749"
],
"CVE-2009-1747": [
"8751"
],
"CVE-2009-2234": [
"8755"
],
"CVE-2009-2243": [
"8756"
],
"CVE-2009-2242": [
"8756"
],
"CVE-2009-2241": [
"8756"
],
"CVE-2009-1843": [
"8759"
],
"CVE-2009-2236": [
"8761"
],
"CVE-2009-2235": [
"8762"
],
"CVE-2009-2293": [
"8766"
],
"CVE-2009-4674": [
"8774"
],
"CVE-2009-4675": [
"8775"
],
"CVE-2009-2290": [
"8779"
],
"CVE-2009-1960": [
"8781",
"8812"
],
"CVE-2009-4665": [
"8785"
],
"CVE-2009-4673": [
"8788"
],
"CVE-2009-3358": [
"8788",
"9634"
],
"CVE-2009-1936": [
"8790"
],
"CVE-2009-4672": [
"8791"
],
"CVE-2009-4666": [
"8792"
],
"CVE-2009-4671": [
"8797"
],
"CVE-2009-4670": [
"8797"
],
"CVE-2009-4669": [
"8797"
],
"CVE-2009-1853": [
"8802"
],
"CVE-2009-1852": [
"8803"
],
"CVE-2009-1850": [
"8808"
],
"CVE-2009-4667": [
"8810"
],
"CVE-2009-1854": [
"8813"
],
"CVE-2009-1848": [
"8814"
],
"CVE-2009-1847": [
"8815"
],
"CVE-2009-1846": [
"8816"
],
"CVE-2009-4939": [
"8818",
"34389"
],
"CVE-2009-4936": [
"8819"
],
"CVE-2009-2600": [
"8823",
"34940"
],
"CVE-2009-2604": [
"8825"
],
"CVE-2009-4203": [
"8828"
],
"CVE-2009-4940": [
"8829"
],
"CVE-2009-4206": [
"8830"
],
"CVE-2009-2605": [
"8831"
],
"CVE-2009-2599": [
"8834"
],
"CVE-2009-3040": [
"8836"
],
"CVE-2009-4208": [
"8839"
],
"CVE-2009-2603": [
"8840"
],
"CVE-2009-1949": [
"8841"
],
"CVE-2009-1948": [
"8841"
],
"CVE-2009-1947": [
"8841"
],
"CVE-2009-2598": [
"8844",
"8854"
],
"CVE-2009-2601": [
"8847"
],
"CVE-2009-2602": [
"8849"
],
"CVE-2009-1941": [
"8850"
],
"CVE-2009-1946": [
"8851"
],
"CVE-2009-2606": [
"8852"
],
"CVE-2009-2037": [
"8853"
],
"CVE-2009-4205": [
"8856"
],
"CVE-2009-4204": [
"8856"
],
"CVE-2009-1945": [
"8857"
],
"CVE-2009-1952": [
"8858"
],
"CVE-2009-1951": [
"8858"
],
"CVE-2009-1950": [
"8859"
],
"CVE-2009-4198": [
"8864"
],
"CVE-2009-2168": [
"8865"
],
"CVE-2009-2167": [
"8865"
],
"CVE-2009-4200": [
"8867"
],
"CVE-2009-2166": [
"8868"
],
"CVE-2009-4202": [
"8870"
],
"CVE-2009-4836": [
"8871"
],
"CVE-2009-4199": [
"8872"
],
"CVE-2009-2164": [
"8884",
"8885"
],
"CVE-2009-2018": [
"8886"
],
"CVE-2009-2024": [
"8889"
],
"CVE-2009-2022": [
"8890"
],
"CVE-2009-2014": [
"8891"
],
"CVE-2009-2021": [
"8892"
],
"CVE-2009-2017": [
"8893"
],
"CVE-2009-2016": [
"8894"
],
"CVE-2009-2640": [
"8895"
],
"CVE-2009-2015": [
"8898"
],
"CVE-2009-2013": [
"8900"
],
"CVE-2009-2020": [
"8901"
],
"CVE-2009-2019": [
"8901"
],
"CVE-2009-2040": [
"8902"
],
"CVE-2009-2025": [
"8903"
],
"CVE-2009-2023": [
"8906"
],
"CVE-2009-2637": [
"8908"
],
"CVE-2009-2638": [
"8911"
],
"CVE-2009-2634": [
"8912"
],
"CVE-2009-2639": [
"8917"
],
"CVE-2009-2080": [
"8917"
],
"CVE-2009-2635": [
"8919"
],
"CVE-2009-2633": [
"8920"
],
"CVE-2009-1151": [
"8921",
"8992",
"16913"
],
"CVE-2009-2641": [
"8924"
],
"CVE-2009-2642": [
"8925"
],
"CVE-2009-2036": [
"8927"
],
"CVE-2009-2081": [
"8928"
],
"CVE-2009-2101": [
"8931"
],
"CVE-2009-2034": [
"8932"
],
"CVE-2009-2033": [
"8932"
],
"CVE-2009-2142": [
"8935"
],
"CVE-2009-2132": [
"8936"
],
"CVE-2009-2131": [
"8936"
],
"CVE-2009-2150": [
"8937"
],
"CVE-2009-2149": [
"8937"
],
"CVE-2009-2148": [
"8937"
],
"CVE-2009-2147": [
"8939"
],
"CVE-2009-2134": [
"8941"
],
"CVE-2009-2133": [
"8941"
],
"CVE-2009-2141": [
"8942"
],
"CVE-2009-2138": [
"8942"
],
"CVE-2009-2145": [
"8943"
],
"CVE-2009-2100": [
"8946"
],
"CVE-2009-2154": [
"8947"
],
"CVE-2009-2153": [
"8947"
],
"CVE-2009-2095": [
"8948"
],
"CVE-2009-2146": [
"8949"
],
"CVE-2009-1777": [
"8950"
],
"CVE-2009-1776": [
"8950"
],
"CVE-2009-2111": [
"8951"
],
"CVE-2009-2110": [
"8952"
],
"CVE-2009-2130": [
"8953"
],
"CVE-2009-2129": [
"8953"
],
"CVE-2009-2127": [
"8953"
],
"CVE-2009-2124": [
"8953"
],
"CVE-2009-2123": [
"8953"
],
"CVE-2009-2152": [
"8954"
],
"CVE-2009-2151": [
"8954"
],
"CVE-2009-2161": [
"8958"
],
"CVE-2009-2160": [
"8958"
],
"CVE-2009-2159": [
"8958"
],
"CVE-2009-2158": [
"8958"
],
"CVE-2009-2157": [
"8958"
],
"CVE-2009-2156": [
"8958"
],
"CVE-2009-2099": [
"8959"
],
"CVE-2009-2122": [
"8961"
],
"CVE-2009-2096": [
"8962"
],
"CVE-2009-2172": [
"8965"
],
"CVE-2009-2098": [
"8966"
],
"CVE-2009-2102": [
"8968"
],
"CVE-2009-2112": [
"8975"
],
"CVE-2009-2120": [
"8977"
],
"CVE-2009-2177": [
"8978"
],
"CVE-2009-2176": [
"8978"
],
"CVE-2009-2109": [
"8979"
],
"CVE-2009-2113": [
"8980"
],
"CVE-2009-2117": [
"8981"
],
"CVE-2009-2231": [
"8987"
],
"CVE-2009-2180": [
"8988"
],
"CVE-2009-2179": [
"8990"
],
"CVE-2009-2178": [
"8990"
],
"CVE-2009-2233": [
"8994"
],
"CVE-2009-2183": [
"8995"
],
"CVE-2009-2182": [
"8995"
],
"CVE-2009-2181": [
"8995"
],
"CVE-2009-2184": [
"8996"
],
"CVE-2009-2229": [
"8997"
],
"CVE-2009-2228": [
"8997"
],
"CVE-2009-2209": [
"9000"
],
"CVE-2009-2230": [
"9001"
],
"CVE-2009-2255": [
"9004"
],
"CVE-2009-2254": [
"9005"
],
"CVE-2009-2219": [
"9008"
],
"CVE-2009-2218": [
"9008"
],
"CVE-2009-2220": [
"9012"
],
"CVE-2009-2402": [
"9014"
],
"CVE-2009-2401": [
"9014"
],
"CVE-2009-2223": [
"9015"
],
"CVE-2009-2609": [
"9016"
],
"CVE-2009-2607": [
"9017"
],
"CVE-2009-2611": [
"9018"
],
"CVE-2009-2618": [
"9021"
],
"CVE-2009-2393": [
"9022"
],
"CVE-2009-2392": [
"9022"
],
"CVE-2009-2391": [
"9022"
],
"CVE-2009-2608": [
"9023"
],
"CVE-2009-2259": [
"9023"
],
"CVE-2009-2366": [
"9024"
],
"CVE-2009-2263": [
"9025"
],
"CVE-2009-2394": [
"9027"
],
"CVE-2009-2400": [
"9028"
],
"CVE-2009-2395": [
"9030"
],
"CVE-2009-2361": [
"9032"
],
"CVE-2009-2398": [
"9036"
],
"CVE-2009-2325": [
"9037"
],
"CVE-2009-2390": [
"9040"
],
"CVE-2009-2397": [
"9041"
],
"CVE-2009-2389": [
"9042"
],
"CVE-2009-2396": [
"9043"
],
"CVE-2009-2399": [
"9044"
],
"CVE-2009-2385": [
"9050"
],
"CVE-2009-2378": [
"9051"
],
"CVE-2009-2379": [
"9052"
],
"CVE-2009-2382": [
"9053"
],
"CVE-2009-2383": [
"9054"
],
"CVE-2009-2308": [
"9055"
],
"CVE-2009-2307": [
"9056"
],
"CVE-2009-2276": [
"9058"
],
"CVE-2009-2329": [
"9068"
],
"CVE-2009-2328": [
"9068"
],
"CVE-2009-2327": [
"9068"
],
"CVE-2009-2326": [
"9068"
],
"CVE-2009-2333": [
"9069"
],
"CVE-2009-2332": [
"9069"
],
"CVE-2009-2331": [
"9069"
],
"CVE-2009-2330": [
"9069"
],
"CVE-2009-2344": [
"9074"
],
"CVE-2009-2388": [
"9079"
],
"CVE-2009-2340": [
"9079"
],
"CVE-2009-2341": [
"9080"
],
"CVE-2009-2339": [
"9081"
],
"CVE-2009-3535": [
"9089"
],
"CVE-2009-2585": [
"9091"
],
"CVE-2009-4874": [
"9095"
],
"CVE-2009-4854": [
"9095"
],
"CVE-2009-2443": [
"9098"
],
"CVE-2009-3531": [
"9099"
],
"CVE-2009-3756": [
"9101"
],
"CVE-2009-3755": [
"9101"
],
"CVE-2009-3754": [
"9101"
],
"CVE-2009-3825": [
"9103"
],
"CVE-2009-3528": [
"9105"
],
"CVE-2009-3543": [
"9107"
],
"CVE-2009-3750": [
"9109"
],
"CVE-2009-2334": [
"9110"
],
"CVE-2009-2427": [
"9111"
],
"CVE-2009-3597": [
"9115"
],
"CVE-2009-2424": [
"9118"
],
"CVE-2009-2423": [
"9118"
],
"CVE-2009-3534": [
"9119"
],
"CVE-2009-3713": [
"9121"
],
"CVE-2009-3753": [
"9122"
],
"CVE-2009-3752": [
"9122"
],
"CVE-2009-3751": [
"9122"
],
"CVE-2009-3712": [
"9125"
],
"CVE-2009-2594": [
"9129"
],
"CVE-2009-2593": [
"9129"
],
"CVE-2009-2925": [
"9140"
],
"CVE-2009-3823": [
"9144"
],
"CVE-2009-4748": [
"9150"
],
"CVE-2009-2557": [
"9153"
],
"CVE-2009-4566": [
"9154"
],
"CVE-2009-4564": [
"9154"
],
"CVE-2009-3541": [
"9155"
],
"CVE-2009-3824": [
"9156"
],
"CVE-2009-3949": [
"9159"
],
"CVE-2009-2558": [
"9161"
],
"CVE-2009-4560": [
"9162"
],
"CVE-2009-4561": [
"9165"
],
"CVE-2009-4563": [
"9166"
],
"CVE-2009-4562": [
"9166"
],
"CVE-2009-3595": [
"9171"
],
"CVE-2009-4749": [
"9174"
],
"CVE-2009-2552": [
"9179"
],
"CVE-2009-2553": [
"9180"
],
"CVE-2009-3596": [
"9182"
],
"CVE-2009-3719": [
"9183"
],
"CVE-2009-3718": [
"9183"
],
"CVE-2009-4683": [
"9185"
],
"CVE-2009-4682": [
"9185"
],
"CVE-2009-2554": [
"9187"
],
"CVE-2009-3530": [
"9194"
],
"CVE-2009-3529": [
"9194"
],
"CVE-2009-4695": [
"9195"
],
"CVE-2009-4694": [
"9195"
],
"CVE-2009-4692": [
"9195"
],
"CVE-2009-4697": [
"9196"
],
"CVE-2009-4696": [
"9196"
],
"CVE-2009-4687": [
"9202"
],
"CVE-2009-4876": [
"9203"
],
"CVE-2009-4693": [
"9204"
],
"CVE-2009-3716": [
"9205"
],
"CVE-2009-3715": [
"9205"
],
"CVE-2009-3714": [
"9205"
],
"CVE-2009-2439": [
"9211",
"12333"
],
"CVE-2009-2591": [
"9217"
],
"CVE-2009-2770": [
"9219"
],
"CVE-2009-4681": [
"9226"
],
"CVE-2009-4680": [
"9226"
],
"CVE-2009-3219": [
"9237"
],
"CVE-2009-3218": [
"9237"
],
"CVE-2009-2881": [
"9246"
],
"CVE-2009-2883": [
"9248"
],
"CVE-2009-4714": [
"9249"
],
"CVE-2009-4713": [
"9249"
],
"CVE-2009-4698": [
"9249",
"9261"
],
"CVE-2009-2851": [
"9250"
],
"CVE-2009-2892": [
"9252"
],
"CVE-2009-4987": [
"9256"
],
"CVE-2009-2922": [
"9257"
],
"CVE-2009-3155": [
"9258"
],
"CVE-2009-3154": [
"9258"
],
"CVE-2009-4739": [
"9260"
],
"CVE-2009-4700": [
"9260"
],
"CVE-2009-4699": [
"9260"
],
"CVE-2009-2778": [
"9262"
],
"CVE-2009-2777": [
"9262"
],
"CVE-2009-2895": [
"9263"
],
"CVE-2009-3217": [
"9266"
],
"CVE-2009-3216": [
"9266"
],
"CVE-2009-2773": [
"9269"
],
"CVE-2009-3224": [
"9270"
],
"CVE-2009-3223": [
"9271"
],
"CVE-2009-3430": [
"9273"
],
"CVE-2009-4735": [
"9274"
],
"CVE-2009-4734": [
"9275"
],
"CVE-2009-3215": [
"9276"
],
"CVE-2009-4722": [
"9281"
],
"CVE-2009-2774": [
"9287"
],
"CVE-2009-2775": [
"9288"
],
"CVE-2009-2786": [
"9289"
],
"CVE-2009-3423": [
"9292"
],
"CVE-2009-3421": [
"9293"
],
"CVE-2009-3422": [
"9294"
],
"CVE-2011-4908": [
"9296",
"9926"
],
"CVE-2009-2769": [
"9297"
],
"CVE-2009-3151": [
"9307"
],
"CVE-2009-3511": [
"9308"
],
"CVE-2009-2784": [
"9310"
],
"CVE-2009-3507": [
"9311"
],
"CVE-2009-3506": [
"9311"
],
"CVE-2009-3515": [
"9312"
],
"CVE-2009-3514": [
"9312"
],
"CVE-2009-2792": [
"9313"
],
"CVE-2009-3508": [
"9314"
],
"CVE-2009-2787": [
"9315"
],
"CVE-2009-3510": [
"9316"
],
"CVE-2009-2781": [
"9320"
],
"CVE-2009-3424": [
"9322"
],
"CVE-2009-2782": [
"9324"
],
"CVE-2009-3148": [
"9325"
],
"CVE-2009-2788": [
"9327"
],
"CVE-2009-4721": [
"9328"
],
"CVE-2009-2791": [
"9331"
],
"CVE-2009-4727": [
"9332"
],
"CVE-2009-4723": [
"9333"
],
"CVE-2009-4726": [
"9334"
],
"CVE-2009-4732": [
"9335"
],
"CVE-2009-4733": [
"9336"
],
"CVE-2009-3158": [
"9337"
],
"CVE-2009-3420": [
"9338"
],
"CVE-2009-3419": [
"9338"
],
"CVE-2009-4552": [
"9339"
],
"CVE-2009-4551": [
"9339"
],
"CVE-2009-4730": [
"9340"
],
"CVE-2009-4729": [
"9340"
],
"CVE-2009-4728": [
"9341"
],
"CVE-2009-2920": [
"9342"
],
"CVE-2009-3150": [
"9344"
],
"CVE-2009-4725": [
"9347"
],
"CVE-2009-4719": [
"9349"
],
"CVE-2009-3426": [
"9350"
],
"CVE-2009-3425": [
"9350"
],
"CVE-2009-4724": [
"9351",
"34493"
],
"CVE-2009-2921": [
"9353"
],
"CVE-2009-3149": [
"9355"
],
"CVE-2009-4986": [
"9358"
],
"CVE-2009-4978": [
"9365"
],
"CVE-2009-4977": [
"9365"
],
"CVE-2009-4982": [
"9369"
],
"CVE-2009-4985": [
"9370"
],
"CVE-2009-4984": [
"9370"
],
"CVE-2009-2736": [
"9371"
],
"CVE-2009-2735": [
"9371"
],
"CVE-2009-4855": [
"9380"
],
"CVE-2009-4993": [
"9383"
],
"CVE-2009-4992": [
"9383"
],
"CVE-2009-4862": [
"9384"
],
"CVE-2009-5003": [
"9387"
],
"CVE-2009-4871": [
"9389"
],
"CVE-2009-4860": [
"9390"
],
"CVE-2009-4870": [
"9395"
],
"CVE-2009-4544": [
"9396",
"34487"
],
"CVE-2009-4543": [
"9396"
],
"CVE-2009-4542": [
"9397"
],
"CVE-2009-4541": [
"9397"
],
"CVE-2009-4872": [
"9399"
],
"CVE-2009-4546": [
"9400"
],
"CVE-2009-4545": [
"9400"
],
"CVE-2009-4540": [
"9406"
],
"CVE-2009-4550": [
"9408"
],
"CVE-2009-3417": [
"9413"
],
"CVE-2009-3042": [
"9416"
],
"CVE-2009-3418": [
"9424"
],
"CVE-2009-3182": [
"9425",
"9433"
],
"CVE-2009-3181": [
"9425"
],
"CVE-2009-3180": [
"9425"
],
"CVE-2009-3171": [
"9425"
],
"CVE-2009-2852": [
"9431"
],
"CVE-2009-2929": [
"9434"
],
"CVE-2009-2928": [
"9434"
],
"CVE-2009-2926": [
"9438"
],
"CVE-2009-2927": [
"9440"
],
"CVE-2009-2923": [
"9444"
],
"CVE-2009-3203": [
"9447"
],
"CVE-2009-3041": [
"9448"
],
"CVE-2009-3250": [
"9450"
],
"CVE-2009-3249": [
"9450",
"16280"
],
"CVE-2009-3248": [
"9450"
],
"CVE-2009-3247": [
"9450"
],
"CVE-2009-2924": [
"9453"
],
"CVE-2009-3211": [
"9462"
],
"CVE-2009-3208": [
"9465"
],
"CVE-2009-3209": [
"9470"
],
"CVE-2009-3205": [
"9471"
],
"CVE-2009-3975": [
"9481"
],
"CVE-2009-3966": [
"9482"
],
"CVE-2009-3970": [
"9484"
],
"CVE-2009-2960": [
"9485"
],
"CVE-2009-4961": [
"9490"
],
"CVE-2009-3199": [
"9493"
],
"CVE-2009-3968": [
"9497"
],
"CVE-2009-3965": [
"9499"
],
"CVE-2009-3964": [
"9502"
],
"CVE-2009-3971": [
"9504"
],
"CVE-2009-3972": [
"9510"
],
"CVE-2009-4958": [
"9518"
],
"CVE-2009-4614": [
"9522"
],
"CVE-2009-4974": [
"9524"
],
"CVE-2009-4973": [
"9524"
],
"CVE-2009-4627": [
"9525"
],
"CVE-2009-3185": [
"9529"
],
"CVE-2009-3191": [
"9531"
],
"CVE-2009-3190": [
"9531"
],
"CVE-2009-3188": [
"9533"
],
"CVE-2009-3193": [
"9534"
],
"CVE-2009-3116": [
"9535"
],
"CVE-2009-3081": [
"9535"
],
"CVE-2009-3117": [
"9538"
],
"CVE-2009-3082": [
"9538"
],
"CVE-2009-3252": [
"9553",
"34455"
],
"CVE-2009-3246": [
"9555"
],
"CVE-2009-3054": [
"9563"
],
"CVE-2009-3053": [
"9564"
],
"CVE-2009-4478": [
"9565"
],
"CVE-2009-4477": [
"9565"
],
"CVE-2009-3056": [
"9566"
],
"CVE-2009-3052": [
"9569"
],
"CVE-2009-3064": [
"9570"
],
"CVE-2009-3063": [
"9571"
],
"CVE-2009-3055": [
"9572"
],
"CVE-2009-4621": [
"9576"
],
"CVE-2009-3065": [
"9577"
],
"CVE-2009-3062": [
"9578"
],
"CVE-2009-4471": [
"9582"
],
"CVE-2009-4472": [
"9583"
],
"CVE-2009-4474": [
"9588"
],
"CVE-2009-4834": [
"9590"
],
"CVE-2009-4475": [
"9593"
],
"CVE-2009-3173": [
"9599"
],
"CVE-2009-3174": [
"9600"
],
"CVE-2009-4625": [
"9601"
],
"CVE-2009-4628": [
"9602"
],
"CVE-2009-3175": [
"9603"
],
"CVE-2009-4620": [
"9604"
],
"CVE-2009-4106": [
"9605"
],
"CVE-2009-4626": [
"9611"
],
"CVE-2009-4623": [
"9623"
],
"CVE-2009-3666": [
"9625"
],
"CVE-2009-3665": [
"9625"
],
"CVE-2009-3664": [
"9625"
],
"CVE-2009-4616": [
"9630"
],
"CVE-2009-4615": [
"9630"
],
"CVE-2009-4624": [
"9631"
],
"CVE-2009-4617": [
"9632"
],
"CVE-2009-4618": [
"9633"
],
"CVE-2009-4622": [
"9635"
],
"CVE-2009-3367": [
"9636"
],
"CVE-2009-3366": [
"9636"
],
"CVE-2009-3494": [
"9637"
],
"CVE-2009-3356": [
"9639"
],
"CVE-2009-3349": [
"9640"
],
"CVE-2009-3348": [
"9640"
],
"CVE-2009-3361": [
"9647"
],
"CVE-2009-3368": [
"9648"
],
"CVE-2009-3357": [
"9648"
],
"CVE-2009-3335": [
"9653"
],
"CVE-2009-3342": [
"9654"
],
"CVE-2009-3365": [
"9656"
],
"CVE-2009-3336": [
"9665"
],
"CVE-2009-3659": [
"9669"
],
"CVE-2009-3343": [
"9675"
],
"CVE-2009-3660": [
"9681"
],
"CVE-2009-3661": [
"9693"
],
"CVE-2009-3667": [
"9696"
],
"CVE-2009-3669": [
"9697"
],
"CVE-2009-3321": [
"9700"
],
"CVE-2009-3314": [
"9702"
],
"CVE-2009-3312": [
"9703"
],
"CVE-2009-3318": [
"9706"
],
"CVE-2009-3317": [
"9708"
],
"CVE-2009-3309": [
"9710"
],
"CVE-2009-3313": [
"9711"
],
"CVE-2009-3315": [
"9712"
],
"CVE-2009-3316": [
"9713"
],
"CVE-2009-3333": [
"9714"
],
"CVE-2009-3310": [
"9715"
],
"CVE-2009-3306": [
"9716"
],
"CVE-2009-3308": [
"9719"
],
"CVE-2009-3307": [
"9720"
],
"CVE-2009-3325": [
"9721"
],
"CVE-2009-3331": [
"9722"
],
"CVE-2009-3332": [
"9723"
],
"CVE-2009-3323": [
"9724"
],
"CVE-2009-3330": [
"9726"
],
"CVE-2009-3326": [
"9727"
],
"CVE-2009-3324": [
"9728"
],
"CVE-2009-3492": [
"9729"
],
"CVE-2009-3328": [
"9730"
],
"CVE-2009-3327": [
"9730"
],
"CVE-2009-3334": [
"9732"
],
"CVE-2009-3446": [
"9733"
],
"CVE-2009-3642": [
"9809"
],
"CVE-2009-3443": [
"9822"
],
"CVE-2009-3444": [
"9825"
],
"CVE-2009-3440": [
"9828"
],
"CVE-2009-3439": [
"9828"
],
"CVE-2009-3434": [
"9832"
],
"CVE-2009-3438": [
"9833",
"33238"
],
"CVE-2009-3499": [
"9834"
],
"CVE-2009-3502": [
"9836"
],
"CVE-2009-3500": [
"9838"
],
"CVE-2009-3705": [
"9839"
],
"CVE-2009-3503": [
"9841"
],
"CVE-2009-3913": [
"9850"
],
"CVE-2009-3912": [
"9854"
],
"CVE-2009-4554": [
"9856",
"33290",
"33291"
],
"CVE-2009-4743": [
"9857",
"33268"
],
"CVE-2009-2733": [
"9863",
"33281"
],
"CVE-2009-3802": [
"9867"
],
"CVE-2009-1479": [
"9872"
],
"CVE-2009-3902": [
"9873"
],
"CVE-2009-3904": [
"9875"
],
"CVE-2009-3806": [
"9876"
],
"CVE-2009-4610": [
"9887"
],
"CVE-2009-3822": [
"9888"
],
"CVE-2009-3817": [
"9889"
],
"CVE-2009-3835": [
"9891"
],
"CVE-2009-3789": [
"9903",
"33295",
"33296",
"33297",
"33298",
"33299",
"33300",
"33301",
"33302",
"33303",
"33304",
"33305"
],
"CVE-1999-1053": [
"9907",
"16914"
],
"CVE-2009-4512": [
"9922"
],
"CVE-2006-5675": [
"9958"
],
"CVE-2009-3804": [
"9964",
"33307"
],
"CVE-2009-3830": [
"9967"
],
"CVE-2014-2612": [
"33434"
],
"CVE-2009-3787": [
"9979"
],
"CVE-2009-3748": [
"9981"
],
"CVE-2009-4250": [
"10002",
"33343"
],
"CVE-2009-4249": [
"10002",
"33342"
],
"CVE-2009-4175": [
"10002",
"33341"
],
"CVE-2009-4173": [
"10002",
"33344"
],
"CVE-2009-4172": [
"10002",
"33340"
],
"CVE-2009-4742": [
"10003"
],
"CVE-2009-4746": [
"10006"
],
"CVE-2009-4745": [
"10006",
"33282"
],
"CVE-2009-5067": [
"10012"
],
"CVE-2009-2898": [
"10013"
],
"CVE-2007-3010": [
"10031",
"16857",
"30591"
],
"CVE-2009-2734": [
"10042"
],
"CVE-2009-3694": [
"10050"
],
"CVE-2009-4747": [
"10057"
],
"CVE-2009-3565": [
"10061",
"33346"
],
"CVE-2009-3645": [
"10064"
],
"CVE-2009-3644": [
"10067"
],
"CVE-2009-2269": [
"10069"
],
"CVE-2009-4849": [
"10085"
],
"CVE-2009-3890": [
"10089"
],
"CVE-2009-3730": [
"10094",
"33292",
"33293"
],
"CVE-2009-4058": [
"10165"
],
"CVE-2009-4229": [
"10167"
],
"CVE-2009-4767": [
"10168"
],
"CVE-2015-4181": [
"10169"
],
"CVE-2009-4050": [
"10169"
],
"CVE-2009-4086": [
"10170"
],
"CVE-2009-4057": [
"10177"
],
"CVE-2009-4094": [
"10178"
],
"CVE-2009-4093": [
"10180"
],
"CVE-2009-4092": [
"10180"
],
"CVE-2009-4091": [
"10180"
],
"CVE-2011-4906": [
"10183"
],
"CVE-2009-4056": [
"10189"
],
"CVE-2009-4059": [
"10192"
],
"CVE-2009-3828": [
"10209"
],
"CVE-2009-4223": [
"10216"
],
"CVE-2009-4779": [
"10217"
],
"CVE-2009-4082": [
"10218"
],
"CVE-2009-4085": [
"10219"
],
"CVE-2009-4220": [
"10220"
],
"CVE-2009-4120": [
"10224",
"33375"
],
"CVE-2009-4170": [
"10228"
],
"CVE-2009-4096": [
"10231"
],
"CVE-2009-4099": [
"10232"
],
"CVE-2009-4222": [
"10233"
],
"CVE-2010-2543": [
"10234"
],
"CVE-2009-4032": [
"10234",
"33374"
],
"CVE-2009-4104": [
"10238"
],
"CVE-2009-4221": [
"10245"
],
"CVE-2009-4231": [
"10246"
],
"CVE-2009-4224": [
"10246"
],
"CVE-2009-4234": [
"10247"
],
"CVE-2009-4217": [
"10250"
],
"CVE-2009-4785": [
"10252"
],
"CVE-2009-4155": [
"10253"
],
"CVE-2009-4156": [
"10259"
],
"CVE-2009-4784": [
"10272"
],
"CVE-2009-4789": [
"10273"
],
"CVE-2013-0192": [
"10274"
],
"CVE-2009-5068": [
"10274"
],
"CVE-2009-4197": [
"10276"
],
"CVE-2009-4196": [
"10276"
],
"CVE-2009-4783": [
"10290"
],
"CVE-2009-4782": [
"10290"
],
"CVE-2009-4157": [
"10291"
],
"CVE-2009-4263": [
"10299"
],
"CVE-2009-4266": [
"10305"
],
"CVE-2009-4571": [
"10324",
"24108"
],
"CVE-2009-4264": [
"10329"
],
"CVE-2009-4569": [
"10330"
],
"CVE-2009-4567": [
"10354"
],
"CVE-2009-3061": [
"10357"
],
"CVE-2009-4256": [
"10358"
],
"CVE-2009-4613": [
"10361"
],
"CVE-2009-4600": [
"10361"
],
"CVE-2009-4238": [
"10364"
],
"CVE-2009-4237": [
"10364"
],
"CVE-2009-4599": [
"10366",
"12822"
],
"CVE-2009-4598": [
"10367"
],
"CVE-2009-4604": [
"10369"
],
"CVE-2009-4597": [
"10370"
],
"CVE-2009-4596": [
"10370"
],
"CVE-2009-4595": [
"10370"
],
"CVE-2009-4315": [
"10378"
],
"CVE-2009-4908": [
"10379"
],
"CVE-2009-4907": [
"10379"
],
"CVE-2005-0549": [
"10386"
],
"CVE-2005-0548": [
"10386"
],
"CVE-2009-4386": [
"10393"
],
"CVE-2010-4893": [
"14948"
],
"CVE-2006-6377": [
"10403"
],
"CVE-2009-4905": [
"10406"
],
"CVE-2009-4427": [
"10410"
],
"CVE-2009-4906": [
"10412"
],
"CVE-2009-4319": [
"10422"
],
"CVE-2008-1985": [
"10427",
"31701"
],
"CVE-2009-4501": [
"10432"
],
"CVE-2009-4499": [
"10432"
],
"CVE-2009-4827": [
"10433"
],
"CVE-2009-4349": [
"10436"
],
"CVE-2007-0518": [
"10437"
],
"CVE-2009-4828": [
"10438"
],
"CVE-2009-4385": [
"10439"
],
"CVE-2009-4384": [
"10439"
],
"CVE-2009-4826": [
"10444"
],
"CVE-2009-4351": [
"10446"
],
"CVE-2009-2614": [
"10457"
],
"CVE-2009-4366": [
"10458",
"10461"
],
"CVE-2009-4365": [
"10458",
"10461"
],
"CVE-2009-4364": [
"10458",
"10461"
],
"CVE-2009-2365": [
"10464"
],
"CVE-2009-2619": [
"10473"
],
"CVE-2009-4434": [
"10478"
],
"CVE-2009-4433": [
"10478",
"33411",
"33412"
],
"CVE-2009-4375": [
"10479"
],
"CVE-2009-4372": [
"10480"
],
"CVE-2009-4429": [
"10485",
"33410"
],
"CVE-2009-3703": [
"10488"
],
"CVE-2008-3679": [
"10495",
"32230"
],
"CVE-2006-4524": [
"10496",
"28443"
],
"CVE-2009-3701": [
"10512",
"33406",
"33407",
"33408"
],
"CVE-2009-4367": [
"10513"
],
"CVE-2007-5026": [
"10514"
],
"CVE-2009-4437": [
"10520"
],
"CVE-2009-4436": [
"10529"
],
"CVE-2009-4430": [
"10533"
],
"CVE-2009-4403": [
"10534"
],
"CVE-2009-4424": [
"10535"
],
"CVE-2006-0087": [
"10560"
],
"CVE-2009-4818": [
"10568"
],
"CVE-2009-4426": [
"10569"
],
"CVE-2009-4825": [
"10573"
],
"CVE-2007-4527": [
"10574"
],
"CVE-2009-4820": [
"10576"
],
"CVE-2009-4817": [
"10578"
],
"CVE-2009-4819": [
"10584"
],
"CVE-2009-4432": [
"10586"
],
"CVE-2009-4431": [
"10587"
],
"CVE-2009-4468": [
"10598"
],
"CVE-2009-4467": [
"10598"
],
"CVE-2009-4466": [
"10598"
],
"CVE-2009-4465": [
"10598"
],
"CVE-2009-4816": [
"10599"
],
"CVE-2009-4421": [
"10604"
],
"CVE-2009-4423": [
"10606"
],
"CVE-2009-4447": [
"10626"
],
"CVE-2009-5019": [
"10637",
"15544"
],
"CVE-2008-0135": [
"10639"
],
"CVE-2009-4458": [
"10645",
"33442",
"33443"
],
"CVE-2009-4453": [
"10649"
],
"CVE-2009-4678": [
"10653"
],
"CVE-2005-3937": [
"10656",
"26669",
"26670",
"26671",
"26672"
],
"CVE-2005-0952": [
"10667"
],
"CVE-2004-1975": [
"10667"
],
"CVE-2004-1551": [
"10667"
],
"CVE-2009-4469": [
"10668"
],
"CVE-2009-4451": [
"10672"
],
"CVE-2007-3061": [
"10686"
],
"CVE-2009-4461": [
"10688"
],
"CVE-2009-4456": [
"10710"
],
"CVE-2009-4576": [
"10734"
],
"CVE-2009-4578": [
"10737"
],
"CVE-2009-4575": [
"10738"
],
"CVE-2009-4583": [
"10742"
],
"CVE-2009-4679": [
"10754",
"33440"
],
"CVE-2009-4581": [
"10793"
],
"CVE-2009-4450": [
"10806"
],
"CVE-2009-4582": [
"10807"
],
"CVE-2009-4574": [
"10809"
],
"CVE-2009-4585": [
"10823"
],
"CVE-2008-6264": [
"10832"
],
"CVE-2010-0980": [
"10930"
],
"CVE-2010-0982": [
"10942"
],
"CVE-2010-0157": [
"10943"
],
"CVE-2010-2255": [
"10944"
],
"CVE-2010-2259": [
"10946"
],
"CVE-2010-0985": [
"10948"
],
"CVE-2010-0981": [
"10950"
],
"CVE-2010-0945": [
"10953"
],
"CVE-2010-2254": [
"10964"
],
"CVE-2010-0983": [
"10967"
],
"CVE-2010-0158": [
"10971"
],
"CVE-2010-0984": [
"10972"
],
"CVE-2010-0976": [
"10972"
],
"CVE-2010-5017": [
"10978"
],
"CVE-2010-2257": [
"10983"
],
"CVE-2010-2256": [
"10983"
],
"CVE-2010-1363": [
"10988"
],
"CVE-2010-1070": [
"11002"
],
"CVE-2010-0978": [
"11005"
],
"CVE-2010-1065": [
"11015"
],
"CVE-2010-1064": [
"11023"
],
"CVE-2010-0694": [
"11024"
],
"CVE-2010-1066": [
"11025"
],
"CVE-2010-1073": [
"11026"
],
"CVE-2010-0279": [
"11057"
],
"CVE-2010-0946": [
"11068"
],
"CVE-2010-1069": [
"11080"
],
"CVE-2010-0380": [
"11082"
],
"CVE-2010-0376": [
"11082"
],
"CVE-2010-0375": [
"11082"
],
"CVE-2010-1071": [
"11083"
],
"CVE-2010-0944": [
"11088"
],
"CVE-2010-0942": [
"11089"
],
"CVE-2010-0943": [
"11090"
],
"CVE-2010-0939": [
"11096"
],
"CVE-2010-1067": [
"11098"
],
"CVE-2010-1360": [
"11111"
],
"CVE-2010-0372": [
"11140"
],
"CVE-2010-0287": [
"11141"
],
"CVE-2010-0288": [
"11141"
],
"CVE-2009-2894": [
"11164"
],
"CVE-2010-0390": [
"11169"
],
"CVE-2010-0373": [
"11178"
],
"CVE-2010-0458": [
"11216"
],
"CVE-2010-0456": [
"11222"
],
"CVE-2010-0457": [
"11235"
],
"CVE-2010-0461": [
"11237"
],
"CVE-2010-0459": [
"11243"
],
"CVE-2010-0467": [
"11277",
"11282"
],
"CVE-2010-0608": [
"11278"
],
"CVE-2010-0803": [
"11280"
],
"CVE-2010-0796": [
"11287"
],
"CVE-2010-0800": [
"11289"
],
"CVE-2010-0799": [
"11290"
],
"CVE-2010-0795": [
"11292"
],
"CVE-2010-0632": [
"11294"
],
"CVE-2010-0802": [
"11297"
],
"CVE-2010-0630": [
"11306"
],
"CVE-2010-1611": [
"11311"
],
"CVE-2010-0631": [
"11323"
],
"CVE-2010-1047": [
"11329"
],
"CVE-2010-1044": [
"11330"
],
"CVE-2010-1052": [
"11334"
],
"CVE-2010-1051": [
"11334"
],
"CVE-2010-1050": [
"11334"
],
"CVE-2010-0610": [
"11337"
],
"CVE-2010-1053": [
"11345"
],
"CVE-2010-0611": [
"11346"
],
"CVE-2010-1045": [
"11352"
],
"CVE-2010-1046": [
"11356"
],
"CVE-2010-1049": [
"11357"
],
"CVE-2010-1048": [
"11357"
],
"CVE-2010-1043": [
"11359"
],
"CVE-2010-0765": [
"11361"
],
"CVE-2010-0605": [
"11380"
],
"CVE-2010-0764": [
"11382"
],
"CVE-2010-0701": [
"11393"
],
"CVE-2010-0762": [
"11401"
],
"CVE-2010-0761": [
"11402"
],
"CVE-2010-0642": [
"11403"
],
"CVE-2010-0641": [
"11403"
],
"CVE-2008-1470": [
"11405",
"31411"
],
"CVE-2010-0665": [
"11406"
],
"CVE-2010-0690": [
"11409"
],
"CVE-2010-0763": [
"11410"
],
"CVE-2010-0693": [
"11412"
],
"CVE-2010-0674": [
"11434"
],
"CVE-2008-0843": [
"11434"
],
"CVE-2010-0672": [
"11436"
],
"CVE-2010-0681": [
"11437"
],
"CVE-2010-0680": [
"11437"
],
"CVE-2010-0682": [
"11441"
],
"CVE-2010-0691": [
"11445"
],
"CVE-2010-0696": [
"11447"
],
"CVE-2010-0678": [
"11452"
],
"CVE-2010-0677": [
"11452"
],
"CVE-2010-0673": [
"11458"
],
"CVE-2010-0671": [
"11473"
],
"CVE-2010-0709": [
"11477",
"11478"
],
"CVE-2010-0721": [
"11488"
],
"CVE-2010-0720": [
"11489"
],
"CVE-2010-0760": [
"11498"
],
"CVE-2010-0759": [
"11498"
],
"CVE-2010-0698": [
"11507"
],
"CVE-2010-0702": [
"11508"
],
"CVE-2010-1081": [
"11511"
],
"CVE-2010-0707": [
"11516"
],
"CVE-2010-0758": [
"11518"
],
"CVE-2010-0723": [
"11521",
"11522"
],
"CVE-2010-0725": [
"11524"
],
"CVE-2010-0724": [
"11524"
],
"CVE-2010-1077": [
"11526"
],
"CVE-2010-0722": [
"11547"
],
"CVE-2010-0753": [
"11549"
],
"CVE-2012-1913": [
"11560"
],
"CVE-2010-0757": [
"11560"
],
"CVE-2010-0756": [
"11560"
],
"CVE-2010-0755": [
"11560"
],
"CVE-2010-0754": [
"11560"
],
"CVE-2010-1114": [
"11569"
],
"CVE-2010-1113": [
"11569"
],
"CVE-2010-1368": [
"11577"
],
"CVE-2010-1094": [
"11582"
],
"CVE-2010-2134": [
"11584"
],
"CVE-2010-1537": [
"11585"
],
"CVE-2010-1538": [
"11586"
],
"CVE-2010-2138": [
"11587"
],
"CVE-2010-2137": [
"11587"
],
"CVE-2010-1091": [
"11588"
],
"CVE-2010-1090": [
"11588"
],
"CVE-2010-1369": [
"11589"
],
"CVE-2010-1092": [
"11592"
],
"CVE-2010-1366": [
"11593"
],
"CVE-2010-1364": [
"11599",
"12399"
],
"CVE-2010-1365": [
"11600",
"11837"
],
"CVE-2010-2135": [
"11602"
],
"CVE-2010-1089": [
"11609"
],
"CVE-2010-2133": [
"11616"
],
"CVE-2010-1272": [
"11621"
],
"CVE-2010-1271": [
"11623"
],
"CVE-2010-1540": [
"11625"
],
"CVE-2010-0952": [
"11635"
],
"CVE-2009-4018": [
"11636"
],
"CVE-2010-0953": [
"11641"
],
"CVE-2010-0951": [
"11643"
],
"CVE-2010-0948": [
"11646"
],
"CVE-2010-0955": [
"11648",
"12221"
],
"CVE-2010-0958": [
"11655"
],
"CVE-2010-5062": [
"11671"
],
"CVE-2010-5060": [
"11674"
],
"CVE-2010-0975": [
"11678"
],
"CVE-2010-0974": [
"11678"
],
"CVE-2010-0971": [
"11685"
],
"CVE-2010-0964": [
"11689"
],
"CVE-2010-1341": [
"11715"
],
"CVE-2010-0968": [
"11721"
],
"CVE-2010-0967": [
"11721"
],
"CVE-2010-1057": [
"11722"
],
"CVE-2016-6174": [
"40084"
],
"CVE-2010-0973": [
"11733"
],
"CVE-2010-0966": [
"11735"
],
"CVE-2010-0970": [
"11737"
],
"CVE-2010-0972": [
"11738"
],
"CVE-2010-1058": [
"11754"
],
"CVE-2010-1055": [
"11755"
],
"CVE-2010-1219": [
"11757"
],
"CVE-2010-1056": [
"11760"
],
"CVE-2010-1062": [
"11773"
],
"CVE-2010-1060": [
"11775"
],
"CVE-2010-1270": [
"11776",
"11805",
"11912"
],
"CVE-2010-1269": [
"11776",
"11805",
"11912"
],
"CVE-2010-3314": [
"11777"
],
"CVE-2010-3313": [
"11777"
],
"CVE-2010-1345": [
"11785",
"15453"
],
"CVE-2010-1344": [
"11785"
],
"CVE-2010-1217": [
"11814"
],
"CVE-2010-1855": [
"11816"
],
"CVE-2010-1338": [
"11824"
],
"CVE-2010-1267": [
"11831"
],
"CVE-2010-1266": [
"11831"
],
"CVE-2010-1216": [
"11832"
],
"CVE-2010-1346": [
"11835"
],
"CVE-2010-4968": [
"14128"
],
"CVE-2010-1335": [
"11848"
],
"CVE-2010-1875": [
"11851"
],
"CVE-2010-1858": [
"11853"
],
"CVE-2010-1336": [
"11874"
],
"CVE-2010-1268": [
"11876"
],
"CVE-2010-1343": [
"11881"
],
"CVE-2010-1342": [
"11882"
],
"CVE-2010-1265": [
"11884"
],
"CVE-2010-2677": [
"11903"
],
"CVE-2010-2676": [
"11903"
],
"CVE-2007-5235": [
"11906",
"30633"
],
"CVE-2010-2673": [
"11922"
],
"CVE-2010-2675": [
"11923"
],
"CVE-2010-2674": [
"11923"
],
"CVE-2010-1309": [
"11938"
],
"CVE-2008-7254": [
"11938"
],
"CVE-2010-2335": [
"11947",
"13845"
],
"CVE-2010-1300": [
"11947",
"13845",
"13849",
"13857"
],
"CVE-2010-1302": [
"11978"
],
"CVE-2010-1301": [
"11979"
],
"CVE-2010-1299": [
"11994",
"12018"
],
"CVE-2010-1873": [
"11997",
"12190"
],
"CVE-2010-1304": [
"11998"
],
"CVE-2010-1315": [
"11999"
],
"CVE-2010-3884": [
"12009"
],
"CVE-2009-3119": [
"12028"
],
"CVE-2010-1350": [
"12037",
"12191"
],
"CVE-2010-1351": [
"12047"
],
"CVE-2010-1528": [
"12049"
],
"CVE-2010-1531": [
"12054"
],
"CVE-2010-1983": [
"12055"
],
"CVE-2010-1306": [
"12058"
],
"CVE-2010-1305": [
"12065"
],
"CVE-2010-1308": [
"12066"
],
"CVE-2010-1534": [
"12067"
],
"CVE-2010-1353": [
"12068"
],
"CVE-2010-1307": [
"12070"
],
"CVE-2010-1312": [
"12077"
],
"CVE-2010-1529": [
"12078"
],
"CVE-2010-1313": [
"12082"
],
"CVE-2010-1977": [
"12083"
],
"CVE-2010-1352": [
"12084"
],
"CVE-2010-1980": [
"12085"
],
"CVE-2010-1314": [
"12086"
],
"CVE-2010-1981": [
"12087"
],
"CVE-2010-1979": [
"12088"
],
"CVE-2010-5053": [
"12097"
],
"CVE-2010-1186": [
"12098"
],
"CVE-2010-1354": [
"12102"
],
"CVE-2010-1494": [
"12113"
],
"CVE-2010-1493": [
"12113"
],
"CVE-2010-1532": [
"12118"
],
"CVE-2010-2920": [
"12120"
],
"CVE-2010-1982": [
"12121"
],
"CVE-2010-1716": [
"12132"
],
"CVE-2010-1874": [
"12136"
],
"CVE-2010-1533": [
"12142"
],
"CVE-2010-1478": [
"12145"
],
"CVE-2010-1469": [
"12146"
],
"CVE-2010-1475": [
"12147"
],
"CVE-2010-1480": [
"12148",
"21221"
],
"CVE-2010-1479": [
"12148",
"21221"
],
"CVE-2010-1476": [
"12150"
],
"CVE-2010-1535": [
"12151"
],
"CVE-2010-5016": [
"12158"
],
"CVE-2010-1468": [
"12159"
],
"CVE-2004-1796": [
"12160",
"23517",
"23518"
],
"CVE-2005-1882": [
"12164"
],
"CVE-2010-1470": [
"12166"
],
"CVE-2010-1472": [
"12167"
],
"CVE-2010-1714": [
"12168"
],
"CVE-2010-1471": [
"12170"
],
"CVE-2010-1473": [
"12171"
],
"CVE-2010-1715": [
"12174"
],
"CVE-2010-1722": [
"12177"
],
"CVE-2010-1474": [
"12182"
],
"CVE-2010-1559": [
"12184"
],
"CVE-2010-1477": [
"12184"
],
"CVE-2010-1467": [
"12193"
],
"CVE-2010-1466": [
"12193"
],
"CVE-2010-1720": [
"12200",
"12723"
],
"CVE-2010-5055": [
"12220"
],
"CVE-2010-1461": [
"12232"
],
"CVE-2010-1719": [
"12233"
],
"CVE-2010-1600": [
"12234"
],
"CVE-2010-1957": [
"12235"
],
"CVE-2010-1601": [
"12236"
],
"CVE-2010-1955": [
"12238"
],
"CVE-2010-1952": [
"12239"
],
"CVE-2010-1721": [
"12246"
],
"CVE-2010-1951": [
"12249"
],
"CVE-2010-1711": [
"12260"
],
"CVE-2010-1710": [
"12260"
],
"CVE-2010-1496": [
"12269"
],
"CVE-2006-5918": [
"12272"
],
"CVE-2010-1498": [
"12280"
],
"CVE-2010-1497": [
"12280"
],
"CVE-2010-1718": [
"12282"
],
"CVE-2010-1602": [
"12283"
],
"CVE-2010-1603": [
"12284"
],
"CVE-2010-1956": [
"12285"
],
"CVE-2010-1495": [
"12286"
],
"CVE-2010-1954": [
"12287"
],
"CVE-2010-1953": [
"12288"
],
"CVE-2010-1723": [
"12289"
],
"CVE-2010-1717": [
"12291"
],
"CVE-2010-5056": [
"12299"
],
"CVE-2010-5058": [
"12301"
],
"CVE-2010-5057": [
"12301"
],
"CVE-2010-1499": [
"12303"
],
"CVE-2010-1950": [
"12305"
],
"CVE-2010-1949": [
"12305"
],
"CVE-2010-1877": [
"12306"
],
"CVE-2010-1947": [
"12313"
],
"CVE-2010-1946": [
"12313"
],
"CVE-2010-1607": [
"12316"
],
"CVE-2010-1878": [
"12317"
],
"CVE-2010-1491": [
"12318"
],
"CVE-2010-1712": [
"12323"
],
"CVE-2010-1486": [
"12329"
],
"CVE-2010-1431": [
"12338"
],
"CVE-2009-2779": [
"12346"
],
"CVE-2010-1876": [
"12349"
],
"CVE-2010-1599": [
"12354"
],
"CVE-2010-1935": [
"12364"
],
"CVE-2010-1934": [
"12365"
],
"CVE-2010-1928": [
"12365"
],
"CVE-2010-1948": [
"12366"
],
"CVE-2010-1945": [
"12366"
],
"CVE-2010-1606": [
"12370"
],
"CVE-2010-1604": [
"12370"
],
"CVE-2010-1702": [
"12371"
],
"CVE-2007-4085": [
"12372"
],
"CVE-2010-1704": [
"12395"
],
"CVE-2010-1703": [
"12395"
],
"CVE-2010-1936": [
"12396"
],
"CVE-2010-1927": [
"12398"
],
"CVE-2010-1926": [
"12398"
],
"CVE-2009-4822": [
"12402",
"33424"
],
"CVE-2010-5059": [
"12407"
],
"CVE-2010-1713": [
"12410"
],
"CVE-2010-1708": [
"12411"
],
"CVE-2010-1706": [
"12414"
],
"CVE-2010-1654": [
"12415"
],
"CVE-2010-1662": [
"12416"
],
"CVE-2010-1661": [
"12416"
],
"CVE-2010-1652": [
"12421"
],
"CVE-2010-1660": [
"12423"
],
"CVE-2010-1659": [
"12426"
],
"CVE-2010-1658": [
"12427"
],
"CVE-2010-1657": [
"12428"
],
"CVE-2010-1656": [
"12429"
],
"CVE-2010-1653": [
"12430"
],
"CVE-2006-3271": [
"12438",
"28093",
"28094",
"28095",
"28096"
],
"CVE-2005-3817": [
"12439",
"26580",
"26581",
"26582",
"26583"
],
"CVE-2010-2039": [
"12441"
],
"CVE-2010-1705": [
"12443"
],
"CVE-2010-1701": [
"12444"
],
"CVE-2010-0817": [
"12450"
],
"CVE-2010-2853": [
"12451"
],
"CVE-2010-1583": [
"12452"
],
"CVE-2010-1743": [
"12458"
],
"CVE-2010-1742": [
"12458"
],
"CVE-2010-1726": [
"12459"
],
"CVE-2010-1744": [
"12460"
],
"CVE-2010-1727": [
"12461"
],
"CVE-2010-0711": [
"12464"
],
"CVE-2010-1739": [
"12465"
],
"CVE-2010-1725": [
"12468"
],
"CVE-2010-1746": [
"12473"
],
"CVE-2010-1999": [
"12475"
],
"CVE-2010-1944": [
"12476"
],
"CVE-2010-1740": [
"12484"
],
"CVE-2010-1921": [
"12486"
],
"CVE-2010-1920": [
"12486"
],
"CVE-2010-1737": [
"12488"
],
"CVE-2010-2610": [
"14025"
],
"CVE-2014-9558": [
"12507"
],
"CVE-2009-1443": [
"12520"
],
"CVE-2009-3504": [
"12543"
],
"CVE-2010-1924": [
"12545"
],
"CVE-2010-1925": [
"12552"
],
"CVE-2010-1922": [
"12558"
],
"CVE-2010-2044": [
"12590"
],
"CVE-2010-2045": [
"12595"
],
"CVE-2010-5047": [
"12597"
],
"CVE-2010-2129": [
"12598"
],
"CVE-2010-5028": [
"12601",
"12782"
],
"CVE-2010-2128": [
"12607"
],
"CVE-2010-2050": [
"12611"
],
"CVE-2010-2122": [
"12618",
"12623"
],
"CVE-2010-2016": [
"12620"
],
"CVE-2010-2047": [
"12641"
],
"CVE-2010-2018": [
"12651"
],
"CVE-2010-0475": [
"12660"
],
"CVE-2010-2051": [
"12661"
],
"CVE-2006-7052": [
"28046",
"28039",
"28040",
"28041",
"28042",
"28043",
"28045"
],
"CVE-2006-3185": [
"28047"
],
"CVE-2006-3314": [
"28048"
],
"CVE-2010-2124": [
"12684"
],
"CVE-2010-2127": [
"12688"
],
"CVE-2010-2103": [
"12689"
],
"CVE-2010-2700": [
"14322"
],
"CVE-2010-2699": [
"14322"
],
"CVE-2010-2042": [
"12702"
],
"CVE-2010-5039": [
"12703"
],
"CVE-2010-2099": [
"12715"
],
"CVE-2010-2015": [
"12727"
],
"CVE-2010-2091": [
"12728"
],
"CVE-2010-2141": [
"12735"
],
"CVE-2010-2148": [
"12779"
],
"CVE-2010-2147": [
"12779"
],
"CVE-2010-5032": [
"12780",
"12796"
],
"CVE-2010-5033": [
"12786"
],
"CVE-2010-5041": [
"12787"
],
"CVE-2010-5040": [
"12787"
],
"CVE-2010-2314": [
"12790"
],
"CVE-2010-2144": [
"12805"
],
"CVE-2010-2154": [
"12806"
],
"CVE-2010-2143": [
"12809"
],
"CVE-2010-2146": [
"12820"
],
"CVE-2010-2313": [
"12848"
],
"CVE-2010-2315": [
"12855"
],
"CVE-2007-3212": [
"30170"
],
"CVE-2010-5043": [
"13737"
],
"CVE-2010-5042": [
"13737"
],
"CVE-2010-2317": [
"13739"
],
"CVE-2010-2316": [
"13739"
],
"CVE-2007-3137": [
"13739",
"30162"
],
"CVE-2010-5036": [
"13740"
],
"CVE-2010-5035": [
"13740"
],
"CVE-2010-5034": [
"13741"
],
"CVE-2010-5044": [
"13745",
"13746"
],
"CVE-2010-2319": [
"13749"
],
"CVE-2010-5037": [
"13762"
],
"CVE-2010-5000": [
"13766"
],
"CVE-2010-2312": [
"13784"
],
"CVE-2010-2356": [
"13785"
],
"CVE-2010-2355": [
"13785"
],
"CVE-2010-2354": [
"13785"
],
"CVE-2010-5013": [
"13789"
],
"CVE-2010-2342": [
"13793"
],
"CVE-2006-2899": [
"27972"
],
"CVE-2006-2877": [
"27973",
"27974",
"27975",
"27976"
],
"CVE-2010-5027": [
"13801"
],
"CVE-2010-5026": [
"13801"
],
"CVE-2010-2357": [
"13802"
],
"CVE-2010-5011": [
"13812"
],
"CVE-2010-5010": [
"13812"
],
"CVE-2010-4967": [
"13815"
],
"CVE-2010-5012": [
"13830"
],
"CVE-2010-4998": [
"13832"
],
"CVE-2010-2338": [
"13842"
],
"CVE-2010-5008": [
"13843"
],
"CVE-2010-2336": [
"13845"
],
"CVE-2010-2334": [
"13845",
"13856"
],
"CVE-2010-5009": [
"13854"
],
"CVE-2010-5007": [
"13854"
],
"CVE-2010-5021": [
"13859"
],
"CVE-2010-5023": [
"13860"
],
"CVE-2010-5045": [
"13880"
],
"CVE-2010-2358": [
"13889"
],
"CVE-2010-2341": [
"13890"
],
"CVE-2010-5019": [
"13894"
],
"CVE-2010-5018": [
"13894"
],
"CVE-2010-1622": [
"13918"
],
"CVE-2010-4981": [
"13929"
],
"CVE-2010-2464": [
"13935"
],
"CVE-2010-5014": [
"13936"
],
"CVE-2010-5020": [
"13945"
],
"CVE-2010-0804": [
"13945"
],
"CVE-2010-2461": [
"13946"
],
"CVE-2010-2462": [
"13948"
],
"CVE-2010-2460": [
"13949"
],
"CVE-2010-2438": [
"13954"
],
"CVE-2010-2456": [
"13964"
],
"CVE-2010-2459": [
"13970"
],
"CVE-2010-2458": [
"13970"
],
"CVE-2010-2609": [
"13978"
],
"CVE-2010-5287": [
"13980"
],
"CVE-2010-2507": [
"13981"
],
"CVE-2010-2688": [
"13990"
],
"CVE-2010-2687": [
"13990",
"13995"
],
"CVE-2010-2457": [
"13993"
],
"CVE-2005-3868": [
"13993",
"26619"
],
"CVE-2010-4365": [
"13997",
"15610"
],
"CVE-2010-2513": [
"13997",
"15610"
],
"CVE-2010-2511": [
"14005"
],
"CVE-2010-2512": [
"14008"
],
"CVE-2010-2618": [
"14016",
"15237"
],
"CVE-2010-2682": [
"14017"
],
"CVE-2010-2508": [
"14018"
],
"CVE-2010-2510": [
"14020"
],
"CVE-2010-2509": [
"14020"
],
"CVE-2010-2691": [
"14048"
],
"CVE-2010-5022": [
"14054"
],
"CVE-2010-2681": [
"14055"
],
"CVE-2010-2613": [
"14059"
],
"CVE-2010-2680": [
"14064"
],
"CVE-2010-5004": [
"14074"
],
"CVE-2010-2611": [
"14079"
],
"CVE-2010-4997": [
"14084"
],
"CVE-2010-2685": [
"14089"
],
"CVE-2010-2684": [
"14089"
],
"CVE-2010-4972": [
"14107"
],
"CVE-2010-5029": [
"14104"
],
"CVE-2010-2683": [
"14112"
],
"CVE-2010-1931": [
"14117"
],
"CVE-2010-2857": [
"14274"
],
"CVE-2010-2689": [
"14123"
],
"CVE-2010-2690": [
"14126"
],
"CVE-2010-2622": [
"14127"
],
"CVE-2010-2623": [
"14144"
],
"CVE-2010-4980": [
"14163",
"19775"
],
"CVE-2010-4983": [
"14164"
],
"CVE-2010-2624": [
"14162"
],
"CVE-2010-4989": [
"14192"
],
"CVE-2010-4988": [
"14186"
],
"CVE-2010-4993": [
"14187"
],
"CVE-2010-4975": [
"14196"
],
"CVE-2010-2719": [
"14199"
],
"CVE-2010-2720": [
"14201"
],
"CVE-2010-2715": [
"14203"
],
"CVE-2010-2714": [
"14203"
],
"CVE-2010-4999": [
"14205"
],
"CVE-2010-5001": [
"14206"
],
"CVE-2010-4990": [
"14210"
],
"CVE-2010-4991": [
"14211"
],
"CVE-2010-4970": [
"14217"
],
"CVE-2010-4995": [
"14250"
],
"CVE-2010-2670": [
"14224"
],
"CVE-2010-2656": [
"14237"
],
"CVE-2010-2655": [
"14237"
],
"CVE-2010-2654": [
"14237"
],
"CVE-2010-4974": [
"14239"
],
"CVE-2010-4969": [
"14241"
],
"CVE-2010-2721": [
"14244"
],
"CVE-2010-5003": [
"14249"
],
"CVE-2010-2716": [
"14251"
],
"CVE-2010-3213": [
"14285"
],
"CVE-2010-2698": [
"14260"
],
"CVE-2010-2697": [
"14260"
],
"CVE-2010-2696": [
"14260"
],
"CVE-2010-4986": [
"14262"
],
"CVE-2010-2848": [
"14263"
],
"CVE-2010-2847": [
"14263"
],
"CVE-2010-2846": [
"14263"
],
"CVE-2010-4992": [
"14265"
],
"CVE-2010-4987": [
"14281"
],
"CVE-2010-2694": [
"14312",
"27532"
],
"CVE-2010-2845": [
"14296"
],
"CVE-2010-4985": [
"14325"
],
"CVE-2010-4984": [
"14325"
],
"CVE-2010-4982": [
"14326"
],
"CVE-2010-2282": [
"14331"
],
"CVE-2010-2615": [
"14342"
],
"CVE-2010-2917": [
"14354"
],
"CVE-2010-2905": [
"14370"
],
"CVE-2010-2906": [
"14371"
],
"CVE-2010-4959": [
"14378"
],
"CVE-2010-2912": [
"14392",
"14404"
],
"CVE-2010-2911": [
"14392",
"14404"
],
"CVE-2010-2919": [
"14395"
],
"CVE-2010-2915": [
"14435"
],
"CVE-2010-2916": [
"14436"
],
"CVE-2010-4948": [
"14438"
],
"CVE-2010-2924": [
"14441"
],
"CVE-2010-2921": [
"14448"
],
"CVE-2010-2907": [
"14449"
],
"CVE-2005-0929": [
"14453",
"25311",
"25312"
],
"CVE-2004-0239": [
"14453"
],
"CVE-2010-2922": [
"14461"
],
"CVE-2010-2910": [
"14462"
],
"CVE-2010-2926": [
"14465"
],
"CVE-2010-2908": [
"14466"
],
"CVE-2010-2923": [
"14467"
],
"CVE-2010-2925": [
"14474"
],
"CVE-2010-2918": [
"14476",
"31708"
],
"CVE-2010-2909": [
"14481"
],
"CVE-2010-2850": [
"14485"
],
"CVE-2010-2933": [
"14494"
],
"CVE-2010-4945": [
"14530"
],
"CVE-2010-4925": [
"14556"
],
"CVE-2010-4955": [
"14559"
],
"CVE-2010-3030": [
"14562"
],
"CVE-2010-3026": [
"14562"
],
"CVE-2010-3024": [
"14565"
],
"CVE-2010-3027": [
"14572"
],
"CVE-2010-3029": [
"14578"
],
"CVE-2010-4941": [
"14598"
],
"CVE-2010-5083": [
"14589"
],
"CVE-2010-4937": [
"14596"
],
"CVE-2010-4924": [
"14614"
],
"CVE-2010-4943": [
"14618"
],
"CVE-2010-4934": [
"14637"
],
"CVE-2010-4939": [
"14639"
],
"CVE-2010-4931": [
"14647"
],
"CVE-2010-4298": [
"14672",
"15608"
],
"CVE-2010-3742": [
"14672"
],
"CVE-2010-3307": [
"14672"
],
"CVE-2008-2094": [
"14828",
"31681"
],
"CVE-2010-4878": [
"14809"
],
"CVE-2010-4884": [
"14810"
],
"CVE-2010-3204": [
"14815"
],
"CVE-2010-3206": [
"14822"
],
"CVE-2010-3205": [
"14823"
],
"CVE-2010-3207": [
"14826"
],
"CVE-2010-3210": [
"14835"
],
"CVE-2010-3212": [
"14838"
],
"CVE-2010-3209": [
"14841"
],
"CVE-2010-3203": [
"14845"
],
"CVE-2010-3211": [
"14846"
],
"CVE-2010-4876": [
"14849"
],
"CVE-2010-4879": [
"14851"
],
"CVE-2010-4911": [
"14891"
],
"CVE-2010-4914": [
"14893"
],
"CVE-2010-4917": [
"14894"
],
"CVE-2010-4918": [
"14896"
],
"CVE-2010-4895": [
"14897"
],
"CVE-2010-4894": [
"14897"
],
"CVE-2010-4902": [
"14901",
"14902"
],
"CVE-2010-4921": [
"14908"
],
"CVE-2010-4905": [
"14910"
],
"CVE-2010-4898": [
"14911"
],
"CVE-2010-4910": [
"14932"
],
"CVE-2010-4919": [
"14914"
],
"CVE-2010-4920": [
"14919"
],
"CVE-2010-4904": [
"14922"
],
"CVE-2010-4915": [
"14933"
],
"CVE-2010-4916": [
"14935"
],
"CVE-2010-4913": [
"14935"
],
"CVE-2010-1093": [
"14942"
],
"CVE-2010-3456": [
"14960"
],
"CVE-2010-3426": [
"14964"
],
"CVE-2010-3419": [
"14965"
],
"CVE-2010-3458": [
"14968"
],
"CVE-2010-3457": [
"14968"
],
"CVE-2010-3404": [
"14980"
],
"CVE-2010-3428": [
"14988"
],
"CVE-2010-4912": [
"14997"
],
"CVE-2010-3422": [
"14998"
],
"CVE-2010-3467": [
"15004"
],
"CVE-2010-3461": [
"15006"
],
"CVE-2010-3481": [
"15011"
],
"CVE-2010-3480": [
"15011"
],
"CVE-2010-3603": [
"15018"
],
"CVE-2010-3602": [
"15018"
],
"CVE-2010-4954": [
"15039"
],
"CVE-2010-4928": [
"15040"
],
"CVE-2010-4927": [
"15040"
],
"CVE-2010-3479": [
"15049"
],
"CVE-2010-4944": [
"15100"
],
"CVE-2010-4752": [
"15060"
],
"CVE-2010-4751": [
"15060"
],
"CVE-2010-3485": [
"15060"
],
"CVE-2010-3484": [
"15060"
],
"CVE-2010-3483": [
"15064"
],
"CVE-2010-3482": [
"15064"
],
"CVE-2010-3601": [
"15070"
],
"CVE-2010-3608": [
"15075"
],
"CVE-2010-4926": [
"15084"
],
"CVE-2010-4929": [
"15085"
],
"CVE-2010-4940": [
"15090"
],
"CVE-2010-4933": [
"15091"
],
"CVE-2010-3490": [
"15098"
],
"CVE-2010-4865": [
"15157"
],
"CVE-2010-4942": [
"15110"
],
"CVE-2010-3468": [
"15120"
],
"CVE-2010-4935": [
"15126"
],
"CVE-2010-4947": [
"15128"
],
"CVE-2010-4946": [
"15128"
],
"CVE-2010-4861": [
"15151"
],
"CVE-2010-4860": [
"15154"
],
"CVE-2010-4862": [
"15163"
],
"CVE-2010-4866": [
"15175"
],
"CVE-2010-3425": [
"15185"
],
"CVE-2010-4858": [
"15204"
],
"CVE-2010-4857": [
"15210"
],
"CVE-2010-4143": [
"15284"
],
"CVE-2010-4855": [
"15218"
],
"CVE-2010-4856": [
"15219"
],
"CVE-2010-4797": [
"15220"
],
"CVE-2010-5280": [
"15222"
],
"CVE-2010-4799": [
"15223"
],
"CVE-2010-4795": [
"15224"
],
"CVE-2010-4794": [
"15224"
],
"CVE-2010-4791": [
"15227"
],
"CVE-2010-4774": [
"15594"
],
"CVE-2010-4793": [
"15230"
],
"CVE-2010-4798": [
"15232"
],
"CVE-2010-4800": [
"15233"
],
"CVE-2010-4801": [
"15234"
],
"CVE-2010-4006": [
"15607"
],
"CVE-2010-5285": [
"15240"
],
"CVE-2010-5284": [
"15240"
],
"CVE-2010-4145": [
"15270"
],
"CVE-2010-4144": [
"15270"
],
"CVE-2004-1580": [
"15278"
],
"CVE-2010-3514": [
"15290"
],
"CVE-2010-4869": [
"15309"
],
"CVE-2010-4185": [
"15327"
],
"CVE-2010-4870": [
"15328"
],
"CVE-2010-4874": [
"15330"
],
"CVE-2010-4273": [
"15338"
],
"CVE-2010-4268": [
"15366"
],
"CVE-2010-4272": [
"15367"
],
"CVE-2010-4269": [
"15381"
],
"CVE-2010-4635": [
"15395"
],
"CVE-2010-4186": [
"15397",
"34951"
],
"CVE-2010-4636": [
"15399"
],
"CVE-2010-4633": [
"15405"
],
"CVE-2010-5318": [
"15413"
],
"CVE-2010-5317": [
"15413"
],
"CVE-2010-4853": [
"15430"
],
"CVE-2010-4632": [
"15448"
],
"CVE-2010-4631": [
"15448"
],
"CVE-2010-4976": [
"15496"
],
"CVE-2010-4638": [
"15466"
],
"CVE-2010-3891": [
"15473"
],
"CVE-2010-2892": [
"15488"
],
"CVE-2010-4872": [
"15497"
],
"CVE-2010-4837": [
"15501"
],
"CVE-2010-4838": [
"15502"
],
"CVE-2010-4232": [
"15506"
],
"CVE-2010-4233": [
"15507"
],
"CVE-2010-4810": [
"15510"
],
"CVE-2010-4809": [
"15512"
],
"CVE-2010-4839": [
"15513",
"17814"
],
"CVE-2010-4808": [
"15517"
],
"CVE-2010-4835": [
"15519"
],
"CVE-2010-4834": [
"15519"
],
"CVE-2010-4814": [
"15531"
],
"CVE-2010-4776": [
"15526"
],
"CVE-2010-4366": [
"15543"
],
"CVE-2010-4770": [
"15578"
],
"CVE-2010-4769": [
"15585"
],
"CVE-2010-4772": [
"15588"
],
"CVE-2010-4771": [
"15588"
],
"CVE-2010-4357": [
"15612"
],
"CVE-2010-4360": [
"15621"
],
"CVE-2010-4359": [
"15621"
],
"CVE-2010-4734": [
"15625"
],
"CVE-2010-4356": [
"15627"
],
"CVE-2010-4362": [
"15629"
],
"CVE-2010-4850": [
"15633"
],
"CVE-2010-4313": [
"15636"
],
"CVE-2010-4278": [
"15640"
],
"CVE-2010-4280": [
"15641",
"15642"
],
"CVE-2010-4283": [
"15643"
],
"CVE-2010-4282": [
"15643"
],
"CVE-2010-4281": [
"15643"
],
"CVE-2010-4852": [
"15644"
],
"CVE-2010-4851": [
"15644"
],
"CVE-2010-4781": [
"15645"
],
"CVE-2010-4780": [
"15645"
],
"CVE-2010-4401": [
"15646"
],
"CVE-2010-4400": [
"15646"
],
"CVE-2010-4399": [
"15646"
],
"CVE-2010-4849": [
"15650"
],
"CVE-2010-3267": [
"15653"
],
"CVE-2010-3266": [
"15653",
"35031"
],
"CVE-2010-4406": [
"15656"
],
"CVE-2010-4829": [
"15677"
],
"CVE-2010-4830": [
"15678"
],
"CVE-2010-4736": [
"15686"
],
"CVE-2010-4735": [
"15687"
],
"CVE-2010-4737": [
"15688"
],
"CVE-2010-4330": [
"15691"
],
"CVE-2010-4480": [
"15699"
],
"CVE-2010-3906": [
"15744"
],
"CVE-2010-3449": [
"15710"
],
"CVE-2010-4517": [
"15714"
],
"CVE-2010-4507": [
"15728"
],
"CVE-2010-4349": [
"15735"
],
"CVE-2010-4348": [
"15735"
],
"CVE-2010-4350": [
"15736"
],
"CVE-2010-4332": [
"15740"
],
"CVE-2010-4333": [
"15741"
],
"CVE-2010-5315": [
"15742"
],
"CVE-2010-4750": [
"15743"
],
"CVE-2010-4749": [
"15743"
],
"CVE-2010-4719": [
"15749"
],
"CVE-2010-4721": [
"15754"
],
"CVE-2010-4844": [
"15755"
],
"CVE-2010-4847": [
"15756"
],
"CVE-2010-4275": [
"15766",
"35120"
],
"CVE-2010-4614": [
"15769"
],
"CVE-2010-4842": [
"15770"
],
"CVE-2010-4846": [
"15772"
],
"CVE-2010-4845": [
"15773"
],
"CVE-2010-4619": [
"15775",
"35123"
],
"CVE-2010-4615": [
"15777"
],
"CVE-2010-4843": [
"15790"
],
"CVE-2010-4617": [
"15791"
],
"CVE-2010-4613": [
"15797"
],
"CVE-2010-4612": [
"15797"
],
"CVE-2010-4608": [
"15799"
],
"CVE-2010-4607": [
"15799"
],
"CVE-2010-4611": [
"15800"
],
"CVE-2010-4610": [
"15800"
],
"CVE-2010-4609": [
"15800"
],
"CVE-2012-2344": [
"15856"
],
"CVE-2010-5099": [
"15856"
],
"CVE-2010-3714": [
"15856"
],
"CVE-2011-0519": [
"15891"
],
"CVE-2011-0405": [
"15913"
],
"CVE-2011-0443": [
"15961"
],
"CVE-2011-0407": [
"15922"
],
"CVE-2011-0506": [
"15938"
],
"CVE-2011-0505": [
"15945"
],
"CVE-2011-0518": [
"15964"
],
"CVE-2011-0504": [
"15968"
],
"CVE-2011-0503": [
"15968"
],
"CVE-2011-5318": [
"15969"
],
"CVE-2007-6515": [
"15987",
"30919"
],
"CVE-2011-0646": [
"16020"
],
"CVE-2011-0516": [
"15999"
],
"CVE-2010-4331": [
"16000"
],
"CVE-2011-0510": [
"16003"
],
"CVE-2011-0512": [
"16004"
],
"CVE-2011-5284": [
"16006"
],
"CVE-2011-5283": [
"16006"
],
"CVE-2011-0511": [
"16010"
],
"CVE-2010-4335": [
"16011",
"16902"
],
"CVE-2011-0642": [
"16013"
],
"CVE-2011-0635": [
"16016"
],
"CVE-2011-0645": [
"16019",
"35239"
],
"CVE-2011-0644": [
"16019"
],
"CVE-2011-0643": [
"16037"
],
"CVE-2011-0903": [
"16049"
],
"CVE-2011-5313": [
"16096"
],
"CVE-2011-0535": [
"16097"
],
"CVE-2011-1048": [
"16143"
],
"CVE-2009-0932": [
"16154"
],
"CVE-2011-1062": [
"16158",
"35336",
"35337",
"35338"
],
"CVE-2011-1100": [
"16160"
],
"CVE-2011-1055": [
"16171"
],
"CVE-2010-4738": [
"16178",
"16179"
],
"CVE-2013-1916": [
"16181"
],
"CVE-2011-1047": [
"16235"
],
"CVE-2017-7402": [
"41784"
],
"CVE-2017-2367": [
"41801"
],
"CVE-2017-2445": [
"41802"
],
"CVE-2017-2457": [
"41803"
],
"CVE-2017-2364": [
"41799"
],
"CVE-2017-2442": [
"41800"
],
"CVE-2009-2265": [
"16788",
"50057"
],
"CVE-2000-0322": [
"16858"
],
"CVE-2017-6884": [
"41782"
],
"CVE-2003-0050": [
"16891"
],
"CVE-2005-2877": [
"16892",
"26260",
"26302"
],
"CVE-2005-2612": [
"16895"
],
"CVE-2006-1551": [
"16901"
],
"CVE-2008-0506": [
"16909"
],
"CVE-2011-1099": [
"16933"
],
"CVE-2010-4437": [
"16959"
],
"CVE-2011-5267": [
"16988",
"35436"
],
"CVE-2011-1569": [
"17011"
],
"CVE-2011-1524": [
"17026"
],
"CVE-2011-0545": [
"17026"
],
"CVE-2011-4342": [
"17056"
],
"CVE-2011-1556": [
"17061"
],
"CVE-2011-1546": [
"17084"
],
"CVE-2011-1665": [
"17085"
],
"CVE-2011-1670": [
"17098",
"35548"
],
"CVE-2011-1667": [
"17102"
],
"CVE-2011-5025": [
"17111",
"36498"
],
"CVE-2011-5160": [
"17118",
"18274"
],
"CVE-2011-1669": [
"17119"
],
"CVE-2011-1715": [
"17127"
],
"CVE-2011-1714": [
"17127"
],
"CVE-2012-1416": [
"17193",
"18487"
],
"CVE-2011-1511": [
"17276"
],
"CVE-2012-2765": [
"17349",
"18859"
],
"CVE-2011-5212": [
"17390"
],
"CVE-2011-5211": [
"17390"
],
"CVE-2010-3271": [
"17404"
],
"CVE-2011-2757": [
"17437",
"17442",
"17503"
],
"CVE-2011-2755": [
"17437",
"17442",
"17503"
],
"CVE-2011-2506": [
"17510",
"17514"
],
"CVE-2011-2505": [
"17510",
"17514"
],
"CVE-2011-2260": [
"17551"
],
"CVE-2011-2522": [
"17577"
],
"CVE-2011-4106": [
"17602",
"17872"
],
"CVE-2011-0807": [
"17615"
],
"CVE-2011-5286": [
"17617"
],
"CVE-2010-0904": [
"17698"
],
"CVE-2009-2335": [
"17702"
],
"CVE-2011-2763": [
"17743"
],
"CVE-2011-3394": [
"17811"
],
"CVE-2011-3393": [
"17811"
],
"CVE-2012-6625": [
"17828"
],
"CVE-2011-3502": [
"17840"
],
"CVE-2010-5281": [
"17850"
],
"CVE-2011-3981": [
"17861"
],
"CVE-2012-1205": [
"17869"
],
"CVE-2011-2577": [
"17871"
],
"CVE-2011-2544": [
"17871"
],
"CVE-2011-2543": [
"17871"
],
"CVE-2011-1892": [
"17873"
],
"CVE-2011-4671": [
"17888",
"18114"
],
"CVE-2011-3645": [
"17897"
],
"CVE-2011-5168": [
"17919"
],
"CVE-2011-1653": [
"17922"
],
"CVE-2011-4572": [
"17927"
],
"CVE-2011-4570": [
"17944"
],
"CVE-2011-4026": [
"17946"
],
"CVE-2011-5278": [
"17961"
],
"CVE-2011-5277": [
"17961"
],
"CVE-2011-4569": [
"17962"
],
"CVE-2011-4066": [
"17992"
],
"CVE-2011-4024": [
"18005"
],
"CVE-2011-5139": [
"18009"
],
"CVE-2011-4094": [
"18020"
],
"CVE-2011-4075": [
"18021",
"18031"
],
"CVE-2011-4074": [
"18021"
],
"CVE-2011-5113": [
"18042"
],
"CVE-2011-4830": [
"18046"
],
"CVE-2011-4829": [
"18046"
],
"CVE-2011-5185": [
"18035"
],
"CVE-2011-4803": [
"18039"
],
"CVE-2011-4807": [
"18045"
],
"CVE-2011-4806": [
"18045"
],
"CVE-2005-3948": [
"18045",
"26668"
],
"CVE-2011-4823": [
"18048",
"36592"
],
"CVE-2011-4809": [
"18050"
],
"CVE-2011-4808": [
"18050"
],
"CVE-2011-5257": [
"18053"
],
"CVE-2011-5186": [
"18056"
],
"CVE-2011-5112": [
"18058"
],
"CVE-2012-4746": [
"18061",
"18722"
],
"CVE-2011-4812": [
"18063"
],
"CVE-2011-4811": [
"18063"
],
"CVE-2011-5116": [
"18065"
],
"CVE-2011-4832": [
"18066"
],
"CVE-2011-4095": [
"18069"
],
"CVE-2011-4831": [
"18070"
],
"CVE-2011-4825": [
"18075",
"18083",
"18084",
"18085",
"18151",
"18975"
],
"CVE-2011-4813": [
"18081"
],
"CVE-2011-4810": [
"18088"
],
"CVE-2011-5183": [
"18091"
],
"CVE-2011-4713": [
"18099"
],
"CVE-2011-4334": [
"18100"
],
"CVE-2011-4333": [
"18100"
],
"CVE-2011-3833": [
"18108"
],
"CVE-2011-3829": [
"18108"
],
"CVE-2011-2917": [
"18110"
],
"CVE-2011-5075": [
"18132"
],
"CVE-2011-4337": [
"18132"
],
"CVE-2011-4710": [
"18115"
],
"CVE-2011-4801": [
"18117"
],
"CVE-2011-5005": [
"18118"
],
"CVE-2011-5147": [
"18121"
],
"CVE-2011-5262": [
"18122"
],
"CVE-2011-4673": [
"18126"
],
"CVE-2011-5109": [
"18127"
],
"CVE-2011-4672": [
"18128"
],
"CVE-2011-5110": [
"18129"
],
"CVE-2009-0302": [
"18148",
"32747"
],
"CVE-2011-4453": [
"18149",
"18243"
],
"CVE-2011-4715": [
"18153"
],
"CVE-2011-4674": [
"18155"
],
"CVE-2011-5103": [
"18156"
],
"CVE-2011-4452": [
"18177"
],
"CVE-2011-4451": [
"18177"
],
"CVE-2011-4450": [
"18177"
],
"CVE-2011-4449": [
"18177",
"18865"
],
"CVE-2011-4448": [
"18177"
],
"CVE-2011-4714": [
"18185",
"36375"
],
"CVE-2011-5130": [
"18198",
"18208"
],
"CVE-2011-5135": [
"18224"
],
"CVE-2012-0699": [
"18230",
"18667"
],
"CVE-2011-5230": [
"18246"
],
"CVE-2011-5031": [
"18247"
],
"CVE-2011-5219": [
"18248"
],
"CVE-2011-5229": [
"18249"
],
"CVE-2011-5228": [
"18249"
],
"CVE-2011-5218": [
"18250"
],
"CVE-2011-5040": [
"18259"
],
"CVE-2011-5039": [
"18259"
],
"CVE-2011-5150": [
"18261"
],
"CVE-2011-5149": [
"18261"
],
"CVE-2011-3587": [
"18262"
],
"CVE-2011-4558": [
"18265"
],
"CVE-2011-5197": [
"18266"
],
"CVE-2011-5196": [
"18266"
],
"CVE-2011-5195": [
"18266"
],
"CVE-2012-2115": [
"18274"
],
"CVE-2011-5161": [
"18274"
],
"CVE-2012-5318": [
"18412"
],
"CVE-2012-1125": [
"18412"
],
"CVE-2011-5148": [
"18287"
],
"CVE-2011-5140": [
"18288"
],
"CVE-2011-5026": [
"18290"
],
"CVE-2011-5200": [
"18292"
],
"CVE-2011-5204": [
"18293"
],
"CVE-2011-5203": [
"18293"
],
"CVE-2012-5098": [
"18298"
],
"CVE-2009-2436": [
"18300"
],
"CVE-2011-4614": [
"18308"
],
"CVE-2012-5291": [
"18320"
],
"CVE-2012-0694": [
"19381",
"19403"
],
"CVE-2012-5347": [
"18322"
],
"CVE-2012-0393": [
"18329"
],
"CVE-2012-0392": [
"18329"
],
"CVE-2012-5350": [
"18330"
],
"CVE-2012-5349": [
"18330"
],
"CVE-2012-5348": [
"18335"
],
"CVE-2012-5288": [
"18338"
],
"CVE-2012-6644": [
"18341",
"36524",
"36525",
"36526",
"36527",
"36528",
"36529",
"36530"
],
"CVE-2012-5293": [
"18342"
],
"CVE-2012-1025": [
"18343"
],
"CVE-2012-1024": [
"18343"
],
"CVE-2012-6038": [
"18344"
],
"CVE-2012-5918": [
"18344"
],
"CVE-2012-6500": [
"18347"
],
"CVE-2012-6523": [
"18348"
],
"CVE-2012-6522": [
"18348",
"18711"
],
"CVE-2012-6499": [
"18350",
"36540"
],
"CVE-2012-6039": [
"18352"
],
"CVE-2012-0896": [
"18355"
],
"CVE-2012-0895": [
"18355"
],
"CVE-2011-4107": [
"18371"
],
"CVE-2012-6524": [
"18383"
],
"CVE-2012-6525": [
"18384"
],
"CVE-2012-0905": [
"18385"
],
"CVE-2012-0906": [
"18386"
],
"CVE-2012-1673": [
"18700"
],
"CVE-2012-1153": [
"18392",
"18922"
],
"CVE-2012-0913": [
"18394"
],
"CVE-2012-5315": [
"18402"
],
"CVE-2012-5326": [
"18404"
],
"CVE-2012-0935": [
"18405"
],
"CVE-2012-1011": [
"18407"
],
"CVE-2012-1010": [
"18407"
],
"CVE-2012-5231": [
"18410"
],
"CVE-2012-2156": [
"18699"
],
"CVE-2012-5386": [
"18701"
],
"CVE-2012-1671": [
"18701"
],
"CVE-2012-0286": [
"18416"
],
"CVE-2012-0285": [
"18416"
],
"CVE-2012-0937": [
"18417"
],
"CVE-2012-0782": [
"18417"
],
"CVE-2011-4899": [
"18417"
],
"CVE-2011-4898": [
"18417"
],
"CVE-2012-5005": [
"18418"
],
"CVE-2012-5228": [
"18419"
],
"CVE-2012-4247": [
"18419"
],
"CVE-2012-4246": [
"18419"
],
"CVE-2011-1682": [
"18419"
],
"CVE-2011-0748": [
"18419"
],
"CVE-2012-5227": [
"18422"
],
"CVE-2012-5226": [
"18422"
],
"CVE-2012-5223": [
"18424"
],
"CVE-2012-0980": [
"18432"
],
"CVE-2012-0981": [
"18435"
],
"CVE-2012-0983": [
"18438"
],
"CVE-2012-0982": [
"18441"
],
"CVE-2011-5074": [
"18444"
],
"CVE-2011-5073": [
"18444"
],
"CVE-2011-5072": [
"18444"
],
"CVE-2012-0389": [
"18447",
"36547"
],
"CVE-2012-1005": [
"18451"
],
"CVE-2012-1007": [
"18452"
],
"CVE-2012-1006": [
"18452"
],
"CVE-2012-1059": [
"18455"
],
"CVE-2012-1220": [
"18464"
],
"CVE-2012-1017": [
"18465"
],
"CVE-2012-1029": [
"18466",
"36790"
],
"CVE-2012-1026": [
"18467"
],
"CVE-2012-1058": [
"18468"
],
"CVE-2012-1047": [
"18473"
],
"CVE-2012-1226": [
"18480",
"36873"
],
"CVE-2012-1304": [
"18483",
"18563"
],
"CVE-2012-1208": [
"18483",
"18563"
],
"CVE-2012-1308": [
"18499"
],
"CVE-2012-1203": [
"18498"
],
"CVE-2012-1414": [
"18502"
],
"CVE-2012-5320": [
"18504"
],
"CVE-2012-1305": [
"18563"
],
"CVE-2012-4927": [
"18508"
],
"CVE-2012-1415": [
"18513"
],
"CVE-2012-1309": [
"18511"
],
"CVE-2012-2236": [
"18519"
],
"CVE-2011-2944": [
"18518"
],
"CVE-2012-1790": [
"18523"
],
"CVE-2012-1297": [
"18527"
],
"CVE-2012-1498": [
"18536"
],
"CVE-2012-1672": [
"18702"
],
"CVE-2012-1417": [
"18540"
],
"CVE-2012-4926": [
"18544"
],
"CVE-2012-4925": [
"18544"
],
"CVE-2012-1124": [
"18549"
],
"CVE-2007-6752": [
"18564"
],
"CVE-2012-4996": [
"18553"
],
"CVE-2012-4993": [
"18553"
],
"CVE-2012-2105": [
"18554"
],
"CVE-2012-5000": [
"18558"
],
"CVE-2012-4997": [
"18559"
],
"CVE-2011-4837": [
"18567"
],
"CVE-2011-4835": [
"18567"
],
"CVE-2006-2758": [
"18571"
],
"CVE-2005-3747": [
"18571"
],
"CVE-2012-1900": [
"18575"
],
"CVE-2012-2903": [
"18578"
],
"CVE-2012-1912": [
"18578"
],
"CVE-2012-1911": [
"18578"
],
"CVE-2012-5334": [
"18616"
],
"CVE-2005-2892": [
"18590",
"26231"
],
"CVE-2012-1922": [
"18597",
"18651"
],
"CVE-2012-1921": [
"18597",
"18651"
],
"CVE-2012-5331": [
"18599"
],
"CVE-2012-5330": [
"18599"
],
"CVE-2012-1901": [
"18609"
],
"CVE-2012-5333": [
"18614"
],
"CVE-2012-2741": [
"18639"
],
"CVE-2012-2740": [
"18639"
],
"CVE-2012-6667": [
"18644"
],
"CVE-2012-1670": [
"18647"
],
"CVE-2012-6665": [
"18648"
],
"CVE-2012-1669": [
"18648"
],
"CVE-2012-4870": [
"18649"
],
"CVE-2012-4869": [
"18649",
"18650",
"18659"
],
"CVE-2012-1898": [
"18652"
],
"CVE-2012-1897": [
"18652"
],
"CVE-2012-1300": [
"18655"
],
"CVE-2012-5912": [
"18670"
],
"CVE-2012-6679": [
"18668"
],
"CVE-2012-1614": [
"18680"
],
"CVE-2012-1613": [
"18680"
],
"CVE-2012-5891": [
"18685"
],
"CVE-2012-1979": [
"18686"
],
"CVE-2012-5900": [
"18687"
],
"CVE-2012-5899": [
"18687"
],
"CVE-2012-5898": [
"18687"
],
"CVE-2012-2109": [
"18690"
],
"CVE-2012-1978": [
"18694"
],
"CVE-2011-1571": [
"18715"
],
"CVE-2012-4325": [
"18720"
],
"CVE-2011-4571": [
"18728"
],
"CVE-2012-2226": [
"18736"
],
"CVE-2012-1261": [
"18750"
],
"CVE-2012-1260": [
"18750"
],
"CVE-2012-1259": [
"18750"
],
"CVE-2012-1258": [
"18750"
],
"CVE-2012-4679": [
"18752"
],
"CVE-2012-1935": [
"18752"
],
"CVE-2012-1934": [
"18752"
],
"CVE-2012-1933": [
"18752"
],
"CVE-2012-0984": [
"18753",
"37092",
"37093"
],
"CVE-2012-5919": [
"18772"
],
"CVE-2012-5894": [
"18772"
],
"CVE-2012-0551": [
"18764"
],
"CVE-2012-0550": [
"18766"
],
"CVE-2012-4867": [
"18770"
],
"CVE-2012-1496": [
"18775"
],
"CVE-2012-1495": [
"18775",
"18797"
],
"CVE-2012-6516": [
"18778"
],
"CVE-2012-2209": [
"18782"
],
"CVE-2012-2208": [
"18782"
],
"CVE-2012-6505": [
"18788"
],
"CVE-2012-6504": [
"18788"
],
"CVE-2012-6506": [
"18787"
],
"CVE-2012-1936": [
"18791"
],
"CVE-2012-3835": [
"18800",
"20062"
],
"CVE-2012-3834": [
"18800",
"20062"
],
"CVE-2012-2599": [
"18800",
"20062"
],
"CVE-2012-6510": [
"18801"
],
"CVE-2012-6509": [
"18801"
],
"CVE-2012-6508": [
"18801"
],
"CVE-2012-4259": [
"18802"
],
"CVE-2012-6519": [
"18804"
],
"CVE-2012-6518": [
"18804"
],
"CVE-2012-6517": [
"18804"
],
"CVE-2012-3840": [
"18814"
],
"CVE-2012-3839": [
"18814"
],
"CVE-2012-1002": [
"18820"
],
"CVE-2012-3831": [
"18822"
],
"CVE-2012-3830": [
"18822"
],
"CVE-2012-3838": [
"18827"
],
"CVE-2012-3837": [
"18827"
],
"CVE-2012-3836": [
"18827"
],
"CVE-2012-2227": [
"18828"
],
"CVE-2012-4281": [
"18871"
],
"CVE-2012-2939": [
"18871"
],
"CVE-2012-2938": [
"18871"
],
"CVE-2012-4258": [
"18843",
"19132"
],
"CVE-2012-4262": [
"18844"
],
"CVE-2012-4261": [
"18844"
],
"CVE-2012-4260": [
"18844"
],
"CVE-2012-2925": [
"18845"
],
"CVE-2012-6047": [
"18850"
],
"CVE-2012-2924": [
"18858"
],
"CVE-2012-2923": [
"18858"
],
"CVE-2012-4267": [
"18868"
],
"CVE-2012-4266": [
"18872"
],
"CVE-2012-4265": [
"18872"
],
"CVE-2012-2909": [
"18873"
],
"CVE-2012-2908": [
"18873"
],
"CVE-2012-4280": [
"18874"
],
"CVE-2012-4279": [
"18874"
],
"CVE-2012-4278": [
"18874"
],
"CVE-2012-2338": [
"18875"
],
"CVE-2012-6626": [
"18882"
],
"CVE-2012-2332": [
"18884"
],
"CVE-2012-2331": [
"18884"
],
"CVE-2012-2629": [
"18886"
],
"CVE-2012-2316": [
"18888"
],
"CVE-2012-2315": [
"18888"
],
"CVE-2012-2905": [
"18889"
],
"CVE-2012-6560": [
"18900"
],
"CVE-2012-6559": [
"18900"
],
"CVE-2012-6557": [
"18911"
],
"CVE-2012-6556": [
"18912"
],
"CVE-2012-6555": [
"18908"
],
"CVE-2012-2952": [
"18921"
],
"CVE-2012-2216": [
"18927"
],
"CVE-2012-3791": [
"18955"
],
"CVE-2012-3814": [
"18994"
],
"CVE-2012-3574": [
"18997"
],
"CVE-2012-3588": [
"19018"
],
"CVE-2012-3575": [
"19019"
],
"CVE-2012-3576": [
"19023"
],
"CVE-2012-0299": [
"19038"
],
"CVE-2012-6649": [
"19050"
],
"CVE-2017-16843": [
"43150"
],
"CVE-2012-0298": [
"19406"
],
"CVE-2012-2172": [
"19321"
],
"CVE-2012-2171": [
"19321"
],
"CVE-2011-2751": [
"19394"
],
"CVE-2012-3363": [
"19408"
],
"CVE-2012-5972": [
"19455"
],
"CVE-2012-4031": [
"19526"
],
"CVE-2012-0911": [
"19573",
"19630"
],
"CVE-2012-3996": [
"19573",
"19630"
],
"CVE-2007-0694": [
"30094"
],
"CVE-2012-3350": [
"19629"
],
"CVE-2012-3399": [
"19631"
],
"CVE-2011-4542": [
"19758"
],
"CVE-2012-4399": [
"19863"
],
"CVE-2012-2570": [
"20010",
"37522"
],
"CVE-2012-2602": [
"20011"
],
"CVE-2012-2577": [
"20011"
],
"CVE-2012-4344": [
"20035"
],
"CVE-2012-2601": [
"20035"
],
"CVE-2012-2589": [
"20035"
],
"CVE-2012-2574": [
"20038"
],
"CVE-2012-2961": [
"20044"
],
"CVE-2012-6658": [
"20063"
],
"CVE-2012-2956": [
"20063"
],
"CVE-2012-2957": [
"20064"
],
"CVE-2012-3435": [
"20087"
],
"CVE-2012-4178": [
"20123"
],
"CVE-2000-0745": [
"20158"
],
"CVE-2008-0474": [
"20171"
],
"CVE-2000-0872": [
"20208"
],
"CVE-2000-0919": [
"20278"
],
"CVE-2012-3873": [
"20347"
],
"CVE-2012-2592": [
"20348"
],
"CVE-2012-2591": [
"20349"
],
"CVE-2012-2590": [
"20350"
],
"CVE-2012-2588": [
"20351"
],
"CVE-2012-2587": [
"20352"
],
"CVE-2012-2586": [
"20353"
],
"CVE-2012-2585": [
"20356"
],
"CVE-2012-2584": [
"20357"
],
"CVE-2012-2583": [
"20358"
],
"CVE-2012-2582": [
"20359"
],
"CVE-2012-2580": [
"20360"
],
"CVE-2012-2579": [
"20361"
],
"CVE-2012-2578": [
"20362"
],
"CVE-2012-2575": [
"20363"
],
"CVE-2012-2573": [
"20364",
"20579"
],
"CVE-2012-2572": [
"20365"
],
"CVE-2012-2571": [
"20366"
],
"CVE-2012-2569": [
"20367"
],
"CVE-2012-2955": [
"20368"
],
"CVE-2012-2202": [
"20368"
],
"CVE-2012-3294": [
"20477"
],
"CVE-2012-2206": [
"20478"
],
"CVE-2001-1044": [
"20538"
],
"CVE-2012-2977": [
"20706",
"20707"
],
"CVE-2012-4668": [
"20549"
],
"CVE-2012-3508": [
"20549"
],
"CVE-2000-1228": [
"20586"
],
"CVE-2000-1234": [
"20587"
],
"CVE-2000-1230": [
"20588"
],
"CVE-2006-0469": [
"20675"
],
"CVE-2012-4680": [
"20677"
],
"CVE-2001-0383": [
"20729"
],
"CVE-2012-4385": [
"20759"
],
"CVE-2012-4384": [
"20759"
],
"CVE-2001-1334": [
"20848"
],
"CVE-2001-0555": [
"20925"
],
"CVE-2012-4751": [
"20959",
"22070"
],
"CVE-2012-4600": [
"20959",
"22070"
],
"CVE-2001-0760": [
"20987"
],
"CVE-2001-1408": [
"20995"
],
"CVE-2001-1045": [
"20996"
],
"CVE-2012-4749": [
"21005"
],
"CVE-2012-4748": [
"21005"
],
"CVE-2001-1370": [
"21022"
],
"CVE-2001-1472": [
"21046"
],
"CVE-2012-1500": [
"21052"
],
"CVE-2012-4240": [
"21056"
],
"CVE-2001-1471": [
"21065"
],
"CVE-2011-5028": [
"21082"
],
"CVE-2001-1460": [
"21119"
],
"CVE-2012-2275": [
"21135"
],
"CVE-2001-0900": [
"21157"
],
"CVE-2001-1524": [
"21165",
"21166"
],
"CVE-2001-1525": [
"21168"
],
"CVE-2001-1199": [
"21184"
],
"CVE-2001-1212": [
"21187"
],
"CVE-2002-1995": [
"21206"
],
"CVE-2002-0117": [
"21208"
],
"CVE-2002-0118": [
"21209"
],
"CVE-2002-0206": [
"21230"
],
"CVE-2002-2032": [
"21233"
],
"CVE-2002-2106": [
"21241"
],
"CVE-2002-2113": [
"21257"
],
"CVE-2012-4773": [
"21267",
"22159"
],
"CVE-2012-5864": [
"21273"
],
"CVE-2012-5863": [
"21273"
],
"CVE-2012-5862": [
"21273"
],
"CVE-2012-5861": [
"21273"
],
"CVE-2002-2084": [
"21277",
"21278"
],
"CVE-2002-0319": [
"21299"
],
"CVE-2002-0316": [
"21300"
],
"CVE-2002-0330": [
"21301",
"21474"
],
"CVE-2002-0328": [
"21304"
],
"CVE-2002-0329": [
"21308"
],
"CVE-2002-0413": [
"21312"
],
"CVE-2012-2996": [
"21319"
],
"CVE-2012-2995": [
"21319"
],
"CVE-2012-3859": [
"21330"
],
"CVE-2002-0451": [
"21343"
],
"CVE-2002-0483": [
"21349"
],
"CVE-2002-0492": [
"21352"
],
"CVE-2002-2015": [
"21357"
],
"CVE-2002-0516": [
"21358"
],
"CVE-2002-0554": [
"21374"
],
"CVE-2002-0553": [
"21377"
],
"CVE-2002-2021": [
"21380"
],
"CVE-2002-0588": [
"21391"
],
"CVE-2002-0589": [
"21397"
],
"CVE-2002-0590": [
"21399"
],
"CVE-2002-0607": [
"21400"
],
"CVE-2002-0535": [
"21401",
"21403"
],
"CVE-2002-2011": [
"21405"
],
"CVE-2002-0730": [
"21406"
],
"CVE-2002-0731": [
"21411"
],
"CVE-2002-1757": [
"21421"
],
"CVE-2002-0613": [
"21425"
],
"CVE-2002-0599": [
"21426"
],
"CVE-2012-5193": [
"22216"
],
"CVE-2012-5192": [
"22216"
],
"CVE-2002-0732": [
"21433"
],
"CVE-2002-1720": [
"21434"
],
"CVE-2002-1727": [
"21435"
],
"CVE-2002-0734": [
"21436"
],
"CVE-2002-2343": [
"21449"
],
"CVE-2002-0772": [
"21455"
],
"CVE-2002-0773": [
"21457"
],
"CVE-2002-0764": [
"21459"
],
"CVE-2002-0775": [
"21464"
],
"CVE-2002-0771": [
"21473"
],
"CVE-2002-1829": [
"21474"
],
"CVE-2002-1830": [
"21478"
],
"CVE-2002-0388": [
"21480"
],
"CVE-2002-0902": [
"21486"
],
"CVE-2002-1837": [
"21487"
],
"CVE-2002-0879": [
"21493"
],
"CVE-2002-0919": [
"21494",
"21495"
],
"CVE-2002-0918": [
"21494"
],
"CVE-2002-2055": [
"21509"
],
"CVE-2002-0959": [
"21514"
],
"CVE-2002-0961": [
"21517"
],
"CVE-2002-0931": [
"21519",
"21526"
],
"CVE-2002-0962": [
"21525",
"21528"
],
"CVE-2002-0932": [
"21527"
],
"CVE-2002-1878": [
"21529"
],
"CVE-2002-0922": [
"21532"
],
"CVE-2002-0923": [
"21533"
],
"CVE-2002-0948": [
"21535"
],
"CVE-2002-0951": [
"21543"
],
"CVE-2012-4051": [
"21545"
],
"CVE-2012-2998": [
"21546"
],
"CVE-2002-1702": [
"21552"
],
"CVE-2002-1703": [
"21553"
],
"CVE-2002-1704": [
"21557"
],
"CVE-2002-1966": [
"21558"
],
"CVE-2002-0926": [
"21562"
],
"CVE-2002-2019": [
"21563"
],
"CVE-2002-1991": [
"21563"
],
"CVE-2002-0953": [
"21564"
],
"CVE-2002-1993": [
"21567"
],
"CVE-2002-1708": [
"21570"
],
"CVE-2002-0955": [
"21573"
],
"CVE-2002-1006": [
"21587"
],
"CVE-2002-1007": [
"21588"
],
"CVE-2002-0995": [
"21590"
],
"CVE-2002-1036": [
"21609"
],
"CVE-2002-1034": [
"21610"
],
"CVE-2002-1033": [
"21610"
],
"CVE-2002-2165": [
"21617"
],
"CVE-2002-1027": [
"21621"
],
"CVE-2002-1070": [
"21622"
],
"CVE-2002-1058": [
"21640"
],
"CVE-2002-1427": [
"21658"
],
"CVE-2002-1410": [
"21659"
],
"CVE-2002-2176": [
"21660"
],
"CVE-2002-1428": [
"21661"
],
"CVE-2002-1429": [
"21668"
],
"CVE-2015-8309": [
"40361"
],
"CVE-2002-1412": [
"21676"
],
"CVE-2002-1868": [
"21679"
],
"CVE-2002-1432": [
"21702"
],
"CVE-2002-1457": [
"21708"
],
"CVE-2002-1423": [
"21723"
],
"CVE-2002-1422": [
"21724"
],
"CVE-2002-1113": [
"21727"
],
"CVE-2002-1434": [
"21728"
],
"CVE-2003-0154": [
"21729"
],
"CVE-2003-0153": [
"21730"
],
"CVE-2012-5159": [
"21834"
],
"CVE-2012-4902": [
"21742"
],
"CVE-2012-4901": [
"21742"
],
"CVE-2012-6534": [
"21744"
],
"CVE-2002-1435": [
"21745"
],
"CVE-2002-2424": [
"21755"
],
"CVE-2002-1499": [
"21766"
],
"CVE-2002-2420": [
"21768"
],
"CVE-2002-1494": [
"21769"
],
"CVE-2002-1482": [
"21778"
],
"CVE-2002-1505": [
"21779"
],
"CVE-2002-1480": [
"21780"
],
"CVE-2002-1481": [
"21783"
],
"CVE-2002-1493": [
"21802"
],
"CVE-2002-1131": [
"21811"
],
"CVE-2002-1495": [
"21817"
],
"CVE-2002-1884": [
"21886"
],
"CVE-2002-1135": [
"21825"
],
"CVE-2002-1802": [
"21829"
],
"CVE-2002-1803": [
"21859"
],
"CVE-2002-1804": [
"21860"
],
"CVE-2002-1805": [
"21861"
],
"CVE-2002-1806": [
"21863"
],
"CVE-2002-2178": [
"21864",
"21899"
],
"CVE-2002-1660": [
"21874"
],
"CVE-2002-1533": [
"21875"
],
"CVE-2002-1527": [
"21877"
],
"CVE-2002-1526": [
"21878"
],
"CVE-2002-1525": [
"21879"
],
"CVE-2002-1886": [
"21893"
],
"CVE-2002-1798": [
"21894",
"21896"
],
"CVE-2002-1178": [
"21895"
],
"CVE-2002-2319": [
"21900"
],
"CVE-2002-2143": [
"21901"
],
"CVE-2002-2321": [
"21906"
],
"CVE-2002-2335": [
"21912"
],
"CVE-2002-2339": [
"21914"
],
"CVE-2003-0002": [
"21920"
],
"CVE-2002-1529": [
"21924"
],
"CVE-2002-1530": [
"21925"
],
"CVE-2002-2348": [
"21926"
],
"CVE-2002-2349": [
"21931"
],
"CVE-2002-1799": [
"21933"
],
"CVE-2002-1922": [
"21946"
],
"CVE-2002-1845": [
"21950"
],
"CVE-2002-1958": [
"21956"
],
"CVE-2002-1929": [
"21957"
],
"CVE-2002-1560": [
"21960"
],
"CVE-2002-2362": [
"21961"
],
"CVE-2002-2193": [
"21962"
],
"CVE-2002-1581": [
"21966"
],
"CVE-2002-2200": [
"21967",
"21968",
"21969",
"21970"
],
"CVE-2002-1211": [
"21976"
],
"CVE-2002-1242": [
"21977"
],
"CVE-2002-1559": [
"21979"
],
"CVE-2002-2190": [
"21995"
],
"CVE-2002-1818": [
"22009"
],
"CVE-2002-2399": [
"22015"
],
"CVE-2002-2287": [
"22017"
],
"CVE-2004-1824": [
"22030"
],
"CVE-2012-3186": [
"22041"
],
"CVE-2012-3185": [
"22041"
],
"CVE-2012-3184": [
"22041"
],
"CVE-2012-3183": [
"22041"
],
"CVE-2002-2235": [
"22042"
],
"CVE-2002-2249": [
"22048"
],
"CVE-2002-1334": [
"22050",
"22051"
],
"CVE-2002-2296": [
"22052"
],
"CVE-2002-2255": [
"22065"
],
"CVE-2002-2246": [
"22083"
],
"CVE-2002-2247": [
"22086"
],
"CVE-2002-2288": [
"22087"
],
"CVE-2002-2304": [
"22088"
],
"CVE-2002-2129": [
"22109"
],
"CVE-2002-2219": [
"22111"
],
"CVE-2002-2134": [
"22114"
],
"CVE-2003-1251": [
"22115",
"22116"
],
"CVE-2003-1278": [
"22125"
],
"CVE-2003-1252": [
"22134"
],
"CVE-2003-1533": [
"22148"
],
"CVE-2012-1503": [
"22151"
],
"CVE-2012-5388": [
"22156"
],
"CVE-2012-5387": [
"22156"
],
"CVE-2012-5452": [
"22159"
],
"CVE-2012-4772": [
"22159"
],
"CVE-2012-4771": [
"22159"
],
"CVE-2012-5453": [
"22160"
],
"CVE-2012-5167": [
"22160"
],
"CVE-2003-1347": [
"22163",
"22164",
"22165",
"22166"
],
"CVE-2003-1530": [
"22182"
],
"CVE-2003-1412": [
"22279"
],
"CVE-2003-0038": [
"22198",
"22199"
],
"CVE-2003-1348": [
"22202"
],
"CVE-2000-0912": [
"22204"
],
"CVE-2003-1436": [
"22206"
],
"CVE-2003-1532": [
"22209"
],
"CVE-2003-1400": [
"22211"
],
"CVE-2003-1409": [
"22222"
],
"CVE-2002-0612": [
"22227"
],
"CVE-2002-0611": [
"22228"
],
"CVE-2003-1410": [
"22241"
],
"CVE-2003-1411": [
"22242"
],
"CVE-2003-1401": [
"22252"
],
"CVE-2003-1405": [
"22253",
"22254"
],
"CVE-2003-1406": [
"22256",
"22257"
],
"CVE-2003-1425": [
"22260",
"22261",
"22262",
"22263"
],
"CVE-2003-1435": [
"22266"
],
"CVE-2003-1244": [
"22267"
],
"CVE-2003-1372": [
"22268"
],
"CVE-2003-1371": [
"22277"
],
"CVE-2003-1245": [
"22281"
],
"CVE-2003-1239": [
"22282"
],
"CVE-2003-1240": [
"22283",
"22284",
"22285"
],
"CVE-2003-1256": [
"22293"
],
"CVE-2003-1385": [
"22295"
],
"CVE-2003-1548": [
"22378"
],
"CVE-2003-1203": [
"22382"
],
"CVE-2003-1536": [
"22387"
],
"CVE-2003-1550": [
"22389"
],
"CVE-2003-1541": [
"22408"
],
"CVE-2003-1181": [
"22412"
],
"CVE-2016-7400": [
"40412"
],
"CVE-2003-1545": [
"22422"
],
"CVE-2012-6653": [
"22427"
],
"CVE-2017-16841": [
"43149"
],
"CVE-2003-1535": [
"22444"
],
"CVE-2003-1555": [
"22445"
],
"CVE-2003-0536": [
"22459"
],
"CVE-2012-5686": [
"22490"
],
"CVE-2012-5685": [
"22490"
],
"CVE-2012-5684": [
"22490"
],
"CVE-2012-5683": [
"22490"
],
"CVE-2003-0770": [
"22499",
"22500"
],
"CVE-2003-0243": [
"22571",
"22572"
],
"CVE-2003-0215": [
"22529"
],
"CVE-2003-1488": [
"22534"
],
"CVE-2003-1453": [
"22539"
],
"CVE-2003-1469": [
"22544"
],
"CVE-2003-1456": [
"22545"
],
"CVE-2003-0118": [
"22554",
"22555"
],
"CVE-2003-1459": [
"22577",
"22578"
],
"CVE-2003-0283": [
"22579"
],
"CVE-2003-0278": [
"22588"
],
"CVE-2004-0269": [
"22589",
"23680"
],
"CVE-2003-0277": [
"22592"
],
"CVE-2003-1210": [
"22597"
],
"CVE-2003-1468": [
"22598"
],
"CVE-2003-0295": [
"22599"
],
"CVE-2003-0303": [
"22605"
],
"CVE-2003-0304": [
"22606"
],
"CVE-2003-0310": [
"22607"
],
"CVE-2003-0320": [
"22612"
],
"CVE-2003-0375": [
"22632",
"22820"
],
"CVE-2003-0377": [
"22639"
],
"CVE-2003-0394": [
"22641"
],
"CVE-2003-0395": [
"22642"
],
"CVE-2003-0416": [
"22669"
],
"CVE-2004-0304": [
"22698"
],
"CVE-2006-0755": [
"22708",
"27217",
"27218",
"27219",
"27220",
"27221",
"27222",
"27223",
"27224",
"27225"
],
"CVE-2012-6585": [
"22713"
],
"CVE-2012-6584": [
"22713"
],
"CVE-2012-6589": [
"22711"
],
"CVE-2012-6588": [
"22711"
],
"CVE-2012-6587": [
"22712"
],
"CVE-2012-6586": [
"22712"
],
"CVE-2002-1954": [
"22725"
],
"CVE-2012-5700": [
"22741"
],
"CVE-2012-5699": [
"22741"
],
"CVE-2012-5698": [
"22741"
],
"CVE-2003-1213": [
"22747"
],
"CVE-2003-1086": [
"22776"
],
"CVE-2003-0495": [
"22777"
],
"CVE-2003-0492": [
"22778"
],
"CVE-2003-0488": [
"22799",
"22804"
],
"CVE-2003-0481": [
"22818"
],
"CVE-2003-0482": [
"22819"
],
"CVE-2003-0483": [
"22821"
],
"CVE-2003-0523": [
"22866"
],
"CVE-2003-1304": [
"22868"
],
"CVE-2003-0521": [
"22874"
],
"CVE-2003-0560": [
"22888",
"22889"
],
"CVE-2003-0590": [
"22910"
],
"CVE-2003-0586": [
"22925"
],
"CVE-2003-0614": [
"22961"
],
"CVE-2003-1088": [
"23011"
],
"CVE-2003-0735": [
"23013"
],
"CVE-2003-0736": [
"23014",
"23015",
"23016",
"23017"
],
"CVE-2003-1031": [
"22990"
],
"CVE-2004-1957": [
"22997",
"24037"
],
"CVE-2003-1089": [
"23018"
],
"CVE-2003-0752": [
"23064"
],
"CVE-2003-1317": [
"23067"
],
"CVE-2012-0308": [
"23109"
],
"CVE-2012-4347": [
"23110"
],
"CVE-2003-0769": [
"23120"
],
"CVE-2003-0763": [
"23127"
],
"CVE-2013-1627": [
"23132"
],
"CVE-2003-1313": [
"23218"
],
"CVE-2003-1227": [
"23238"
],
"CVE-2003-1498": [
"23244"
],
"CVE-2012-5849": [
"23252"
],
"CVE-2012-5865": [
"23253"
],
"CVE-2003-1504": [
"23259"
],
"CVE-2003-1499": [
"23261"
],
"CVE-2003-1513": [
"23262"
],
"CVE-1999-0819": [
"23264"
],
"CVE-2003-1517": [
"23266"
],
"CVE-2003-1519": [
"23268"
],
"CVE-2003-1520": [
"23269"
],
"CVE-2003-1506": [
"23275"
],
"CVE-2003-1197": [
"23313"
],
"CVE-2003-1136": [
"23294"
],
"CVE-2003-1148": [
"23302"
],
"CVE-2003-0624": [
"23315"
],
"CVE-2003-1162": [
"23319"
],
"CVE-2012-4991": [
"23324"
],
"CVE-2003-1166": [
"23326"
],
"CVE-2003-1175": [
"23330"
],
"CVE-2003-1176": [
"23331"
],
"CVE-2003-1182": [
"23332"
],
"CVE-2003-1187": [
"23333"
],
"CVE-2003-1196": [
"23335"
],
"CVE-2003-1145": [
"23336"
],
"CVE-2003-1146": [
"23338"
],
"CVE-2012-5469": [
"23356"
],
"CVE-2012-5967": [
"23362"
],
"CVE-2003-1219": [
"23445"
],
"CVE-2013-1744": [
"23448"
],
"CVE-2004-2347": [
"23629"
],
"CVE-2004-2130": [
"23475"
],
"CVE-2003-1131": [
"23476"
],
"CVE-2004-0237": [
"23630"
],
"CVE-2007-1156": [
"23628"
],
"CVE-2004-0073": [
"23507"
],
"CVE-2004-1782": [
"23513"
],
"CVE-2004-1786": [
"23515"
],
"CVE-2004-1788": [
"23516"
],
"CVE-2004-1797": [
"23519"
],
"CVE-2004-0030": [
"23520"
],
"CVE-2004-2076": [
"23691"
],
"CVE-2004-0032": [
"23525"
],
"CVE-2004-0033": [
"23526"
],
"CVE-2004-0071": [
"23536"
],
"CVE-2004-0070": [
"23537"
],
"CVE-2004-2746": [
"23547"
],
"CVE-2004-2754": [
"23554"
],
"CVE-2012-5244": [
"23573"
],
"CVE-2012-5243": [
"23573"
],
"CVE-2012-5242": [
"23573"
],
"CVE-2012-5874": [
"23575"
],
"CVE-2004-2124": [
"23599"
],
"CVE-2004-2756": [
"23606"
],
"CVE-2004-2127": [
"23613"
],
"CVE-2004-2132": [
"23615"
],
"CVE-2004-0128": [
"23617"
],
"CVE-2004-2750": [
"23618"
],
"CVE-2004-0246": [
"23619",
"23620",
"23621"
],
"CVE-2004-2071": [
"23687"
],
"CVE-2004-2170": [
"23635"
],
"CVE-2004-0241": [
"23636",
"23637"
],
"CVE-2004-0242": [
"23639"
],
"CVE-2004-0129": [
"23640"
],
"CVE-2004-0249": [
"23644"
],
"CVE-2004-2175": [
"23645",
"23646"
],
"CVE-2004-0251": [
"23647"
],
"CVE-2004-0254": [
"23653"
],
"CVE-2004-2072": [
"23657"
],
"CVE-2004-0261": [
"23659"
],
"CVE-2004-0265": [
"23669"
],
"CVE-2004-0266": [
"23670"
],
"CVE-2004-0271": [
"23676",
"23677"
],
"CVE-2004-0132": [
"23683",
"23684"
],
"CVE-2004-0275": [
"23685"
],
"CVE-2004-0285": [
"23697",
"23698",
"23699"
],
"CVE-2004-2172": [
"23702"
],
"CVE-2005-0994": [
"23703",
"23704"
],
"CVE-2004-0293": [
"23705",
"23706"
],
"CVE-2004-0291": [
"23710"
],
"CVE-2004-0300": [
"23711",
"23718",
"23719",
"23720"
],
"CVE-2004-0301": [
"23712"
],
"CVE-2004-0302": [
"23722",
"23723",
"23724"
],
"CVE-2004-0303": [
"23725",
"23726",
"23727"
],
"CVE-2004-0305": [
"23729"
],
"CVE-2004-0319": [
"23744"
],
"CVE-2004-0322": [
"23745",
"23746",
"23747"
],
"CVE-2004-0323": [
"23748"
],
"CVE-2004-2374": [
"23753"
],
"CVE-2004-0344": [
"23774"
],
"CVE-2004-0343": [
"23775"
],
"CVE-2004-1962": [
"24047"
],
"CVE-2004-1960": [
"24048"
],
"CVE-2004-0348": [
"23791"
],
"CVE-2004-0358": [
"23792"
],
"CVE-2004-2308": [
"23806"
],
"CVE-2004-1770": [
"23807"
],
"CVE-2004-2385": [
"23809"
],
"CVE-2004-2334": [
"23810"
],
"CVE-2004-1827": [
"23812"
],
"CVE-2004-1813": [
"23813"
],
"CVE-2004-1817": [
"23814"
],
"CVE-2004-1820": [
"23815"
],
"CVE-2004-1821": [
"23816"
],
"CVE-2004-1818": [
"23817"
],
"CVE-2004-1822": [
"23818",
"23819",
"23820"
],
"CVE-2004-2350": [
"23821"
],
"CVE-2004-1823": [
"23822",
"23823"
],
"CVE-2004-1825": [
"23824"
],
"CVE-2012-6433": [
"23828"
],
"CVE-2012-6434": [
"23829"
],
"CVE-2004-1826": [
"23834"
],
"CVE-2004-1842": [
"23835"
],
"CVE-2004-1828": [
"23843"
],
"CVE-2004-1830": [
"23844"
],
"CVE-2004-1829": [
"23845"
],
"CVE-2004-1843": [
"23851",
"23852"
],
"CVE-2004-1844": [
"23853",
"23854"
],
"CVE-2004-1845": [
"23857",
"23858",
"23859"
],
"CVE-2004-1846": [
"23860",
"23861",
"23862"
],
"CVE-2004-1847": [
"23863"
],
"CVE-2004-1835": [
"23867",
"43807"
],
"CVE-2004-1836": [
"23868"
],
"CVE-2004-1859": [
"23875"
],
"CVE-2004-1870": [
"23885",
"43808"
],
"CVE-2004-1867": [
"23890"
],
"CVE-2004-1873": [
"23891",
"29085"
],
"CVE-2004-0374": [
"23895"
],
"CVE-2004-1878": [
"23897"
],
"CVE-2004-1881": [
"23898"
],
"CVE-2004-1882": [
"23899"
],
"CVE-2004-1888": [
"23907"
],
"CVE-2012-6493": [
"23924"
],
"CVE-2004-1912": [
"23928",
"23929",
"23930",
"23931"
],
"CVE-2004-1913": [
"23932"
],
"CVE-2004-1914": [
"23933"
],
"CVE-2004-1911": [
"23934",
"23935"
],
"CVE-2004-2447": [
"23937",
"23938",
"23939",
"23940",
"23941",
"23942"
],
"CVE-2004-1924": [
"23947",
"23953",
"23954",
"23955",
"23956",
"23957",
"23958",
"23959",
"23960",
"23961",
"23962",
"43809"
],
"CVE-2004-1928": [
"23948",
"43809"
],
"CVE-2004-1927": [
"23949",
"43809"
],
"CVE-2004-1926": [
"23950",
"23951",
"43809"
],
"CVE-2004-1923": [
"23952",
"43809"
],
"CVE-2004-1925": [
"23963",
"23964",
"23965",
"23966",
"23971",
"23972",
"23973",
"23974",
"23975",
"23976",
"23977",
"23978",
"23982",
"23983",
"23984",
"43809"
],
"CVE-2013-2299": [
"23968"
],
"CVE-2012-4915": [
"23970"
],
"CVE-2009-4381": [
"33401"
],
"CVE-2004-1937": [
"23988"
],
"CVE-2004-1930": [
"23990"
],
"CVE-2004-1929": [
"23998"
],
"CVE-2004-1939": [
"24001"
],
"CVE-2004-1935": [
"24008"
],
"CVE-2004-1934": [
"24009"
],
"CVE-2004-1938": [
"24016"
],
"CVE-2004-1943": [
"24026"
],
"CVE-2004-1955": [
"24034"
],
"CVE-2004-1953": [
"24035"
],
"CVE-2004-1954": [
"24036"
],
"CVE-2004-1952": [
"24050"
],
"CVE-2004-1965": [
"24052",
"24053",
"24054",
"24055",
"43811"
],
"CVE-2004-1966": [
"24056",
"24057",
"24058",
"24059"
],
"CVE-2004-1972": [
"24060"
],
"CVE-2004-1968": [
"24061"
],
"CVE-2004-0519": [
"24068"
],
"CVE-2004-1978": [
"24071"
],
"CVE-2004-1985": [
"24072"
],
"CVE-2004-1986": [
"24073"
],
"CVE-2004-1988": [
"24074"
],
"CVE-2004-1989": [
"24075"
],
"CVE-2004-1995": [
"24081"
],
"CVE-2004-1996": [
"24082"
],
"CVE-2004-2363": [
"24083"
],
"CVE-2013-5123": [
"24086"
],
"CVE-2013-4266": [
"24086"
],
"CVE-2004-2364": [
"24088",
"24089",
"24090",
"24091",
"24092",
"43812"
],
"CVE-2004-2254": [
"24094"
],
"CVE-2004-2007": [
"24099"
],
"CVE-2004-2008": [
"24100"
],
"CVE-2017-7851": [
"43146"
],
"CVE-2004-2017": [
"24122"
],
"CVE-2004-2288": [
"24124"
],
"CVE-2004-2021": [
"24126"
],
"CVE-2004-2018": [
"24127"
],
"CVE-2004-2287": [
"24131"
],
"CVE-2004-2028": [
"24138"
],
"CVE-2004-2030": [
"24139"
],
"CVE-2004-2036": [
"24151"
],
"CVE-2004-2038": [
"24152"
],
"CVE-2004-2040": [
"24153",
"24154"
],
"CVE-2013-0397": [
"24158"
],
"CVE-2004-2636": [
"24164"
],
"CVE-2004-2044": [
"24166"
],
"CVE-2004-0639": [
"24167"
],
"CVE-2004-2355": [
"24169"
],
"CVE-2004-2507": [
"24175"
],
"CVE-2004-2547": [
"24176"
],
"CVE-2004-2548": [
"24177"
],
"CVE-2004-2699": [
"24184"
],
"CVE-2004-2701": [
"24185"
],
"CVE-2005-1023": [
"24190"
],
"CVE-2004-2293": [
"24191"
],
"CVE-2004-2295": [
"24192"
],
"CVE-2004-2297": [
"24193"
],
"CVE-2004-2294": [
"24194"
],
"CVE-2004-2508": [
"24197"
],
"CVE-2004-2411": [
"24198"
],
"CVE-2004-2413": [
"24199"
],
"CVE-2013-1360": [
"24203"
],
"CVE-2004-2716": [
"24215"
],
"CVE-2004-2715": [
"24216"
],
"CVE-2004-2717": [
"24217"
],
"CVE-2004-0613": [
"24225"
],
"CVE-2004-0591": [
"24227"
],
"CVE-2004-0617": [
"24231"
],
"CVE-2004-0620": [
"24234"
],
"CVE-2004-0621": [
"24235"
],
"CVE-2004-0675": [
"24236"
],
"CVE-2004-0665": [
"24237"
],
"CVE-2004-0660": [
"24238",
"24239",
"24240",
"24290",
"24372"
],
"CVE-2004-0664": [
"24241"
],
"CVE-2004-0672": [
"24244",
"24245"
],
"CVE-2004-0671": [
"24251"
],
"CVE-2004-0676": [
"24252"
],
"CVE-2004-2445": [
"24255"
],
"CVE-2004-2443": [
"24256"
],
"CVE-2004-2444": [
"24257"
],
"CVE-2004-0682": [
"24260"
],
"CVE-2004-0681": [
"24261"
],
"CVE-2004-0725": [
"24279"
],
"CVE-2004-2518": [
"24284",
"24285"
],
"CVE-2004-2522": [
"24286"
],
"CVE-2004-1441": [
"24287"
],
"CVE-2004-2625": [
"24291"
],
"CVE-2004-2561": [
"24298"
],
"CVE-2004-2737": [
"24299"
],
"CVE-2004-2562": [
"24300"
],
"CVE-2004-2736": [
"24302"
],
"CVE-2004-2551": [
"24303"
],
"CVE-2004-2047": [
"24306"
],
"CVE-2004-2053": [
"24311"
],
"CVE-2004-2059": [
"24313",
"24314",
"24315",
"24316"
],
"CVE-2004-2060": [
"24317"
],
"CVE-2004-2062": [
"24329"
],
"CVE-2004-2063": [
"24330"
],
"CVE-2004-2242": [
"24331"
],
"CVE-2004-2064": [
"24333"
],
"CVE-2004-2067": [
"24334"
],
"CVE-2004-2514": [
"24340"
],
"CVE-2004-1703": [
"24341"
],
"CVE-2004-2670": [
"24348"
],
"CVE-2012-6290": [
"24365"
],
"CVE-2004-1737": [
"24375"
],
"CVE-2004-1719": [
"24377",
"24378",
"24379",
"24380"
],
"CVE-2004-1720": [
"24381"
],
"CVE-2004-1722": [
"24382"
],
"CVE-2004-1466": [
"24383"
],
"CVE-2004-1724": [
"24384"
],
"CVE-2004-1735": [
"24389"
],
"CVE-2004-1731": [
"24392"
],
"CVE-2004-2425": [
"24400"
],
"CVE-2004-1467": [
"24403"
],
"CVE-2004-2702": [
"24405"
],
"CVE-2004-1742": [
"24408"
],
"CVE-2004-1746": [
"24410"
],
"CVE-2004-1640": [
"24415"
],
"CVE-2004-1647": [
"24420"
],
"CVE-2004-1656": [
"24422"
],
"CVE-2004-1657": [
"24424"
],
"CVE-2004-1655": [
"24425"
],
"CVE-2013-1451": [
"24432"
],
"CVE-2013-1471": [
"24435"
],
"CVE-2013-1120": [
"24449"
],
"CVE-2013-1114": [
"24449"
],
"CVE-2013-1465": [
"24465"
],
"CVE-2013-2678": [
"24475",
"24478",
"25292"
],
"CVE-2013-1469": [
"24520",
"24561"
],
"CVE-2012-6276": [
"24504"
],
"CVE-2012-5687": [
"24504"
],
"CVE-2013-1466": [
"24536"
],
"CVE-2013-1453": [
"24551"
],
"CVE-2013-1468": [
"24561"
],
"CVE-2013-7375": [
"24562"
],
"CVE-2013-1807": [
"24562"
],
"CVE-2013-1806": [
"24562"
],
"CVE-2013-1805": [
"24562"
],
"CVE-2013-1804": [
"24562"
],
"CVE-2013-1803": [
"24562"
],
"CVE-2013-2271": [
"24563"
],
"CVE-2004-1661": [
"24565"
],
"CVE-2004-1659": [
"24566"
],
"CVE-2004-1665": [
"24575"
],
"CVE-2004-1678": [
"24591"
],
"CVE-2004-1100": [
"24721"
],
"CVE-2004-1687": [
"24604"
],
"CVE-2004-2143": [
"24613"
],
"CVE-2004-1692": [
"24614"
],
"CVE-2004-1693": [
"24615"
],
"CVE-2004-2161": [
"24616"
],
"CVE-2004-2162": [
"24617"
],
"CVE-2004-1555": [
"24625",
"24626"
],
"CVE-2013-1668": [
"24629"
],
"CVE-2004-1554": [
"24638"
],
"CVE-2004-1559": [
"24641",
"24642",
"24643",
"24644",
"24645",
"24646"
],
"CVE-2004-1562": [
"24648"
],
"CVE-2004-1563": [
"24649",
"24650",
"24652"
],
"CVE-2004-1564": [
"24651"
],
"CVE-2004-2511": [
"24659",
"24661",
"24662"
],
"CVE-2004-2512": [
"24665"
],
"CVE-2004-0847": [
"24666"
],
"CVE-2004-2202": [
"24671"
],
"CVE-2004-2198": [
"24672"
],
"CVE-2004-2201": [
"24673",
"24674",
"24675"
],
"CVE-2004-1601": [
"24685"
],
"CVE-2004-1621": [
"24690"
],
"CVE-2004-1620": [
"24697"
],
"CVE-2004-1622": [
"24698"
],
"CVE-2004-2732": [
"24700"
],
"CVE-2004-2640": [
"24703"
],
"CVE-2013-2637": [
"24922"
],
"CVE-2004-1499": [
"24717"
],
"CVE-2004-2246": [
"24718"
],
"CVE-2004-2245": [
"24719"
],
"CVE-2004-1101": [
"24722"
],
"CVE-2004-1102": [
"24723"
],
"CVE-2004-2725": [
"24731"
],
"CVE-2013-1814": [
"24744"
],
"CVE-2004-1535": [
"24751"
],
"CVE-2004-1536": [
"24759"
],
"CVE-2004-1537": [
"24762"
],
"CVE-2004-1225": [
"24768"
],
"CVE-2004-1227": [
"24769"
],
"CVE-2004-1543": [
"24771"
],
"CVE-2004-1075": [
"24772"
],
"CVE-2004-1196": [
"24779"
],
"CVE-2004-1206": [
"24783"
],
"CVE-2013-3431": [
"24786"
],
"CVE-2013-3430": [
"24786"
],
"CVE-2013-3429": [
"24786"
],
"CVE-2013-1852": [
"24789"
],
"CVE-2013-1651": [
"24791"
],
"CVE-2013-1650": [
"24791"
],
"CVE-2013-1649": [
"24791"
],
"CVE-2013-1648": [
"24791"
],
"CVE-2013-1647": [
"24791"
],
"CVE-2013-1646": [
"24791"
],
"CVE-2013-1645": [
"24791"
],
"CVE-2004-1210": [
"24792"
],
"CVE-2004-1212": [
"24796"
],
"CVE-2004-1213": [
"24797"
],
"CVE-2005-0780": [
"24798"
],
"CVE-2004-1221": [
"24806"
],
"CVE-2004-0067": [
"24810",
"24814",
"24816",
"24819",
"24820",
"24821",
"24822",
"24829",
"24830",
"24831",
"24832",
"24834",
"24835",
"24837"
],
"CVE-2004-1147": [
"24817"
],
"CVE-2004-2510": [
"24824"
],
"CVE-2004-2509": [
"24825",
"24826",
"24827"
],
"CVE-2004-1400": [
"24838"
],
"CVE-2004-1401": [
"24840"
],
"CVE-2004-1402": [
"24842"
],
"CVE-2004-1384": [
"24844",
"24845"
],
"CVE-2004-1383": [
"24846"
],
"CVE-2004-1385": [
"24847"
],
"CVE-2013-0126": [
"24860"
],
"CVE-2013-2294": [
"24862"
],
"CVE-2013-1891": [
"24877"
],
"CVE-2013-3721": [
"24893"
],
"CVE-2013-2690": [
"24898"
],
"CVE-2013-2474": [
"24906"
],
"CVE-2013-2618": [
"24913"
],
"CVE-2013-3529": [
"24914"
],
"CVE-2013-2619": [
"24915"
],
"CVE-2013-2748": [
"24924"
],
"CVE-2013-3527": [
"24927"
],
"CVE-2013-2643": [
"24932"
],
"CVE-2013-2642": [
"24932"
],
"CVE-2013-2641": [
"24932"
],
"CVE-2013-3536": [
"24934"
],
"CVE-2013-3050": [
"24942"
],
"CVE-2006-1271": [
"27434"
],
"CVE-2006-1258": [
"27435"
],
"CVE-2006-1326": [
"27436",
"27437",
"27438",
"27439",
"27440",
"27441",
"27442"
],
"CVE-2013-2498": [
"24954"
],
"CVE-2013-3535": [
"24959"
],
"CVE-2013-3524": [
"24960"
],
"CVE-2013-1509": [
"24964"
],
"CVE-2013-2713": [
"24965"
],
"CVE-2013-2712": [
"24965"
],
"CVE-2005-1959": [
"25817"
],
"CVE-2005-1955": [
"25818"
],
"CVE-2005-0345": [
"25089"
],
"CVE-2004-1406": [
"24986"
],
"CVE-2004-1405": [
"24994"
],
"CVE-2013-2594": [
"25002"
],
"CVE-2013-3241": [
"25003"
],
"CVE-2013-3240": [
"25003"
],
"CVE-2013-3239": [
"25003"
],
"CVE-2005-0650": [
"25183"
],
"CVE-2004-1412": [
"25037"
],
"CVE-2004-1413": [
"25038"
],
"CVE-2004-2573": [
"25043"
],
"CVE-2004-2574": [
"25044"
],
"CVE-2004-1415": [
"25045"
],
"CVE-2004-1418": [
"25051"
],
"CVE-2005-0305": [
"25052",
"25053"
],
"CVE-2005-0307": [
"25059"
],
"CVE-2005-0313": [
"25064",
"25065"
],
"CVE-2005-0320": [
"25068",
"25069"
],
"CVE-2005-0420": [
"25084"
],
"CVE-2013-3242": [
"25087"
],
"CVE-2005-0443": [
"25097"
],
"CVE-2005-0442": [
"25098"
],
"CVE-2005-0409": [
"25099",
"25100"
],
"CVE-2005-0410": [
"25101"
],
"CVE-2005-0408": [
"25102"
],
"CVE-2005-0411": [
"25104"
],
"CVE-2005-0452": [
"25110"
],
"CVE-2005-0475": [
"25114",
"25115",
"25116",
"25117"
],
"CVE-2005-0251": [
"25118",
"25119"
],
"CVE-2005-0253": [
"25120"
],
"CVE-2005-0252": [
"25121"
],
"CVE-2005-0479": [
"25123"
],
"CVE-2005-0513": [
"25127"
],
"CVE-2013-1603": [
"25138"
],
"CVE-2013-1602": [
"25138"
],
"CVE-2013-1601": [
"25138"
],
"CVE-2013-1600": [
"25138"
],
"CVE-2013-1599": [
"25138"
],
"CVE-2013-1598": [
"25139"
],
"CVE-2013-1597": [
"25139"
],
"CVE-2013-1596": [
"25139"
],
"CVE-2013-1595": [
"25139"
],
"CVE-2013-1594": [
"25139"
],
"CVE-2005-0477": [
"25143"
],
"CVE-2005-0543": [
"25152",
"25153",
"25154",
"25155"
],
"CVE-2005-0569": [
"25160"
],
"CVE-2005-0606": [
"25162"
],
"CVE-2005-0670": [
"25174",
"25175"
],
"CVE-2005-0629": [
"25178"
],
"CVE-2005-0632": [
"25180"
],
"CVE-2005-0741": [
"25199"
],
"CVE-2005-0735": [
"25201"
],
"CVE-2005-0776": [
"25208"
],
"CVE-2005-0781": [
"25213",
"25214"
],
"CVE-2005-0782": [
"25215",
"25216"
],
"CVE-2005-0795": [
"25217"
],
"CVE-2005-0796": [
"25222"
],
"CVE-2005-0783": [
"25223"
],
"CVE-2005-0786": [
"25224"
],
"CVE-2005-0791": [
"25225"
],
"CVE-2005-0862": [
"25227",
"25228",
"25229"
],
"CVE-2005-0818": [
"25230"
],
"CVE-2005-0800": [
"25232"
],
"CVE-2005-0802": [
"25233"
],
"CVE-2005-0805": [
"25235"
],
"CVE-2005-0863": [
"25236"
],
"CVE-2005-0828": [
"25237"
],
"CVE-2005-0857": [
"25239"
],
"CVE-2005-0858": [
"25240"
],
"CVE-2005-0829": [
"25241"
],
"CVE-2005-0860": [
"25243"
],
"CVE-2005-0853": [
"25252"
],
"CVE-2005-0854": [
"25253",
"25254"
],
"CVE-2005-0842": [
"25257"
],
"CVE-2005-0843": [
"25258"
],
"CVE-2005-0879": [
"25260",
"25261"
],
"CVE-2005-0881": [
"25262"
],
"CVE-2005-0883": [
"25263",
"25264"
],
"CVE-2005-0870": [
"25265",
"25266"
],
"CVE-2005-0886": [
"25267"
],
"CVE-2005-0873": [
"25269"
],
"CVE-2005-0872": [
"25270"
],
"CVE-2005-0887": [
"25271"
],
"CVE-2005-0889": [
"25272"
],
"CVE-2005-0890": [
"25273",
"25555",
"25556"
],
"CVE-2005-0896": [
"25276"
],
"CVE-2005-0935": [
"25278",
"25279"
],
"CVE-2005-0936": [
"25280"
],
"CVE-2013-2684": [
"25292"
],
"CVE-2013-2683": [
"25292"
],
"CVE-2013-2682": [
"25292"
],
"CVE-2013-2681": [
"25292"
],
"CVE-2013-2680": [
"25292"
],
"CVE-2013-2945": [
"25298"
],
"CVE-2013-3336": [
"25305"
],
"CVE-2005-0928": [
"25308",
"25309",
"25310"
],
"CVE-2005-0945": [
"25313"
],
"CVE-2005-0931": [
"25314"
],
"CVE-2005-0925": [
"25317"
],
"CVE-2005-0948": [
"25318"
],
"CVE-2005-0962": [
"25320"
],
"CVE-2005-0955": [
"25323"
],
"CVE-2005-1008": [
"25324"
],
"CVE-2005-0980": [
"25327"
],
"CVE-2005-0981": [
"25328"
],
"CVE-2005-0992": [
"25330"
],
"CVE-2005-1006": [
"25331"
],
"CVE-2005-1011": [
"25332"
],
"CVE-2005-1004": [
"25337"
],
"CVE-2005-1005": [
"25338"
],
"CVE-2005-1000": [
"25339",
"25340",
"25342",
"25343"
],
"CVE-2005-1027": [
"25341"
],
"CVE-2005-1026": [
"25344",
"25345"
],
"CVE-2005-1029": [
"25346",
"25347"
],
"CVE-2005-1030": [
"25348",
"25349",
"25351",
"25352"
],
"CVE-2005-1095": [
"25354"
],
"CVE-2005-1033": [
"25355",
"25356",
"25357",
"25358"
],
"CVE-2005-0997": [
"25360"
],
"CVE-2005-1049": [
"25366",
"25367"
],
"CVE-2005-1073": [
"25369"
],
"CVE-2005-1074": [
"25370"
],
"CVE-2005-1075": [
"25371",
"25372"
],
"CVE-2005-1081": [
"25373"
],
"CVE-2005-1082": [
"25374"
],
"CVE-2005-1054": [
"25376"
],
"CVE-2005-1053": [
"25377",
"25378"
],
"CVE-2005-1079": [
"25379"
],
"CVE-2005-1070": [
"25380"
],
"CVE-2005-1076": [
"25381"
],
"CVE-2005-1071": [
"25382"
],
"CVE-2005-1188": [
"25390"
],
"CVE-2005-1130": [
"25394"
],
"CVE-2005-1117": [
"25422"
],
"CVE-2005-1135": [
"25423"
],
"CVE-2005-1161": [
"25424",
"25425",
"25426"
],
"CVE-2005-1162": [
"25427",
"25428"
],
"CVE-2005-1181": [
"25431"
],
"CVE-2005-1170": [
"25432"
],
"CVE-2005-1171": [
"25433"
],
"CVE-2005-1202": [
"25434",
"25435"
],
"CVE-2005-1203": [
"25436",
"25437"
],
"CVE-2005-1183": [
"25438"
],
"CVE-2013-2754": [
"25449"
],
"CVE-2005-1196": [
"25451"
],
"CVE-2005-1199": [
"25457"
],
"CVE-2005-4670": [
"25458"
],
"CVE-2005-4671": [
"25464"
],
"CVE-2005-1412": [
"25466"
],
"CVE-2005-1222": [
"25467"
],
"CVE-2005-1233": [
"25468",
"25473"
],
"CVE-2005-1223": [
"25469"
],
"CVE-2005-1224": [
"25476",
"25477",
"25478",
"25479",
"25480",
"25481"
],
"CVE-2005-1236": [
"25482",
"25483",
"25485",
"25484"
],
"CVE-2005-1285": [
"25503"
],
"CVE-2013-3294": [
"25518"
],
"CVE-2005-1293": [
"25529"
],
"CVE-2005-1329": [
"25530"
],
"CVE-2005-1325": [
"25531"
],
"CVE-2005-1308": [
"25534"
],
"CVE-2005-1360": [
"25538"
],
"CVE-2005-1398": [
"25548"
],
"CVE-2005-1374": [
"25549",
"25550",
"25551"
],
"CVE-2005-1378": [
"25558"
],
"CVE-2005-1403": [
"25560",
"25564",
"25565",
"25566"
],
"CVE-2005-1384": [
"25568",
"25569"
],
"CVE-2005-1479": [
"25570"
],
"CVE-2005-1440": [
"25575",
"25576",
"25577",
"25578",
"25579",
"25580"
],
"CVE-2005-1417": [
"25585",
"25586",
"25587",
"25588",
"25589"
],
"CVE-2005-1611": [
"25592"
],
"CVE-2005-1492": [
"25594"
],
"CVE-2005-1486": [
"25601",
"25602"
],
"CVE-2005-1487": [
"25603",
"25604"
],
"CVE-2005-1998": [
"25823"
],
"CVE-2005-1498": [
"25612"
],
"CVE-2005-1503": [
"25614"
],
"CVE-2005-1494": [
"25622"
],
"CVE-2005-1506": [
"25623"
],
"CVE-2005-1193": [
"25628"
],
"CVE-2005-1548": [
"25630"
],
"CVE-2005-1550": [
"25634"
],
"CVE-2005-1593": [
"25637"
],
"CVE-2005-1594": [
"25638"
],
"CVE-2004-2181": [
"25641"
],
"CVE-2005-1610": [
"25642"
],
"CVE-2005-1587": [
"25650"
],
"CVE-2005-1561": [
"25651"
],
"CVE-2005-1614": [
"25654"
],
"CVE-2005-1615": [
"25655"
],
"CVE-2005-1612": [
"25656"
],
"CVE-2005-1613": [
"25657"
],
"CVE-2005-1619": [
"25659",
"25660"
],
"CVE-2005-1645": [
"25661"
],
"CVE-2005-1620": [
"25662"
],
"CVE-2005-1366": [
"25666"
],
"CVE-2005-1637": [
"25671",
"25672"
],
"CVE-2005-1633": [
"25673",
"25674",
"25675",
"25676",
"25677",
"25678",
"25679"
],
"CVE-2005-1681": [
"25686"
],
"CVE-2005-1715": [
"25689"
],
"CVE-2005-1752": [
"25693"
],
"CVE-2005-1823": [
"25766",
"25759",
"25760",
"25761",
"25762",
"25763",
"25764",
"25765"
],
"CVE-2005-1754": [
"25702"
],
"CVE-2013-3531": [
"25726"
],
"CVE-2005-1782": [
"25727",
"25728",
"25729",
"25730",
"25731",
"25732",
"25733",
"25734",
"25735"
],
"CVE-2005-1800": [
"25740"
],
"CVE-2005-1817": [
"25741"
],
"CVE-2005-1803": [
"25742",
"25743",
"25744",
"25746",
"25747",
"25750"
],
"CVE-2005-1804": [
"25748",
"25749"
],
"CVE-2005-1805": [
"25751"
],
"CVE-2005-1788": [
"25753",
"25754"
],
"CVE-2005-1822": [
"25767",
"25768",
"25769",
"25770",
"25771",
"25772",
"25773",
"25774"
],
"CVE-2009-4823": [
"33417"
],
"CVE-2009-4428": [
"33418"
],
"CVE-2009-4435": [
"33419",
"33420"
],
"CVE-2013-2118": [
"33425"
],
"CVE-2005-1821": [
"25777"
],
"CVE-2005-1870": [
"25788"
],
"CVE-2005-1881": [
"25792"
],
"CVE-2005-1886": [
"25793"
],
"CVE-2005-1884": [
"25794"
],
"CVE-2005-1967": [
"25795",
"25796",
"25797",
"25798"
],
"CVE-2005-1893": [
"25799"
],
"CVE-2005-1895": [
"25800"
],
"CVE-2005-1894": [
"25801"
],
"CVE-2005-1943": [
"25804",
"25805"
],
"CVE-2005-1948": [
"25806"
],
"CVE-2013-2573": [
"25812"
],
"CVE-2013-2572": [
"25812"
],
"CVE-2013-1605": [
"25813"
],
"CVE-2013-1604": [
"25813"
],
"CVE-2013-2570": [
"25815"
],
"CVE-2013-2569": [
"25815"
],
"CVE-2013-2568": [
"25815"
],
"CVE-2013-2567": [
"25815"
],
"CVE-2005-2044": [
"25826",
"25827",
"25828",
"25829",
"25830",
"25831",
"25832",
"25833",
"25834"
],
"CVE-2005-2030": [
"25838"
],
"CVE-2005-2035": [
"25839"
],
"CVE-2005-1951": [
"25840"
],
"CVE-2005-2009": [
"25843",
"25844"
],
"CVE-2005-2010": [
"25845"
],
"CVE-2005-2021": [
"25846"
],
"CVE-2003-0557": [
"25847"
],
"CVE-2005-3043": [
"26291"
],
"CVE-2005-2033": [
"25853"
],
"CVE-2005-2011": [
"25854"
],
"CVE-2005-2012": [
"25856"
],
"CVE-2005-1526": [
"25857"
],
"CVE-2005-2199": [
"25858",
"25960"
],
"CVE-2005-1524": [
"25859",
"25927"
],
"CVE-2005-2046": [
"25860",
"25861",
"25862",
"25863",
"25864",
"25865",
"25867"
],
"CVE-2006-6365": [
"25866"
],
"CVE-2005-2048": [
"25868",
"25869",
"25870",
"25871"
],
"CVE-2005-2049": [
"25872",
"25873"
],
"CVE-2005-1250": [
"25874"
],
"CVE-2005-2064": [
"25905",
"25906"
],
"CVE-2005-2065": [
"25907"
],
"CVE-2005-2077": [
"25913"
],
"CVE-2003-0509": [
"25922",
"25923"
],
"CVE-2005-2154": [
"25926"
],
"CVE-2005-2140": [
"25924"
],
"CVE-2005-2155": [
"25928",
"25929",
"25930",
"25931",
"25932"
],
"CVE-2005-2256": [
"25938"
],
"CVE-2005-2163": [
"25940"
],
"CVE-2005-2162": [
"25941"
],
"CVE-2005-2318": [
"25965"
],
"CVE-2013-4098": [
"25976"
],
"CVE-2013-4097": [
"25976"
],
"CVE-2013-4096": [
"25976"
],
"CVE-2013-4095": [
"25977"
],
"CVE-2013-4094": [
"25977"
],
"CVE-2013-4093": [
"25977"
],
"CVE-2013-4092": [
"25977"
],
"CVE-2013-4091": [
"25977"
],
"CVE-2005-2326": [
"25990"
],
"CVE-2005-2330": [
"25994"
],
"CVE-2013-5948": [
"25998"
],
"CVE-2005-2276": [
"26001"
],
"CVE-2005-3052": [
"26293"
],
"CVE-2013-1081": [
"26012"
],
"CVE-2005-2383": [
"26016"
],
"CVE-2005-2455": [
"26017"
],
"CVE-2005-2386": [
"26033"
],
"CVE-2005-2397": [
"26034"
],
"CVE-2005-2324": [
"26037",
"26038"
],
"CVE-2005-2432": [
"26045"
],
"CVE-2005-2441": [
"26049",
"26050"
],
"CVE-2005-2460": [
"26051"
],
"CVE-2005-2461": [
"26052"
],
"CVE-2005-2467": [
"26056",
"26057",
"26058"
],
"CVE-2005-2560": [
"26060"
],
"CVE-2005-2466": [
"26062"
],
"CVE-2005-2476": [
"26063"
],
"CVE-2005-2480": [
"26065"
],
"CVE-2005-2483": [
"26066"
],
"CVE-2005-2488": [
"26067",
"26068"
],
"CVE-2005-2486": [
"26072"
],
"CVE-2005-3200": [
"26327",
"26328"
],
"CVE-2005-3083": [
"26298"
],
"CVE-2005-2543": [
"26080"
],
"CVE-2008-6562": [
"26086",
"31564"
],
"CVE-2005-4880": [
"26089",
"26090",
"26091",
"26092"
],
"CVE-2005-2539": [
"26098",
"26099"
],
"CVE-2005-3159": [
"26102"
],
"CVE-2005-2542": [
"26104"
],
"CVE-2005-2562": [
"26106"
],
"CVE-2005-2588": [
"26107",
"26108",
"26109"
],
"CVE-2007-3627": [
"26112",
"26113",
"26114"
],
"CVE-2005-2569": [
"26117",
"26118",
"26119",
"26120",
"26121",
"26122"
],
"CVE-2013-3739": [
"26125"
],
"CVE-2013-3961": [
"26136"
],
"CVE-2005-2616": [
"26140",
"26141",
"26142",
"26143"
],
"CVE-2005-2587": [
"26144"
],
"CVE-2005-2580": [
"26147",
"26148",
"26149",
"26150"
],
"CVE-2005-2603": [
"26153"
],
"CVE-2005-2637": [
"26159"
],
"CVE-2005-2638": [
"26160",
"26161"
],
"CVE-2005-2633": [
"26162",
"26163",
"26164",
"26165",
"26166"
],
"CVE-2005-2648": [
"26169"
],
"CVE-2005-2649": [
"26170"
],
"CVE-2005-2651": [
"26171"
],
"CVE-2005-2557": [
"26172"
],
"CVE-2013-3691": [
"26174"
],
"CVE-2013-3687": [
"26174"
],
"CVE-2013-3686": [
"26174"
],
"CVE-2013-3541": [
"26174"
],
"CVE-2013-3540": [
"26174"
],
"CVE-2005-2673": [
"26176"
],
"CVE-2005-2675": [
"26177",
"26178",
"26179",
"26180",
"26207"
],
"CVE-2005-2674": [
"26181",
"26182"
],
"CVE-2005-2683": [
"26184"
],
"CVE-2005-2689": [
"26187",
"26188"
],
"CVE-2005-2690": [
"26189"
],
"CVE-2005-2721": [
"26197"
],
"CVE-2005-2869": [
"26199"
],
"CVE-2005-2769": [
"26200"
],
"CVE-2005-2775": [
"26201"
],
"CVE-2005-2777": [
"26203"
],
"CVE-2005-2788": [
"26205",
"26206"
],
"CVE-2005-2782": [
"26208"
],
"CVE-2005-2783": [
"26209"
],
"CVE-2005-2792": [
"26211"
],
"CVE-2005-2813": [
"26212"
],
"CVE-2005-2814": [
"26215"
],
"CVE-2005-2846": [
"26217"
],
"CVE-2005-2855": [
"26224"
],
"CVE-2005-2885": [
"26225"
],
"CVE-2005-2896": [
"26234",
"26235",
"26236"
],
"CVE-2013-4665": [
"26244"
],
"CVE-2013-4664": [
"26244"
],
"CVE-2005-2952": [
"26252"
],
"CVE-2005-4821": [
"26253",
"26254"
],
"CVE-2005-2953": [
"26256"
],
"CVE-2005-2954": [
"26257"
],
"CVE-2005-2956": [
"26258"
],
"CVE-2005-2979": [
"26259"
],
"CVE-2005-2980": [
"26261"
],
"CVE-2005-2985": [
"26263"
],
"CVE-2005-2989": [
"26264",
"26265",
"26266",
"26267",
"26268"
],
"CVE-2005-3208": [
"26333",
"26334"
],
"CVE-2005-3026": [
"26272"
],
"CVE-2005-3019": [
"26273",
"26274",
"26275",
"26276"
],
"CVE-2005-3020": [
"26278",
"26279",
"26280",
"26281",
"26282",
"26283"
],
"CVE-2005-3004": [
"26284"
],
"CVE-2005-3005": [
"26285"
],
"CVE-2005-3127": [
"26300"
],
"CVE-2005-3152": [
"26303",
"26304"
],
"CVE-2005-3128": [
"26305"
],
"CVE-2005-3130": [
"26307"
],
"CVE-2005-3131": [
"26308",
"26309",
"26310",
"26311"
],
"CVE-2005-3133": [
"26313"
],
"CVE-2005-3305": [
"26386",
"26387",
"26388",
"26389"
],
"CVE-2005-4698": [
"26324"
],
"CVE-2005-3236": [
"26337",
"26338"
],
"CVE-2005-3237": [
"26339"
],
"CVE-2005-4770": [
"26343"
],
"CVE-2005-4694": [
"26344"
],
"CVE-2005-4799": [
"26345"
],
"CVE-2005-3290": [
"26346"
],
"CVE-2005-4674": [
"26348"
],
"CVE-2005-4675": [
"26349"
],
"CVE-2005-3518": [
"26350"
],
"CVE-2005-3285": [
"26351"
],
"CVE-2005-3522": [
"26354"
],
"CVE-2005-3520": [
"26355",
"26356",
"26357",
"26358",
"26359",
"26360",
"26361"
],
"CVE-2005-3519": [
"26362",
"26363",
"26364",
"26365",
"26369",
"26370",
"26371",
"26372",
"26373"
],
"CVE-2013-2227": [
"26366"
],
"CVE-2013-2226": [
"26366"
],
"CVE-2005-3514": [
"26378",
"26379"
],
"CVE-2005-3515": [
"26380"
],
"CVE-2005-3516": [
"26381"
],
"CVE-2005-3308": [
"26383"
],
"CVE-2005-3307": [
"26384"
],
"CVE-2005-3320": [
"26391"
],
"CVE-2005-3301": [
"26392",
"26393"
],
"CVE-2005-3324": [
"26394"
],
"CVE-2005-3325": [
"26395"
],
"CVE-2005-3326": [
"26396"
],
"CVE-2005-4702": [
"26397"
],
"CVE-2005-3329": [
"26398"
],
"CVE-2005-3332": [
"26399"
],
"CVE-2005-3334": [
"26400"
],
"CVE-2013-4953": [
"26405"
],
"CVE-2013-5321": [
"26406"
],
"CVE-2006-1579": [
"27541"
],
"CVE-2006-1659": [
"27542",
"27543",
"27544",
"27545",
"27546"
],
"CVE-2013-3307": [
"26415"
],
"CVE-2013-4952": [
"26416"
],
"CVE-2005-4243": [
"26827",
"26829",
"26830",
"26828",
"26831",
"26832"
],
"CVE-2005-3369": [
"26425"
],
"CVE-2005-3408": [
"26427"
],
"CVE-2005-3368": [
"26428"
],
"CVE-2005-3315": [
"26429",
"26430"
],
"CVE-2005-3405": [
"26431"
],
"CVE-2005-3404": [
"26432",
"26433"
],
"CVE-2005-3422": [
"26435"
],
"CVE-2005-3432": [
"26436"
],
"CVE-2005-3395": [
"26438"
],
"CVE-2005-3411": [
"26439"
],
"CVE-2005-3478": [
"26440"
],
"CVE-2005-3394": [
"26441"
],
"CVE-2005-3388": [
"26442"
],
"CVE-2005-3397": [
"26444"
],
"CVE-2005-4769": [
"26446"
],
"CVE-2005-3412": [
"26447"
],
"CVE-2005-3512": [
"26455"
],
"CVE-2005-3469": [
"26458"
],
"CVE-2005-3584": [
"26459"
],
"CVE-2005-3473": [
"26461",
"26462",
"26463"
],
"CVE-2005-3507": [
"26465",
"26466"
],
"CVE-2005-3508": [
"26468"
],
"CVE-2005-3509": [
"26469",
"26470"
],
"CVE-2005-4657": [
"26473"
],
"CVE-2005-4423": [
"26474"
],
"CVE-2005-3559": [
"26475"
],
"CVE-2005-3558": [
"26476"
],
"CVE-2005-3544": [
"26477",
"27206"
],
"CVE-2005-3547": [
"26478"
],
"CVE-2005-3550": [
"26480"
],
"CVE-2005-3555": [
"26481",
"26482"
],
"CVE-2005-3556": [
"26483",
"26484",
"26485"
],
"CVE-2005-3636": [
"26486"
],
"CVE-2005-3635": [
"26487"
],
"CVE-2005-3634": [
"26488"
],
"CVE-2005-3676": [
"26500"
],
"CVE-2005-3679": [
"26501"
],
"CVE-2005-3639": [
"26502"
],
"CVE-2005-3571": [
"26505"
],
"CVE-2005-3576": [
"26506"
],
"CVE-2005-3577": [
"26507"
],
"CVE-2005-3578": [
"26508"
],
"CVE-2005-3579": [
"26509"
],
"CVE-2005-4647": [
"26510"
],
"CVE-2005-4646": [
"26511"
],
"CVE-2005-3789": [
"26512",
"26513"
],
"CVE-2005-3790": [
"26514"
],
"CVE-2005-3797": [
"26515"
],
"CVE-2005-3638": [
"26516"
],
"CVE-2013-1414": [
"26528"
],
"CVE-2013-2225": [
"26530"
],
"CVE-2005-3727": [
"26532"
],
"CVE-2005-3728": [
"26533"
],
"CVE-2005-3730": [
"26534"
],
"CVE-2005-3695": [
"26535"
],
"CVE-2005-3685": [
"26537"
],
"CVE-2005-3742": [
"26539"
],
"CVE-2005-3743": [
"26541"
],
"CVE-2005-3746": [
"26543"
],
"CVE-2005-3769": [
"26544"
],
"CVE-2005-3748": [
"26545"
],
"CVE-2005-3770": [
"26546",
"26547"
],
"CVE-2005-4160": [
"26549"
],
"CVE-2005-3893": [
"26550",
"26551"
],
"CVE-2005-3894": [
"26552"
],
"CVE-2013-4950": [
"26553"
],
"CVE-2013-4949": [
"26553"
],
"CVE-2013-4948": [
"26553"
],
"CVE-2005-3902": [
"26559"
],
"CVE-2005-3849": [
"26560"
],
"CVE-2005-3855": [
"26561"
],
"CVE-2005-3914": [
"26562",
"26563",
"26564"
],
"CVE-2005-3833": [
"26565"
],
"CVE-2005-3834": [
"26566"
],
"CVE-2005-3916": [
"26567"
],
"CVE-2005-3826": [
"26571"
],
"CVE-2005-3954": [
"26572"
],
"CVE-2005-3955": [
"26573",
"26574"
],
"CVE-2005-3816": [
"26576"
],
"CVE-2005-3818": [
"26584",
"26585"
],
"CVE-2005-3819": [
"26586"
],
"CVE-2005-3825": [
"26587"
],
"CVE-2005-3815": [
"26588"
],
"CVE-2005-3918": [
"26589",
"26590"
],
"CVE-2005-4167": [
"26591"
],
"CVE-2005-4168": [
"26592"
],
"CVE-2005-4169": [
"26593"
],
"CVE-2005-4170": [
"26594"
],
"CVE-2005-3838": [
"26595"
],
"CVE-2005-3827": [
"26596"
],
"CVE-2005-3919": [
"26597"
],
"CVE-2005-3860": [
"26598"
],
"CVE-2005-3861": [
"26599"
],
"CVE-2005-3859": [
"26600"
],
"CVE-2005-3875": [
"26602",
"26603"
],
"CVE-2005-3884": [
"26604"
],
"CVE-2005-3920": [
"26605"
],
"CVE-2005-3920 ": [
"26606"
],
"CVE-2005-4781": [
"26607"
],
"CVE-2005-3844": [
"26608"
],
"CVE-2005-3953": [
"26609",
"26610",
"26611"
],
"CVE-2005-3879": [
"26613",
"26614",
"26615",
"26616"
],
"CVE-2005-3864": [
"26617"
],
"CVE-2005-3865": [
"26618"
],
"CVE-2013-3729": [
"26623"
],
"CVE-2013-3728": [
"26623"
],
"CVE-2013-3727": [
"26623"
],
"CVE-2013-7376": [
"26624"
],
"CVE-2013-3515": [
"26624"
],
"CVE-2013-3514": [
"26624"
],
"CVE-2005-3870": [
"26625"
],
"CVE-2005-3872": [
"26626",
"26627"
],
"CVE-2005-3873": [
"26628"
],
"CVE-2005-3874": [
"26629"
],
"CVE-2000-0751": [
"26630"
],
"CVE-2005-3877": [
"26631",
"26632"
],
"CVE-2005-3924": [
"26634"
],
"CVE-2005-3959": [
"26635"
],
"CVE-2005-3925": [
"26637",
"26638"
],
"CVE-2005-3927": [
"26639",
"26640",
"26641",
"26642"
],
"CVE-2005-3878": [
"26643"
],
"CVE-2005-3931": [
"26645"
],
"CVE-2005-3947": [
"26646"
],
"CVE-2005-3846": [
"26647"
],
"CVE-2005-3956": [
"26649"
],
"CVE-2005-3958": [
"26650"
],
"CVE-2005-3911": [
"26651"
],
"CVE-2005-3909": [
"26652"
],
"CVE-2005-3908": [
"26653"
],
"CVE-2005-3942": [
"26656"
],
"CVE-2005-3941": [
"26657"
],
"CVE-2005-3940": [
"26658"
],
"CVE-2005-3943": [
"26659",
"26660"
],
"CVE-2005-3944": [
"26661"
],
"CVE-2005-3930": [
"26662"
],
"CVE-2005-3935": [
"26667"
],
"CVE-2005-3938": [
"26673",
"26674",
"26675",
"26676",
"26677"
],
"CVE-2005-3882": [
"26678"
],
"CVE-2005-3939": [
"26679",
"26680",
"26681"
],
"CVE-2005-3932": [
"26683"
],
"CVE-2005-3933": [
"26684"
],
"CVE-2005-3986": [
"26685",
"26686"
],
"CVE-2005-3988": [
"26688"
],
"CVE-2005-3963": [
"26689"
],
"CVE-2005-3982": [
"26691"
],
"CVE-2005-3972": [
"26692"
],
"CVE-2005-3980": [
"26693"
],
"CVE-2005-3991": [
"26694",
"26695",
"26696"
],
"CVE-2005-3968": [
"26697"
],
"CVE-2005-3966": [
"26700"
],
"CVE-2005-4003": [
"26701",
"26702"
],
"CVE-2005-3998": [
"26704"
],
"CVE-2005-4000": [
"26705"
],
"CVE-2005-4005": [
"26706"
],
"CVE-2005-4081": [
"26707"
],
"CVE-2005-4001": [
"26713",
"26714"
],
"CVE-2005-4016": [
"26715"
],
"CVE-2005-4032": [
"26716"
],
"CVE-2005-4035": [
"26717",
"26718",
"26719"
],
"CVE-2005-4018": [
"26720"
],
"CVE-2005-4091": [
"26721"
],
"CVE-2005-4043": [
"26722"
],
"CVE-2005-4019": [
"26723"
],
"CVE-2005-4034": [
"26724",
"26725",
"26726",
"26727"
],
"CVE-2005-4037": [
"26729"
],
"CVE-2005-4039": [
"26730"
],
"CVE-2005-4049": [
"26731"
],
"CVE-2005-4065": [
"26732"
],
"CVE-2013-5633": [
"26736"
],
"CVE-2013-5632": [
"26736"
],
"CVE-2013-5631": [
"26736"
],
"CVE-2013-5630": [
"26736",
"28053"
],
"CVE-2013-5628": [
"26736"
],
"CVE-2013-5627": [
"26736",
"28053"
],
"CVE-2013-5625": [
"26736",
"28053"
],
"CVE-2013-5624": [
"26736",
"28053"
],
"CVE-2013-5623": [
"26736"
],
"CVE-2013-5622": [
"26736",
"28053"
],
"CVE-2013-5621": [
"26736",
"28053"
],
"CVE-2006-1783": [
"27634"
],
"CVE-2005-4166": [
"26742"
],
"CVE-2005-4047": [
"26743"
],
"CVE-2005-4063": [
"26744"
],
"CVE-2005-4060": [
"26745"
],
"CVE-2005-4064": [
"26746",
"26747"
],
"CVE-2005-4054": [
"26750"
],
"CVE-2005-4055": [
"26751"
],
"CVE-2005-4139": [
"26755",
"26756",
"26757"
],
"CVE-2005-4136": [
"26758"
],
"CVE-2005-4141": [
"26759",
"26760"
],
"CVE-2005-4073": [
"26763"
],
"CVE-2005-4071": [
"26764",
"26765"
],
"CVE-2005-4074": [
"26766"
],
"CVE-2005-4075": [
"26767"
],
"CVE-2005-4161": [
"26770"
],
"CVE-2005-4197": [
"26771"
],
"CVE-2005-4177": [
"26772"
],
"CVE-2005-4205": [
"26777"
],
"CVE-2005-4206": [
"26778"
],
"CVE-2005-4196": [
"26780",
"26781",
"26782"
],
"CVE-2005-4207": [
"26784"
],
"CVE-2005-4221": [
"26785"
],
"CVE-2005-4229": [
"26786"
],
"CVE-2005-4211": [
"26787"
],
"CVE-2005-4212": [
"26788"
],
"CVE-2005-4234": [
"26789"
],
"CVE-2005-4228": [
"26790",
"26791",
"26792"
],
"CVE-2005-4246": [
"26793"
],
"CVE-2005-4247": [
"26794"
],
"CVE-2005-4240": [
"26795"
],
"CVE-2005-4241": [
"26796"
],
"CVE-2005-4239": [
"26797"
],
"CVE-2005-4238": [
"26798"
],
"CVE-2005-4244": [
"26799",
"26800"
],
"CVE-2005-4245": [
"26801"
],
"CVE-2013-4946": [
"26806"
],
"CVE-2013-4945": [
"26806"
],
"CVE-2013-4883": [
"26807"
],
"CVE-2013-4882": [
"26807"
],
"CVE-2005-4250": [
"26808"
],
"CVE-2005-4251": [
"26809",
"26810"
],
"CVE-2005-4233": [
"26812"
],
"CVE-2005-4232": [
"26813"
],
"CVE-2005-4254": [
"26814"
],
"CVE-2005-4260": [
"26817"
],
"CVE-2005-4262": [
"26818"
],
"CVE-2005-4263": [
"26819"
],
"CVE-2005-4256": [
"26820"
],
"CVE-2005-4259": [
"26821",
"26822",
"26823"
],
"CVE-2005-4255": [
"26824"
],
"CVE-2005-4198": [
"26826"
],
"CVE-2005-4317": [
"26836"
],
"CVE-2005-4319": [
"26837"
],
"CVE-2005-4288": [
"26838"
],
"CVE-2005-4415": [
"26839"
],
"CVE-2005-4416": [
"26840"
],
"CVE-2005-4287": [
"26841"
],
"CVE-2005-4306": [
"26842",
"26843"
],
"CVE-2005-4311": [
"26844"
],
"CVE-2005-4299": [
"26845"
],
"CVE-2005-4298": [
"26846"
],
"CVE-2005-4289": [
"26847"
],
"CVE-2005-4290": [
"26848"
],
"CVE-2005-4291": [
"26849"
],
"CVE-2005-4314": [
"26850"
],
"CVE-2005-4293": [
"26851"
],
"CVE-2005-4285": [
"26852"
],
"CVE-2005-4302": [
"26853"
],
"CVE-2005-4303": [
"26854"
],
"CVE-2005-4330": [
"26855"
],
"CVE-2005-4331": [
"26856"
],
"CVE-2005-4329": [
"26857"
],
"CVE-2005-4333": [
"26858",
"26859",
"26860"
],
"CVE-2005-4307": [
"26861",
"26862",
"26863"
],
"CVE-2005-4328": [
"26864"
],
"CVE-2005-4327": [
"26865"
],
"CVE-2005-4432": [
"26871"
],
"CVE-2005-4516": [
"26872"
],
"CVE-2005-4370": [
"26873"
],
"CVE-2005-4371": [
"26874"
],
"CVE-2005-4374": [
"26875",
"26876"
],
"CVE-2005-4375": [
"26877"
],
"CVE-2005-4381": [
"26878"
],
"CVE-2005-4385": [
"26879"
],
"CVE-2005-4365": [
"26880",
"26881"
],
"CVE-2005-4364": [
"26882"
],
"CVE-2005-4399": [
"26883"
],
"CVE-2005-4400": [
"26884"
],
"CVE-2005-4780": [
"26885"
],
"CVE-2005-4361": [
"26895"
],
"CVE-2005-4390": [
"26896"
],
"CVE-2005-4527": [
"26897"
],
"CVE-2005-4403": [
"26899"
],
"CVE-2005-4408": [
"26900",
"26901",
"26902"
],
"CVE-2005-4378": [
"26903"
],
"CVE-2005-4380": [
"26904",
"26905",
"26906",
"26907",
"26908"
],
"CVE-2005-4363": [
"26911"
],
"CVE-2005-4510": [
"26914"
],
"CVE-2005-4563": [
"26916"
],
"CVE-2005-4454": [
"26917"
],
"CVE-2005-4573": [
"26918"
],
"CVE-2005-4435": [
"26919"
],
"CVE-2005-4419": [
"26920"
],
"CVE-2005-4462": [
"26921"
],
"CVE-2005-4460": [
"26923"
],
"CVE-2005-4476": [
"26924"
],
"CVE-2005-4477": [
"26925"
],
"CVE-2005-4482": [
"26926"
],
"CVE-2005-4483": [
"26927"
],
"CVE-2005-4484": [
"26928",
"26929"
],
"CVE-2005-4485": [
"26930",
"26931",
"26932",
"26933",
"26934",
"26935",
"26936"
],
"CVE-2005-4488": [
"26937"
],
"CVE-2005-4489": [
"26938",
"26939"
],
"CVE-2005-4490": [
"26940",
"26941",
"26942",
"26943",
"26944",
"26945",
"26946"
],
"CVE-2005-4491": [
"26947",
"26948",
"26949"
],
"CVE-2013-5979": [
"26955"
],
"CVE-2013-5099": [
"26958"
],
"CVE-2005-4478": [
"26959",
"26960",
"26961"
],
"CVE-2005-4479": [
"26962"
],
"CVE-2005-4486": [
"26963",
"26964"
],
"CVE-2005-4500": [
"26965",
"27445"
],
"CVE-2005-4496": [
"26968"
],
"CVE-2005-4497": [
"26969"
],
"CVE-2005-4550": [
"26972"
],
"CVE-2005-4427": [
"26973",
"26974",
"26975"
],
"CVE-2005-4555": [
"26978"
],
"CVE-2005-4556": [
"26979",
"26980"
],
"CVE-2005-4557": [
"26981"
],
"CVE-2005-4558": [
"26982",
"26983"
],
"CVE-2005-4559": [
"26984"
],
"CVE-2005-4574": [
"26986"
],
"CVE-2005-4576": [
"26987"
],
"CVE-2005-4588": [
"26988"
],
"CVE-2005-4627": [
"26989"
],
"CVE-2005-4596": [
"26992"
],
"CVE-2005-4598": [
"26993"
],
"CVE-2005-4637": [
"26994"
],
"CVE-2006-0076": [
"26998"
],
"CVE-2006-0075": [
"26999"
],
"CVE-2006-0074": [
"27002"
],
"CVE-2006-0088": [
"27003"
],
"CVE-2006-0066": [
"27004"
],
"CVE-2006-0136": [
"27016"
],
"CVE-2006-0137": [
"27017"
],
"CVE-2006-0079": [
"27018"
],
"CVE-2006-0073": [
"27021"
],
"CVE-2005-4430": [
"27028"
],
"CVE-2005-3845": [
"27029"
],
"CVE-2005-4429": [
"27030"
],
"CVE-2006-0110": [
"27033"
],
"CVE-2006-0115": [
"27034",
"27035",
"27036"
],
"CVE-2006-0135": [
"27037"
],
"CVE-2006-0103": [
"27038"
],
"CVE-2006-1121": [
"27356"
],
"CVE-2006-1073": [
"27357"
],
"CVE-2006-1071": [
"27358"
],
"CVE-2006-1070": [
"27359"
],
"CVE-2006-1216": [
"27360"
],
"CVE-2006-0125": [
"27048"
],
"CVE-2006-0154": [
"27052"
],
"CVE-2006-0160": [
"27053"
],
"CVE-2006-0153": [
"27054"
],
"CVE-2006-0163": [
"27058"
],
"CVE-2006-0198": [
"27059"
],
"CVE-2006-0185": [
"27060"
],
"CVE-2006-0173": [
"27061"
],
"CVE-2006-0174": [
"27062"
],
"CVE-2006-0175": [
"27063"
],
"CVE-2006-0171": [
"27064"
],
"CVE-2006-0167": [
"27067",
"27068"
],
"CVE-2006-0210": [
"27070"
],
"CVE-2006-0194": [
"27071"
],
"CVE-2006-0209": [
"27075"
],
"CVE-2013-2574": [
"27076"
],
"CVE-2006-0222": [
"27078"
],
"CVE-2006-0211": [
"27079"
],
"CVE-2006-0217": [
"27081",
"27091"
],
"CVE-2006-0240": [
"27083"
],
"CVE-2006-0320": [
"27084"
],
"CVE-2006-0361": [
"27085"
],
"CVE-2006-0235": [
"27086"
],
"CVE-2006-0249": [
"27087"
],
"CVE-2006-0251": [
"27088"
],
"CVE-2006-0237": [
"27092"
],
"CVE-2006-0315": [
"27093"
],
"CVE-2006-0244": [
"27097"
],
"CVE-2006-0317": [
"27098"
],
"CVE-2006-0318": [
"27099"
],
"CVE-2006-0234": [
"27100"
],
"CVE-2006-0358": [
"27102",
"27103"
],
"CVE-2006-0310": [
"27104"
],
"CVE-2006-0311": [
"27105"
],
"CVE-2006-0312": [
"27106"
],
"CVE-2006-0366": [
"27109"
],
"CVE-2006-0349": [
"27110"
],
"CVE-2006-0350": [
"27111"
],
"CVE-2006-0345": [
"27112"
],
"CVE-2006-0324": [
"27114"
],
"CVE-2006-0341": [
"27115"
],
"CVE-2006-0413": [
"27116"
],
"CVE-2006-0372": [
"27117"
],
"CVE-2006-0407": [
"27120"
],
"CVE-2006-0418": [
"27121"
],
"CVE-2006-0442": [
"27122"
],
"CVE-2006-0409": [
"27123"
],
"CVE-2006-0415": [
"27124"
],
"CVE-2006-0417": [
"27125"
],
"CVE-2006-0443": [
"27126"
],
"CVE-2006-0461": [
"27127"
],
"CVE-2013-1616": [
"27136"
],
"CVE-2006-0470": [
"27137"
],
"CVE-2006-0462": [
"27138"
],
"CVE-2006-0473": [
"27139"
],
"CVE-2005-4334": [
"27143"
],
"CVE-2006-0480": [
"27146"
],
"CVE-2006-0479": [
"27147"
],
"CVE-2006-0524": [
"27149"
],
"CVE-2006-0510": [
"27151"
],
"CVE-2006-0509": [
"27153"
],
"CVE-2006-0502": [
"27154"
],
"CVE-2006-1974": [
"27155"
],
"CVE-2006-0491": [
"27156"
],
"CVE-2006-0518": [
"27158"
],
"CVE-2006-0532": [
"27160"
],
"CVE-2006-0534": [
"27161"
],
"CVE-2006-0513": [
"27163"
],
"CVE-2006-0545": [
"27164"
],
"CVE-2005-4461": [
"27165"
],
"CVE-2006-0624": [
"27169"
],
"CVE-2006-0651": [
"27170"
],
"CVE-2006-0625": [
"27172"
],
"CVE-2006-0650": [
"27173"
],
"CVE-2006-0669": [
"27174"
],
"CVE-2006-0942": [
"27175"
],
"CVE-2013-3365": [
"27177"
],
"CVE-2013-3098": [
"27177"
],
"CVE-2006-1076": [
"27361"
],
"CVE-2006-0758": [
"27186"
],
"CVE-2006-0713": [
"27192",
"27193",
"27194",
"27195"
],
"CVE-2006-0700": [
"27197"
],
"CVE-2006-0701": [
"27198"
],
"CVE-2006-0703": [
"27199"
],
"CVE-2006-0702": [
"27200"
],
"CVE-2006-0675": [
"27201"
],
"CVE-2006-0774": [
"27202"
],
"CVE-2006-0684": [
"27204"
],
"CVE-2006-0685": [
"27205"
],
"CVE-2006-0676": [
"27208"
],
"CVE-2006-0706": [
"27209"
],
"CVE-2006-0699": [
"27213"
],
"CVE-2006-0719": [
"27214"
],
"CVE-2006-0715": [
"27215"
],
"CVE-2005-3853": [
"27216"
],
"CVE-2006-0721": [
"27226"
],
"CVE-2006-0733": [
"27227"
],
"CVE-2006-0841": [
"27228",
"27229"
],
"CVE-2006-0735": [
"27230"
],
"CVE-2006-0791": [
"27238"
],
"CVE-2006-0775": [
"27239"
],
"CVE-2006-0783": [
"27243"
],
"CVE-2006-0792": [
"27245"
],
"CVE-2006-0857": [
"27247"
],
"CVE-2006-0832": [
"27248"
],
"CVE-2006-0805": [
"27249"
],
"CVE-2006-0691": [
"27250"
],
"CVE-2006-0673": [
"27251"
],
"CVE-2006-0885": [
"27252"
],
"CVE-2006-0800": [
"27254"
],
"CVE-2006-0801": [
"27255"
],
"CVE-2006-0875": [
"27256"
],
"CVE-2006-0880": [
"27259"
],
"CVE-2006-0879": [
"27260"
],
"CVE-2006-0882": [
"27261"
],
"CVE-2006-0881": [
"27262"
],
"CVE-2006-1033": [
"27263",
"27264",
"27265",
"27266",
"27267",
"27268",
"27269"
],
"CVE-2006-1425": [
"27494"
],
"CVE-2006-1428": [
"27495",
"27496"
],
"CVE-2013-4898": [
"27272"
],
"CVE-2013-5318": [
"27274"
],
"CVE-2013-3215": [
"27279"
],
"CVE-2013-3213": [
"27279"
],
"CVE-2013-3212": [
"27279"
],
"CVE-2013-7389": [
"27283"
],
"CVE-2013-4859": [
"27284"
],
"CVE-2013-4865": [
"27286"
],
"CVE-2013-4864": [
"27286"
],
"CVE-2013-4862": [
"27286"
],
"CVE-2013-4861": [
"27286"
],
"CVE-2013-4789": [
"27287"
],
"CVE-2013-5006": [
"27288"
],
"CVE-2013-2581": [
"27289"
],
"CVE-2013-2580": [
"27289"
],
"CVE-2013-2579": [
"27289"
],
"CVE-2013-2578": [
"27289"
],
"CVE-2013-3803": [
"27291"
],
"CVE-2006-0835": [
"27298"
],
"CVE-2006-0894": [
"27299",
"27300",
"27301",
"27302"
],
"CVE-2006-0920": [
"27303"
],
"CVE-2006-0922": [
"27304"
],
"CVE-2006-0933": [
"27305"
],
"CVE-2006-0927": [
"27306",
"27307"
],
"CVE-2006-0923": [
"27308",
"27309"
],
"CVE-2006-0974": [
"27310"
],
"CVE-2006-0976": [
"27311"
],
"CVE-2006-0936": [
"27312"
],
"CVE-2006-0939": [
"27313",
"27314"
],
"CVE-2013-5317": [
"27315"
],
"CVE-2013-5316": [
"27315"
],
"CVE-2006-0946": [
"27320"
],
"CVE-2006-0972": [
"27321"
],
"CVE-2006-1034": [
"27322",
"27323"
],
"CVE-2006-0944": [
"27324"
],
"CVE-2006-0906": [
"27327",
"27328"
],
"CVE-2006-1007": [
"27330"
],
"CVE-2006-1008": [
"27331",
"27332"
],
"CVE-2006-0983": [
"27333"
],
"CVE-2006-0984": [
"27336"
],
"CVE-2006-1045": [
"27337"
],
"CVE-2006-1021": [
"27338"
],
"CVE-2006-1022": [
"27339"
],
"CVE-2006-1013": [
"27340"
],
"CVE-2006-1018": [
"27341"
],
"CVE-2006-1081": [
"27342"
],
"CVE-2006-1040": [
"27343"
],
"CVE-2006-1098": [
"27344"
],
"CVE-2006-1099": [
"27345"
],
"CVE-2006-1132": [
"27346"
],
"CVE-2006-1133": [
"27347",
"27348"
],
"CVE-2006-0877": [
"27354"
],
"CVE-2006-1215": [
"27355"
],
"CVE-2006-1131": [
"27362"
],
"CVE-2006-3053": [
"27363"
],
"CVE-2006-1080": [
"27364"
],
"CVE-2006-1199": [
"27367"
],
"CVE-2006-1113": [
"27368"
],
"CVE-2006-1114": [
"27369",
"27370"
],
"CVE-2006-1144": [
"27371",
"27372"
],
"CVE-2006-1202": [
"27373"
],
"CVE-2006-1135": [
"27374",
"27375"
],
"CVE-2006-1157": [
"27379"
],
"CVE-2006-1205": [
"27380",
"27381",
"27382",
"27383",
"27384",
"27385",
"27386",
"27387",
"27388",
"27389"
],
"CVE-2006-1120": [
"27390",
"27391",
"27392",
"27393",
"27394",
"27395"
],
"CVE-2013-4977": [
"27402"
],
"CVE-2013-4976": [
"27402"
],
"CVE-2013-4975": [
"27402"
],
"CVE-2013-4884": [
"27406"
],
"CVE-2006-1196": [
"27409",
"27410",
"27411",
"27412"
],
"CVE-2006-1212": [
"27413"
],
"CVE-2006-1230": [
"27414"
],
"CVE-2006-1233": [
"27415",
"27416",
"27417"
],
"CVE-2006-1234": [
"27423"
],
"CVE-2006-1232": [
"27424"
],
"CVE-2013-5121": [
"27430"
],
"CVE-2013-5120": [
"27430"
],
"CVE-2013-4880": [
"27431"
],
"CVE-2013-4879": [
"27431"
],
"CVE-2013-4881": [
"27431"
],
"CVE-2006-2973": [
"27990"
],
"CVE-2006-1336": [
"27443"
],
"CVE-2006-1324": [
"27444"
],
"CVE-2006-1349": [
"27446",
"27447"
],
"CVE-2006-1330": [
"27448",
"27449"
],
"CVE-2006-1323": [
"27450"
],
"CVE-2006-1344": [
"27451"
],
"CVE-2006-1367": [
"27454"
],
"CVE-2006-1372": [
"27455",
"27456",
"27457"
],
"CVE-2006-1377": [
"27458",
"27459"
],
"CVE-2006-1374": [
"27462"
],
"CVE-2006-1384": [
"27463"
],
"CVE-2006-1395": [
"27464"
],
"CVE-2006-1496": [
"27465"
],
"CVE-2006-1497": [
"27466"
],
"CVE-2006-1482": [
"27467"
],
"CVE-2006-1419": [
"27468"
],
"CVE-2006-1413": [
"27469",
"27470",
"27471",
"27472",
"27473"
],
"CVE-2006-1420": [
"27475"
],
"CVE-2006-1334": [
"27477",
"27478"
],
"CVE-2006-1414": [
"27479"
],
"CVE-2006-1417": [
"27480",
"27481"
],
"CVE-2006-1418": [
"27482"
],
"CVE-2006-1426": [
"27483",
"27484"
],
"CVE-2006-1238": [
"27485"
],
"CVE-2006-1407": [
"27486",
"27487"
],
"CVE-2006-1404": [
"27488"
],
"CVE-2006-1431": [
"27489"
],
"CVE-2006-1429": [
"27490"
],
"CVE-2006-1489": [
"27491"
],
"CVE-2006-1487": [
"27492"
],
"CVE-2006-1486": [
"27493"
],
"CVE-2006-1430": [
"27497",
"27498",
"27499"
],
"CVE-2006-1504": [
"27500",
"27501"
],
"CVE-2006-1508": [
"27502",
"27503",
"27504",
"27505",
"27506"
],
"CVE-2006-1556": [
"27507"
],
"CVE-2006-1501": [
"27509"
],
"CVE-2006-1536": [
"27510",
"27511"
],
"CVE-2006-1535": [
"27512"
],
"CVE-2006-1543": [
"27513"
],
"CVE-2013-5312": [
"27519"
],
"CVE-2013-5311": [
"27519"
],
"CVE-2008-2335": [
"27519"
],
"CVE-2006-2001": [
"27729"
],
"CVE-2013-7368": [
"27522"
],
"CVE-2013-7349": [
"27522",
"28684"
],
"CVE-2013-5640": [
"27522",
"28684"
],
"CVE-2006-1557": [
"27533"
],
"CVE-2005-3302": [
"27728"
],
"CVE-2013-4241": [
"27531"
],
"CVE-2013-4240": [
"27531"
],
"CVE-2006-1573": [
"27534"
],
"CVE-2006-1572": [
"27535"
],
"CVE-2006-1567": [
"27536"
],
"CVE-2006-1584": [
"27537"
],
"CVE-2006-1569": [
"27538",
"27539"
],
"CVE-2006-1568": [
"27540"
],
"CVE-2006-1595": [
"27548",
"27549"
],
"CVE-2006-1581": [
"27550"
],
"CVE-2006-1582": [
"27551"
],
"CVE-2006-1586": [
"27552"
],
"CVE-2006-1580": [
"27558",
"27559"
],
"CVE-2006-1613": [
"27560"
],
"CVE-2006-1427": [
"27561",
"27562"
],
"CVE-2006-1634": [
"27563"
],
"CVE-2006-1661": [
"27571",
"27572",
"27573"
],
"CVE-2006-1590": [
"27574"
],
"CVE-2006-1755": [
"27575"
],
"CVE-2006-1676": [
"27576"
],
"CVE-2006-1679": [
"27578"
],
"CVE-2006-1745": [
"27579"
],
"CVE-2006-1673": [
"27580"
],
"CVE-2006-1699": [
"27582"
],
"CVE-2006-1682": [
"27583"
],
"CVE-2006-1765": [
"27584"
],
"CVE-2006-1713": [
"27585"
],
"CVE-2006-1714": [
"27586"
],
"CVE-2006-1675": [
"27587",
"27588"
],
"CVE-2006-1702": [
"27589"
],
"CVE-2006-1685": [
"27590"
],
"CVE-2006-1701": [
"27591"
],
"CVE-2006-1704": [
"27592"
],
"CVE-2006-1758": [
"27593"
],
"CVE-2006-1697": [
"27594"
],
"CVE-2014-1222": [
"27597",
"32213",
"36581"
],
"CVE-2013-5117": [
"27602"
],
"CVE-2006-1706": [
"27612",
"27613",
"27614"
],
"CVE-2006-1770": [
"27615"
],
"CVE-2006-1760": [
"27616",
"27617",
"27618",
"27619"
],
"CVE-2006-0015": [
"27620"
],
"CVE-2006-1718": [
"27621"
],
"CVE-2006-1759": [
"27623"
],
"CVE-2006-1773": [
"27624"
],
"CVE-2006-1768": [
"27626"
],
"CVE-2006-1754": [
"27628"
],
"CVE-2006-1683": [
"27629"
],
"CVE-2006-1709": [
"27631"
],
"CVE-2006-1803": [
"27632"
],
"CVE-2006-1800": [
"27638"
],
"CVE-2006-1893": [
"27642"
],
"CVE-2006-1839": [
"27643"
],
"CVE-2006-1801": [
"27644"
],
"CVE-2006-1805": [
"27645"
],
"CVE-2006-1808": [
"27646"
],
"CVE-2006-1918": [
"27647"
],
"CVE-2006-1820": [
"27648"
],
"CVE-2006-1821": [
"27649"
],
"CVE-2006-1822": [
"27650"
],
"CVE-2006-1802": [
"27651"
],
"CVE-2006-2871": [
"27970"
],
"CVE-2006-1878": [
"27659"
],
"CVE-2006-1916": [
"27663"
],
"CVE-2006-1913": [
"27664"
],
"CVE-2006-1835": [
"27665"
],
"CVE-2006-1912": [
"27667"
],
"CVE-2006-1909": [
"27669"
],
"CVE-2006-1825": [
"27673"
],
"CVE-2006-1954": [
"27674"
],
"CVE-2006-1906": [
"27675"
],
"CVE-2006-1925": [
"27676"
],
"CVE-2006-1852": [
"27677"
],
"CVE-2006-1853": [
"27678"
],
"CVE-2006-1946": [
"27679",
"27680",
"27681"
],
"CVE-2006-1944": [
"27682",
"27683"
],
"CVE-2006-1960": [
"27684"
],
"CVE-2006-1943": [
"27685",
"27686"
],
"CVE-2006-1926": [
"27687"
],
"CVE-2006-1971": [
"27688"
],
"CVE-2006-1950": [
"27689"
],
"CVE-2006-1849": [
"27690"
],
"CVE-2006-1850": [
"27691"
],
"CVE-2006-1947": [
"27692"
],
"CVE-2006-1922": [
"27693"
],
"CVE-2006-1945": [
"27694"
],
"CVE-2006-1965": [
"27695",
"27696",
"27697"
],
"CVE-2006-3158": [
"28058"
],
"CVE-2006-3109": [
"28061",
"28062"
],
"CVE-2006-5108": [
"28700",
"28699",
"28701",
"28702",
"28703",
"28704"
],
"CVE-2013-5673": [
"28054"
],
"CVE-2013-5672": [
"28054"
],
"CVE-2006-1929": [
"27707"
],
"CVE-2006-1980": [
"27710"
],
"CVE-2006-2883": [
"27977"
],
"CVE-2006-2884": [
"27978"
],
"CVE-2006-5104": [
"28694"
],
"CVE-2006-2037": [
"27711"
],
"CVE-2006-1979": [
"27713"
],
"CVE-2006-2016": [
"27717",
"27718",
"27719",
"27721",
"27722"
],
"CVE-2009-4382": [
"33404"
],
"CVE-2006-1995": [
"27724"
],
"CVE-2006-2067": [
"27725"
],
"CVE-2006-2028": [
"27726"
],
"CVE-2006-2040": [
"27731",
"27732",
"27733"
],
"CVE-2006-2051": [
"27734"
],
"CVE-2006-2048": [
"27735"
],
"CVE-2006-2061": [
"27736"
],
"CVE-2006-2052": [
"27737",
"27739"
],
"CVE-2006-2079": [
"27738"
],
"CVE-2006-2070": [
"27742"
],
"CVE-2006-2089": [
"27743"
],
"CVE-2013-3586": [
"27753"
],
"CVE-2013-3585": [
"27753"
],
"CVE-2006-2132": [
"27757"
],
"CVE-2006-2138": [
"27761"
],
"CVE-2006-2121": [
"27763"
],
"CVE-2006-2119": [
"27767"
],
"CVE-2006-2122": [
"27768"
],
"CVE-2006-2127": [
"27770"
],
"CVE-2006-2365": [
"27855"
],
"CVE-2006-2360": [
"27857"
],
"CVE-2013-4775": [
"27774"
],
"CVE-2013-2113": [
"27776"
],
"CVE-2013-4900": [
"27777",
"38737"
],
"CVE-2006-2214": [
"27780",
"27781"
],
"CVE-2006-2143": [
"27782"
],
"CVE-2006-2228": [
"27783"
],
"CVE-2006-2116": [
"27784"
],
"CVE-2006-2144": [
"27785"
],
"CVE-2006-2126": [
"27787"
],
"CVE-2006-2140": [
"27788",
"27789"
],
"CVE-2006-2124": [
"27792"
],
"CVE-2006-2141": [
"27793"
],
"CVE-2006-2109": [
"27794"
],
"CVE-2006-2187": [
"27795",
"27796"
],
"CVE-2006-2177": [
"27798"
],
"CVE-2006-2174": [
"27799"
],
"CVE-2006-2163": [
"27800"
],
"CVE-2006-2211": [
"27803"
],
"CVE-2006-2210": [
"27804"
],
"CVE-2006-2241": [
"27807"
],
"CVE-2006-2209": [
"27808"
],
"CVE-2006-2208": [
"27809"
],
"CVE-2006-2181": [
"27810",
"27811"
],
"CVE-2006-2176": [
"27812"
],
"CVE-2006-2179": [
"27813",
"27814"
],
"CVE-2006-2178": [
"27815",
"27816",
"27817"
],
"CVE-2006-2217": [
"27818"
],
"CVE-2006-2249": [
"27819"
],
"CVE-2006-2252": [
"27821"
],
"CVE-2006-2269": [
"27822"
],
"CVE-2006-2280": [
"27823"
],
"CVE-2006-2262": [
"27824"
],
"CVE-2006-2264": [
"27825",
"27826",
"27827"
],
"CVE-2006-2265": [
"27828"
],
"CVE-2006-2255": [
"27831",
"27832",
"27833",
"27834",
"27835",
"27836"
],
"CVE-2006-2339": [
"27837"
],
"CVE-2006-2295": [
"27838",
"27839"
],
"CVE-2006-2294": [
"27840",
"27841"
],
"CVE-2006-2293": [
"27842"
],
"CVE-2006-2336": [
"27843"
],
"CVE-2006-2306": [
"27844"
],
"CVE-2006-2315": [
"27845"
],
"CVE-2006-2300": [
"27846",
"27848"
],
"CVE-2006-2296": [
"27849"
],
"CVE-2006-2359": [
"27858"
],
"CVE-2006-2390": [
"27859"
],
"CVE-2006-4450": [
"27863"
],
"CVE-2006-2397": [
"27864",
"27865",
"27866"
],
"CVE-2006-2398": [
"27867"
],
"CVE-2006-2395": [
"27868"
],
"CVE-2006-7005": [
"27869"
],
"CVE-2006-7004": [
"27870"
],
"CVE-2013-3314": [
"27878"
],
"CVE-2006-2404": [
"27880"
],
"CVE-2006-2396": [
"27881"
],
"CVE-2006-2423": [
"27884"
],
"CVE-2006-2425": [
"27885"
],
"CVE-2006-2437": [
"27888"
],
"CVE-2006-2491": [
"27889"
],
"CVE-2006-2473": [
"27890"
],
"CVE-2006-2474": [
"27895"
],
"CVE-2006-2497": [
"27896",
"27897"
],
"CVE-2006-2499": [
"27898"
],
"CVE-2006-2552": [
"27899"
],
"CVE-2006-2608": [
"27900"
],
"CVE-2006-7042": [
"27909"
],
"CVE-2006-2732": [
"27913"
],
"CVE-2006-2728": [
"27916"
],
"CVE-2006-2635": [
"27917"
],
"CVE-2006-2648": [
"27918"
],
"CVE-2006-2699": [
"27919"
],
"CVE-2006-2689": [
"27920",
"27921",
"27922"
],
"CVE-2006-2747": [
"27926"
],
"CVE-2006-2805": [
"27929"
],
"CVE-2006-2771": [
"27932"
],
"CVE-2006-2817": [
"27933"
],
"CVE-2006-2853": [
"27934"
],
"CVE-2006-3009": [
"27994",
"27995",
"27996",
"27997",
"27998"
],
"CVE-2006-4240": [
"28394"
],
"CVE-2006-2873": [
"27945"
],
"CVE-2006-2842": [
"27948"
],
"CVE-2006-2811": [
"27949",
"27950",
"27951",
"27952",
"27953",
"27954",
"27955",
"27956"
],
"CVE-2006-2821": [
"27958"
],
"CVE-2006-2803": [
"27959"
],
"CVE-2006-2858": [
"27960"
],
"CVE-2006-2865": [
"27961"
],
"CVE-2006-2854": [
"27962"
],
"CVE-2006-2855": [
"27963"
],
"CVE-2006-2867": [
"27964"
],
"CVE-2006-2892": [
"27982"
],
"CVE-2006-2680": [
"27985"
],
"CVE-2006-2922": [
"27988",
"27989"
],
"CVE-2006-2986": [
"27999",
"28000"
],
"CVE-2006-2955": [
"28002",
"28003",
"28004"
],
"CVE-2006-3061": [
"28009",
"28010"
],
"CVE-2006-3006": [
"28011"
],
"CVE-2006-3051": [
"28013"
],
"CVE-2006-3050": [
"28014"
],
"CVE-2006-3069": [
"28016"
],
"CVE-2006-3052": [
"28017"
],
"CVE-2006-3036": [
"28020",
"28021"
],
"CVE-2006-3315": [
"28025"
],
"CVE-2006-3042": [
"28027"
],
"CVE-2006-3161": [
"28059"
],
"CVE-2006-3189": [
"28031"
],
"CVE-2006-3191": [
"28032"
],
"CVE-2006-3175": [
"28035",
"28036",
"28037"
],
"CVE-2006-3259": [
"28063",
"28078"
],
"CVE-2006-3194": [
"28066"
],
"CVE-2006-3195": [
"28067"
],
"CVE-2006-3366": [
"28068",
"28069",
"28070",
"28071",
"28072",
"28073",
"28074"
],
"CVE-2006-6995": [
"28075"
],
"CVE-2006-3253": [
"28076"
],
"CVE-2006-3143": [
"28086"
],
"CVE-2005-4011": [
"28088"
],
"CVE-2006-3254": [
"28089"
],
"CVE-2006-3256": [
"28090"
],
"CVE-2006-3255": [
"28091"
],
"CVE-2006-6958": [
"28098"
],
"CVE-2006-3563": [
"28102"
],
"CVE-2006-3337": [
"28107"
],
"CVE-2006-3299": [
"28109"
],
"CVE-2006-3245": [
"28110"
],
"CVE-2006-3295": [
"28111"
],
"CVE-2006-3296": [
"28112"
],
"CVE-2006-3343": [
"28114"
],
"CVE-2006-3323": [
"28115",
"28117"
],
"CVE-2006-3474": [
"28119",
"28120",
"28121",
"28122"
],
"CVE-2006-3329": [
"28125"
],
"CVE-2006-3358": [
"28132",
"28133"
],
"CVE-2006-3359": [
"28134"
],
"CVE-2006-3607": [
"28137",
"28138",
"28139",
"28140"
],
"CVE-2006-3395": [
"28141"
],
"CVE-2006-3763": [
"28142"
],
"CVE-2006-3381": [
"28143"
],
"CVE-2006-3385": [
"28146"
],
"CVE-2006-3562": [
"28147",
"28148",
"28149"
],
"CVE-2006-3475": [
"28150",
"28151",
"28152",
"28153",
"28154",
"28155",
"28156"
],
"CVE-2006-3402": [
"28157"
],
"CVE-2006-3405": [
"28158"
],
"CVE-2006-3363": [
"28159"
],
"CVE-2006-3476": [
"28161"
],
"CVE-2006-3374": [
"28162"
],
"CVE-2006-3577": [
"28166"
],
"CVE-2006-3543": [
"28167"
],
"CVE-2013-4341": [
"28174"
],
"CVE-2006-3484": [
"28176",
"28177",
"28178",
"28179",
"28180"
],
"CVE-2006-3556": [
"28190"
],
"CVE-2013-5689": [
"28191"
],
"CVE-2013-5688": [
"28191"
],
"CVE-2006-3662": [
"28192"
],
"CVE-2006-3518": [
"28193"
],
"CVE-2006-3517": [
"28195"
],
"CVE-2006-3602": [
"28200"
],
"CVE-2006-3560": [
"28201"
],
"CVE-2006-2835": [
"28204"
],
"CVE-2006-3603": [
"28205"
],
"CVE-2006-3568": [
"28206"
],
"CVE-2006-3604": [
"28208"
],
"CVE-2006-3616": [
"28211",
"28212"
],
"CVE-2006-3680": [
"28214"
],
"CVE-2006-3608": [
"28216"
],
"CVE-2006-3621": [
"28219"
],
"CVE-2006-3689": [
"28223"
],
"CVE-2006-3692": [
"28231"
],
"CVE-2006-3843": [
"28233"
],
"CVE-2013-3179": [
"28238"
],
"CVE-2013-5730": [
"28239"
],
"CVE-2006-3777": [
"28247"
],
"CVE-2006-3776": [
"28248"
],
"CVE-2006-3822": [
"28249"
],
"CVE-2006-3823": [
"28250",
"33075"
],
"CVE-2006-3955": [
"28251"
],
"CVE-2003-1179": [
"28253"
],
"CVE-2006-3836": [
"28255"
],
"CVE-2006-3850": [
"28260"
],
"CVE-2006-3886": [
"28262"
],
"CVE-2006-3884": [
"28267"
],
"CVE-2006-3883": [
"28268",
"28269",
"28270"
],
"CVE-2010-4513": [
"28272",
"35063",
"35064"
],
"CVE-2006-3927": [
"28274"
],
"CVE-2006-3926": [
"28275",
"28276"
],
"CVE-2006-3909": [
"28280"
],
"CVE-2006-3940": [
"28281",
"28282"
],
"CVE-2006-3929": [
"28283"
],
"CVE-2006-3957": [
"28289"
],
"CVE-2006-7072": [
"28292"
],
"CVE-2006-3948": [
"28294"
],
"CVE-2006-4992": [
"28295",
"28296",
"28297"
],
"CVE-2006-3959": [
"28303"
],
"CVE-2006-3960": [
"28304"
],
"CVE-2006-3972": [
"28305"
],
"CVE-2006-3963": [
"28306",
"28307"
],
"CVE-2006-3964": [
"28308"
],
"CVE-2006-3967": [
"28310"
],
"CVE-2006-4040": [
"28311"
],
"CVE-2006-3997": [
"28317"
],
"CVE-2006-3982": [
"28318"
],
"CVE-2006-4008": [
"28319"
],
"CVE-2006-4007": [
"28320"
],
"CVE-2006-4000": [
"28321"
],
"CVE-2006-4308": [
"28324"
],
"CVE-2006-4009": [
"28326"
],
"CVE-2006-4010": [
"28327"
],
"CVE-2006-4068": [
"28340"
],
"CVE-2006-4273": [
"28342"
],
"CVE-2006-4751": [
"28509"
],
"CVE-2006-4025": [
"28347"
],
"CVE-2006-1747": [
"28350",
"28351",
"28352",
"28353",
"28354",
"28355",
"28356"
],
"CVE-2006-4061": [
"28359"
],
"CVE-2006-4122": [
"28362"
],
"CVE-2006-4161": [
"28364"
],
"CVE-2006-4156": [
"28370"
],
"CVE-2006-4157": [
"28371"
],
"CVE-2013-5962": [
"28377"
],
"CVE-2006-4163": [
"28378"
],
"CVE-2006-4208": [
"28382"
],
"CVE-2006-4190": [
"28388"
],
"CVE-2006-4230": [
"28390"
],
"CVE-2006-4215": [
"28392"
],
"CVE-2006-4241": [
"28396"
],
"CVE-2016-5740": [
"40378"
],
"CVE-2006-4279": [
"28406"
],
"CVE-2013-5091": [
"28409"
],
"CVE-2006-4358": [
"28412"
],
"CVE-2006-4293": [
"28413",
"28414",
"28415"
],
"CVE-2006-4322": [
"28416"
],
"CVE-2006-4349": [
"28417"
],
"CVE-2006-4609": [
"28418"
],
"CVE-2006-4357": [
"28419"
],
"CVE-2006-4362": [
"28422"
],
"CVE-2006-4366": [
"28423"
],
"CVE-2006-4421": [
"28428"
],
"CVE-2006-4449": [
"28429"
],
"CVE-2006-4428": [
"28430"
],
"CVE-2006-4422": [
"28431"
],
"CVE-2006-4423": [
"28432",
"28433",
"28434",
"28435"
],
"CVE-2006-4443": [
"28436"
],
"CVE-2006-4553": [
"28437"
],
"CVE-2006-4454": [
"28439"
],
"CVE-2006-4545": [
"28440"
],
"CVE-2006-4497": [
"28441"
],
"CVE-2006-4591": [
"28444"
],
"CVE-2006-4543": [
"28446"
],
"CVE-2006-5190": [
"28749",
"28750",
"28751",
"28743",
"28744",
"28745",
"28746",
"28747",
"28748",
"28752",
"28753",
"28754",
"28755",
"28756",
"28757",
"28758",
"28759"
],
"CVE-2006-4478": [
"28464"
],
"CVE-2006-4479": [
"28465"
],
"CVE-2006-4540": [
"28466"
],
"CVE-2013-5961": [
"28452"
],
"CVE-2006-4477": [
"28453",
"28454",
"28455",
"28456",
"28457",
"28458",
"28459",
"28460",
"28461",
"28462"
],
"CVE-2006-4634": [
"28470"
],
"CVE-2006-4599": [
"28473"
],
"CVE-2013-5917": [
"28485"
],
"CVE-2006-4563": [
"28487"
],
"CVE-2006-4631": [
"28488"
],
"CVE-2006-4593": [
"28490"
],
"CVE-2006-4643": [
"28492"
],
"CVE-2006-4668": [
"28494"
],
"CVE-2006-4294": [
"28495"
],
"CVE-2006-4673": [
"28496"
],
"CVE-2006-4708": [
"28497",
"28498"
],
"CVE-2006-4709": [
"28499"
],
"CVE-2006-4747": [
"28502",
"28503"
],
"CVE-2006-4754": [
"28510"
],
"CVE-2006-4753": [
"28511"
],
"CVE-2006-4731": [
"28514"
],
"CVE-2006-4884": [
"28515",
"28516",
"28517"
],
"CVE-2016-6854": [
"40377"
],
"CVE-2016-6853": [
"40377"
],
"CVE-2016-6851": [
"40377"
],
"CVE-2006-4771": [
"28543"
],
"CVE-2006-4794": [
"28545",
"28546",
"28547",
"28548",
"28549",
"28551",
"28552",
"28554",
"28556"
],
"CVE-2013-5118": [
"28555"
],
"CVE-2013-5693": [
"28557"
],
"CVE-2013-5692": [
"28557"
],
"CVE-2006-5060": [
"28659"
],
"CVE-2013-6852": [
"28562"
],
"CVE-2006-4825": [
"28565"
],
"CVE-2006-4796": [
"28566"
],
"CVE-2006-4504": [
"28567"
],
"CVE-2006-4505": [
"28568"
],
"CVE-2006-3636": [
"28570"
],
"CVE-2006-4838": [
"28571",
"28572"
],
"CVE-2006-4836": [
"28573"
],
"CVE-2006-4829": [
"28574"
],
"CVE-2006-4857": [
"28577"
],
"CVE-2006-4875": [
"28581"
],
"CVE-2006-4874": [
"28582",
"28583",
"28584",
"28585"
],
"CVE-2006-4876": [
"28586"
],
"CVE-2006-4848": [
"28590"
],
"CVE-2006-4877": [
"28591"
],
"CVE-2006-4881": [
"28592"
],
"CVE-2006-4872": [
"28597"
],
"CVE-2006-4894": [
"28599"
],
"CVE-2006-4871": [
"28600"
],
"CVE-2006-4917": [
"28601"
],
"CVE-2006-4915": [
"28603"
],
"CVE-2006-4923": [
"28604"
],
"CVE-2006-4955": [
"28605"
],
"CVE-2006-4952": [
"28606"
],
"CVE-2006-4953": [
"28607",
"28608"
],
"CVE-2006-4954": [
"28609"
],
"CVE-2006-4956": [
"28610"
],
"CVE-2006-5021": [
"28611",
"28612",
"28613",
"28614"
],
"CVE-2006-4973": [
"28615"
],
"CVE-2006-4985": [
"28617",
"28618",
"28619",
"28620",
"28621",
"28622",
"28623",
"28624",
"28625",
"28626",
"28627",
"28628",
"28629",
"28630",
"28631",
"28632",
"28633",
"28634",
"28635",
"28636",
"28637",
"28638"
],
"CVE-2006-5019": [
"28644"
],
"CVE-2006-5031": [
"28645"
],
"CVE-2006-5028": [
"28647"
],
"CVE-2006-5107": [
"28695",
"28696",
"28697",
"28698"
],
"CVE-2013-5697": [
"28653"
],
"CVE-2013-2586": [
"28654"
],
"CVE-2013-5748": [
"28656"
],
"CVE-2006-5057": [
"28662",
"28663"
],
"CVE-2006-5056": [
"28664"
],
"CVE-2006-5064": [
"28667",
"28668",
"28669"
],
"CVE-2006-5066": [
"28670",
"28671"
],
"CVE-2006-5103": [
"28672"
],
"CVE-2006-5920": [
"28673"
],
"CVE-2006-5076": [
"28674",
"28675",
"28676"
],
"CVE-2013-5639": [
"28684"
],
"CVE-2006-5089": [
"28686"
],
"CVE-2006-5090": [
"28692",
"28693"
],
"CVE-2006-5145": [
"28730",
"28731"
],
"CVE-2006-5146": [
"28732",
"28733",
"28734"
],
"CVE-2006-5141": [
"28728"
],
"CVE-2006-5074": [
"28711"
],
"CVE-2006-5118": [
"28714"
],
"CVE-2013-6275": [
"29274"
],
"CVE-2006-2066": [
"28716"
],
"CVE-2013-6794": [
"29279"
],
"CVE-2013-6793": [
"29279"
],
"CVE-2006-5096": [
"28719"
],
"CVE-2006-5120": [
"28721",
"28722"
],
"CVE-2006-5154": [
"28736"
],
"CVE-2006-5166": [
"28737"
],
"CVE-2006-5164": [
"28738"
],
"CVE-2006-4206": [
"28742"
],
"CVE-2006-5193": [
"28761"
],
"CVE-2006-7231": [
"28762"
],
"CVE-2006-5228": [
"28767"
],
"CVE-2006-5217": [
"28768"
],
"CVE-2006-5219": [
"28770"
],
"CVE-2006-5232": [
"28772"
],
"CVE-2006-5251": [
"28773"
],
"CVE-2006-5234": [
"28774"
],
"CVE-2006-5239": [
"28776"
],
"CVE-2006-5262": [
"28777"
],
"CVE-2006-5210": [
"28778"
],
"CVE-2006-5250": [
"28781"
],
"CVE-2006-5249": [
"28782"
],
"CVE-2006-7146": [
"28786"
],
"CVE-2006-5294": [
"28790"
],
"CVE-2006-7091": [
"28791"
],
"CVE-2006-6634": [
"28792",
"28793"
],
"CVE-2006-5411": [
"28795"
],
"CVE-2006-5311": [
"28796"
],
"CVE-2006-6592": [
"28797",
"28798",
"28799",
"28800",
"28801",
"28802"
],
"CVE-2006-7168": [
"28804"
],
"CVE-2006-7104": [
"28818"
],
"CVE-2006-5422": [
"28819"
],
"CVE-2006-7120": [
"28821"
],
"CVE-2006-5524": [
"28824"
],
"CVE-2006-5428": [
"28826"
],
"CVE-2006-5431": [
"28828"
],
"CVE-2006-5450": [
"28829"
],
"CVE-2006-5436": [
"28830"
],
"CVE-2006-5503": [
"28831"
],
"CVE-2006-5446": [
"28833"
],
"CVE-2006-5529": [
"28839"
],
"CVE-2006-5528": [
"28840"
],
"CVE-2006-5535": [
"28843",
"28844"
],
"CVE-2006-5566": [
"28845"
],
"CVE-2006-5516": [
"28846"
],
"CVE-2006-5603": [
"28857"
],
"CVE-2006-5530": [
"28858",
"28859"
],
"CVE-2006-5564": [
"28863"
],
"CVE-2006-6416": [
"28864"
],
"CVE-2006-5609": [
"28867"
],
"CVE-2006-5635": [
"28869"
],
"CVE-2007-2064": [
"28871",
"29863"
],
"CVE-2007-2065": [
"28872"
],
"CVE-2006-7184": [
"28873",
"28874"
],
"CVE-2006-5716": [
"28875"
],
"CVE-2006-5662": [
"28878",
"28879"
],
"CVE-2006-5643": [
"28881"
],
"CVE-2006-5626": [
"28882"
],
"CVE-2006-5720": [
"28885"
],
"CVE-2006-5661": [
"28889"
],
"CVE-2006-5652": [
"28890"
],
"CVE-2006-5712": [
"28891"
],
"CVE-2006-5838": [
"28899"
],
"CVE-2006-5770": [
"28900",
"28901",
"28902",
"28903",
"28904",
"28905"
],
"CVE-2006-5761": [
"28909"
],
"CVE-2006-5899": [
"28913"
],
"CVE-2006-5810": [
"28914"
],
"CVE-2006-5830": [
"28917",
"28918",
"28919",
"28920",
"28921"
],
"CVE-2006-5831": [
"28922"
],
"CVE-2006-5829": [
"28923",
"28924",
"28925",
"28926",
"28927",
"28928",
"28929",
"28930",
"28931",
"28932",
"28933",
"28934"
],
"CVE-2006-5832": [
"28935",
"28936",
"28937"
],
"CVE-2006-5924": [
"28938"
],
"CVE-2006-5825": [
"28939"
],
"CVE-2006-5853": [
"28941"
],
"CVE-2006-5846": [
"28942"
],
"CVE-2006-5847": [
"28943"
],
"CVE-2006-6923": [
"28949"
],
"CVE-2006-5915": [
"28950"
],
"CVE-2006-5914": [
"28951"
],
"CVE-2006-6924": [
"28953",
"28963",
"28964",
"28965"
],
"CVE-2006-6925": [
"28954"
],
"CVE-2013-5978": [
"28959"
],
"CVE-2013-5977": [
"28959"
],
"CVE-2006-6095": [
"29086",
"29087"
],
"CVE-2006-5951": [
"28967"
],
"CVE-2013-5743": [
"28972"
],
"CVE-2013-5147": [
"28978"
],
"CVE-2006-5883": [
"28982",
"28983"
],
"CVE-2006-5958": [
"28989",
"28990",
"28991"
],
"CVE-2006-5957": [
"28992",
"28993",
"28994"
],
"CVE-2006-6147": [
"29152",
"29153"
],
"CVE-2006-6083": [
"29154"
],
"CVE-2006-6082": [
"29155",
"29156"
],
"CVE-2006-6581": [
"28998"
],
"CVE-2006-5983": [
"28999",
"29000",
"29001",
"29002",
"29003",
"29004",
"29005",
"29006"
],
"CVE-2006-5946": [
"29008"
],
"CVE-2006-5936": [
"29010"
],
"CVE-2006-5987": [
"29011"
],
"CVE-2006-7118": [
"29012"
],
"CVE-2006-5945": [
"29014",
"29015"
],
"CVE-2006-5944": [
"29016"
],
"CVE-2006-6451": [
"29017",
"29018"
],
"CVE-2006-5943": [
"29024"
],
"CVE-2006-7170": [
"29026",
"29027"
],
"CVE-2006-6708": [
"29028"
],
"CVE-2006-6709": [
"29029",
"29030",
"29031"
],
"CVE-2006-6109": [
"29037",
"29038"
],
"CVE-2006-6066": [
"29042",
"29043",
"29044"
],
"CVE-2006-7086": [
"29047"
],
"CVE-2006-6088": [
"29048"
],
"CVE-2006-6020": [
"29049"
],
"CVE-2006-6951": [
"29050"
],
"CVE-2006-6932": [
"29053",
"29054"
],
"CVE-2006-6942": [
"29058",
"29059",
"29060",
"29061"
],
"CVE-2006-6943": [
"29062"
],
"CVE-2006-6937": [
"29063"
],
"CVE-2006-6936": [
"29064"
],
"CVE-2006-6363": [
"29221"
],
"CVE-2006-6366": [
"29222"
],
"CVE-2004-1875": [
"29071"
],
"CVE-2006-7133": [
"29072"
],
"CVE-2006-6092": [
"29075"
],
"CVE-2006-6067": [
"29077",
"29078"
],
"CVE-2006-6040": [
"29079"
],
"CVE-2006-6021": [
"29080"
],
"CVE-2006-6022": [
"29081"
],
"CVE-2006-6111": [
"29084"
],
"CVE-2006-6096": [
"29088"
],
"CVE-2006-6094": [
"29089",
"29090"
],
"CVE-2006-6208": [
"29118",
"29119",
"29120"
],
"CVE-2006-6050": [
"29093",
"29094"
],
"CVE-2006-6035": [
"29095"
],
"CVE-2006-6211": [
"29098",
"29099",
"29100",
"29101"
],
"CVE-2006-6152": [
"29103",
"29104"
],
"CVE-2006-6153": [
"29105",
"29106"
],
"CVE-2006-6927": [
"29107",
"29108",
"29109",
"29110",
"29111",
"29112",
"29113"
],
"CVE-2006-6928": [
"29114",
"29115",
"29116",
"29117"
],
"CVE-2006-6205": [
"29124"
],
"CVE-2006-6080": [
"29126"
],
"CVE-2006-6284": [
"29128"
],
"CVE-2006-6930": [
"29133"
],
"CVE-2006-6929": [
"29134",
"29135",
"29136",
"29137"
],
"CVE-2006-6768": [
"29141"
],
"CVE-2006-6342": [
"29142",
"29143"
],
"CVE-2006-6185": [
"29145"
],
"CVE-2006-6087": [
"29162"
],
"CVE-2006-6300": [
"29217"
],
"CVE-2006-6356": [
"29218"
],
"CVE-2006-6367": [
"29219"
],
"CVE-2006-6298": [
"29220"
],
"CVE-2006-6158": [
"29165",
"29166"
],
"CVE-2006-5911": [
"29992",
"29993",
"29994",
"29995",
"29966",
"29967",
"29968",
"29969",
"29970",
"29971",
"29972",
"29973",
"29974",
"29975",
"29976",
"29977",
"29978",
"29979",
"29980",
"29981",
"29982",
"29983",
"29984",
"29985",
"29986",
"29987",
"29988",
"29989",
"29990",
"29991",
"29996",
"29997",
"29998",
"29999",
"30003",
"30004",
"30005",
"30006"
],
"CVE-2006-6337": [
"29216"
],
"CVE-2006-6209": [
"29174"
],
"CVE-2006-6272": [
"29175"
],
"CVE-2006-6210": [
"29176"
],
"CVE-2006-6118": [
"29177"
],
"CVE-2006-6195": [
"29178",
"29179"
],
"CVE-2006-6198": [
"29182",
"29183",
"29184",
"29185",
"29186",
"29187",
"29188"
],
"CVE-2006-6243": [
"29189"
],
"CVE-2006-6181": [
"29191"
],
"CVE-2006-6189": [
"29192"
],
"CVE-2006-6247": [
"29195",
"29196"
],
"CVE-2006-6207": [
"29197"
],
"CVE-2006-6197": [
"29198",
"29199",
"29200"
],
"CVE-2006-6343": [
"29202"
],
"CVE-2006-6339": [
"29207"
],
"CVE-2006-6414": [
"29231"
],
"CVE-2006-6387": [
"29232",
"29233"
],
"CVE-2006-6364": [
"29223"
],
"CVE-2006-6389": [
"29225",
"29226"
],
"CVE-2006-6447": [
"29227",
"29228"
],
"CVE-2006-6523": [
"29237"
],
"CVE-2006-6536": [
"29240"
],
"CVE-2006-6521": [
"29242"
],
"CVE-2006-6520": [
"29243",
"29244",
"29245"
],
"CVE-2006-6478": [
"29246",
"29252",
"29253"
],
"CVE-2006-6479": [
"29247",
"29248",
"29249",
"29250",
"29251"
],
"CVE-2013-6236": [
"29266"
],
"CVE-2006-6518": [
"29267",
"29269"
],
"CVE-2006-6519": [
"29268"
],
"CVE-2006-6845": [
"29272"
],
"CVE-2006-6569": [
"29282"
],
"CVE-2006-6571": [
"29283"
],
"CVE-2006-6625": [
"29284"
],
"CVE-2006-6640": [
"29288"
],
"CVE-2006-6642": [
"29293"
],
"CVE-2006-6721": [
"29294"
],
"CVE-2006-6733": [
"29298"
],
"CVE-2006-6734": [
"29299"
],
"CVE-2006-6690": [
"29300"
],
"CVE-2006-6697": [
"29301"
],
"CVE-2006-6729": [
"29306"
],
"CVE-2006-6703": [
"29308"
],
"CVE-2006-6746": [
"29311",
"29313"
],
"CVE-2006-6747": [
"29314"
],
"CVE-2013-5694": [
"29326"
],
"CVE-2007-3339": [
"30207",
"30206",
"30216"
],
"CVE-2007-3323": [
"30203"
],
"CVE-2007-3324": [
"30204",
"30205"
],
"CVE-2006-6794": [
"29333"
],
"CVE-2006-6776": [
"29334"
],
"CVE-2006-6777": [
"29335"
],
"CVE-2006-6791": [
"29336"
],
"CVE-2006-6778": [
"29337"
],
"CVE-2006-6779": [
"29338"
],
"CVE-2006-6788": [
"29342"
],
"CVE-2006-3019": [
"29343",
"29344",
"29345",
"29346",
"29347",
"29348",
"29349",
"29350",
"29351",
"29352"
],
"CVE-2007-0054": [
"29376"
],
"CVE-2006-6808": [
"29356"
],
"CVE-2006-6814": [
"29357"
],
"CVE-2006-6816": [
"29358",
"29359",
"29360",
"29361"
],
"CVE-2006-6824": [
"29363",
"29364",
"29365",
"29366",
"29367",
"29368",
"29369",
"29370"
],
"CVE-2006-6851": [
"29372"
],
"CVE-2006-6861": [
"29373"
],
"CVE-2007-0056": [
"29377",
"29378",
"29379",
"29380",
"29381",
"29382"
],
"CVE-2007-0121": [
"29384"
],
"CVE-2007-0140": [
"29385"
],
"CVE-2007-0118": [
"29390",
"29391",
"29392",
"29393"
],
"CVE-2007-0119": [
"29394",
"29395",
"29396"
],
"CVE-2007-0122": [
"29397"
],
"CVE-2007-0142": [
"29398"
],
"CVE-2007-0112": [
"29401"
],
"CVE-2007-0177": [
"29404"
],
"CVE-2007-0179": [
"29405"
],
"CVE-2007-0182": [
"29407",
"29408",
"29409",
"29410",
"29411",
"29412",
"29413",
"29414",
"29415",
"29416",
"29417",
"29418",
"29419",
"29420",
"29421",
"29422",
"29423",
"29424",
"29425",
"29426",
"29427",
"29428",
"29429",
"29430",
"29431",
"29432",
"29433",
"29434"
],
"CVE-2013-6357": [
"29435"
],
"CVE-2007-0178": [
"29437"
],
"CVE-2007-0190": [
"29438"
],
"CVE-2006-6421": [
"29442"
],
"CVE-2007-0316": [
"29451"
],
"CVE-2007-0309": [
"29453"
],
"CVE-2007-0302": [
"29456",
"29457"
],
"CVE-2007-0364": [
"29477",
"29478",
"29479",
"29480",
"29481",
"29483",
"29484",
"29485",
"29486",
"29487",
"29488",
"29489"
],
"CVE-2007-0335": [
"29468",
"29469"
],
"CVE-2006-6487": [
"29472"
],
"CVE-2007-0353": [
"29491",
"29492"
],
"CVE-2007-0399": [
"29499"
],
"CVE-2007-1903": [
"30029"
],
"CVE-2013-7091": [
"30085",
"30472"
],
"CVE-2007-1902": [
"30035"
],
"CVE-2007-2714": [
"30036"
],
"CVE-2007-1898": [
"30040"
],
"CVE-2007-2732": [
"30041",
"30042"
],
"CVE-2007-2908": [
"30047"
],
"CVE-2007-2757": [
"30050"
],
"CVE-2007-2780": [
"30051"
],
"CVE-2007-2805": [
"30053"
],
"CVE-2013-7025": [
"30054"
],
"CVE-2007-3267": [
"30201"
],
"CVE-2007-3281": [
"30200"
],
"CVE-2007-0609": [
"30015"
],
"CVE-2007-2632": [
"30022"
],
"CVE-2007-2718": [
"30027"
],
"CVE-2007-2716": [
"30028"
],
"CVE-2013-3528": [
"29512"
],
"CVE-2013-2749": [
"29512"
],
"CVE-2013-6058": [
"29514"
],
"CVE-2013-4985": [
"29516"
],
"CVE-2013-6164": [
"29517"
],
"CVE-2013-5220": [
"29518"
],
"CVE-2013-5219": [
"29518"
],
"CVE-2013-5218": [
"29518"
],
"CVE-2013-5039": [
"29518"
],
"CVE-2013-5038": [
"29518"
],
"CVE-2013-5037": [
"29518"
],
"CVE-2013-6364": [
"29519"
],
"CVE-2007-0540": [
"29522"
],
"CVE-2007-0567": [
"29529"
],
"CVE-2007-0575": [
"29533"
],
"CVE-2007-0574": [
"29534"
],
"CVE-2007-0623": [
"29537"
],
"CVE-2007-0635": [
"29539"
],
"CVE-2007-1241": [
"29677"
],
"CVE-2007-1242": [
"29678"
],
"CVE-2007-1231": [
"29680",
"33154"
],
"CVE-2007-1158": [
"29681"
],
"CVE-2007-1244": [
"29682"
],
"CVE-2013-6618": [
"29544"
],
"CVE-2007-0649": [
"29556",
"29557"
],
"CVE-2007-0759": [
"29559"
],
"CVE-2007-0758": [
"29560"
],
"CVE-2007-0821": [
"29562",
"29563"
],
"CVE-2007-0820": [
"29564",
"29565",
"29566",
"31679"
],
"CVE-2007-0817": [
"29567"
],
"CVE-2007-0836": [
"29568"
],
"CVE-2007-0828": [
"29569"
],
"CVE-2014-1990": [
"29570"
],
"CVE-2007-0849": [
"29571"
],
"CVE-2007-0890": [
"29572"
],
"CVE-2007-0871": [
"29574"
],
"CVE-2007-0885": [
"29576"
],
"CVE-2007-0900": [
"29578",
"29579",
"29580",
"29581",
"29582",
"29583",
"29584",
"29585",
"29586",
"29587",
"29588",
"29589",
"29590",
"29591",
"29592",
"29593"
],
"CVE-2007-0925": [
"29597"
],
"CVE-2007-1049": [
"29598"
],
"CVE-2007-0982": [
"29599"
],
"CVE-2007-0950": [
"29600"
],
"CVE-2007-0951": [
"29601"
],
"CVE-2007-0970": [
"29602"
],
"CVE-2007-1243": [
"29676"
],
"CVE-2007-1020": [
"29608",
"29624"
],
"CVE-2007-1024": [
"29609"
],
"CVE-2007-1043": [
"29610"
],
"CVE-2007-1022": [
"29611"
],
"CVE-2007-1044": [
"29615"
],
"CVE-2007-1050": [
"29621"
],
"CVE-2007-1077": [
"29622"
],
"CVE-2007-1085": [
"29623"
],
"CVE-2007-1076": [
"29625",
"29626"
],
"CVE-2007-1141": [
"29627"
],
"CVE-2007-1142": [
"29628",
"29629"
],
"CVE-2007-1159": [
"29631"
],
"CVE-2007-1152": [
"29632"
],
"CVE-2007-1138": [
"29634"
],
"CVE-2007-1140": [
"29635"
],
"CVE-2007-1148": [
"29636"
],
"CVE-2007-1149": [
"29637",
"29638"
],
"CVE-2007-1151": [
"29639"
],
"CVE-2007-1127": [
"29640"
],
"CVE-2007-1126": [
"29641"
],
"CVE-2007-1124": [
"29642"
],
"CVE-2007-1125": [
"29643"
],
"CVE-2007-1100": [
"29644"
],
"CVE-2007-1110": [
"29645"
],
"CVE-2007-1111": [
"29646",
"29647",
"29648",
"29649",
"29650",
"29651",
"29652",
"29653"
],
"CVE-2007-1101": [
"29658"
],
"CVE-2007-1240": [
"29661",
"29662"
],
"CVE-2006-7099": [
"29663"
],
"CVE-2007-1232": [
"29665"
],
"CVE-2007-4079": [
"30367",
"30368"
],
"CVE-2007-2449": [
"30189"
],
"CVE-2007-3249": [
"30190"
],
"CVE-2007-3101": [
"30191"
],
"CVE-2013-6225": [
"29672"
],
"CVE-2013-6117": [
"29673"
],
"CVE-2013-3615": [
"29673"
],
"CVE-2013-3614": [
"29673"
],
"CVE-2013-3613": [
"29673"
],
"CVE-2013-3612": [
"29673"
],
"CVE-2007-1247": [
"29696"
],
"CVE-2007-1248": [
"29697",
"29698"
],
"CVE-2007-1277": [
"29701",
"29702"
],
"CVE-2007-1289": [
"29703"
],
"CVE-2007-1291": [
"29704",
"29705"
],
"CVE-2013-5030": [
"29709"
],
"CVE-2007-4081": [
"30369",
"30370"
],
"CVE-2007-4084": [
"30371"
],
"CVE-2007-1331": [
"29715"
],
"CVE-2007-1416": [
"29722"
],
"CVE-2007-1422": [
"29726"
],
"CVE-2007-1421": [
"29727",
"29728",
"29729"
],
"CVE-2007-1424": [
"29730",
"29731"
],
"CVE-2007-1430": [
"29736"
],
"CVE-2007-1515": [
"29742"
],
"CVE-2007-1514": [
"29744"
],
"CVE-2007-1473": [
"29745"
],
"CVE-2007-1508": [
"29747"
],
"CVE-2007-1509": [
"29748"
],
"CVE-2007-1622": [
"29754"
],
"CVE-2007-1550": [
"29756",
"29757",
"29758",
"29759",
"29760"
],
"CVE-2007-1540": [
"29761"
],
"CVE-2007-1548": [
"29762"
],
"CVE-2007-1604": [
"29763"
],
"CVE-2007-1606": [
"29764",
"29765",
"29766"
],
"CVE-2006-5764": [
"29772"
],
"CVE-2006-5763": [
"29773",
"29774"
],
"CVE-2007-1714": [
"29776"
],
"CVE-2007-1873": [
"29780"
],
"CVE-2007-3332": [
"29782"
],
"CVE-2007-1678": [
"29783"
],
"CVE-2013-7319": [
"30105"
],
"CVE-2007-3130": [
"30157",
"30158"
],
"CVE-2007-2962": [
"30109"
],
"CVE-2007-3003": [
"30111"
],
"CVE-2007-3000": [
"30112",
"30113"
],
"CVE-2007-3001": [
"30114",
"30115",
"30116"
],
"CVE-2007-3217": [
"30118",
"30119",
"30120",
"30121",
"30122",
"30123",
"30124",
"30125",
"30126",
"30127",
"30128",
"30129"
],
"CVE-2007-3049": [
"30131"
],
"CVE-2007-2991": [
"30132"
],
"CVE-2007-3060": [
"30133",
"30134",
"30135",
"30136",
"30137"
],
"CVE-2007-3055": [
"30138"
],
"CVE-2007-3080": [
"30141"
],
"CVE-2007-3070": [
"30143"
],
"CVE-2007-3063": [
"30152"
],
"CVE-2007-3064": [
"30153"
],
"CVE-2007-3158": [
"30159"
],
"CVE-2007-3134": [
"30161"
],
"CVE-2007-3196": [
"30168"
],
"CVE-2007-3190": [
"30171"
],
"CVE-2007-3189": [
"30172"
],
"CVE-2007-3191": [
"30173"
],
"CVE-2007-3192": [
"30174"
],
"CVE-2007-3243": [
"30175"
],
"CVE-2007-3301": [
"30202"
],
"CVE-2013-6936": [
"29797"
],
"CVE-2007-1849": [
"29805"
],
"CVE-2007-1845": [
"29806"
],
"CVE-2007-1971": [
"29817"
],
"CVE-2007-1919": [
"29821"
],
"CVE-2007-1905": [
"29824"
],
"CVE-2007-1956": [
"29825"
],
"CVE-2007-1906": [
"29827"
],
"CVE-2007-2011": [
"29828"
],
"CVE-2007-2013": [
"29829"
],
"CVE-2007-2014": [
"29830"
],
"CVE-2007-1364": [
"29831"
],
"CVE-2007-1363": [
"29832",
"29833"
],
"CVE-2007-1989": [
"29838",
"29839"
],
"CVE-2007-2155": [
"29841"
],
"CVE-2007-2232": [
"29842"
],
"CVE-2007-2233": [
"29844"
],
"CVE-2007-2300": [
"29845",
"29846",
"29847"
],
"CVE-2007-2090": [
"29848"
],
"CVE-2007-1872": [
"29849"
],
"CVE-2007-2061": [
"29851"
],
"CVE-2007-2310": [
"29854"
],
"CVE-2007-2308": [
"29855"
],
"CVE-2007-2081": [
"29864"
],
"CVE-2007-2098": [
"29865"
],
"CVE-2007-2257": [
"29869"
],
"CVE-2007-2337": [
"29870",
"29871"
],
"CVE-2007-2252": [
"29872"
],
"CVE-2007-2503": [
"29874"
],
"CVE-2007-2256": [
"29876"
],
"CVE-2007-2207": [
"29877"
],
"CVE-2007-2258": [
"29879"
],
"CVE-2007-2262": [
"29880"
],
"CVE-2007-2247": [
"29882"
],
"CVE-2007-2202": [
"29883"
],
"CVE-2007-2205": [
"29886"
],
"CVE-2007-2248": [
"29887",
"29888"
],
"CVE-2007-2249": [
"29889"
],
"CVE-2007-2250": [
"29890"
],
"CVE-2007-2338": [
"29891"
],
"CVE-2007-2339": [
"29892",
"29893",
"29894"
],
"CVE-2007-2268": [
"29898"
],
"CVE-2007-2325": [
"29899"
],
"CVE-2007-2428": [
"29903"
],
"CVE-2007-2290": [
"29904",
"29905",
"29906"
],
"CVE-2007-2287": [
"29907"
],
"CVE-2007-2474": [
"29908"
],
"CVE-2007-2326": [
"29909"
],
"CVE-2007-2327": [
"29910"
],
"CVE-2007-2330": [
"29911",
"29912"
],
"CVE-2007-2288": [
"29914"
],
"CVE-2007-2423": [
"29915"
],
"CVE-2013-7043": [
"29927"
],
"CVE-2007-2420": [
"29929"
],
"CVE-2007-2810": [
"29933"
],
"CVE-2007-2416": [
"29938"
],
"CVE-2007-2473": [
"29941"
],
"CVE-2007-2628": [
"29944"
],
"CVE-2007-3127": [
"30197"
],
"CVE-2007-3310": [
"30198"
],
"CVE-2007-3266": [
"30199"
],
"CVE-2007-2532": [
"29956",
"29957"
],
"CVE-2007-2561": [
"29958"
],
"CVE-2013-6023": [
"29959"
],
"CVE-2007-2549": [
"29960"
],
"CVE-2007-2547": [
"29961"
],
"CVE-2007-2524": [
"29962"
],
"CVE-2007-0605": [
"29965"
],
"CVE-2013-7187": [
"30002"
],
"CVE-2013-6787": [
"30012"
],
"CVE-2013-6341": [
"30013"
],
"CVE-2013-5945": [
"30062"
],
"CVE-2007-2806": [
"30065"
],
"CVE-2007-2685": [
"30066"
],
"CVE-2007-2686": [
"30068"
],
"CVE-2007-2857": [
"30071"
],
"CVE-2007-2865": [
"30075"
],
"CVE-2007-2887": [
"30076"
],
"CVE-2007-2832": [
"30077"
],
"CVE-2007-2892": [
"30081"
],
"CVE-2007-2879": [
"30082"
],
"CVE-2007-2932": [
"30086"
],
"CVE-2007-5579": [
"30088"
],
"CVE-2007-0693": [
"30095",
"30099"
],
"CVE-2007-3170": [
"30097"
],
"CVE-2007-3171": [
"30098"
],
"CVE-2007-2959": [
"30101"
],
"CVE-2013-7194": [
"30213"
],
"CVE-2007-3636": [
"30283"
],
"CVE-2007-3346": [
"30220"
],
"CVE-2007-3354": [
"30223"
],
"CVE-2007-3394": [
"30225",
"30226"
],
"CVE-2007-2520": [
"30230"
],
"CVE-2007-3182": [
"30232"
],
"CVE-2007-3183": [
"30234"
],
"CVE-2006-6355": [
"30250"
],
"CVE-2007-2801": [
"30253"
],
"CVE-2007-3517": [
"30259"
],
"CVE-2007-3572": [
"30260"
],
"CVE-2007-3555": [
"30261"
],
"CVE-2007-3556": [
"30262"
],
"CVE-2007-3569": [
"30263"
],
"CVE-2007-3593": [
"30266",
"30267",
"30268",
"30269",
"30270"
],
"CVE-2007-3594": [
"30271",
"30272",
"30273",
"30274",
"30275"
],
"CVE-2007-3619": [
"30277"
],
"CVE-2007-3629": [
"30282"
],
"CVE-2007-3714": [
"30286"
],
"CVE-2005-1413": [
"30289"
],
"CVE-2007-3693": [
"30293"
],
"CVE-2007-3789": [
"30294"
],
"CVE-2007-3013": [
"30296"
],
"CVE-2007-3014": [
"30297",
"30298"
],
"CVE-2007-3017": [
"30299"
],
"CVE-2007-3824": [
"30300"
],
"CVE-2007-3792": [
"30301",
"30302",
"30303"
],
"CVE-2007-4088": [
"30383",
"30384",
"30385",
"30386"
],
"CVE-2007-4089": [
"30387",
"30388"
],
"CVE-2007-4092": [
"30389"
],
"CVE-2007-4095": [
"30390"
],
"CVE-2007-6001": [
"30801"
],
"CVE-2007-3822": [
"30312"
],
"CVE-2007-3838": [
"30313"
],
"CVE-2007-3884": [
"30316"
],
"CVE-2007-3889": [
"30317"
],
"CVE-2007-3888": [
"30318"
],
"CVE-2007-4047": [
"30320",
"30321"
],
"CVE-2007-3963": [
"30323",
"30324"
],
"CVE-2008-0192": [
"30978",
"30977"
],
"CVE-2007-3989": [
"30327"
],
"CVE-2007-4076": [
"30328"
],
"CVE-2013-7316": [
"30329"
],
"CVE-2007-4075": [
"30330"
],
"CVE-2007-3991": [
"30331"
],
"CVE-2007-3987": [
"30332"
],
"CVE-2007-4024": [
"30382"
],
"CVE-2007-4022": [
"30380"
],
"CVE-2007-6138": [
"30793"
],
"CVE-2013-7136": [
"30358"
],
"CVE-2013-7274": [
"30356"
],
"CVE-2013-6976": [
"30415",
"30362"
],
"CVE-2013-6884": [
"30396"
],
"CVE-2013-6881": [
"30396"
],
"CVE-2013-6882": [
"30396"
],
"CVE-2013-6883": [
"30396"
],
"CVE-2013-6839": [
"30398"
],
"CVE-2007-4052": [
"30402"
],
"CVE-2007-4104": [
"30403"
],
"CVE-2007-3909": [
"30405"
],
"CVE-2013-5573": [
"30408"
],
"CVE-2013-5676": [
"30409"
],
"CVE-2008-6555": [
"31466"
],
"CVE-2008-1504": [
"31467"
],
"CVE-2007-6136": [
"30799"
],
"CVE-2007-6380": [
"30873",
"30874",
"30875",
"30861",
"30862",
"30863",
"30864"
],
"CVE-2007-4116": [
"30423"
],
"CVE-2007-4119": [
"30424"
],
"CVE-2007-4109": [
"30425"
],
"CVE-2007-4110": [
"30426"
],
"CVE-2007-4106": [
"30427"
],
"CVE-2007-4111": [
"30428"
],
"CVE-2007-4143": [
"30429"
],
"CVE-2007-4115": [
"30433",
"30434",
"30435"
],
"CVE-2007-4101": [
"30436",
"30437",
"30438"
],
"CVE-2007-4146": [
"30440"
],
"CVE-2007-4178": [
"30442"
],
"CVE-2007-4186": [
"30445"
],
"CVE-2007-4173": [
"30446"
],
"CVE-2007-4208": [
"30451"
],
"CVE-2007-4244": [
"30452"
],
"CVE-2007-4264": [
"30453"
],
"CVE-2007-4235": [
"30456",
"30457",
"30459"
],
"CVE-2007-6158": [
"30810"
],
"CVE-2007-4283": [
"30463"
],
"CVE-2007-4325": [
"30465"
],
"CVE-2007-4327": [
"30466",
"30467"
],
"CVE-2013-6987": [
"30475"
],
"CVE-2007-4330": [
"30479"
],
"CVE-2007-4328": [
"30480"
],
"CVE-2007-4329": [
"30481",
"30482",
"30483"
],
"CVE-2007-4341": [
"30486"
],
"CVE-2007-4334": [
"30487"
],
"CVE-2007-4338": [
"30488"
],
"CVE-2007-4359": [
"30492"
],
"CVE-2007-4384": [
"30501"
],
"CVE-2007-4419": [
"30504"
],
"CVE-2007-4434": [
"30505"
],
"CVE-2007-4457": [
"30509"
],
"CVE-2007-4458": [
"30510"
],
"CVE-2007-4491": [
"30511"
],
"CVE-2007-4479": [
"30514"
],
"CVE-2005-4053": [
"30515"
],
"CVE-2006-1151": [
"30516"
],
"CVE-2007-4522": [
"30518"
],
"CVE-2007-4482": [
"30520"
],
"CVE-2007-4611": [
"30533"
],
"CVE-2007-4634": [
"30541"
],
"CVE-2007-4630": [
"30545"
],
"CVE-2008-0094": [
"30969",
"30968"
],
"CVE-2008-4616": [
"31030"
],
"CVE-2014-10038": [
"30872"
],
"CVE-2007-4711": [
"30553",
"30554"
],
"CVE-2007-4718": [
"30556"
],
"CVE-2007-4717": [
"30557",
"30558",
"30559"
],
"CVE-2007-4719": [
"30560"
],
"CVE-2007-6321": [
"30877"
],
"CVE-2007-6374": [
"30878",
"30879"
],
"CVE-2007-6375": [
"30880"
],
"CVE-2007-6376": [
"30881"
],
"CVE-2006-7196": [
"30563"
],
"CVE-2007-4762": [
"30564"
],
"CVE-2007-4896": [
"30570"
],
"CVE-2007-4899": [
"30575",
"30576"
],
"CVE-2007-4892": [
"30577"
],
"CVE-2008-4139": [
"32387"
],
"CVE-2008-5998": [
"32415"
],
"CVE-2008-5997": [
"32412"
],
"CVE-2008-6406": [
"32411"
],
"CVE-2008-4344": [
"32410"
],
"CVE-2008-4140": [
"32389"
],
"CVE-2008-6034": [
"32409"
],
"CVE-2008-6026": [
"32408"
],
"CVE-2008-6039": [
"32407"
],
"CVE-2008-6045": [
"32406"
],
"CVE-2008-6044": [
"32405"
],
"CVE-2008-3098": [
"32404"
],
"CVE-2008-6038": [
"32403"
],
"CVE-2008-6404": [
"32398"
],
"CVE-2008-6043": [
"32397"
],
"CVE-2008-7008": [
"32395"
],
"CVE-2008-4172": [
"32388"
],
"CVE-2007-4937": [
"30581"
],
"CVE-2007-4917": [
"30583"
],
"CVE-2007-4930": [
"30585",
"30586",
"30587"
],
"CVE-2007-4925": [
"30588"
],
"CVE-2007-4977": [
"30594"
],
"CVE-2007-4976": [
"30595"
],
"CVE-2007-4975": [
"30596"
],
"CVE-2007-5027": [
"30597"
],
"CVE-2007-5010": [
"30598"
],
"CVE-2007-5011": [
"30599"
],
"CVE-2007-5052": [
"30601"
],
"CVE-2007-5105": [
"30602"
],
"CVE-2007-5060": [
"30603"
],
"CVE-2007-5112": [
"30606"
],
"CVE-2007-5120": [
"30608",
"30609",
"30610",
"30611",
"30612",
"30613"
],
"CVE-2007-5092": [
"30614"
],
"CVE-2007-5127": [
"30615",
"30616"
],
"CVE-2007-4874": [
"30617",
"30618"
],
"CVE-2007-5142": [
"30621"
],
"CVE-2007-5181": [
"30624"
],
"CVE-2007-5180": [
"30625",
"30626"
],
"CVE-2008-6875": [
"30629"
],
"CVE-2007-5218": [
"30632"
],
"CVE-2006-3173": [
"30634"
],
"CVE-2007-5229": [
"30637"
],
"CVE-2007-5253": [
"30639"
],
"CVE-2007-5290": [
"30641",
"30642"
],
"CVE-2007-5370": [
"30649"
],
"CVE-2007-5410": [
"30651"
],
"CVE-2007-5386": [
"30653"
],
"CVE-2007-5426": [
"30654"
],
"CVE-2007-5427": [
"30655"
],
"CVE-2007-5417": [
"30656"
],
"CVE-2007-5428": [
"30657"
],
"CVE-2007-5440": [
"30658"
],
"CVE-2007-5429": [
"30659"
],
"CVE-2007-5430": [
"30660",
"30662",
"30664"
],
"CVE-2007-5113": [
"30661"
],
"CVE-2007-4486": [
"30663"
],
"CVE-2013-7282": [
"30665"
],
"CVE-2014-0621": [
"30667"
],
"CVE-2014-0620": [
"30668"
],
"CVE-2014-10037": [
"30865"
],
"CVE-2008-1607": [
"31531"
],
"CVE-2007-5478": [
"30674"
],
"CVE-2007-5480": [
"30675",
"30676"
],
"CVE-2007-5694": [
"30682"
],
"CVE-2007-5693": [
"30683"
],
"CVE-2007-5692": [
"30684",
"30685",
"30686"
],
"CVE-2007-6141": [
"30804"
],
"CVE-2014-10032": [
"30689"
],
"CVE-2008-0334": [
"31027"
],
"CVE-2008-0286": [
"31028"
],
"CVE-2008-7216": [
"31029"
],
"CVE-2007-5190": [
"30691"
],
"CVE-2007-5647": [
"30693"
],
"CVE-2007-5649": [
"30694"
],
"CVE-2007-5648": [
"30695"
],
"CVE-2007-5625": [
"30696"
],
"CVE-2007-5650": [
"30697"
],
"CVE-2007-5677": [
"30699"
],
"CVE-2007-5679": [
"30700"
],
"CVE-2007-5706": [
"30701"
],
"CVE-2007-5733": [
"30703"
],
"CVE-2007-5739": [
"30704"
],
"CVE-2007-5737": [
"30705"
],
"CVE-2007-6032": [
"30708"
],
"CVE-2007-5688": [
"30712"
],
"CVE-2007-5710": [
"30715"
],
"CVE-2007-5725": [
"30716"
],
"CVE-2007-5724": [
"30717"
],
"CVE-2007-4862": [
"30718"
],
"CVE-2007-4863": [
"30719"
],
"CVE-2007-6135": [
"30806"
],
"CVE-2007-6163": [
"30807"
],
"CVE-2013-6924": [
"30723",
"30725"
],
"CVE-2013-6922": [
"30726"
],
"CVE-2013-6923": [
"30727"
],
"CVE-2007-5816": [
"30732"
],
"CVE-2007-5589": [
"30733"
],
"CVE-2007-5952": [
"30734"
],
"CVE-2007-5915": [
"30735"
],
"CVE-2007-5567": [
"30737"
],
"CVE-2007-5951": [
"30738"
],
"CVE-2007-5954": [
"30739"
],
"CVE-2007-5890": [
"30741"
],
"CVE-2007-5776": [
"30743"
],
"CVE-2007-5918": [
"30745"
],
"CVE-2007-5923": [
"30746"
],
"CVE-2007-5978": [
"30748"
],
"CVE-2007-3694": [
"30751"
],
"CVE-2007-5983": [
"30754"
],
"CVE-2007-5982": [
"30757",
"30758"
],
"CVE-2007-5993": [
"30759"
],
"CVE-2007-5817": [
"30764"
],
"CVE-2007-6056": [
"30770"
],
"CVE-2007-6055": [
"30774"
],
"CVE-2007-6091": [
"30775"
],
"CVE-2007-6037": [
"30777"
],
"CVE-2008-0146": [
"30975"
],
"CVE-2014-1619": [
"30790"
],
"CVE-2007-6157": [
"30811"
],
"CVE-2007-6162": [
"30813"
],
"CVE-2007-6160": [
"30815"
],
"CVE-2007-6173": [
"30817"
],
"CVE-2007-6110": [
"30818"
],
"CVE-2007-6191": [
"30820",
"30821"
],
"CVE-2007-6198": [
"30822"
],
"CVE-2007-6266": [
"30823",
"30824"
],
"CVE-2007-6218": [
"30826",
"30827",
"30828",
"30829",
"30830",
"30831"
],
"CVE-2007-6275": [
"30836"
],
"CVE-2007-6268": [
"30841"
],
"CVE-2007-6269": [
"30842"
],
"CVE-2007-6270": [
"30843",
"30844"
],
"CVE-2007-6271": [
"30845"
],
"CVE-2007-6297": [
"30846",
"30847"
],
"CVE-2007-6272": [
"30848",
"30849"
],
"CVE-2007-6301": [
"30853"
],
"CVE-2007-6307": [
"30854"
],
"CVE-2007-6309": [
"30857",
"30858"
],
"CVE-2007-6467": [
"30886"
],
"CVE-2007-6471": [
"30887"
],
"CVE-2007-6470": [
"30888"
],
"CVE-2007-6455": [
"30899"
],
"CVE-2014-10010": [
"30911"
],
"CVE-2014-10015": [
"30913"
],
"CVE-2014-10014": [
"30913"
],
"CVE-2013-7204": [
"30914"
],
"CVE-2013-7137": [
"30916"
],
"CVE-2013-7139": [
"30917"
],
"CVE-2007-6539": [
"30918"
],
"CVE-2007-6538": [
"30921"
],
"CVE-2007-6574": [
"30924",
"30925",
"30926"
],
"CVE-2007-6559": [
"30929",
"30930"
],
"CVE-2007-6560": [
"30931",
"30932"
],
"CVE-2007-6564": [
"30937"
],
"CVE-2007-6597": [
"30940",
"30941"
],
"CVE-2007-6633": [
"30945"
],
"CVE-2013-6872": [
"30946"
],
"CVE-2007-6634": [
"30947"
],
"CVE-2007-6608": [
"30948",
"30949",
"30951"
],
"CVE-2007-6670": [
"30957"
],
"CVE-2007-6669": [
"30958"
],
"CVE-2007-6673": [
"30959"
],
"CVE-2007-6641": [
"30962"
],
"CVE-2007-6671": [
"30963"
],
"CVE-2007-6646": [
"30964",
"30965",
"30966",
"30967"
],
"CVE-2008-0193": [
"30979"
],
"CVE-2008-0190": [
"30980"
],
"CVE-2008-0207": [
"30981"
],
"CVE-2008-0559": [
"31083"
],
"CVE-2008-0266": [
"30994"
],
"CVE-2008-0268": [
"30995"
],
"CVE-2008-0267": [
"30996",
"30997"
],
"CVE-2008-0184": [
"31000"
],
"CVE-2008-0218": [
"31001"
],
"CVE-2008-1134": [
"31003"
],
"CVE-2008-0239": [
"31004",
"31005",
"31007"
],
"CVE-2008-0240": [
"31006"
],
"CVE-2008-0281": [
"31009"
],
"CVE-2008-0289": [
"31011"
],
"CVE-2008-0178": [
"31082"
],
"CVE-2008-0123": [
"31020"
],
"CVE-2008-0258": [
"31022"
],
"CVE-2008-0383": [
"31034"
],
"CVE-2008-0433": [
"31037"
],
"CVE-2008-0432": [
"31038"
],
"CVE-2008-0436": [
"31042"
],
"CVE-2008-7165": [
"31043"
],
"CVE-2008-0400": [
"31044"
],
"CVE-2008-0451": [
"31048"
],
"CVE-2008-0439": [
"31049"
],
"CVE-2008-0744": [
"31058"
],
"CVE-2008-0540": [
"31061",
"31062"
],
"CVE-2007-6696": [
"31063",
"31064"
],
"CVE-2008-0539": [
"31065"
],
"CVE-2008-7213": [
"31066"
],
"CVE-2008-0489": [
"31067"
],
"CVE-2008-0552": [
"31069"
],
"CVE-2008-0487": [
"31070"
],
"CVE-2008-0488": [
"31071"
],
"CVE-2008-4727": [
"31073"
],
"CVE-2008-0497": [
"31074"
],
"CVE-2008-0496": [
"31075"
],
"CVE-2008-0574": [
"31079"
],
"CVE-2008-4611": [
"31080"
],
"CVE-2007-6700": [
"31081"
],
"CVE-2014-10018": [
"31087"
],
"CVE-2008-0688": [
"31091"
],
"CVE-2008-0691": [
"31092"
],
"CVE-2008-0685": [
"31093",
"31140"
],
"CVE-2008-0684": [
"31094"
],
"CVE-2008-0700": [
"31097"
],
"CVE-2008-0650": [
"31098"
],
"CVE-2008-0651": [
"31099"
],
"CVE-2008-0605": [
"31103",
"31104"
],
"CVE-2008-0645": [
"31107",
"31108",
"31109",
"31110"
],
"CVE-2008-7036": [
"31112"
],
"CVE-2008-0723": [
"31115"
],
"CVE-2008-0722": [
"31116"
],
"CVE-2008-5692": [
"31117"
],
"CVE-2008-7242": [
"31120"
],
"CVE-2008-0749": [
"31124"
],
"CVE-2008-0743": [
"31125"
],
"CVE-2008-0751": [
"31126"
],
"CVE-2008-0636": [
"31129"
],
"CVE-2008-0753": [
"31134"
],
"CVE-2014-10002": [
"31140",
"31961"
],
"CVE-2014-10020": [
"31142"
],
"CVE-2008-0733": [
"31154"
],
"CVE-2008-0785": [
"31156",
"31159",
"31160",
"31161"
],
"CVE-2008-0783": [
"31157",
"31158"
],
"CVE-2008-0815": [
"31162"
],
"CVE-2008-1228": [
"31335"
],
"CVE-2014-0793": [
"31174"
],
"CVE-2014-0794": [
"31175"
],
"CVE-2013-7248": [
"31180"
],
"CVE-2013-7247": [
"31180"
],
"CVE-2008-0980": [
"31269",
"31265",
"31266",
"31267",
"31268"
],
"CVE-2008-0982": [
"31270"
],
"CVE-2008-0026": [
"31189"
],
"CVE-2008-7030": [
"31191"
],
"CVE-2008-0850": [
"31194",
"31195",
"31199",
"31200"
],
"CVE-2008-0851": [
"31196",
"31197",
"31198"
],
"CVE-2008-0819": [
"31202"
],
"CVE-2008-0816": [
"31208"
],
"CVE-2008-0854": [
"31213"
],
"CVE-2008-0817": [
"31215"
],
"CVE-2008-0810": [
"31216"
],
"CVE-2008-0812": [
"31217"
],
"CVE-2008-3682": [
"32241"
],
"CVE-2008-5946": [
"32242"
],
"CVE-2008-5945": [
"32243"
],
"CVE-2008-5947": [
"32244"
],
"CVE-2008-5944": [
"32245"
],
"CVE-2008-5943": [
"32246",
"32247"
],
"CVE-2008-0846": [
"31224"
],
"CVE-2008-7222": [
"31225"
],
"CVE-2008-0853": [
"31226"
],
"CVE-2008-7040": [
"31227"
],
"CVE-2008-5584": [
"31229"
],
"CVE-2008-0845": [
"31230"
],
"CVE-2008-5674": [
"31233",
"31234"
],
"CVE-2008-0877": [
"31235",
"31236",
"31237",
"31238"
],
"CVE-2008-5283": [
"31239"
],
"CVE-2008-0872": [
"31240"
],
"CVE-2008-0855": [
"31242"
],
"CVE-2008-0879": [
"31252"
],
"CVE-2014-10000": [
"31262",
"34968"
],
"CVE-2008-0943": [
"31275",
"31276",
"31277"
],
"CVE-2008-0942": [
"31278"
],
"CVE-2008-0937": [
"31282"
],
"CVE-2004-2000": [
"31283"
],
"CVE-2008-0936": [
"31284"
],
"CVE-2008-7226": [
"31287"
],
"CVE-2008-1050": [
"31294"
],
"CVE-2008-7033": [
"31296"
],
"CVE-2008-1045": [
"31299"
],
"CVE-2008-1181": [
"31313"
],
"CVE-2008-1174": [
"31314"
],
"CVE-2008-1129": [
"31315"
],
"CVE-2008-2044": [
"31317"
],
"CVE-2008-1178": [
"31318"
],
"CVE-2008-4803": [
"31319"
],
"CVE-2008-1128": [
"31320"
],
"CVE-2008-1314": [
"31322"
],
"CVE-2008-1170": [
"31324",
"31325"
],
"CVE-2008-1173": [
"31328"
],
"CVE-2008-1225": [
"31337"
],
"CVE-2008-1370": [
"31341"
],
"CVE-2008-1219": [
"31344"
],
"CVE-2008-1220": [
"31351"
],
"CVE-2008-1273": [
"31352",
"31353",
"31354",
"31355"
],
"CVE-2008-1304": [
"31356",
"31357"
],
"CVE-2008-1300": [
"31365"
],
"CVE-2008-1301": [
"31366"
],
"CVE-2008-1326": [
"31369"
],
"CVE-2008-1327": [
"31370"
],
"CVE-2008-7133": [
"31371",
"31372",
"31373",
"31374"
],
"CVE-2008-1371": [
"31375"
],
"CVE-2008-1298": [
"31377"
],
"CVE-2008-1296": [
"31379",
"31380"
],
"CVE-2008-1308": [
"31383"
],
"CVE-2008-1315": [
"31384"
],
"CVE-2008-1325": [
"31387"
],
"CVE-2008-1324": [
"31388"
],
"CVE-2008-7134": [
"31389",
"31390",
"31391"
],
"CVE-2008-1355": [
"31393"
],
"CVE-2008-1974": [
"31697"
],
"CVE-2008-1348": [
"31402"
],
"CVE-2008-1354": [
"31404"
],
"CVE-2008-1413": [
"31406"
],
"CVE-2008-1479": [
"31408"
],
"CVE-2008-1463": [
"31413"
],
"CVE-2008-0125": [
"31414"
],
"CVE-2008-1481": [
"31416"
],
"CVE-2014-10023": [
"31419"
],
"CVE-2013-7055": [
"31425"
],
"CVE-2013-7054": [
"31425"
],
"CVE-2013-7053": [
"31425"
],
"CVE-2013-7052": [
"31425"
],
"CVE-2013-7051": [
"31425"
],
"CVE-2014-1665": [
"31427"
],
"CVE-2014-1836": [
"31431"
],
"CVE-2007-4592": [
"31438"
],
"CVE-2008-7142": [
"31439"
],
"CVE-2008-1458": [
"31443"
],
"CVE-2008-1606": [
"31445",
"31446"
],
"CVE-2008-1540": [
"31448"
],
"CVE-2008-1466": [
"31449",
"31450",
"31451",
"31452",
"31453",
"31454",
"31455",
"31456",
"31457"
],
"CVE-2008-1511": [
"31469",
"31470"
],
"CVE-2008-1500": [
"31471"
],
"CVE-2008-1499": [
"31472"
],
"CVE-2008-1510": [
"31475"
],
"CVE-2008-1508": [
"31476"
],
"CVE-2014-10033": [
"31515"
],
"CVE-2013-2639": [
"31517"
],
"CVE-2014-1401": [
"31520"
],
"CVE-2014-1459": [
"31521"
],
"CVE-2014-0329": [
"31527"
],
"CVE-2008-1565": [
"31535"
],
"CVE-2008-1795": [
"31537",
"31538"
],
"CVE-2008-7145": [
"31539"
],
"CVE-2008-6565": [
"31541"
],
"CVE-2008-1621": [
"31543",
"31544",
"31545"
],
"CVE-2008-1560": [
"31546",
"31547"
],
"CVE-2008-6544": [
"31555"
],
"CVE-2008-7140": [
"31565",
"31566"
],
"CVE-2008-7141": [
"31567"
],
"CVE-2014-1889": [
"31571"
],
"CVE-2008-4435": [
"32215",
"32216"
],
"CVE-2014-1204": [
"31578"
],
"CVE-2014-1843": [
"31579"
],
"CVE-2014-1842": [
"31579"
],
"CVE-2014-1841": [
"31579"
],
"CVE-2005-4879": [
"31580"
],
"CVE-2008-6491": [
"31581"
],
"CVE-2008-1641": [
"31582"
],
"CVE-2008-6522": [
"31584"
],
"CVE-2008-6196": [
"31587",
"31588",
"31589"
],
"CVE-2008-1800": [
"31590"
],
"CVE-2008-4777": [
"31595"
],
"CVE-2008-6211": [
"31596",
"31597",
"31598",
"31599",
"31600",
"31601",
"31602"
],
"CVE-2008-6478": [
"31603"
],
"CVE-2008-6479": [
"31604"
],
"CVE-2008-1787": [
"31605"
],
"CVE-2008-6550": [
"31606"
],
"CVE-2008-1757": [
"31608"
],
"CVE-2008-1873": [
"31609"
],
"CVE-2008-6206": [
"31610",
"31611"
],
"CVE-2008-6545": [
"31616"
],
"CVE-2008-6205": [
"31622"
],
"CVE-2008-6200": [
"31628"
],
"CVE-2008-1733": [
"31631"
],
"CVE-2008-1844": [
"31636"
],
"CVE-2008-1843": [
"31637"
],
"CVE-2008-1969": [
"31644",
"31645",
"31646"
],
"CVE-2014-1219": [
"31647"
],
"CVE-2008-1968": [
"31648",
"31649"
],
"CVE-2008-1967": [
"31650"
],
"CVE-2008-1917": [
"31651",
"31652",
"31653"
],
"CVE-2008-1893": [
"31654"
],
"CVE-2008-4911": [
"31655"
],
"CVE-2008-1955": [
"31658"
],
"CVE-2008-6212": [
"31659"
],
"CVE-2008-2037": [
"31660",
"31661",
"31662",
"31663",
"31664",
"31665"
],
"CVE-2008-6203": [
"31666"
],
"CVE-2008-4768": [
"31668"
],
"CVE-2008-1956": [
"31669"
],
"CVE-2008-4769": [
"31670"
],
"CVE-2008-6585": [
"31671"
],
"CVE-2008-6586": [
"31672"
],
"CVE-2008-1983": [
"31677"
],
"CVE-2008-2219": [
"31714"
],
"CVE-2008-1385": [
"31682"
],
"CVE-2008-4767": [
"31702"
],
"CVE-2008-1986": [
"31703"
],
"CVE-2008-6596": [
"31704"
],
"CVE-2008-6597": [
"31705"
],
"CVE-2010-5063": [
"31716"
],
"CVE-2008-2187": [
"31717"
],
"CVE-2008-2188": [
"31721",
"31722"
],
"CVE-2008-2118": [
"31723"
],
"CVE-2008-2117": [
"31724"
],
"CVE-2008-6615": [
"31725"
],
"CVE-2008-6616": [
"31726"
],
"CVE-2008-2186": [
"31727"
],
"CVE-2008-6617": [
"31729"
],
"CVE-2008-6655": [
"31730",
"31731",
"31732"
],
"CVE-2014-1206": [
"31738"
],
"CVE-2008-2196": [
"31740"
],
"CVE-2008-2202": [
"31741",
"31742",
"31743"
],
"CVE-2008-6640": [
"31745",
"31746"
],
"CVE-2008-2130": [
"31747"
],
"CVE-2008-2110": [
"31750"
],
"CVE-2008-5211": [
"31751"
],
"CVE-2008-2227": [
"31752"
],
"CVE-2008-2126": [
"31753"
],
"CVE-2008-2123": [
"31754",
"31755"
],
"CVE-2008-2070": [
"31771",
"31772",
"31773"
],
"CVE-2008-6631": [
"31774"
],
"CVE-2008-2449": [
"31778",
"31779"
],
"CVE-2008-2264": [
"31780"
],
"CVE-2008-2284": [
"31783"
],
"CVE-2014-10009": [
"31792"
],
"CVE-2014-10008": [
"31792"
],
"CVE-2008-2334": [
"31797",
"31798",
"31799"
],
"CVE-2008-2339": [
"31800"
],
"CVE-2008-2412": [
"31801"
],
"CVE-2008-2413": [
"31802"
],
"CVE-2008-2414": [
"31803"
],
"CVE-2008-2415": [
"31804"
],
"CVE-2008-2350": [
"31806"
],
"CVE-2008-2478": [
"31807"
],
"CVE-2008-2398": [
"31808"
],
"CVE-2008-2458": [
"31809"
],
"CVE-2008-2422": [
"31810"
],
"CVE-2008-2421": [
"31816"
],
"CVE-2008-6437": [
"31821",
"31822"
],
"CVE-2008-6435": [
"31823",
"31824"
],
"CVE-2008-6431": [
"31825",
"31826",
"31827"
],
"CVE-2008-6572": [
"31829"
],
"CVE-2008-6439": [
"31830"
],
"CVE-2008-6924": [
"32045"
],
"CVE-2014-2090": [
"31833"
],
"CVE-2014-2089": [
"31833"
],
"CVE-2014-2088": [
"31833"
],
"CVE-2014-1854": [
"31834"
],
"CVE-2008-6637": [
"31835"
],
"CVE-2008-2510": [
"31836"
],
"CVE-2008-2781": [
"31837"
],
"CVE-2008-2783": [
"31838",
"31839",
"31840"
],
"CVE-2008-6620": [
"31841"
],
"CVE-2008-2491": [
"31842"
],
"CVE-2008-2509": [
"31843"
],
"CVE-2008-2479": [
"31844",
"31845"
],
"CVE-2008-6618": [
"31846",
"31847",
"31848"
],
"CVE-2008-6619": [
"31849"
],
"CVE-2008-2493": [
"31850"
],
"CVE-2008-2492": [
"31851",
"31852"
],
"CVE-2008-2508": [
"31855"
],
"CVE-2008-2507": [
"31858"
],
"CVE-2008-5222": [
"31861"
],
"CVE-2008-6644": [
"31865"
],
"CVE-2008-6418": [
"31866"
],
"CVE-2008-5264": [
"31892"
],
"CVE-2014-1677": [
"31894"
],
"CVE-2008-2995": [
"31904",
"31905"
],
"CVE-2008-2994": [
"31906",
"31907"
],
"CVE-2008-6736": [
"31908"
],
"CVE-2008-2744": [
"31910"
],
"CVE-2014-4613": [
"31916"
],
"CVE-2008-2787": [
"31933"
],
"CVE-2008-2871": [
"31945"
],
"CVE-2008-3186": [
"31949",
"31950",
"31951",
"31952",
"31953"
],
"CVE-2008-2987": [
"31954",
"31955",
"31956"
],
"CVE-2008-3448": [
"32135"
],
"CVE-2008-3161": [
"32046"
],
"CVE-2008-5164": [
"31975",
"31976"
],
"CVE-2008-5163": [
"31977",
"31978"
],
"CVE-2013-6043": [
"31982"
],
"CVE-2013-6042": [
"31982"
],
"CVE-2013-6041": [
"31982"
],
"CVE-2014-9304": [
"31983"
],
"CVE-2014-9181": [
"31983"
],
"CVE-2014-1908": [
"31986"
],
"CVE-2014-1907": [
"31986"
],
"CVE-2014-1906": [
"31986"
],
"CVE-2014-1905": [
"31986"
],
"CVE-2013-6231": [
"31990"
],
"CVE-2013-5877": [
"31992"
],
"CVE-2014-0372": [
"31993"
],
"CVE-2014-0379": [
"31994"
],
"CVE-2013-5795": [
"31995"
],
"CVE-2008-3034": [
"32001",
"32002"
],
"CVE-2008-3033": [
"32003"
],
"CVE-2007-3653": [
"32004",
"32005"
],
"CVE-2008-3163": [
"32011"
],
"CVE-2008-6837": [
"32013"
],
"CVE-2008-6838": [
"32014"
],
"CVE-2008-3151": [
"32015"
],
"CVE-2008-3164": [
"32016"
],
"CVE-2008-3184": [
"32017"
],
"CVE-2008-3201": [
"32020"
],
"CVE-2008-3202": [
"32021"
],
"CVE-2008-6839": [
"32022",
"32023"
],
"CVE-2008-6840": [
"32024",
"32025",
"32026",
"32027",
"32028",
"32029",
"32030",
"32031",
"32032",
"32033",
"32034",
"32035",
"32036"
],
"CVE-2014-10035": [
"32037"
],
"CVE-2014-10034": [
"32037"
],
"CVE-2013-6232": [
"32038"
],
"CVE-2013-6233": [
"32039"
],
"CVE-2013-6234": [
"32040"
],
"CVE-2008-4744": [
"32283"
],
"CVE-2008-3774": [
"32284"
],
"CVE-2008-3206": [
"32051"
],
"CVE-2008-3233": [
"32053"
],
"CVE-2008-7087": [
"32058"
],
"CVE-2008-3260": [
"32059",
"32060",
"32061",
"32062",
"32063",
"32064",
"32065",
"32066",
"32067",
"32068",
"32069",
"32070"
],
"CVE-2008-3261": [
"32071"
],
"CVE-2014-2317": [
"32075"
],
"CVE-2014-1945": [
"32075"
],
"CVE-2014-1944": [
"32076"
],
"CVE-2008-3313": [
"32079",
"32080"
],
"CVE-2008-3312": [
"32081"
],
"CVE-2008-3388": [
"32082",
"32083"
],
"CVE-2008-3380": [
"32087"
],
"CVE-2008-3347": [
"32088"
],
"CVE-2008-3343": [
"32089"
],
"CVE-2007-3198": [
"32090"
],
"CVE-2008-3311": [
"32092"
],
"CVE-2008-6443": [
"32093"
],
"CVE-2008-3345": [
"32096"
],
"CVE-2008-3296": [
"32097"
],
"CVE-2008-3295": [
"32098"
],
"CVE-2008-3354": [
"32099",
"32100"
],
"CVE-2008-3299": [
"32101"
],
"CVE-2008-3300": [
"32102"
],
"CVE-2008-3315": [
"32106",
"32107",
"32108",
"32109"
],
"CVE-2008-3370": [
"32113"
],
"CVE-2008-3575": [
"32116"
],
"CVE-2008-3391": [
"32119",
"32120"
],
"CVE-2008-3375": [
"32121"
],
"CVE-2008-3100": [
"32122"
],
"CVE-2008-3483": [
"32126"
],
"CVE-2008-3404": [
"32128"
],
"CVE-2008-3566": [
"32139"
],
"CVE-2008-3513": [
"32140"
],
"CVE-2008-3587": [
"32141"
],
"CVE-2008-3573": [
"32142"
],
"CVE-2008-3582": [
"32143"
],
"CVE-2008-3565": [
"32144",
"32145",
"32146",
"32147",
"32148",
"32149"
],
"CVE-2008-3568": [
"32150"
],
"CVE-2008-3495": [
"32151"
],
"CVE-2014-2044": [
"32162"
],
"CVE-2008-3574": [
"32168"
],
"CVE-2008-3510": [
"32169"
],
"CVE-2008-3511": [
"32170",
"32171",
"32172",
"32173",
"32174",
"32175",
"32176",
"32177",
"32178"
],
"CVE-2008-3561": [
"32179"
],
"CVE-2008-3562": [
"32180"
],
"CVE-2008-3556": [
"32181"
],
"CVE-2008-6516": [
"32182",
"32183"
],
"CVE-2008-3559": [
"32184",
"32185"
],
"CVE-2008-3560": [
"32190"
],
"CVE-2008-3512": [
"32191"
],
"CVE-2008-4432": [
"32196"
],
"CVE-2008-3668": [
"32198",
"32199",
"32200",
"32201",
"32202",
"32203"
],
"CVE-2014-2043": [
"32212"
],
"CVE-2008-4424": [
"32218"
],
"CVE-2008-3700": [
"32219",
"32220"
],
"CVE-2008-3701": [
"32221"
],
"CVE-2008-4439": [
"32226"
],
"CVE-2008-4438": [
"32227"
],
"CVE-2008-6066": [
"32231",
"32232",
"32233",
"32234",
"32235",
"32236"
],
"CVE-2008-3723": [
"32251"
],
"CVE-2008-3712": [
"32252",
"32253"
],
"CVE-2008-3715": [
"32254"
],
"CVE-2008-3722": [
"32255"
],
"CVE-2008-3714": [
"32258"
],
"CVE-2008-3770": [
"32259",
"32264",
"32265",
"32266",
"32267",
"32268",
"32269",
"32270"
],
"CVE-2008-3773": [
"32285"
],
"CVE-2008-6517": [
"32271"
],
"CVE-2008-3917": [
"32272"
],
"CVE-2014-2588": [
"32368"
],
"CVE-2014-2587": [
"32368"
],
"CVE-2014-2586": [
"32368"
],
"CVE-2008-3758": [
"32279"
],
"CVE-2008-3752": [
"32280"
],
"CVE-2008-3754": [
"32281"
],
"CVE-2008-4741": [
"32287"
],
"CVE-2008-4742": [
"32288"
],
"CVE-2008-3850": [
"32290"
],
"CVE-2008-3786": [
"32291"
],
"CVE-2008-4053": [
"32296"
],
"CVE-2008-4051": [
"32297"
],
"CVE-2008-4056": [
"32299"
],
"CVE-2008-3101": [
"32307"
],
"CVE-2008-3942": [
"32309"
],
"CVE-2008-3941": [
"32312"
],
"CVE-2008-3937": [
"32313",
"32314",
"32315"
],
"CVE-2008-4046": [
"32316"
],
"CVE-2008-3664": [
"32318",
"32320",
"32321",
"32322",
"32323",
"32324",
"32325",
"32326",
"32327"
],
"CVE-2008-6396": [
"32334"
],
"CVE-2008-6764": [
"32337"
],
"CVE-2008-6979": [
"32338"
],
"CVE-2008-4459": [
"32342"
],
"CVE-2008-4458": [
"32346"
],
"CVE-2008-6970": [
"32347"
],
"CVE-2008-3824": [
"32353"
],
"CVE-2008-3823": [
"32354"
],
"CVE-2008-7120": [
"32355"
],
"CVE-2008-4179": [
"32360",
"32361"
],
"CVE-2008-4174": [
"32364"
],
"CVE-2008-4349": [
"32365"
],
"CVE-2014-2017": [
"32375"
],
"CVE-2014-2016": [
"32375"
],
"CVE-2008-4096": [
"32383"
],
"CVE-2008-4328": [
"32418"
],
"CVE-2008-4120": [
"32421"
],
"CVE-2008-4320": [
"32423",
"32424",
"32425"
],
"CVE-2008-4737": [
"32430"
],
"CVE-2008-4672": [
"32431"
],
"CVE-2008-4670": [
"32432"
],
"CVE-2008-4669": [
"32434"
],
"CVE-2008-7017": [
"32443"
],
"CVE-2008-4671": [
"32444"
],
"CVE-2008-6103": [
"32447"
],
"CVE-2008-6094": [
"32448"
],
"CVE-2008-4447": [
"32449"
],
"CVE-2008-6097": [
"32450"
],
"CVE-2008-6164": [
"32453"
],
"CVE-2008-4532": [
"32455"
],
"CVE-2008-4393": [
"32459"
],
"CVE-2008-4525": [
"32461"
],
"CVE-2008-4499": [
"32463",
"32464"
],
"CVE-2008-4694": [
"32467"
],
"CVE-2008-6660": [
"32479"
],
"CVE-2008-5707": [
"32485"
],
"CVE-2008-4648": [
"32487"
],
"CVE-2008-4649": [
"32488"
],
"CVE-2008-4601": [
"32492"
],
"CVE-2008-6799": [
"32494"
],
"CVE-2008-4651": [
"32495",
"32496"
],
"CVE-2008-6779": [
"32497"
],
"CVE-2008-6803": [
"32498"
],
"CVE-2008-6802": [
"32499"
],
"CVE-2008-6075": [
"32500"
],
"CVE-2014-2531": [
"32516"
],
"CVE-2008-6807": [
"32521"
],
"CVE-2008-7269": [
"32523"
],
"CVE-2008-6174": [
"32525"
],
"CVE-2008-6173": [
"32526"
],
"CVE-2008-4761": [
"32527"
],
"CVE-2008-4751": [
"32528"
],
"CVE-2008-4775": [
"32531"
],
"CVE-2008-5039": [
"32538"
],
"CVE-2008-4787": [
"32539"
],
"CVE-2008-5064": [
"32541"
],
"CVE-2008-5037": [
"32542"
],
"CVE-2008-5067": [
"32543"
],
"CVE-2008-5068": [
"32544"
],
"CVE-2014-1982": [
"32545"
],
"CVE-2013-6719": [
"32546"
],
"CVE-2013-6720": [
"32546"
],
"CVE-2008-6217": [
"32547"
],
"CVE-2008-6266": [
"32553"
],
"CVE-2014-2879": [
"32556"
],
"CVE-2008-4931": [
"32566"
],
"CVE-2008-6297": [
"32567"
],
"CVE-2008-5057": [
"32577"
],
"CVE-2008-5115": [
"32579"
],
"CVE-2008-5126": [
"32588"
],
"CVE-2008-6306": [
"32595"
],
"CVE-2006-3151": [
"32600"
],
"CVE-2008-6278": [
"32607"
],
"CVE-2008-6279": [
"32608"
],
"CVE-2008-6887": [
"32609"
],
"CVE-2008-6888": [
"32610"
],
"CVE-2008-6500": [
"32611"
],
"CVE-2008-6325": [
"32612",
"32613",
"32614",
"32615",
"32616",
"32617"
],
"CVE-2014-2674": [
"32622"
],
"CVE-2014-0644": [
"32623"
],
"CVE-2008-5977": [
"32624"
],
"CVE-2008-5976": [
"32625"
],
"CVE-2008-6890": [
"32626"
],
"CVE-2008-6891": [
"32627",
"32628",
"32629"
],
"CVE-2008-6847": [
"32630"
],
"CVE-2008-5330": [
"32631"
],
"CVE-2008-6843": [
"32632"
],
"CVE-2008-6392": [
"32633"
],
"CVE-2008-6386": [
"32634"
],
"CVE-2008-6391": [
"32635"
],
"CVE-2008-6376": [
"32635"
],
"CVE-2008-5970": [
"32636"
],
"CVE-2008-5971": [
"32637"
],
"CVE-2008-6495": [
"32639"
],
"CVE-2008-6515": [
"32640"
],
"CVE-2008-6385": [
"32641"
],
"CVE-2008-5305": [
"32645"
],
"CVE-2008-5304": [
"32646"
],
"CVE-2008-6503": [
"32647",
"32648"
],
"CVE-2008-5569": [
"32649",
"32650",
"32651",
"32652"
],
"CVE-2008-3058": [
"32656"
],
"CVE-2008-5923": [
"32658"
],
"CVE-2014-2847": [
"32660"
],
"CVE-2008-5891": [
"32663"
],
"CVE-2008-6609": [
"32669"
],
"CVE-2014-2880": [
"32670"
],
"CVE-2008-6019": [
"32671"
],
"CVE-2008-6880": [
"32672"
],
"CVE-2009-0496": [
"32677",
"32678",
"32679"
],
"CVE-2009-0497": [
"32680"
],
"CVE-2008-6757": [
"32685"
],
"CVE-2014-2340": [
"32701"
],
"CVE-2009-0699": [
"32708"
],
"CVE-2009-0700": [
"32709",
"32710"
],
"CVE-2009-0431": [
"32729"
],
"CVE-2009-0430": [
"32730"
],
"CVE-2009-0429": [
"32731"
],
"CVE-2009-0339": [
"32735"
],
"CVE-2009-0338": [
"32736"
],
"CVE-2009-0026": [
"32741",
"32742"
],
"CVE-2009-0260": [
"32746"
],
"CVE-2005-3304": [
"32747"
],
"CVE-2009-0285": [
"32748"
],
"CVE-2009-0283": [
"32750"
],
"CVE-2009-0300": [
"32760"
],
"CVE-2006-2636": [
"32760"
],
"CVE-2009-0347": [
"32766"
],
"CVE-2009-0573": [
"32782",
"32783"
],
"CVE-2009-0455": [
"32784"
],
"CVE-2014-3792": [
"33129"
],
"CVE-2009-2780": [
"33198",
"33197",
"33199",
"33200",
"33201",
"33202"
],
"CVE-2014-2996": [
"32790"
],
"CVE-2014-2579": [
"32790"
],
"CVE-2014-2540": [
"32792"
],
"CVE-2009-0741": [
"32797"
],
"CVE-2008-6104": [
"32803"
],
"CVE-2009-0541": [
"32808",
"32809",
"32810"
],
"CVE-2014-2341": [
"32830"
],
"CVE-2009-0814": [
"32833"
],
"CVE-2009-0825": [
"32843"
],
"CVE-2009-4888": [
"32844"
],
"CVE-2009-1204": [
"32852",
"32853",
"32854"
],
"CVE-2009-1218": [
"32862"
],
"CVE-2009-1729": [
"32863",
"32864"
],
"CVE-2014-2598": [
"32867"
],
"CVE-2014-2995": [
"32868"
],
"CVE-2014-2559": [
"32868"
],
"CVE-2006-3682": [
"32870"
],
"CVE-2009-1070": [
"32871"
],
"CVE-2008-6476": [
"32874"
],
"CVE-2009-1225": [
"32880"
],
"CVE-2014-3138": [
"32886"
],
"CVE-2009-1288": [
"32894",
"32895"
],
"CVE-2009-1290": [
"32896"
],
"CVE-2009-1287": [
"32897"
],
"CVE-2009-1334": [
"32908"
],
"CVE-2009-1294": [
"32909"
],
"CVE-2009-1458": [
"32924"
],
"CVE-2009-0307": [
"32927"
],
"CVE-2009-1456": [
"32928"
],
"CVE-2009-4934": [
"32932"
],
"CVE-2009-4926": [
"32933",
"32934",
"32935",
"32936",
"32937"
],
"CVE-2009-1357": [
"32940"
],
"CVE-2014-10019": [
"32943"
],
"CVE-2009-1620": [
"32958"
],
"CVE-2009-1616": [
"32963"
],
"CVE-2009-1468": [
"32968"
],
"CVE-2009-1467": [
"32969",
"32985"
],
"CVE-2014-2976": [
"32973"
],
"CVE-2014-3757": [
"32983"
],
"CVE-2009-1469": [
"32986"
],
"CVE-2009-2571": [
"32988"
],
"CVE-2009-2569": [
"32989"
],
"CVE-2009-1907": [
"32991"
],
"CVE-2009-2302": [
"33057"
],
"CVE-2009-1786": [
"33001"
],
"CVE-2009-1593": [
"33002"
],
"CVE-2014-2383": [
"33004"
],
"CVE-2014-2846": [
"33005"
],
"CVE-2009-1842": [
"33011"
],
"CVE-2009-1845": [
"33013"
],
"CVE-2014-2347": [
"33019"
],
"CVE-2009-1938": [
"33022"
],
"CVE-2009-2107": [
"33038"
],
"CVE-2009-2216": [
"33048"
],
"CVE-2011-4909": [
"33061"
],
"CVE-2009-2360": [
"33065"
],
"CVE-2009-2438": [
"33068"
],
"CVE-2014-3871": [
"33075"
],
"CVE-2014-8949": [
"33076"
],
"CVE-2014-8948": [
"33076"
],
"CVE-2014-3849": [
"33076"
],
"CVE-2014-3848": [
"33076"
],
"CVE-2014-3842": [
"33076"
],
"CVE-2009-2551": [
"33085"
],
"CVE-2009-3566": [
"33347"
],
"CVE-2009-4690": [
"33097",
"33098"
],
"CVE-2009-2882": [
"33106",
"33107",
"33108",
"33109"
],
"CVE-2009-2893": [
"33110"
],
"CVE-2009-3220": [
"33111"
],
"CVE-2009-2772": [
"33112",
"33113"
],
"CVE-2009-3226": [
"33115"
],
"CVE-2009-3225": [
"33116",
"33117"
],
"CVE-2009-3513": [
"33119",
"33120",
"33121"
],
"CVE-2009-3152": [
"33130"
],
"CVE-2009-2783": [
"33131"
],
"CVE-2009-2790": [
"33132"
],
"CVE-2014-9727": [
"33136"
],
"CVE-2009-2595": [
"33144"
],
"CVE-2009-2579": [
"33146"
],
"CVE-2009-4989": [
"33147"
],
"CVE-2009-4547": [
"33155",
"33157",
"33158"
],
"CVE-2009-2915": [
"33166"
],
"CVE-2009-1872": [
"33167",
"33168",
"33169",
"33170"
],
"CVE-2009-2704": [
"33178"
],
"CVE-2009-3469": [
"33254"
],
"CVE-2016-4264": [
"40346"
],
"CVE-2009-1879": [
"33180"
],
"CVE-2009-2705": [
"33181"
],
"CVE-2009-3186": [
"33186",
"33187",
"33188"
],
"CVE-2008-7000": [
"33204"
],
"CVE-2009-4470": [
"33214"
],
"CVE-2009-2937": [
"33219"
],
"CVE-2009-3647": [
"33226"
],
"CVE-2009-3436": [
"33236"
],
"CVE-2009-3491": [
"33237"
],
"CVE-2009-3495": [
"33240"
],
"CVE-2009-3496": [
"33241"
],
"CVE-2009-4174": [
"33345"
],
"CVE-2014-3246": [
"33249"
],
"CVE-2014-3247": [
"33250"
],
"CVE-2014-3225": [
"33252"
],
"CVE-2009-4192": [
"33262"
],
"CVE-2009-3592": [
"33267"
],
"CVE-2010-0801": [
"33590"
],
"CVE-2014-5383": [
"33317"
],
"CVE-2009-4521": [
"33286"
],
"CVE-2009-4522": [
"33287"
],
"CVE-2009-4523": [
"33288"
],
"CVE-2009-3747": [
"33294"
],
"CVE-2009-3625": [
"33308"
],
"CVE-2009-3833": [
"33309"
],
"CVE-2009-3911": [
"33320"
],
"CVE-2014-3740": [
"33330"
],
"CVE-2014-3806": [
"33334"
],
"CVE-2014-2046": [
"33353"
],
"CVE-2009-4047": [
"33354",
"33355",
"33356",
"33357",
"33358",
"33359"
],
"CVE-2009-4218": [
"33361"
],
"CVE-2009-4060": [
"33362"
],
"CVE-2009-4168": [
"33371"
],
"CVE-2009-4216": [
"33376"
],
"CVE-2009-4112": [
"33377"
],
"CVE-2009-4253": [
"33380"
],
"CVE-2009-4360": [
"33381"
],
"CVE-2009-4359": [
"33382"
],
"CVE-2009-4154": [
"33383"
],
"CVE-2009-4780": [
"33385"
],
"CVE-2014-2987": [
"33389"
],
"CVE-2009-4601": [
"33396"
],
"CVE-2009-3702": [
"33436",
"33437"
],
"CVE-2009-4814": [
"33438"
],
"CVE-2009-4813": [
"33439"
],
"CVE-2009-4446": [
"33445"
],
"CVE-2009-4497": [
"33469"
],
"CVE-2010-0321": [
"33485"
],
"CVE-2010-1361": [
"33487"
],
"CVE-2014-3840": [
"33493"
],
"CVE-2010-0319": [
"33505"
],
"CVE-2010-0712": [
"33511"
],
"CVE-2014-3962": [
"33514"
],
"CVE-2014-4162": [
"33518"
],
"CVE-2010-0468": [
"33575"
],
"CVE-2010-0374": [
"33529"
],
"CVE-2010-2006": [
"33530"
],
"CVE-2009-4650": [
"33637"
],
"CVE-2009-4651": [
"33638"
],
"CVE-2010-2005": [
"33541",
"33542",
"33543",
"33544"
],
"CVE-2010-1111": [
"33545",
"33546"
],
"CVE-2014-3974": [
"33555"
],
"CVE-2014-3975": [
"33555"
],
"CVE-2014-3415": [
"33557"
],
"CVE-2014-3414": [
"33557"
],
"CVE-2009-4612": [
"33564"
],
"CVE-2010-0614": [
"33602"
],
"CVE-2010-0368": [
"33603"
],
"CVE-2014-3961": [
"33613"
],
"CVE-2014-3878": [
"33633"
],
"CVE-2010-0695": [
"33644"
],
"CVE-2010-0675": [
"33649"
],
"CVE-2010-1078": [
"33656"
],
"CVE-2010-0706": [
"33657"
],
"CVE-2010-0714": [
"33675"
],
"CVE-2010-2130": [
"33678"
],
"CVE-2010-1372": [
"33673"
],
"CVE-2010-1095": [
"33679"
],
"CVE-2014-4033": [
"33697"
],
"CVE-2014-4307": [
"33699"
],
"CVE-2014-4306": [
"33699"
],
"CVE-2014-2575": [
"33700"
],
"CVE-2014-4034": [
"33702"
],
"CVE-2014-4166": [
"33714"
],
"CVE-2010-1054": [
"33761"
],
"CVE-2013-5757": [
"33740"
],
"CVE-2013-5756": [
"33740"
],
"CVE-2010-2275": [
"33764"
],
"CVE-2010-2273": [
"33765"
],
"CVE-2010-1856": [
"33787"
],
"CVE-2010-1003": [
"33769"
],
"CVE-2010-1337": [
"33781"
],
"CVE-2014-3778": [
"33792"
],
"CVE-2009-2907": [
"33794"
],
"CVE-2010-1340": [
"33797"
],
"CVE-2014-4155": [
"33803"
],
"CVE-2014-4154": [
"33803"
],
"CVE-2014-4019": [
"33803"
],
"CVE-2014-4018": [
"33803"
],
"CVE-2010-2436": [
"34141"
],
"CVE-2010-1997": [
"33976"
],
"CVE-2014-4644": [
"33809",
"35578"
],
"CVE-2010-2679": [
"33812"
],
"CVE-2010-1453": [
"33814"
],
"CVE-2014-3119": [
"33818"
],
"CVE-2014-4645": [
"33822"
],
"CVE-2014-4718": [
"33830"
],
"CVE-2009-4511": [
"33832"
],
"CVE-2010-5048": [
"33998"
],
"CVE-2014-4194": [
"33846"
],
"CVE-2014-4663": [
"33851"
],
"CVE-2014-4716": [
"33866"
],
"CVE-2010-1872": [
"33870"
],
"CVE-2010-1724": [
"33884",
"33885"
],
"CVE-2014-4650": [
"33894"
],
"CVE-2014-4717": [
"33896"
],
"CVE-2014-2399": [
"33897"
],
"CVE-2010-1918": [
"33969"
],
"CVE-2010-1741": [
"33917"
],
"CVE-2010-5046": [
"33925"
],
"CVE-2010-1905": [
"33959"
],
"CVE-2014-3857": [
"33954"
],
"CVE-2010-1112": [
"33957"
],
"CVE-2014-0894": [
"33942"
],
"CVE-2014-0871": [
"33942"
],
"CVE-2014-0870": [
"33942"
],
"CVE-2014-0869": [
"33942"
],
"CVE-2014-0868": [
"33942"
],
"CVE-2014-0867": [
"33942"
],
"CVE-2014-0866": [
"33942"
],
"CVE-2014-0865": [
"33942"
],
"CVE-2014-0864": [
"33942"
],
"CVE-2010-1859": [
"33945"
],
"CVE-2010-2003": [
"33972"
],
"CVE-2010-1994": [
"33978"
],
"CVE-2014-4912": [
"33983"
],
"CVE-2010-2034": [
"34003"
],
"CVE-2010-2036": [
"34004"
],
"CVE-2010-2037": [
"34005"
],
"CVE-2010-2035": [
"34006"
],
"CVE-2014-3992": [
"34007"
],
"CVE-2014-3991": [
"34007"
],
"CVE-2010-2033": [
"34008"
],
"CVE-2010-2040": [
"34011"
],
"CVE-2010-2032": [
"34012"
],
"CVE-2010-1923": [
"34014"
],
"CVE-2010-2126": [
"34016",
"34017"
],
"CVE-2014-3418": [
"34030"
],
"CVE-2010-2038": [
"34031"
],
"CVE-2010-2142": [
"34034"
],
"CVE-2014-4965": [
"34062"
],
"CVE-2014-4964": [
"34062"
],
"CVE-2014-4963": [
"34062"
],
"CVE-2014-4962": [
"34062"
],
"CVE-2014-5194": [
"34189"
],
"CVE-2014-5193": [
"34189"
],
"CVE-2014-5192": [
"34189"
],
"CVE-2014-5082": [
"34189",
"34238"
],
"CVE-2010-5051": [
"34040"
],
"CVE-2010-5052": [
"34041"
],
"CVE-2010-2153": [
"34073"
],
"CVE-2014-5350": [
"34086"
],
"CVE-2014-4960": [
"34087"
],
"CVE-2010-5015": [
"34153"
],
"CVE-2010-4971": [
"34138"
],
"CVE-2010-5024": [
"34096"
],
"CVE-2010-5025": [
"34097"
],
"CVE-2010-0367": [
"34116",
"34117"
],
"CVE-2010-0371": [
"34118"
],
"CVE-2010-0366": [
"34119",
"34120"
],
"CVE-2010-0365": [
"34121"
],
"CVE-2014-5100": [
"34100"
],
"CVE-2010-2437": [
"34140"
],
"CVE-2014-5201": [
"34105"
],
"CVE-2014-9095": [
"34130"
],
"CVE-2010-2340": [
"34127"
],
"CVE-2014-9098": [
"34161"
],
"CVE-2014-9097": [
"34161",
"36058"
],
"CVE-2014-3738": [
"34165"
],
"CVE-2014-9096": [
"34168"
],
"CVE-2014-3544": [
"34169"
],
"CVE-2014-4710": [
"34170"
],
"CVE-2014-5115": [
"34173"
],
"CVE-2010-2433": [
"34179"
],
"CVE-2010-2463": [
"34183"
],
"CVE-2014-2225": [
"34187"
],
"CVE-2014-9101": [
"34190"
],
"CVE-2010-2616": [
"34213"
],
"CVE-2010-2617": [
"34214"
],
"CVE-2010-4979": [
"34219"
],
"CVE-2010-4978": [
"34220"
],
"CVE-2010-2626": [
"34223"
],
"CVE-2010-1327": [
"34225"
],
"CVE-2014-5087": [
"34238"
],
"CVE-2014-5086": [
"34238"
],
"CVE-2014-5085": [
"34238"
],
"CVE-2014-5084": [
"34238"
],
"CVE-2014-5083": [
"34238"
],
"CVE-2014-5081": [
"34238"
],
"CVE-2014-5094": [
"34239"
],
"CVE-2014-5093": [
"34239"
],
"CVE-2014-5092": [
"34239"
],
"CVE-2014-5091": [
"34239"
],
"CVE-2014-5090": [
"34239"
],
"CVE-2014-5089": [
"34239"
],
"CVE-2014-5088": [
"34239"
],
"CVE-2014-5347": [
"34336"
],
"CVE-2014-5346": [
"34336"
],
"CVE-2014-5345": [
"34336"
],
"CVE-2014-4170": [
"34245"
],
"CVE-2010-4977": [
"34250"
],
"CVE-2010-2669": [
"34253"
],
"CVE-2010-2844": [
"34258"
],
"CVE-2010-5002": [
"34265"
],
"CVE-2014-5276": [
"34275"
],
"CVE-2014-5275": [
"34275"
],
"CVE-2010-2856": [
"34284"
],
"CVE-2010-2858": [
"34286"
],
"CVE-2014-3978": [
"34308"
],
"CVE-2009-4548": [
"34499",
"34497",
"34498",
"34494",
"34495",
"34496"
],
"CVE-2014-5246": [
"34361"
],
"CVE-2009-3856": [
"34366"
],
"CVE-2009-4039": [
"34367"
],
"CVE-2010-4949": [
"34374"
],
"CVE-2009-3901": [
"34376"
],
"CVE-2009-4464": [
"34380"
],
"CVE-2014-5335": [
"34408"
],
"CVE-2014-3996": [
"34409"
],
"CVE-2010-4963": [
"34412"
],
"CVE-2010-3023": [
"34413",
"34414"
],
"CVE-2014-5464": [
"34419"
],
"CVE-2014-2081": [
"34420"
],
"CVE-2010-4922": [
"34429"
],
"CVE-2009-3059": [
"34456"
],
"CVE-2014-5465": [
"34436"
],
"CVE-2009-3320": [
"34443"
],
"CVE-2009-3311": [
"34444"
],
"CVE-2009-3260": [
"34445"
],
"CVE-2009-3256": [
"34446"
],
"CVE-2014-2223": [
"34447"
],
"CVE-2014-5377": [
"34449"
],
"CVE-2014-5519": [
"34451"
],
"CVE-2014-5521": [
"34452"
],
"CVE-2014-5520": [
"34452"
],
"CVE-2009-3493": [
"34453",
"34454"
],
"CVE-2009-3803": [
"34459"
],
"CVE-2009-3057": [
"34470",
"34471"
],
"CVE-2009-3066": [
"34473",
"34474"
],
"CVE-2010-4938": [
"34475"
],
"CVE-2009-4858": [
"34482"
],
"CVE-2009-4869": [
"34483"
],
"CVE-2009-4868": [
"34501"
],
"CVE-2010-2544": [
"34504"
],
"CVE-2015-1579": [
"34511",
"36554"
],
"CVE-2014-9734": [
"34511",
"36554"
],
"CVE-2014-5469": [
"34513"
],
"CVE-2014-5460": [
"34514",
"34681"
],
"CVE-2014-6043": [
"34519"
],
"CVE-2014-7153": [
"34524"
],
"CVE-2014-6070": [
"34525"
],
"CVE-2010-4882": [
"34533"
],
"CVE-2010-3003": [
"34543",
"34544",
"34545",
"34546",
"34547"
],
"CVE-2009-3360": [
"34548",
"34549",
"34550"
],
"CVE-2014-5140": [
"34552"
],
"CVE-2010-4877": [
"34563"
],
"CVE-2010-4899": [
"34564"
],
"CVE-2010-3070": [
"34565"
],
"CVE-2014-6050": [
"34580"
],
"CVE-2014-6049": [
"34580"
],
"CVE-2014-6048": [
"34580"
],
"CVE-2014-6047": [
"34580"
],
"CVE-2014-6046": [
"34580"
],
"CVE-2014-6045": [
"34580"
],
"CVE-2014-4873": [
"34924"
],
"CVE-2014-4874": [
"34924"
],
"CVE-2014-2009": [
"34586"
],
"CVE-2014-2008": [
"34586"
],
"CVE-2009-3355": [
"34597"
],
"CVE-2009-3362": [
"34598"
],
"CVE-2009-3359": [
"34600",
"34601"
],
"CVE-2010-3077": [
"34605"
],
"CVE-2010-4901": [
"34609"
],
"CVE-2010-4906": [
"34610"
],
"CVE-2010-4907": [
"34611"
],
"CVE-2009-2440": [
"34806"
],
"CVE-2009-2930": [
"34616"
],
"CVE-2009-4991": [
"34618"
],
"CVE-2010-4909": [
"34619",
"34620"
],
"CVE-2009-3162": [
"34632"
],
"CVE-2009-4864": [
"34634"
],
"CVE-2010-3462": [
"34640"
],
"CVE-2009-4983": [
"34643",
"34644",
"34645"
],
"CVE-2010-3489": [
"34649"
],
"CVE-2009-3153": [
"34656",
"34657",
"34658",
"34659",
"34660",
"34661",
"34662",
"34663"
],
"CVE-2014-4865": [
"34672"
],
"CVE-2009-4717": [
"34674",
"34675",
"34676",
"34677",
"34678",
"34679"
],
"CVE-2009-2776": [
"34687"
],
"CVE-2010-4930": [
"34690"
],
"CVE-2009-4685": [
"34709"
],
"CVE-2009-4688": [
"34710"
],
"CVE-2009-4689": [
"34711"
],
"CVE-2009-3599": [
"34712"
],
"CVE-2009-3593": [
"34713",
"34714"
],
"CVE-2009-4686": [
"34715"
],
"CVE-2009-2441": [
"34803"
],
"CVE-2009-2437": [
"34804"
],
"CVE-2014-6409": [
"34718"
],
"CVE-2014-6607": [
"34718"
],
"CVE-2010-4792": [
"34826"
],
"CVE-2014-6420": [
"34721"
],
"CVE-2014-6030": [
"34722"
],
"CVE-2009-2587": [
"34730",
"34731",
"34732",
"34733",
"34734",
"34735"
],
"CVE-2009-2586": [
"34736"
],
"CVE-2009-4684": [
"34737"
],
"CVE-2009-3858": [
"34738"
],
"CVE-2009-3512": [
"34740",
"34741",
"34742"
],
"CVE-2009-3539": [
"34744",
"34745"
],
"CVE-2009-3542": [
"34747"
],
"CVE-2009-4691": [
"34748"
],
"CVE-2009-3509": [
"34749"
],
"CVE-2014-6619": [
"34760"
],
"CVE-2014-5258": [
"34761"
],
"CVE-2014-6312": [
"34762"
],
"CVE-2014-6308": [
"34763"
],
"CVE-2014-8307": [
"34764"
],
"CVE-2014-8306": [
"34764"
],
"CVE-2014-8305": [
"34764"
],
"CVE-2009-2888": [
"34770"
],
"CVE-2009-2889": [
"34771"
],
"CVE-2009-3222": [
"34772"
],
"CVE-2010-3695": [
"34773"
],
"CVE-2009-2588": [
"34774",
"34775",
"34776"
],
"CVE-2009-3601": [
"34783"
],
"CVE-2010-4821": [
"34785"
],
"CVE-2010-4883": [
"34787"
],
"CVE-2010-5278": [
"34788"
],
"CVE-2010-4863": [
"34789"
],
"CVE-2009-4751": [
"34791"
],
"CVE-2009-4752": [
"34792"
],
"CVE-2009-4750": [
"34793"
],
"CVE-2010-3201": [
"34797"
],
"CVE-2014-6242": [
"34781"
],
"CVE-2014-7201": [
"34800"
],
"CVE-2014-7200": [
"34800"
],
"CVE-2009-2428": [
"34809",
"34810"
],
"CVE-2009-2442": [
"34811"
],
"CVE-2010-4864": [
"34820"
],
"CVE-2014-7190": [
"34818"
],
"CVE-2010-4875": [
"34976"
],
"CVE-2010-3581": [
"34834"
],
"CVE-2010-5286": [
"34837"
],
"CVE-2010-3841": [
"34842",
"34843"
],
"CVE-2009-4857": [
"34845"
],
"CVE-2009-4856": [
"34847"
],
"CVE-2010-1106": [
"34849"
],
"CVE-2014-8295": [
"34851"
],
"CVE-2014-7226": [
"34852"
],
"CVE-2014-6389": [
"34861"
],
"CVE-2014-5308": [
"34863"
],
"CVE-2014-4312": [
"34864"
],
"CVE-2014-4311": [
"34864"
],
"CVE-2014-5300": [
"34865"
],
"CVE-2009-3598": [
"34871"
],
"CVE-2009-3123": [
"34873"
],
"CVE-2009-2114": [
"34874"
],
"CVE-2009-3124": [
"34875"
],
"CVE-2009-3184": [
"34876"
],
"CVE-2009-3189": [
"34877"
],
"CVE-2009-3187": [
"34878"
],
"CVE-2010-4152": [
"34883"
],
"CVE-2009-3194": [
"34884"
],
"CVE-2009-3195": [
"34885",
"34886"
],
"CVE-2009-3196": [
"34887"
],
"CVE-2009-3202": [
"34888"
],
"CVE-2009-2884": [
"34893"
],
"CVE-2009-2885": [
"34894"
],
"CVE-2014-7969": [
"34922"
],
"CVE-2009-2890": [
"34902"
],
"CVE-2009-2891": [
"34903"
],
"CVE-2009-2965": [
"34904"
],
"CVE-2010-4867": [
"34905"
],
"CVE-2010-4868": [
"34906"
],
"CVE-2010-4120": [
"34907",
"34908",
"34909",
"34910",
"34911",
"34912",
"34913",
"34914",
"34915",
"34916",
"34917"
],
"CVE-2009-2116": [
"34919"
],
"CVE-2014-7280": [
"34929"
],
"CVE-2009-2163": [
"34930"
],
"CVE-2009-2289": [
"34941"
],
"CVE-2010-3977": [
"34946"
],
"CVE-2014-8577": [
"34959"
],
"CVE-2014-7281": [
"34969"
],
"CVE-2014-3704": [
"34984",
"34992",
"34993",
"35150",
"44355"
],
"CVE-2010-4836": [
"34988"
],
"CVE-2010-4873": [
"34989"
],
"CVE-2010-4784": [
"35016"
],
"CVE-2010-4783": [
"35017"
],
"CVE-2010-4367": [
"35035"
],
"CVE-2010-4514": [
"35045"
],
"CVE-2013-7057": [
"35046"
],
"CVE-2014-8770": [
"35052"
],
"CVE-2013-3304": [
"35056"
],
"CVE-2014-8555": [
"35127"
],
"CVE-2010-4503": [
"35060"
],
"CVE-2010-4747": [
"35066"
],
"CVE-2010-4518": [
"35067"
],
"CVE-2014-8586": [
"35073"
],
"CVE-2014-8657": [
"35075"
],
"CVE-2014-8655": [
"35075"
],
"CVE-2014-8653": [
"35075"
],
"CVE-2014-8654": [
"35075"
],
"CVE-2014-8656": [
"35075"
],
"CVE-2014-2647": [
"35076"
],
"CVE-2014-9000": [
"35079"
],
"CVE-2014-9001": [
"35080"
],
"CVE-2014-7176": [
"35098",
"35099"
],
"CVE-2014-7177": [
"35099"
],
"CVE-2014-7178": [
"35100"
],
"CVE-2014-2023": [
"35102"
],
"CVE-2014-8728": [
"35214"
],
"CVE-2014-7868": [
"35209",
"43896"
],
"CVE-2014-7866": [
"35209",
"43896"
],
"CVE-2015-1587": [
"35113"
],
"CVE-2010-4111": [
"35116"
],
"CVE-2014-8953": [
"35129"
],
"CVE-2014-8607": [
"35212"
],
"CVE-2014-8606": [
"35212"
],
"CVE-2014-8605": [
"35212"
],
"CVE-2014-8604": [
"35212"
],
"CVE-2014-8603": [
"35212"
],
"CVE-2010-5096": [
"35140",
"35141"
],
"CVE-2010-4276": [
"35149"
],
"CVE-2010-4693": [
"35156",
"35157"
],
"CVE-2014-8775": [
"35159"
],
"CVE-2014-8774": [
"35159"
],
"CVE-2014-8773": [
"35159"
],
"CVE-2011-0005": [
"35167"
],
"CVE-2014-3439": [
"35181"
],
"CVE-2014-3438": [
"35181"
],
"CVE-2014-3437": [
"35181"
],
"CVE-2014-9005": [
"35193"
],
"CVE-2014-9004": [
"35193"
],
"CVE-2014-8954": [
"35198"
],
"CVE-2014-8499": [
"35210"
],
"CVE-2014-8498": [
"35210"
],
"CVE-2014-10013": [
"35204"
],
"CVE-2014-8596": [
"35206"
],
"CVE-2014-9178": [
"35313"
],
"CVE-2011-4280": [
"35297"
],
"CVE-2014-9115": [
"35221"
],
"CVE-2014-9179": [
"35218"
],
"CVE-2014-9237": [
"35219",
"35275"
],
"CVE-2014-8727": [
"35222"
],
"CVE-2014-8997": [
"35223"
],
"CVE-2014-9241": [
"35224"
],
"CVE-2014-9240": [
"35224"
],
"CVE-2014-8681": [
"35237"
],
"CVE-2014-8682": [
"35238"
],
"CVE-2011-0773": [
"35254"
],
"CVE-2011-0678": [
"35256"
],
"CVE-2011-0772": [
"35259",
"35260"
],
"CVE-2011-0740": [
"35261"
],
"CVE-2014-8493": [
"35272",
"35276"
],
"CVE-2014-8995": [
"35271"
],
"CVE-2014-8469": [
"35274"
],
"CVE-2014-9243": [
"35277"
],
"CVE-2014-9242": [
"35277"
],
"CVE-2014-9236": [
"35278"
],
"CVE-2014-9235": [
"35278"
],
"CVE-2014-9344": [
"35301"
],
"CVE-2014-8801": [
"35303"
],
"CVE-2014-8429": [
"35381"
],
"CVE-2014-8877": [
"35324"
],
"CVE-2010-3272": [
"35330"
],
"CVE-2010-3274": [
"35331"
],
"CVE-2014-9175": [
"35340"
],
"CVE-2014-9348": [
"35344"
],
"CVE-2014-8799": [
"35346"
],
"CVE-2014-8387": [
"35357"
],
"CVE-2011-1060": [
"35360"
],
"CVE-2014-9347": [
"35365"
],
"CVE-2014-9173": [
"35371",
"35447"
],
"CVE-2014-8425": [
"35372"
],
"CVE-2014-8424": [
"35372"
],
"CVE-2014-8423": [
"35372"
],
"CVE-2011-1106": [
"35374"
],
"CVE-2014-9119": [
"35378"
],
"CVE-2011-1427": [
"35411",
"35412"
],
"CVE-2015-1517": [
"36125"
],
"CVE-2014-8800": [
"35439"
],
"CVE-2014-9303": [
"35442"
],
"CVE-2014-8868": [
"35442"
],
"CVE-2014-6235": [
"35443"
],
"CVE-2014-9305": [
"35459"
],
"CVE-2014-9144": [
"35462"
],
"CVE-2014-9143": [
"35462"
],
"CVE-2014-9142": [
"35462"
],
"CVE-2014-9345": [
"35463"
],
"CVE-2011-0745": [
"35467"
],
"CVE-2014-9215": [
"35473"
],
"CVE-2014-5462": [
"35518"
],
"CVE-2011-1609": [
"35672"
],
"CVE-2014-8810": [
"35505"
],
"CVE-2014-9528": [
"35510"
],
"CVE-2011-1671": [
"35523"
],
"CVE-2014-9258": [
"35528"
],
"CVE-2011-1557": [
"35547"
],
"CVE-2014-9522": [
"35551"
],
"CVE-2011-1668": [
"35555"
],
"CVE-2011-1723": [
"35572"
],
"CVE-2014-9254": [
"35579"
],
"CVE-2014-1155": [
"35582"
],
"CVE-2011-3713": [
"35582"
],
"CVE-2014-9580": [
"35582"
],
"CVE-2014-1470": [
"35583"
],
"CVE-2014-9445": [
"35584"
],
"CVE-2014-1137": [
"35584",
"35585"
],
"CVE-2014-9582": [
"35585"
],
"CVE-2014-9581": [
"35585"
],
"CVE-2014-9440": [
"35591"
],
"CVE-2014-9436": [
"35593"
],
"CVE-2014-9412": [
"35594"
],
"CVE-2014-5216": [
"35594"
],
"CVE-2014-2239": [
"35605"
],
"CVE-2014-9457": [
"35625"
],
"CVE-2014-9439": [
"35626"
],
"CVE-2014-9516": [
"35659"
],
"CVE-2014-9435": [
"35670"
],
"CVE-2014-9434": [
"35670"
],
"CVE-2015-1057": [
"35679"
],
"CVE-2015-1054": [
"35691"
],
"CVE-2015-1059": [
"35710"
],
"CVE-2015-1058": [
"35710"
],
"CVE-2015-1060": [
"35710"
],
"CVE-2014-9464": [
"35720"
],
"CVE-2015-0554": [
"35721"
],
"CVE-2015-0919": [
"35722"
],
"CVE-2014-9308": [
"35730",
"36043"
],
"CVE-2015-1028": [
"35747",
"35750",
"35751"
],
"CVE-2011-1838": [
"35761"
],
"CVE-2015-1424": [
"35767"
],
"CVE-2015-1423": [
"35767"
],
"CVE-2015-1422": [
"35767"
],
"CVE-2015-1482": [
"35786"
],
"CVE-2015-1481": [
"35786"
],
"CVE-2015-1368": [
"35786"
],
"CVE-2014-8272": [
"35770"
],
"CVE-2014-8802": [
"35823"
],
"CVE-2011-5071": [
"35985",
"35986",
"35988",
"35987"
],
"CVE-2015-2068": [
"35996"
],
"CVE-2015-2067": [
"35996"
],
"CVE-2015-1376": [
"35846"
],
"CVE-2015-1375": [
"35846"
],
"CVE-2015-1366": [
"35846"
],
"CVE-2015-1365": [
"35846"
],
"CVE-2015-1364": [
"35857"
],
"CVE-2015-1476": [
"35878"
],
"CVE-2014-9473": [
"35879"
],
"CVE-2015-1479": [
"35890"
],
"CVE-2014-9331": [
"35980"
],
"CVE-2015-1480": [
"35904"
],
"CVE-2015-1478": [
"35911"
],
"CVE-2015-1477": [
"35911"
],
"CVE-2014-7883": [
"35982"
],
"CVE-2015-1471": [
"35991"
],
"CVE-2015-1374": [
"35914"
],
"CVE-2015-1373": [
"35914"
],
"CVE-2015-1372": [
"35914"
],
"CVE-2015-1371": [
"35914"
],
"CVE-2014-9226": [
"35915"
],
"CVE-2014-9225": [
"35915"
],
"CVE-2014-9224": [
"35915"
],
"CVE-2014-7289": [
"35915"
],
"CVE-2014-9312": [
"35916"
],
"CVE-2012-4891": [
"35933"
],
"CVE-2012-4889": [
"35933",
"37029",
"37030",
"37031",
"37032"
],
"CVE-2011-3642": [
"35941"
],
"CVE-2011-2743": [
"35943",
"35944"
],
"CVE-2011-2744": [
"35945"
],
"CVE-2011-2780": [
"35946"
],
"CVE-2011-2745": [
"35947"
],
"CVE-2015-1400": [
"35950"
],
"CVE-2015-1428": [
"35972"
],
"CVE-2011-4336": [
"35974"
],
"CVE-2011-2403": [
"36000"
],
"CVE-2015-0107": [
"36002"
],
"CVE-2015-0104": [
"36002"
],
"CVE-2015-1467": [
"36041"
],
"CVE-2015-1518": [
"36023"
],
"CVE-2014-8690": [
"36059"
],
"CVE-2015-1576": [
"36027"
],
"CVE-2015-1575": [
"36029"
],
"CVE-2015-2065": [
"36058"
],
"CVE-2015-2090": [
"36054"
],
"CVE-2014-6137": [
"36057"
],
"CVE-2015-2196": [
"36061"
],
"CVE-2011-2938": [
"36068"
],
"CVE-2015-2218": [
"36086"
],
"CVE-2015-2199": [
"36086"
],
"CVE-2015-1494": [
"36087"
],
"CVE-2015-2071": [
"36089"
],
"CVE-2015-2070": [
"36089"
],
"CVE-2011-3390": [
"36091"
],
"CVE-2014-9262": [
"36112"
],
"CVE-2011-3979": [
"36121"
],
"CVE-2015-2198": [
"36154"
],
"CVE-2015-2102": [
"36156"
],
"CVE-2013-5572": [
"36157"
],
"CVE-2015-2184": [
"36159"
],
"CVE-2015-2183": [
"36159"
],
"CVE-2015-2182": [
"36159"
],
"CVE-2010-5322": [
"36159"
],
"CVE-2015-2147": [
"36160"
],
"CVE-2015-2145": [
"36160"
],
"CVE-2015-2143": [
"36160"
],
"CVE-2015-2142": [
"36160"
],
"CVE-2004-1519": [
"36160"
],
"CVE-2015-2084": [
"36161"
],
"CVE-2011-3010": [
"36162",
"36163"
],
"CVE-2011-3579": [
"36165"
],
"CVE-2011-3850": [
"36178"
],
"CVE-2011-3855": [
"36180"
],
"CVE-2011-3856": [
"36181"
],
"CVE-2011-3852": [
"36182"
],
"CVE-2011-3860": [
"36183"
],
"CVE-2011-3861": [
"36184"
],
"CVE-2011-3858": [
"36185"
],
"CVE-2011-3862": [
"36186"
],
"CVE-2011-3865": [
"36187"
],
"CVE-2011-3863": [
"36191"
],
"CVE-2011-3859": [
"36195"
],
"CVE-2011-5169": [
"36196"
],
"CVE-2011-3340": [
"36200"
],
"CVE-2011-4561": [
"36201"
],
"CVE-2011-4670": [
"36203",
"36204"
],
"CVE-2011-4559": [
"36208"
],
"CVE-2014-9566": [
"36262"
],
"CVE-2011-4564": [
"36213"
],
"CVE-2011-4335": [
"36225"
],
"CVE-2011-4958": [
"36226"
],
"CVE-2014-9463": [
"36232"
],
"CVE-2015-2216": [
"36242"
],
"CVE-2015-2208": [
"36251"
],
"CVE-2011-1513": [
"36252"
],
"CVE-2011-4090": [
"36283"
],
"CVE-2011-4340": [
"36280"
],
"CVE-2011-4341": [
"36281"
],
"CVE-2011-4431": [
"36293"
],
"CVE-2014-9260": [
"36301"
],
"CVE-2015-2564": [
"36303"
],
"CVE-2015-1875": [
"36305"
],
"CVE-2015-2237": [
"36306"
],
"CVE-2011-4709": [
"36307"
],
"CVE-2011-5105": [
"36316"
],
"CVE-2011-5106": [
"36317"
],
"CVE-2014-9261": [
"36320"
],
"CVE-2015-2680": [
"36321"
],
"CVE-2015-2679": [
"36321"
],
"CVE-2015-2678": [
"36321"
],
"CVE-2011-5107": [
"36323"
],
"CVE-2011-4618": [
"36324"
],
"CVE-2011-4926": [
"36325"
],
"CVE-2011-5182": [
"36326"
],
"CVE-2011-4814": [
"36330"
],
"CVE-2011-4802": [
"36331",
"36332",
"36333"
],
"CVE-2011-5181": [
"36338"
],
"CVE-2011-5265": [
"36339"
],
"CVE-2011-4544": [
"36341",
"36342",
"36343",
"36344"
],
"CVE-2011-4545": [
"36345"
],
"CVE-2011-4567": [
"36346"
],
"CVE-2011-4541": [
"36347"
],
"CVE-2011-5108": [
"36349"
],
"CVE-2011-5111": [
"36350",
"36351"
],
"CVE-2011-5184": [
"36353",
"36354",
"36355",
"36356",
"36357"
],
"CVE-2015-2701": [
"36358"
],
"CVE-2011-5177": [
"36362"
],
"CVE-2011-5179": [
"36363"
],
"CVE-2015-2275": [
"36368"
],
"CVE-2015-2841": [
"36369"
],
"CVE-2011-5258": [
"36379",
"36380"
],
"CVE-2011-5259": [
"36381"
],
"CVE-2011-5180": [
"36382"
],
"CVE-2011-4833": [
"36384"
],
"CVE-2011-4918": [
"36406",
"36407"
],
"CVE-2011-5207": [
"36481"
],
"CVE-2011-4595": [
"36408"
],
"CVE-2015-2292": [
"36413"
],
"CVE-2011-4540": [
"36401"
],
"CVE-2015-2791": [
"36414"
],
"CVE-2015-2315": [
"36414"
],
"CVE-2015-2314": [
"36414"
],
"CVE-2012-5346": [
"36483"
],
"CVE-2012-5099": [
"36484"
],
"CVE-2012-5295": [
"36485"
],
"CVE-2012-5294": [
"36486"
],
"CVE-2015-2269": [
"36418"
],
"CVE-2015-2746": [
"36423"
],
"CVE-2015-0514": [
"36436"
],
"CVE-2015-2562": [
"36439"
],
"CVE-2015-0516": [
"36440"
],
"CVE-2015-2682": [
"36441"
],
"CVE-2015-2838": [
"36442"
],
"CVE-2011-5041": [
"36447"
],
"CVE-2011-5213": [
"36448",
"36449"
],
"CVE-2011-5214": [
"36450",
"36451",
"36453",
"36454"
],
"CVE-2011-5222": [
"36460"
],
"CVE-2014-5144": [
"36463"
],
"CVE-2014-9014": [
"36466",
"36490"
],
"CVE-2014-9013": [
"36466",
"36490"
],
"CVE-2011-5045": [
"36468"
],
"CVE-2011-4551": [
"36470"
],
"CVE-2011-5050": [
"36473"
],
"CVE-2015-2295": [
"36506"
],
"CVE-2011-5193": [
"36488"
],
"CVE-2011-5019": [
"36489"
],
"CVE-2011-5209": [
"36492"
],
"CVE-2011-5252": [
"36493"
],
"CVE-2012-5343": [
"36494"
],
"CVE-2011-5022": [
"36495"
],
"CVE-2011-5023": [
"36496"
],
"CVE-2012-5104": [
"36497"
],
"CVE-2012-5341": [
"36499"
],
"CVE-2012-5102": [
"36508"
],
"CVE-2012-5105": [
"36509",
"36510"
],
"CVE-2015-2780": [
"36520"
],
"CVE-2012-5292": [
"36521",
"36522",
"36523"
],
"CVE-2012-6643": [
"36531",
"36532"
],
"CVE-2012-6529": [
"36534",
"36535",
"36536"
],
"CVE-2012-6040": [
"36539"
],
"CVE-2012-6043": [
"36541"
],
"CVE-2012-0988": [
"36543"
],
"CVE-2015-2798": [
"36561"
],
"CVE-2012-6528": [
"36565"
],
"CVE-2012-0900": [
"36566"
],
"CVE-2012-0899": [
"36569"
],
"CVE-2012-6526": [
"36574"
],
"CVE-2015-2223": [
"36580"
],
"CVE-2014-9148": [
"36581"
],
"CVE-2014-9147": [
"36581"
],
"CVE-2014-9146": [
"36581"
],
"CVE-2014-9145": [
"36581"
],
"CVE-2012-0989": [
"36582"
],
"CVE-2012-5313": [
"36585"
],
"CVE-2012-0933": [
"36588"
],
"CVE-2012-5312": [
"36590"
],
"CVE-2011-4804": [
"36598"
],
"CVE-2012-0901": [
"36620"
],
"CVE-2014-5288": [
"36609"
],
"CVE-2014-5287": [
"36609"
],
"CVE-2015-2824": [
"36613"
],
"CVE-2015-2825": [
"36614"
],
"CVE-2015-2826": [
"36615"
],
"CVE-2015-2166": [
"36619"
],
"CVE-2012-0973": [
"36625"
],
"CVE-2012-0974": [
"36626"
],
"CVE-2012-0990": [
"36627"
],
"CVE-2012-5224": [
"36628"
],
"CVE-2012-5229": [
"36631"
],
"CVE-2012-5225": [
"36632"
],
"CVE-2012-1022": [
"36643"
],
"CVE-2012-1021": [
"36644"
],
"CVE-2012-1023": [
"36645"
],
"CVE-2012-0932": [
"36647"
],
"CVE-2012-0991": [
"36648",
"36649",
"36650"
],
"CVE-2012-0992": [
"36651"
],
"CVE-2012-0834": [
"36654"
],
"CVE-2012-1069": [
"36658"
],
"CVE-2012-1018": [
"36659"
],
"CVE-2012-1027": [
"36660"
],
"CVE-2012-1028": [
"36665"
],
"CVE-2012-1049": [
"36666",
"36667"
],
"CVE-2012-1048": [
"36668"
],
"CVE-2014-9311": [
"36674"
],
"CVE-2012-1225": [
"36683"
],
"CVE-2012-0865": [
"36685",
"36686",
"36687"
],
"CVE-2011-4403": [
"36688"
],
"CVE-2000-0920": [
"36689"
],
"CVE-2012-1213": [
"36695"
],
"CVE-2012-1200": [
"36696",
"36697",
"36698",
"36699"
],
"CVE-2012-1199": [
"36702",
"36703",
"36704",
"36705",
"36706",
"36707",
"36708",
"36709",
"36710",
"36711",
"36712",
"36713",
"36714",
"36715",
"36716",
"36717",
"36718",
"36719",
"36720",
"36721",
"36722",
"36723",
"36724",
"36725",
"36726",
"36727",
"36728",
"36729",
"36730",
"36731",
"36732",
"36752",
"36753",
"36754",
"36755",
"36757",
"36758",
"36759"
],
"CVE-2012-1198": [
"36760"
],
"CVE-2012-1211": [
"36765"
],
"CVE-2012-1210": [
"36766"
],
"CVE-2012-1217": [
"36769",
"36770",
"36771"
],
"CVE-2015-2844": [
"36807"
],
"CVE-2015-2842": [
"36807"
],
"CVE-2012-0996": [
"36784",
"36785"
],
"CVE-2012-0997": [
"36786"
],
"CVE-2015-3314": [
"36802"
],
"CVE-2015-3313": [
"36805"
],
"CVE-2014-5370": [
"36815"
],
"CVE-2012-5321": [
"36848"
],
"CVE-2012-0869": [
"36851"
],
"CVE-2012-1294": [
"36830"
],
"CVE-2015-3440": [
"36844"
],
"CVE-2014-1695": [
"36842"
],
"CVE-2009-5114": [
"36994"
],
"CVE-2012-0873": [
"36853",
"36854"
],
"CVE-2015-3302": [
"36860"
],
"CVE-2015-3301": [
"36860"
],
"CVE-2015-3300": [
"36860"
],
"CVE-2015-3986": [
"36860"
],
"CVE-2012-1224": [
"36870"
],
"CVE-2012-1001": [
"36874",
"36875"
],
"CVE-2012-4928": [
"36876"
],
"CVE-2012-1784": [
"36882"
],
"CVE-2012-1787": [
"36883"
],
"CVE-2012-1782": [
"36886"
],
"CVE-2012-1039": [
"36888",
"36889",
"36890",
"36891"
],
"CVE-2012-1188": [
"36893",
"36894"
],
"CVE-2012-4998": [
"36895"
],
"CVE-2012-1110": [
"36898",
"36899",
"36900"
],
"CVE-2012-1617": [
"36917"
],
"CVE-2012-1112": [
"36910"
],
"CVE-2012-1116": [
"36913"
],
"CVE-2012-4873": [
"36973"
],
"CVE-2015-2248": [
"36940"
],
"CVE-2014-0910": [
"36941"
],
"CVE-2012-1556": [
"36944"
],
"CVE-2012-6520": [
"36946"
],
"CVE-2012-2099": [
"36947",
"36948"
],
"CVE-2015-3141": [
"36949"
],
"CVE-2015-3140": [
"36950",
"36951",
"36953"
],
"CVE-2009-5112": [
"36976"
],
"CVE-2012-1778": [
"36977"
],
"CVE-2013-5223": [
"36987",
"36988"
],
"CVE-2012-1469": [
"36999",
"37000"
],
"CVE-2012-1468": [
"37001"
],
"CVE-2012-1467": [
"37002"
],
"CVE-2012-1592": [
"37009"
],
"CVE-2012-1603": [
"37012"
],
"CVE-2012-1604": [
"37013"
],
"CVE-2012-5913": [
"37016"
],
"CVE-2012-5909": [
"37018"
],
"CVE-2012-5908": [
"37019"
],
"CVE-2012-5907": [
"37021"
],
"CVE-2012-1470": [
"37022"
],
"CVE-2012-1597": [
"37024"
],
"CVE-2012-5903": [
"37027"
],
"CVE-2012-4878": [
"37034"
],
"CVE-2012-4877": [
"37035"
],
"CVE-2012-1664": [
"37038",
"37039",
"37040",
"37041",
"37042",
"37043",
"37044",
"37045",
"37046"
],
"CVE-2012-1665": [
"37047",
"37048"
],
"CVE-2015-3337": [
"37054"
],
"CVE-2012-4686": [
"37062"
],
"CVE-2015-4018": [
"37067"
],
"CVE-2015-4039": [
"37074"
],
"CVE-2015-4038": [
"37074"
],
"CVE-2012-1835": [
"37075",
"37076",
"37077",
"37078"
],
"CVE-2015-3325": [
"37080"
],
"CVE-2012-2104": [
"37084"
],
"CVE-2012-2234": [
"37087"
],
"CVE-2012-4745": [
"37091"
],
"CVE-2012-2270": [
"37094"
],
"CVE-2015-5065": [
"37253"
],
"CVE-2011-5099": [
"37101"
],
"CVE-2012-6513": [
"37104"
],
"CVE-2015-4063": [
"37107"
],
"CVE-2015-4062": [
"37107"
],
"CVE-2015-4065": [
"37108"
],
"CVE-2015-4064": [
"37108"
],
"CVE-2015-4066": [
"37109"
],
"CVE-2015-1833": [
"37110"
],
"CVE-2015-4127": [
"37112"
],
"CVE-2014-0999": [
"37114"
],
"CVE-2014-8391": [
"37114"
],
"CVE-2012-4060": [
"37119"
],
"CVE-2012-4055": [
"37120"
],
"CVE-2012-4251": [
"37125",
"37127",
"37128",
"37133"
],
"CVE-2012-4253": [
"37126",
"37129"
],
"CVE-2012-4254": [
"37130"
],
"CVE-2012-4252": [
"37131"
],
"CVE-2015-4084": [
"37132"
],
"CVE-2012-4282": [
"37136"
],
"CVE-2012-1990": [
"37137"
],
"CVE-2012-6045": [
"37138"
],
"CVE-2012-6046": [
"37140"
],
"CVE-2012-1506": [
"37142"
],
"CVE-2012-1507": [
"37143",
"37144",
"37145"
],
"CVE-2012-2274": [
"37146"
],
"CVE-2012-2918": [
"37147"
],
"CVE-2012-2919": [
"37148"
],
"CVE-2012-2371": [
"37155"
],
"CVE-2015-1389": [
"37172"
],
"CVE-2012-2913": [
"37191",
"37192"
],
"CVE-2012-6622": [
"37195"
],
"CVE-2015-4465": [
"37200"
],
"CVE-2015-4153": [
"37200"
],
"CVE-2012-2917": [
"37202"
],
"CVE-2012-6624": [
"37203"
],
"CVE-2012-2904": [
"37205"
],
"CVE-2012-2910": [
"37206",
"37207"
],
"CVE-2012-2911": [
"37208"
],
"CVE-2012-2914": [
"37216"
],
"CVE-2012-2906": [
"37217"
],
"CVE-2012-2941": [
"37224"
],
"CVE-2012-3577": [
"37353"
],
"CVE-2015-4137": [
"37248"
],
"CVE-2015-4659": [
"37266"
],
"CVE-2015-2125": [
"37250"
],
"CVE-2015-2803": [
"37301"
],
"CVE-2015-5079": [
"37304"
],
"CVE-2007-6587": [
"37305"
],
"CVE-2012-2436": [
"37311"
],
"CVE-2012-2452": [
"37312",
"37313"
],
"CVE-2015-4677": [
"37257"
],
"CVE-2015-4119": [
"37259"
],
"CVE-2015-4118": [
"37259"
],
"CVE-2015-3898": [
"37260"
],
"CVE-2015-3897": [
"37260"
],
"CVE-2015-2805": [
"37261"
],
"CVE-2015-4010": [
"37264"
],
"CVE-2015-4420": [
"37271"
],
"CVE-2015-7347": [
"37272"
],
"CVE-2015-7346": [
"37272"
],
"CVE-2015-4414": [
"37274"
],
"CVE-2015-4455": [
"37275"
],
"CVE-2015-4658": [
"37290"
],
"CVE-2015-3624": [
"37296"
],
"CVE-2015-5150": [
"37322"
],
"CVE-2015-5149": [
"37322"
],
"CVE-2015-5148": [
"37325"
],
"CVE-2014-8008": [
"37816"
],
"CVE-2014-5101": [
"39249"
],
"CVE-2011-2165": [
"37440"
],
"CVE-2015-5066": [
"37360"
],
"CVE-2015-3221": [
"37360"
],
"CVE-2015-3933": [
"37363"
],
"CVE-2015-4117": [
"37369"
],
"CVE-2012-3578": [
"37370"
],
"CVE-2012-2959": [
"37372"
],
"CVE-2015-4633": [
"37387"
],
"CVE-2015-4632": [
"37388"
],
"CVE-2015-4631": [
"37389"
],
"CVE-2015-4630": [
"37389"
],
"CVE-2015-3443": [
"37394"
],
"CVE-2015-2169": [
"37395"
],
"CVE-2012-2698": [
"37404"
],
"CVE-2012-2237": [
"37565"
],
"CVE-2015-4553": [
"37423"
],
"CVE-2012-3232": [
"37435"
],
"CVE-2015-5354": [
"37439"
],
"CVE-2015-5353": [
"37439"
],
"CVE-2015-3934": [
"37446"
],
"CVE-2015-4460": [
"37447"
],
"CVE-2015-4685": [
"37449"
],
"CVE-2015-4684": [
"37449"
],
"CVE-2015-4683": [
"37449"
],
"CVE-2015-4682": [
"37449"
],
"CVE-2015-4681": [
"37449"
],
"CVE-2012-4000": [
"37457"
],
"CVE-2012-3414": [
"37470"
],
"CVE-2012-3805": [
"37498"
],
"CVE-2012-4032": [
"37488"
],
"CVE-2015-4616": [
"37534"
],
"CVE-2015-4614": [
"37534"
],
"CVE-2015-6518": [
"37515"
],
"CVE-2015-6517": [
"37515"
],
"CVE-2012-1915": [
"37521"
],
"CVE-2015-2280": [
"37527"
],
"CVE-2015-1561": [
"37528"
],
"CVE-2015-1560": [
"37528"
],
"CVE-2015-2863": [
"37621"
],
"CVE-2015-2862": [
"37621"
],
"CVE-2015-5468": [
"37530"
],
"CVE-2015-2279": [
"37532"
],
"CVE-2015-5520": [
"37533"
],
"CVE-2012-3848": [
"37547"
],
"CVE-2012-2627": [
"37548"
],
"CVE-2012-2626": [
"37549"
],
"CVE-2012-3351": [
"37552"
],
"CVE-2012-3872": [
"37578",
"37579",
"37580"
],
"CVE-2012-4070": [
"37581"
],
"CVE-2012-4237": [
"37584",
"37585"
],
"CVE-2012-3952": [
"37590"
],
"CVE-2015-6512": [
"37592"
],
"CVE-2015-6519": [
"37594"
],
"CVE-2015-5530": [
"37596"
],
"CVE-2015-5529": [
"37596"
],
"CVE-2015-5471": [
"37601"
],
"CVE-2015-5595": [
"37602"
],
"CVE-2015-5594": [
"37602"
],
"CVE-2015-5591": [
"37602"
],
"CVE-2014-8677": [
"37604"
],
"CVE-2014-8676": [
"37604"
],
"CVE-2014-8675": [
"37604"
],
"CVE-2014-8674": [
"37604"
],
"CVE-2014-8673": [
"37604"
],
"CVE-2015-4425": [
"37609"
],
"CVE-2015-6516": [
"37610"
],
"CVE-2012-3953": [
"37613"
],
"CVE-2012-4034": [
"37614"
],
"CVE-2012-4035": [
"37615"
],
"CVE-2012-4036": [
"37616"
],
"CVE-2012-4236": [
"37632"
],
"CVE-2012-0744": [
"37643"
],
"CVE-2015-5399": [
"37659"
],
"CVE-2015-4075": [
"37666"
],
"CVE-2015-4074": [
"37666"
],
"CVE-2015-4073": [
"37666"
],
"CVE-2015-4072": [
"37666"
],
"CVE-2015-4071": [
"37666"
],
"CVE-2012-4234": [
"37683"
],
"CVE-2012-2517": [
"37684"
],
"CVE-2015-2878": [
"37686"
],
"CVE-2012-3551": [
"37690"
],
"CVE-2012-3233": [
"37698"
],
"CVE-2015-5533": [
"37707"
],
"CVE-2015-4669": [
"37708"
],
"CVE-2015-4668": [
"37708"
],
"CVE-2015-4667": [
"37708"
],
"CVE-2015-4666": [
"37708"
],
"CVE-2015-4665": [
"37708"
],
"CVE-2015-4664": [
"37708"
],
"CVE-2015-2321": [
"37738"
],
"CVE-2015-6522": [
"37824"
],
"CVE-2012-4231": [
"37950"
],
"CVE-2015-5161": [
"37765",
"38573"
],
"CVE-2012-4336": [
"37779"
],
"CVE-2012-4768": [
"37787"
],
"CVE-2012-5342": [
"37940",
"37941",
"37942"
],
"CVE-2011-4640": [
"37943"
],
"CVE-2012-4242": [
"37829"
],
"CVE-2012-4989": [
"37938"
],
"CVE-2012-6312": [
"38066"
],
"CVE-2015-5437": [
"37891"
],
"CVE-2015-6805": [
"37907"
],
"CVE-2014-9613": [
"37926"
],
"CVE-2014-9612": [
"37927"
],
"CVE-2014-9605": [
"37928"
],
"CVE-2014-9610": [
"37929"
],
"CVE-2014-9611": [
"37931"
],
"CVE-2014-9619": [
"37932"
],
"CVE-2014-9618": [
"37933"
],
"CVE-2015-6655": [
"37955"
],
"CVE-2015-1397": [
"37977"
],
"CVE-2015-6810": [
"37989"
],
"CVE-2012-4939": [
"37995"
],
"CVE-2012-4951": [
"38010"
],
"CVE-2012-5367": [
"38011"
],
"CVE-2012-2437": [
"38015"
],
"CVE-2012-4949": [
"38016"
],
"CVE-2012-5851": [
"38024"
],
"CVE-2012-3448": [
"38030"
],
"CVE-2015-6811": [
"38034"
],
"CVE-2012-5701": [
"38042"
],
"CVE-2012-5702": [
"38043"
],
"CVE-2015-6809": [
"38051"
],
"CVE-2012-4982": [
"38062"
],
"CVE-2015-6545": [
"38074"
],
"CVE-2015-6965": [
"38086"
],
"CVE-2012-6608": [
"38078"
],
"CVE-2015-6945": [
"38098"
],
"CVE-2015-6944": [
"38098"
],
"CVE-2012-6313": [
"38111"
],
"CVE-2012-5878": [
"38114"
],
"CVE-2012-4932": [
"38115"
],
"CVE-2015-3623": [
"38118"
],
"CVE-2015-6827": [
"38119"
],
"CVE-2015-6912": [
"38128"
],
"CVE-2015-6911": [
"38128"
],
"CVE-2012-5190": [
"38204"
],
"CVE-2012-6448": [
"38153"
],
"CVE-2013-0161": [
"38169"
],
"CVE-2015-7235": [
"38187"
],
"CVE-2015-7707": [
"38190"
],
"CVE-2015-6972": [
"38191"
],
"CVE-2015-6973": [
"38192"
],
"CVE-2012-6430": [
"38207"
],
"CVE-2015-3203": [
"38256"
],
"CVE-2015-6962": [
"38213"
],
"CVE-2013-1402": [
"38234"
],
"CVE-2013-1410": [
"38235"
],
"CVE-2013-0807": [
"38236"
],
"CVE-2013-1463": [
"38251"
],
"CVE-2015-7241": [
"38261"
],
"CVE-2015-7382": [
"38292"
],
"CVE-2015-7381": [
"38292"
],
"CVE-2015-6009": [
"38292"
],
"CVE-2015-6008": [
"38292"
],
"CVE-2013-1409": [
"38296"
],
"CVE-2013-1408": [
"38297"
],
"CVE-2013-1464": [
"38300"
],
"CVE-2015-4148": [
"38304"
],
"CVE-2013-0291": [
"38314"
],
"CVE-2015-8038": [
"38316"
],
"CVE-2015-8037": [
"38316"
],
"CVE-2015-5075": [
"38321"
],
"CVE-2015-5074": [
"38323"
],
"CVE-2013-1636": [
"38324"
],
"CVE-2012-6550": [
"38329"
],
"CVE-2013-1765": [
"38331"
],
"CVE-2013-2289": [
"38332"
],
"CVE-2012-5337": [
"38334"
],
"CVE-2015-7904": [
"38338"
],
"CVE-2015-7903": [
"38338"
],
"CVE-2015-7902": [
"38338"
],
"CVE-2015-7900": [
"38338"
],
"CVE-2015-6494": [
"38338"
],
"CVE-2015-6493": [
"38338"
],
"CVE-2016-1713": [
"38345",
"44379"
],
"CVE-2015-6000": [
"38345"
],
"CVE-2015-6589": [
"38351",
"43882"
],
"CVE-2013-2287": [
"38355"
],
"CVE-2015-6970": [
"38369"
],
"CVE-2013-2501": [
"38373"
],
"CVE-2013-2714": [
"38376"
],
"CVE-2013-2503": [
"38377"
],
"CVE-2015-5531": [
"38383"
],
"CVE-2015-7293": [
"38411"
],
"CVE-2013-0125": [
"38415"
],
"CVE-2013-2750": [
"38416"
],
"CVE-2013-2559": [
"38417"
],
"CVE-2013-2267": [
"38418"
],
"CVE-2015-5285": [
"38424"
],
"CVE-2013-0135": [
"38425",
"38426",
"38427",
"38428",
"38429",
"38430",
"38431",
"38432",
"38433",
"38434",
"38435"
],
"CVE-2013-1938": [
"38436"
],
"CVE-2013-3526": [
"38439"
],
"CVE-2013-1937": [
"38440"
],
"CVE-2013-3530": [
"38441"
],
"CVE-2015-4040": [
"38448"
],
"CVE-2015-6018": [
"38455"
],
"CVE-2013-3538": [
"38476"
],
"CVE-2013-3537": [
"38477"
],
"CVE-2013-3532": [
"38458"
],
"CVE-2013-3525": [
"38459"
],
"CVE-2013-1942": [
"38460"
],
"CVE-2013-2649": [
"38461",
"38462"
],
"CVE-2013-2504": [
"38479"
],
"CVE-2014-2962": [
"38488"
],
"CVE-2013-2009": [
"38494"
],
"CVE-2013-3320": [
"38506",
"38507"
],
"CVE-2013-2107": [
"38517"
],
"CVE-2013-3082": [
"38518"
],
"CVE-2013-3081": [
"38519"
],
"CVE-2013-2108": [
"38520"
],
"CVE-2015-7714": [
"38527"
],
"CVE-2015-7715": [
"38528"
],
"CVE-2013-2623": [
"38545"
],
"CVE-2013-2621": [
"38546"
],
"CVE-2013-2624": [
"38548"
],
"CVE-2013-0143": [
"38550"
],
"CVE-2013-3574": [
"38562"
],
"CVE-2013-3575": [
"38563"
],
"CVE-2015-5534": [
"38581"
],
"CVE-2013-3684": [
"38585"
],
"CVE-2013-3639": [
"38596"
],
"CVE-2013-4692": [
"38608",
"38621"
],
"CVE-2013-4117": [
"38625"
],
"CVE-2015-7808": [
"38629",
"38790",
"48761"
],
"CVE-2013-5314": [
"38642"
],
"CVE-2013-4951": [
"38638"
],
"CVE-2013-5020": [
"38639"
],
"CVE-2015-1793": [
"38640"
],
"CVE-2014-6593": [
"38641"
],
"CVE-2013-4954": [
"38643"
],
"CVE-2013-4620": [
"38654"
],
"CVE-2017-16836": [
"38657"
],
"CVE-2013-4759": [
"38675"
],
"CVE-2013-4625": [
"38676"
],
"CVE-2013-4624": [
"38682",
"38683"
],
"CVE-2013-2653": [
"38689"
],
"CVE-2013-5028": [
"38691"
],
"CVE-2015-5999": [
"38707"
],
"CVE-2013-4200": [
"38738"
],
"CVE-2013-3597": [
"38739"
],
"CVE-2013-4727": [
"38740"
],
"CVE-2013-4888": [
"38745"
],
"CVE-2013-4889": [
"38746"
],
"CVE-2015-7984": [
"38765"
],
"CVE-2015-8703": [
"38773"
],
"CVE-2015-7252": [
"38773"
],
"CVE-2015-7251": [
"38773"
],
"CVE-2015-7250": [
"38773"
],
"CVE-2015-7249": [
"38773"
],
"CVE-2015-7248": [
"38773"
],
"CVE-2013-5967": [
"38781"
],
"CVE-2013-6129": [
"38785"
],
"CVE-2013-1742": [
"38806"
],
"CVE-2013-1743": [
"38807"
],
"CVE-2013-6873": [
"38842"
],
"CVE-2015-8368": [
"38836"
],
"CVE-2013-6797": [
"38844"
],
"CVE-2015-8351": [
"38861"
],
"CVE-2013-6985": [
"38862"
],
"CVE-2013-7097": [
"38873"
],
"CVE-2013-7193": [
"38876",
"38877"
],
"CVE-2013-7108": [
"38882"
],
"CVE-2013-7192": [
"38883",
"38884"
],
"CVE-2013-7189": [
"38885",
"38886",
"38887",
"38888"
],
"CVE-2013-7190": [
"38889",
"38890",
"38891",
"38892"
],
"CVE-2013-2627": [
"38908"
],
"CVE-2013-7209": [
"38919"
],
"CVE-2016-5312": [
"40437"
],
"CVE-2013-7233": [
"38924"
],
"CVE-2013-7278": [
"38935"
],
"CVE-2013-7240": [
"38936"
],
"CVE-2014-1636": [
"38944",
"38945",
"38946",
"38947",
"38948",
"38949",
"38950",
"38951",
"38952",
"38953",
"38954",
"38955"
],
"CVE-2014-1637": [
"38956"
],
"CVE-2014-1915": [
"38957",
"38958"
],
"CVE-2014-1597": [
"39096"
],
"CVE-2014-1671": [
"39057"
],
"CVE-2015-8358": [
"38975"
],
"CVE-2015-8357": [
"38976"
],
"CVE-2015-8562": [
"38977",
"39033"
],
"CVE-2014-1618": [
"39011",
"39012"
],
"CVE-2013-6017": [
"39015"
],
"CVE-2015-8352": [
"39017"
],
"CVE-2013-7219": [
"39028"
],
"CVE-2015-8566": [
"39033"
],
"CVE-2014-1631": [
"39065",
"39066"
],
"CVE-2014-1632": [
"39066"
],
"CVE-2013-6229": [
"39079",
"39080",
"39081"
],
"CVE-2014-1214": [
"39088"
],
"CVE-2014-2069": [
"39106"
],
"CVE-2014-2091": [
"39107"
],
"CVE-2014-2211": [
"39108"
],
"CVE-2014-2339": [
"39116"
],
"CVE-2013-5954": [
"39117"
],
"CVE-2013-7346": [
"39136"
],
"CVE-2013-7196": [
"39139"
],
"CVE-2014-0358": [
"39142",
"39143",
"39145"
],
"CVE-2015-8399": [
"39170"
],
"CVE-2015-8398": [
"39170"
],
"CVE-2014-2934": [
"39173",
"39174"
],
"CVE-2014-2989": [
"39176"
],
"CVE-2014-3749": [
"39187"
],
"CVE-2014-3935": [
"39188"
],
"CVE-2015-2049": [
"39192"
],
"CVE-2013-7285": [
"39193"
],
"CVE-2014-3210": [
"39197"
],
"CVE-2014-3866": [
"39198"
],
"CVE-2014-3854": [
"39199"
],
"CVE-2014-3934": [
"39200"
],
"CVE-2014-2303": [
"39206"
],
"CVE-2014-4030": [
"39212"
],
"CVE-2014-4163": [
"39213"
],
"CVE-2014-3868": [
"39223"
],
"CVE-2015-8261": [
"39231"
],
"CVE-2014-4852": [
"39238"
],
"CVE-2014-4741": [
"39239"
],
"CVE-2014-4944": [
"39240"
],
"CVE-2015-8770": [
"39245"
],
"CVE-2015-8356": [
"39246"
],
"CVE-2014-9094": [
"39250"
],
"CVE-2014-4937": [
"39251"
],
"CVE-2014-4938": [
"39252"
],
"CVE-2014-4939": [
"39253"
],
"CVE-2014-4940": [
"39256",
"39257"
],
"CVE-2015-8284": [
"39266"
],
"CVE-2015-8283": [
"39266"
],
"CVE-2015-8282": [
"39266"
],
"CVE-2014-4736": [
"39267"
],
"CVE-2014-2227": [
"39268"
],
"CVE-2014-5189": [
"39269"
],
"CVE-2014-9099": [
"39270"
],
"CVE-2014-5180": [
"39280"
],
"CVE-2014-8375": [
"39282"
],
"CVE-2014-5200": [
"39283"
],
"CVE-2014-5368": [
"39287"
],
"CVE-2014-3997": [
"39288"
],
"CVE-2014-5097": [
"39289"
],
"CVE-2014-3427": [
"39334"
],
"CVE-2014-5104": [
"39343",
"39344",
"39345",
"39346"
],
"CVE-2014-5109": [
"39347"
],
"CVE-2014-5111": [
"39348",
"39349",
"39350",
"39351"
],
"CVE-2014-5112": [
"39352"
],
"CVE-2015-7986": [
"39382"
],
"CVE-2015-4593": [
"39402"
],
"CVE-2015-4594": [
"39402"
],
"CVE-2015-4592": [
"39402"
],
"CVE-2015-4591": [
"39402"
],
"CVE-2016-2534": [
"39405"
],
"CVE-2014-2045": [
"39407"
],
"CVE-2016-0862": [
"39408"
],
"CVE-2016-0861": [
"39408"
],
"CVE-2015-7247": [
"39409"
],
"CVE-2015-7246": [
"39409"
],
"CVE-2015-7245": [
"39409"
],
"CVE-2016-1524": [
"39412"
],
"CVE-2010-0122": [
"39427"
],
"CVE-2016-0956": [
"39435"
],
"CVE-2015-7572": [
"39436"
],
"CVE-2015-7571": [
"39436"
],
"CVE-2015-7570": [
"39436"
],
"CVE-2015-7569": [
"39436"
],
"CVE-2015-7568": [
"39436"
],
"CVE-2015-7567": [
"39436"
],
"CVE-2016-1915": [
"39481"
],
"CVE-2016-1914": [
"39481"
],
"CVE-2016-4004": [
"39486"
],
"CVE-2015-6541": [
"39500"
],
"CVE-2016-2539": [
"39524"
],
"CVE-2015-7564": [
"39559"
],
"CVE-2015-7563": [
"39559"
],
"CVE-2015-7562": [
"39559"
],
"CVE-2016-0793": [
"39573"
],
"CVE-2016-0784": [
"39642"
],
"CVE-2016-4337": [
"40046"
],
"CVE-2015-8256": [
"39683"
],
"CVE-2016-1596": [
"39687"
],
"CVE-2016-1595": [
"39687"
],
"CVE-2016-1594": [
"39687"
],
"CVE-2015-9266": [
"39701"
],
"CVE-2016-3694": [
"39710"
],
"CVE-2016-2203": [
"39715"
],
"CVE-2016-0891": [
"39738"
],
"CVE-2015-9222": [
"39739"
],
"CVE-2016-2784": [
"39760"
],
"CVE-2015-6024": [
"39762"
],
"CVE-2015-6023": [
"39762"
],
"CVE-2015-2794": [
"39777"
],
"CVE-2016-4793": [
"39813"
],
"CVE-2016-4313": [
"39816"
],
"CVE-2016-4808": [
"39821"
],
"CVE-2016-4807": [
"39821"
],
"CVE-2016-4806": [
"39821"
],
"CVE-2016-2296": [
"39822"
],
"CVE-2016-2389": [
"39837"
],
"CVE-2016-4010": [
"39838"
],
"CVE-2016-2386": [
"39840",
"43495"
],
"CVE-2016-2388": [
"39841",
"43495"
],
"CVE-2016-6435": [
"40464"
],
"CVE-2016-3670": [
"39880"
],
"CVE-2016-1337": [
"39904"
],
"CVE-2016-1336": [
"39904"
],
"CVE-2016-1328": [
"39904"
],
"CVE-2015-6402": [
"39904"
],
"CVE-2015-6401": [
"39904"
],
"CVE-2016-4309": [
"39983"
],
"CVE-2016-3974": [
"39995"
],
"CVE-2016-3976": [
"39996"
],
"CVE-2016-5304": [
"40041"
],
"CVE-2016-3653": [
"40041"
],
"CVE-2016-3652": [
"40041"
],
"CVE-2016-4469": [
"40109"
],
"CVE-2014-2021": [
"40114"
],
"CVE-2014-2022": [
"40115"
],
"CVE-2015-8257": [
"40171"
],
"CVE-2016-6186": [
"40129"
],
"CVE-2016-6175": [
"40154"
],
"CVE-2016-1610": [
"40161"
],
"CVE-2016-1611": [
"40161"
],
"CVE-2016-1609": [
"40161"
],
"CVE-2016-1608": [
"40161"
],
"CVE-2016-1607": [
"40161"
],
"CVE-2016-5840": [
"40180"
],
"CVE-2016-5734": [
"40185"
],
"CVE-2016-6483": [
"40225"
],
"CVE-2016-6603": [
"40229"
],
"CVE-2016-6602": [
"40229"
],
"CVE-2016-6601": [
"40229"
],
"CVE-2016-6600": [
"40229"
],
"CVE-2016-4340": [
"40236"
],
"CVE-2016-4312": [
"40239"
],
"CVE-2016-4311": [
"40239"
],
"CVE-2016-4314": [
"40240"
],
"CVE-2016-4316": [
"40241"
],
"CVE-2016-4315": [
"40242"
],
"CVE-2016-6909": [
"40276"
],
"CVE-2005-4664": [
"40285"
],
"CVE-2016-6897": [
"40288"
],
"CVE-2016-6896": [
"40288"
],
"CVE-2018-5479": [
"43567"
],
"CVE-2017-17976": [
"43590"
],
"CVE-2017-17999": [
"43591"
],
"CVE-2017-3528": [
"43592"
],
"CVE-2017-10366": [
"43594"
],
"CVE-2018-5688": [
"43595",
"43595"
],
"CVE-2018-5705": [
"43676"
],
"CVE-2018-5715": [
"43683"
],
"CVE-2004-1871": [
"43808"
],
"CVE-2005-1672": [
"43814"
],
"CVE-2005-1673": [
"43814"
],
"CVE-2005-1674": [
"43814"
],
"CVE-2004-2566": [
"43815"
],
"CVE-2004-1420": [
"43818"
],
"CVE-2004-1421": [
"43818"
],
"CVE-2004-1422": [
"43818"
],
"CVE-2004-1423": [
"43819"
],
"CVE-2005-0270": [
"43821"
],
"CVE-2005-0271": [
"43821"
],
"CVE-2005-0272": [
"43821"
],
"CVE-2005-0273": [
"43822"
],
"CVE-2005-0274": [
"43822"
],
"CVE-2005-1200": [
"43823"
],
"CVE-2005-1201": [
"43823"
],
"CVE-2005-1597": [
"43824"
],
"CVE-2005-1642": [
"43825"
],
"CVE-2005-2112": [
"43827"
],
"CVE-2005-2095": [
"43830"
],
"CVE-2005-2414": [
"43831"
],
"CVE-2006-0806": [
"43832"
],
"CVE-2006-0823": [
"43833"
],
"CVE-2006-0869": [
"43834"
],
"CVE-2006-0871": [
"43835"
],
"CVE-2006-1794": [
"43835"
],
"CVE-2006-1127": [
"43837"
],
"CVE-2006-1128": [
"43837"
],
"CVE-2006-0887": [
"43838"
],
"CVE-2006-2826": [
"43838"
],
"CVE-2006-4019": [
"43839"
],
"CVE-2006-4525": [
"43840"
],
"CVE-2006-4844": [
"43841"
],
"CVE-2006-4904": [
"43842"
],
"CVE-2017-10273": [
"43848"
],
"CVE-2017-15374": [
"43849"
],
"CVE-2018-5954": [
"43852"
],
"CVE-2017-16921": [
"43853"
],
"CVE-2018-5985": [
"43860"
],
"CVE-2018-5977": [
"43861"
],
"CVE-2018-5976": [
"43862"
],
"CVE-2018-5986": [
"43863"
],
"CVE-2018-5979": [
"43864"
],
"CVE-2018-5978": [
"43865"
],
"CVE-2018-5984": [
"43866"
],
"CVE-2018-5969": [
"43867"
],
"CVE-2018-5972": [
"43868"
],
"CVE-2018-5988": [
"43869"
],
"CVE-2018-5973": [
"43870"
],
"CVE-2017-9248": [
"43873"
],
"CVE-2017-11357": [
"43874"
],
"CVE-2017-11317": [
"43874"
],
"CVE-2016-6599": [
"43883"
],
"CVE-2016-6598": [
"43883"
],
"CVE-2015-3001": [
"43885"
],
"CVE-2015-3000": [
"43885"
],
"CVE-2015-2999": [
"43885"
],
"CVE-2015-2998": [
"43885"
],
"CVE-2015-2997": [
"43885"
],
"CVE-2015-2996": [
"43885"
],
"CVE-2015-2994": [
"43885",
"41691"
],
"CVE-2015-2993": [
"43885"
],
"CVE-2014-2922": [
"43886"
],
"CVE-2014-2921": [
"43886"
],
"CVE-2014-1603": [
"43888"
],
"CVE-2014-0334": [
"43889"
],
"CVE-2014-7862": [
"43892"
],
"CVE-2014-6039": [
"43893"
],
"CVE-2014-6038": [
"43893"
],
"CVE-2014-7864": [
"43894"
],
"CVE-2014-7863": [
"43894"
],
"CVE-2014-5446": [
"43895"
],
"CVE-2014-5445": [
"43895"
],
"CVE-2014-6036": [
"43896"
],
"CVE-2014-6035": [
"43896"
],
"CVE-2018-5720": [
"43898"
],
"CVE-2016-3473": [
"40590"
],
"CVE-2016-7998": [
"40595"
],
"CVE-2016-7982": [
"40596"
],
"CVE-2016-7980": [
"40597"
],
"CVE-2016-8869": [
"40637"
],
"CVE-2016-8870": [
"40637"
],
"CVE-2016-8580": [
"40682",
"41424"
],
"CVE-2016-8581": [
"40683"
],
"CVE-2016-8582": [
"40684"
],
"CVE-2016-7851": [
"40742"
],
"CVE-2016-6195": [
"40751"
],
"CVE-2016-7065": [
"40842"
],
"CVE-2013-5528": [
"40887"
],
"CVE-2016-0736": [
"40961"
],
"CVE-2016-10045": [
"40969",
"40986",
"42221"
],
"CVE-2016-10074": [
"40972",
"40986",
"42221"
],
"CVE-2016-10034": [
"40979",
"40986",
"42221"
],
"CVE-2016-7454": [
"40982"
],
"CVE-2017-5633": [
"40983"
],
"CVE-2016-6283": [
"40989"
],
"CVE-2014-8380": [
"40997"
],
"CVE-2014-7235": [
"41005"
],
"CVE-2017-5473": [
"41141"
],
"CVE-2017-5594": [
"41143"
],
"CVE-2012-1563": [
"41156"
],
"CVE-2016-9838": [
"41157"
],
"CVE-2016-10043": [
"41179"
],
"CVE-2017-5630": [
"41185"
],
"CVE-2017-5521": [
"41205"
],
"CVE-2017-5174": [
"41360"
],
"CVE-2017-5173": [
"41360"
],
"CVE-2016-9316": [
"41361"
],
"CVE-2016-9315": [
"41361"
],
"CVE-2016-9314": [
"41361"
],
"CVE-2016-9269": [
"41361"
],
"CVE-2017-5344": [
"41377"
],
"CVE-2017-6077": [
"41394"
],
"CVE-2017-5496": [
"41395"
],
"CVE-2015-5995": [
"41402"
],
"CVE-2016-9553": [
"41413"
],
"CVE-2016-9554": [
"41414"
],
"CVE-2016-9683": [
"41415"
],
"CVE-2016-9684": [
"41416"
],
"CVE-2017-6098": [
"41438"
],
"CVE-2017-6097": [
"41438"
],
"CVE-2017-6096": [
"41438"
],
"CVE-2017-6095": [
"41438"
],
"CVE-2017-2363": [
"41449"
],
"CVE-2017-2371": [
"41451"
],
"CVE-2017-2365": [
"41453"
],
"CVE-2017-6366": [
"41472"
],
"CVE-2017-6411": [
"41478"
],
"CVE-2016-8527": [
"41482"
],
"CVE-2016-8526": [
"41482"
],
"CVE-2017-5487": [
"41497"
],
"CVE-2017-6443": [
"41502"
],
"CVE-2017-10020": [
"41540",
"41622"
],
"CVE-2017-6104": [
"41540"
],
"CVE-2017-7178": [
"41541"
],
"CVE-2017-6547": [
"41571"
],
"CVE-2017-6549": [
"41572"
],
"CVE-2017-6548": [
"41573"
],
"CVE-2017-6803": [
"41574"
],
"CVE-2017-6550": [
"41577"
],
"CVE-2017-6529": [
"41578"
],
"CVE-2017-6528": [
"41578"
],
"CVE-2017-6527": [
"41578"
],
"CVE-2017-6526": [
"41578"
],
"CVE-2017-6823": [
"41594"
],
"CVE-2016-8855": [
"41618"
],
"CVE-2017-17672": [
"43362"
],
"CVE-2017-17739": [
"43364"
],
"CVE-2017-17738": [
"43364"
],
"CVE-2017-17737": [
"43364"
],
"CVE-2017-17759": [
"43377"
],
"CVE-2017-17752": [
"43378"
],
"CVE-2017-17721": [
"43379"
],
"CVE-2017-17875": [
"43393"
],
"CVE-2017-17876": [
"43394"
],
"CVE-2018-5211": [
"43409"
],
"CVE-2017-17215": [
"43414"
],
"CVE-2018-3811": [
"43420"
],
"CVE-2018-3810": [
"43420"
],
"CVE-2017-14960": [
"43422"
],
"CVE-2017-17098": [
"43431"
],
"CVE-2017-17097": [
"43431"
],
"CVE-2008-6985": [
"43436"
],
"CVE-2017-7997": [
"43447"
],
"CVE-2017-9554": [
"43455"
],
"CVE-2017-16887": [
"43460"
],
"CVE-2017-16886": [
"43460"
],
"CVE-2017-16885": [
"43460"
],
"CVE-2017-17970": [
"43477"
],
"CVE-2018-5315": [
"43479"
],
"CVE-2018-5263": [
"43488"
],
"CVE-2016-1910": [
"43495"
],
"CVE-2018-5370": [
"43535"
],
"CVE-2014-4688": [
"43560"
],
"CVE-2015-8258": [
"41625"
],
"CVE-2015-8255": [
"41626"
],
"CVE-2017-6896": [
"41633"
],
"CVE-2017-5264": [
"43911"
],
"CVE-2018-6007": [
"43912"
],
"CVE-2018-6008": [
"43913"
],
"CVE-2018-6363": [
"43914"
],
"CVE-2018-6365": [
"43915"
],
"CVE-2017-17612": [
"43916",
"43284"
],
"CVE-2018-6364": [
"43917"
],
"CVE-2018-6367": [
"43918"
],
"CVE-2017-16570": [
"43922"
],
"CVE-2017-16716": [
"43928"
],
"CVE-2018-6397": [
"43931"
],
"CVE-2018-6398": [
"43932"
],
"CVE-2018-6395": [
"43933"
],
"CVE-2018-6577": [
"43940"
],
"CVE-2018-6576": [
"43949"
],
"CVE-2018-6578": [
"43948"
],
"CVE-2018-6579": [
"43950"
],
"CVE-2018-6575": [
"43957"
],
"CVE-2018-6580": [
"43958"
],
"CVE-2018-6581": [
"43959"
],
"CVE-2018-2636": [
"43960"
],
"CVE-2017-14521": [
"43963"
],
"CVE-2017-14523": [
"43964"
],
"CVE-2018-6180": [
"43967"
],
"CVE-2018-6605": [
"43974"
],
"CVE-2018-6604": [
"43975"
],
"CVE-2018-6582": [
"43976"
],
"CVE-2018-6610": [
"43977"
],
"CVE-2018-6609": [
"43978"
],
"CVE-2018-6190": [
"43981"
],
"CVE-2018-6845": [
"44016"
],
"CVE-2018-6889": [
"44028"
],
"CVE-2018-6888": [
"44029"
],
"CVE-2018-6940": [
"44033"
],
"CVE-2018-6941": [
"44034"
],
"CVE-2018-1213": [
"44039"
],
"CVE-2018-1204": [
"44039"
],
"CVE-2018-1203": [
"44039"
],
"CVE-2018-1202": [
"44039"
],
"CVE-2018-1201": [
"44039"
],
"CVE-2018-1189": [
"44039"
],
"CVE-2018-1188": [
"44039"
],
"CVE-2018-1187": [
"44039"
],
"CVE-2018-1186": [
"44039"
],
"CVE-2016-3542": [
"44041"
],
"CVE-2018-6388": [
"44043"
],
"CVE-2017-16935": [
"44050"
],
"CVE-2017-16934": [
"44051"
],
"CVE-2017-15647": [
"44054"
],
"CVE-2017-15579": [
"44056"
],
"CVE-2017-15578": [
"44056"
],
"CVE-2017-15236": [
"44058"
],
"CVE-2017-15235": [
"44059"
],
"CVE-2017-13068": [
"44060"
],
"CVE-2017-14335": [
"44061"
],
"CVE-2017-3898": [
"44062"
],
"CVE-2017-12854": [
"44065"
],
"CVE-2017-11502": [
"44070"
],
"CVE-2017-11471": [
"44071"
],
"CVE-2017-11470": [
"44071"
],
"CVE-2017-11469": [
"44071"
],
"CVE-2017-11456": [
"44072"
],
"CVE-2016-6272": [
"44098"
],
"CVE-2017-16356": [
"44104"
],
"CVE-2018-5982": [
"44105"
],
"CVE-2018-5993": [
"44106"
],
"CVE-2018-5990": [
"44107"
],
"CVE-2018-6584": [
"44108"
],
"CVE-2018-6373": [
"44109"
],
"CVE-2018-6004": [
"44110"
],
"CVE-2018-5991": [
"44111"
],
"CVE-2018-5981": [
"44112"
],
"CVE-2018-6396": [
"44113"
],
"CVE-2018-6394": [
"44114"
],
"CVE-2018-6372": [
"44115"
],
"CVE-2018-5970": [
"44116"
],
"CVE-2018-6368": [
"44117"
],
"CVE-2018-5983": [
"44118"
],
"CVE-2018-6006": [
"44119"
],
"CVE-2018-5994": [
"44120"
],
"CVE-2018-6585": [
"44121"
],
"CVE-2018-5971": [
"44122"
],
"CVE-2018-6370": [
"44123"
],
"CVE-2018-6024": [
"44124"
],
"CVE-2018-6005": [
"44125"
],
"CVE-2018-5974": [
"44126"
],
"CVE-2018-5975": [
"44127"
],
"CVE-2018-5980": [
"44128"
],
"CVE-2018-5992": [
"44129"
],
"CVE-2018-6583": [
"44130"
],
"CVE-2018-5987": [
"44131"
],
"CVE-2018-5989": [
"44132"
],
"CVE-2018-7180": [
"44133"
],
"CVE-2018-7177": [
"44134"
],
"CVE-2018-7179": [
"44135"
],
"CVE-2018-7178": [
"44136"
],
"CVE-2018-7176": [
"44137"
],
"CVE-2017-10046": [
"44141"
],
"CVE-2018-7198": [
"44144"
],
"CVE-2017-6206": [
"41662"
],
"CVE-2014-3829": [
"41676"
],
"CVE-2015-1187": [
"41677"
],
"CVE-2014-8598": [
"41685"
],
"CVE-2012-0261": [
"41686"
],
"CVE-2012-0262": [
"41687"
],
"CVE-2016-1004": [
"41688"
],
"CVE-2016-1003": [
"41688"
],
"CVE-2016-1209": [
"41692"
],
"CVE-2015-1592": [
"41697"
],
"CVE-2015-1172": [
"41698"
],
"CVE-2012-6664": [
"41714"
],
"CVE-2017-14843": [
"42804"
],
"CVE-2017-8770": [
"42547"
],
"CVE-2017-9767": [
"42453"
],
"CVE-2017-9650": [
"42544"
],
"CVE-2017-6087": [
"41746"
],
"CVE-2017-6088": [
"41747"
],
"CVE-2017-5869": [
"41748"
],
"CVE-2017-5607": [
"41779"
],
"CVE-2017-7398": [
"41821"
],
"CVE-2017-2641": [
"41828"
],
"CVE-2017-7447": [
"41824"
],
"CVE-2017-7446": [
"41824"
],
"CVE-2017-7462": [
"41829"
],
"CVE-2017-7461": [
"41829"
],
"CVE-2017-7571": [
"41830"
],
"CVE-2017-6190": [
"41840"
],
"CVE-2017-6361": [
"41842"
],
"CVE-2017-6360": [
"41842"
],
"CVE-2017-6359": [
"41842"
],
"CVE-2017-7588": [
"41863"
],
"CVE-2017-2480": [
"41865"
],
"CVE-2017-2479": [
"41866"
],
"CVE-2017-7725": [
"41885"
],
"CVE-2017-7615": [
"41890",
"48818"
],
"CVE-2017-3548": [
"41925",
"43114"
],
"CVE-2017-3549": [
"41926"
],
"CVE-2017-5799": [
"41927"
],
"CVE-2017-5798": [
"41927"
],
"CVE-2017-7221": [
"41928"
],
"CVE-2017-7981": [
"41953"
],
"CVE-2017-8295": [
"41963"
],
"CVE-2017-6086": [
"41967"
],
"CVE-2017-7312": [
"41985"
],
"CVE-2017-7314": [
"41986"
],
"CVE-2017-8912": [
"41997"
],
"CVE-2017-8928": [
"42004"
],
"CVE-2017-8382": [
"42005"
],
"CVE-2017-6412": [
"42012"
],
"CVE-2017-6340": [
"42013"
],
"CVE-2017-6339": [
"42013"
],
"CVE-2017-6338": [
"42013"
],
"CVE-2017-7952": [
"42028"
],
"CVE-2017-7953": [
"42029"
],
"CVE-2017-8917": [
"42033",
"44358"
],
"CVE-2017-3546": [
"42034"
],
"CVE-2016-6256": [
"42036"
],
"CVE-2017-5631": [
"42042"
],
"CVE-2017-5631#": [
"42042"
],
"CVE-2017-7620": [
"42043"
],
"CVE-2016-9834": [
"42062"
],
"CVE-2017-2504": [
"42064"
],
"CVE-2017-2508": [
"42066"
],
"CVE-2017-2510": [
"42067"
],
"CVE-2017-2515": [
"42068"
],
"CVE-2017-7852": [
"42074"
],
"CVE-2017-2528": [
"42105"
],
"CVE-2016-6566": [
"42111"
],
"CVE-2017-9415": [
"42117"
],
"CVE-2017-9413": [
"42118"
],
"CVE-2017-9414": [
"42120"
],
"CVE-2017-8841": [
"42130"
],
"CVE-2017-8840": [
"42130"
],
"CVE-2017-8839": [
"42130"
],
"CVE-2017-8838": [
"42130"
],
"CVE-2017-8837": [
"42130"
],
"CVE-2017-8836": [
"42130"
],
"CVE-2017-8835": [
"42130"
],
"CVE-2017-9516": [
"42143"
],
"CVE-2017-9418": [
"42166"
],
"CVE-2017-9603": [
"42172"
],
"CVE-2017-9429": [
"42173"
],
"CVE-2017-9602": [
"42184"
],
"CVE-2017-9730": [
"42193"
],
"CVE-2016-7508": [
"42262"
],
"CVE-2017-9813": [
"42269"
],
"CVE-2017-9812": [
"42269"
],
"CVE-2017-9811": [
"42269"
],
"CVE-2017-9810": [
"42269"
],
"CVE-2017-9833": [
"42290"
],
"CVE-2017-9834": [
"42291"
],
"CVE-2017-12971": [
"42520"
],
"CVE-2017-12970": [
"42520"
],
"CVE-2017-12965": [
"42520"
],
"CVE-2017-6971": [
"42306"
],
"CVE-2017-11165": [
"42313"
],
"CVE-2017-7175": [
"42314"
],
"CVE-2017-6972": [
"42314"
],
"CVE-2017-6182": [
"42332"
],
"CVE-2017-6320": [
"42333"
],
"CVE-2017-11356": [
"42335"
],
"CVE-2017-11355": [
"42335"
],
"CVE-2017-10246": [
"42340"
],
"CVE-2016-9682": [
"42342"
],
"CVE-2017-6316": [
"42345",
"42346"
],
"CVE-2017-11346": [
"42358"
],
"CVE-2017-7037": [
"42378"
],
"CVE-2017-9640": [
"42543"
],
"CVE-2017-3133": [
"42388"
],
"CVE-2017-3132": [
"42388"
],
"CVE-2017-3131": [
"42388"
],
"CVE-2016-9349": [
"42401",
"42402"
],
"CVE-2016-9351": [
"42402"
],
"CVE-2017-11494": [
"42408"
],
"CVE-2017-11320": [
"42427"
],
"CVE-2017-11155": [
"42434"
],
"CVE-2017-11154": [
"42434"
],
"CVE-2017-11153": [
"42434"
],
"CVE-2017-11152": [
"42434"
],
"CVE-2017-11151": [
"42434"
],
"CVE-2015-9098": [
"42444"
],
"CVE-2017-6327": [
"42519"
],
"CVE-2017-9979": [
"42517"
],
"CVE-2017-9978": [
"42517"
],
"CVE-2017-12984": [
"42535"
],
"CVE-2017-12943": [
"42581"
],
"CVE-2017-6558": [
"42591"
],
"CVE-2016-10001": [
"42596",
"42597",
"42598"
],
"CVE-2017-13713": [
"42608"
],
"CVE-2017-13754": [
"42610"
],
"CVE-2017-6328": [
"42613"
],
"CVE-2017-14126": [
"42618"
],
"CVE-2017-14219": [
"42633"
],
"CVE-2017-14147": [
"42649"
],
"CVE-2017-14396": [
"42660"
],
"CVE-2014-0780": [
"42699"
],
"CVE-2011-3487": [
"42706",
"42707"
],
"CVE-2017-11435": [
"42732"
],
"CVE-2017-14243": [
"42739"
],
"CVE-2017-14244": [
"42740"
],
"CVE-2017-9798": [
"42745"
],
"CVE-2017-14618": [
"42761"
],
"CVE-2017-14703": [
"42772"
],
"CVE-2017-14704": [
"42773"
],
"CVE-2017-14507": [
"42794"
],
"CVE-2017-14838": [
"42795"
],
"CVE-2017-14840": [
"42796"
],
"CVE-2017-14839": [
"42797"
],
"CVE-2017-14842": [
"42798"
],
"CVE-2017-14841": [
"42799"
],
"CVE-2017-14845": [
"42800"
],
"CVE-2017-14844": [
"42801"
],
"CVE-2017-14846": [
"42802"
],
"CVE-2017-14847": [
"42805"
],
"CVE-2017-14083": [
"42889"
],
"CVE-2017-14086": [
"42892"
],
"CVE-2017-14085": [
"42893"
],
"CVE-2017-14087": [
"42895"
],
"CVE-2017-14738": [
"42922"
],
"CVE-2017-14620": [
"42923"
],
"CVE-2017-14848": [
"42924"
],
"CVE-2017-15956": [
"42927"
],
"CVE-2017-6089": [
"42935"
],
"CVE-2017-14757": [
"42939"
],
"CVE-2017-14758": [
"42940"
],
"CVE-2017-14717": [
"42950"
],
"CVE-2017-14712": [
"42950"
],
"CVE-2017-12615": [
"42953"
],
"CVE-2017-12479": [
"42959"
],
"CVE-2017-15084": [
"42961"
],
"CVE-2017-11394": [
"42971"
],
"CVE-2018-7890": [
"44274"
],
"CVE-2017-15284": [
"42978"
],
"CVE-2017-15287": [
"42986"
],
"CVE-2017-14619": [
"42987"
],
"CVE-2017-14956": [
"42988"
],
"CVE-2017-15646": [
"42989"
],
"CVE-2017-15645": [
"42989"
],
"CVE-2017-15644": [
"42989"
],
"CVE-2017-15359": [
"42991"
],
"CVE-2017-15276": [
"43002"
],
"CVE-2017-15012": [
"43003"
],
"CVE-2017-15013": [
"43004"
],
"CVE-2017-15014": [
"43005"
],
"CVE-2017-12629": [
"43009"
],
"CVE-2017-15291": [
"43023"
],
"CVE-2017-13129": [
"43018"
],
"CVE-2017-14680": [
"43019"
],
"CVE-2017-14955": [
"43021"
],
"CVE-2017-13772": [
"43022",
"48994"
],
"CVE-2017-15687": [
"43024"
],
"CVE-2017-15639": [
"43045"
],
"CVE-2017-15879": [
"43053"
],
"CVE-2017-15878": [
"43054"
],
"CVE-2017-5223": [
"43056"
],
"CVE-2017-15081": [
"43062"
],
"CVE-2017-15727": [
"43063"
],
"CVE-2017-15730": [
"43064"
],
"CVE-2017-15993": [
"43066"
],
"CVE-2017-15992": [
"43067"
],
"CVE-2017-15991": [
"43068"
],
"CVE-2017-15990": [
"43069"
],
"CVE-2017-15989": [
"43070"
],
"CVE-2017-15988": [
"43071"
],
"CVE-2017-15987": [
"43072"
],
"CVE-2017-15986": [
"43073"
],
"CVE-2017-15985": [
"43074"
],
"CVE-2017-15984": [
"43075"
],
"CVE-2017-15983": [
"43076"
],
"CVE-2017-15982": [
"43077"
],
"CVE-2017-15981": [
"43078"
],
"CVE-2017-15980": [
"43079"
],
"CVE-2017-15979": [
"43080"
],
"CVE-2017-15978": [
"43081"
],
"CVE-2017-15977": [
"43082"
],
"CVE-2017-15976": [
"43083"
],
"CVE-2017-15975": [
"43084"
],
"CVE-2017-15974": [
"43085"
],
"CVE-2017-15973": [
"43086"
],
"CVE-2017-15972": [
"43087"
],
"CVE-2017-15971": [
"43088"
],
"CVE-2017-15970": [
"43089"
],
"CVE-2017-15969": [
"43090"
],
"CVE-2017-15968": [
"43091"
],
"CVE-2017-15967": [
"43092"
],
"CVE-2017-15966": [
"43093"
],
"CVE-2017-15965": [
"43094"
],
"CVE-2017-15964": [
"43095"
],
"CVE-2017-15963": [
"43096"
],
"CVE-2017-15962": [
"43097"
],
"CVE-2017-15961": [
"43098"
],
"CVE-2017-15960": [
"43099"
],
"CVE-2017-15959": [
"43100"
],
"CVE-2017-15958": [
"43101"
],
"CVE-2017-15957": [
"43102"
],
"CVE-2017-10309": [
"43103"
],
"CVE-2017-16244": [
"43106"
],
"CVE-2017-16562": [
"43117"
],
"CVE-2017-16567": [
"43122"
],
"CVE-2017-16568": [
"43123"
],
"CVE-2017-16543": [
"43129"
],
"CVE-2017-16542": [
"43129"
],
"CVE-2017-16780": [
"43136"
],
"CVE-2017-16781": [
"43137"
],
"CVE-2017-16524": [
"43138"
],
"CVE-2017-16807": [
"43140"
],
"CVE-2017-15806": [
"43155"
],
"CVE-2017-16819": [
"43158"
],
"CVE-2017-16962": [
"43177"
],
"CVE-2017-16953": [
"43188"
],
"CVE-2017-17058": [
"43196"
],
"CVE-2017-16884": [
"43205"
],
"CVE-2017-17055": [
"43206"
],
"CVE-2017-11319": [
"43210"
],
"CVE-2017-17110": [
"43211"
],
"CVE-2017-17111": [
"43212"
],
"CVE-2017-17594": [
"43235"
],
"CVE-2017-17593": [
"43237"
],
"CVE-2017-17592": [
"43238"
],
"CVE-2017-17591": [
"43239"
],
"CVE-2017-17589": [
"43240"
],
"CVE-2017-17590": [
"43241"
],
"CVE-2017-17583": [
"43242"
],
"CVE-2017-17581": [
"43243"
],
"CVE-2017-17586": [
"43244"
],
"CVE-2017-17585": [
"43245"
],
"CVE-2017-17584": [
"43246"
],
"CVE-2017-17580": [
"43249"
],
"CVE-2017-17587": [
"43250"
],
"CVE-2017-17588": [
"43251"
],
"CVE-2017-17582": [
"43252"
],
"CVE-2017-17575": [
"43253"
],
"CVE-2017-17576": [
"43254"
],
"CVE-2017-17579": [
"43255"
],
"CVE-2017-17573": [
"43256"
],
"CVE-2017-17578": [
"43257"
],
"CVE-2017-17574": [
"43258"
],
"CVE-2017-17572": [
"43259"
],
"CVE-2017-17577": [
"43260"
],
"CVE-2017-17570": [
"43261"
],
"CVE-2017-17571": [
"43262"
],
"CVE-2017-17602": [
"43263"
],
"CVE-2017-17599": [
"43264"
],
"CVE-2017-17598": [
"43265"
],
"CVE-2017-17600": [
"43266"
],
"CVE-2017-17595": [
"43267"
],
"CVE-2017-17597": [
"43268"
],
"CVE-2017-17601": [
"43269"
],
"CVE-2017-17609": [
"43270"
],
"CVE-2017-17608": [
"43271"
],
"CVE-2017-17607": [
"43272"
],
"CVE-2017-17606": [
"43273"
],
"CVE-2017-17630": [
"43282"
],
"CVE-2017-17605": [
"43274"
],
"CVE-2017-17596": [
"43275"
],
"CVE-2017-17611": [
"43276"
],
"CVE-2017-17614": [
"43281"
],
"CVE-2017-17610": [
"43277"
],
"CVE-2017-17615": [
"43280"
],
"CVE-2017-17648": [
"43278"
],
"CVE-2017-17616": [
"43279"
],
"CVE-2017-17613": [
"43283"
],
"CVE-2017-17617": [
"43285"
],
"CVE-2017-17618": [
"43286"
],
"CVE-2017-17629": [
"43287"
],
"CVE-2017-17619": [
"43288"
],
"CVE-2017-17620": [
"43289"
],
"CVE-2017-17621": [
"43290"
],
"CVE-2017-17622": [
"43291"
],
"CVE-2017-17623": [
"43292"
],
"CVE-2017-17624": [
"43293"
],
"CVE-2017-17625": [
"43294"
],
"CVE-2017-17626": [
"43295"
],
"CVE-2017-17627": [
"43296"
],
"CVE-2017-17628": [
"43297"
],
"CVE-2017-17631": [
"43299"
],
"CVE-2017-17632": [
"43300"
],
"CVE-2017-17633": [
"43301"
],
"CVE-2017-17634": [
"43302"
],
"CVE-2017-17603": [
"43304"
],
"CVE-2017-17604": [
"43305"
],
"CVE-2017-17635": [
"43306"
],
"CVE-2017-17636": [
"43307"
],
"CVE-2017-17637": [
"43308"
],
"CVE-2017-17638": [
"43309"
],
"CVE-2017-17639": [
"43310"
],
"CVE-2017-17640": [
"43311"
],
"CVE-2017-17641": [
"43312"
],
"CVE-2017-17642": [
"43314"
],
"CVE-2017-17874": [
"43315"
],
"CVE-2017-17873": [
"43316"
],
"CVE-2017-17870": [
"43323"
],
"CVE-2017-16949": [
"43324"
],
"CVE-2017-17871": [
"43329"
],
"CVE-2017-17872": [
"43330"
],
"CVE-2017-16787": [
"43332"
],
"CVE-2017-17649": [
"43333"
],
"CVE-2017-17651": [
"43334"
],
"CVE-2017-17643": [
"43335"
],
"CVE-2017-17645": [
"43336"
],
"CVE-2017-10682": [
"43337"
],
"CVE-2017-14016": [
"43340"
],
"CVE-2018-7313": [
"44158"
],
"CVE-2018-7317": [
"44159"
],
"CVE-2018-7314": [
"44160"
],
"CVE-2018-7315": [
"44161"
],
"CVE-2018-7312": [
"44162"
],
"CVE-2018-7318": [
"44163"
],
"CVE-2018-7316": [
"44164"
],
"CVE-2018-7319": [
"44165"
],
"CVE-2018-6230": [
"44166"
],
"CVE-2018-6229": [
"44166"
],
"CVE-2018-6228": [
"44166"
],
"CVE-2018-6227": [
"44166"
],
"CVE-2018-6226": [
"44166"
],
"CVE-2018-6225": [
"44166"
],
"CVE-2018-6224": [
"44166"
],
"CVE-2018-6223": [
"44166"
],
"CVE-2018-6222": [
"44166"
],
"CVE-2018-6221": [
"44166"
],
"CVE-2018-6220": [
"44166"
],
"CVE-2018-6219": [
"44166"
],
"CVE-2018-7477": [
"44191"
],
"CVE-2018-7448": [
"44192"
],
"CVE-2017-18195": [
"44194"
],
"CVE-2018-6193": [
"44216"
],
"CVE-2018-6936": [
"44219"
],
"CVE-2018-7739": [
"44220",
"44262"
],
"CVE-2018-7490": [
"44223",
"44223"
],
"CVE-2018-7216": [
"44256"
],
"CVE-2017-15367": [
"44272"
],
"CVE-2018-7474": [
"44277"
],
"CVE-2017-16720": [
"44278"
],
"CVE-2018-7707": [
"44285"
],
"CVE-2018-7706": [
"44285"
],
"CVE-2018-7705": [
"44285"
],
"CVE-2018-7704": [
"44285"
],
"CVE-2018-7703": [
"44285"
],
"CVE-2018-7702": [
"44285"
],
"CVE-2018-7701": [
"44285"
],
"CVE-2018-7538": [
"44286"
],
"CVE-2018-7543": [
"44288"
],
"CVE-2017-8046": [
"44289"
],
"CVE-2018-9010": [
"44317"
],
"CVE-2018-8772": [
"44320"
],
"CVE-2018-0114": [
"44324"
],
"CVE-2018-7422": [
"44340"
],
"CVE-2018-8947": [
"44343"
],
"CVE-2018-7171": [
"44350"
],
"CVE-2018-7203": [
"44351"
],
"CVE-2018-0878": [
"44352"
],
"CVE-2018-8903": [
"44354"
],
"CVE-2018-8979": [
"44360"
],
"CVE-2018-7300": [
"44361"
],
"CVE-2018-9092": [
"44362"
],
"CVE-2018-9034": [
"44366"
],
"CVE-2018-9035": [
"44367"
],
"CVE-2018-7297": [
"44368"
],
"CVE-2018-9107": [
"44369"
],
"CVE-2018-9106": [
"44370"
],
"CVE-2018-8719": [
"44371"
],
"CVE-2018-9032": [
"44378"
],
"CVE-2018-8908": [
"44383"
],
"CVE-2018-8732": [
"44384"
],
"CVE-2018-8817": [
"44385"
],
"CVE-2018-5708": [
"44388"
],
"CVE-2018-8811": [
"44391"
],
"CVE-2018-8815": [
"44392"
],
"CVE-2018-9183": [
"44401"
],
"CVE-2018-6849": [
"44403"
],
"CVE-2018-7653": [
"44405"
],
"CVE-2018-7736": [
"44406"
],
"CVE-2018-7737": [
"44407"
],
"CVE-2018-9173": [
"44408"
],
"CVE-2018-8729": [
"44409",
"44437"
],
"CVE-2018-9248": [
"44413"
],
"CVE-2018-9126": [
"44414"
],
"CVE-2018-7746": [
"44416"
],
"CVE-2018-9155": [
"44612"
],
"CVE-2018-9118": [
"44417"
],
"CVE-2018-8814": [
"44418"
],
"CVE-2018-7745": [
"44419"
],
"CVE-2018-8813": [
"44421"
],
"CVE-2018-9238": [
"44424"
],
"CVE-2018-9843": [
"44429"
],
"CVE-2018-9235": [
"44434"
],
"CVE-2018-9237": [
"44436"
],
"CVE-2018-9236": [
"44436"
],
"CVE-2018-9926": [
"44439"
],
"CVE-2018-1217": [
"44441"
],
"CVE-2018-9172": [
"44443"
],
"CVE-2018-9844": [
"44444"
],
"CVE-2018-10063": [
"44447"
],
"CVE-2018-10070": [
"44450"
],
"CVE-2018-8057": [
"44454"
],
"CVE-2016-7786": [
"44469",
"44469"
],
"CVE-2018-10068": [
"44471"
],
"CVE-2018-10258": [
"44534"
],
"CVE-2018-9857": [
"44486"
],
"CVE-2018-8831": [
"44487"
],
"CVE-2018-8880": [
"44488"
],
"CVE-2018-7747": [
"44489"
],
"CVE-2018-10079": [
"44493"
],
"CVE-2018-10078": [
"44493"
],
"CVE-2018-10077": [
"44493"
],
"CVE-2018-8770": [
"44495"
],
"CVE-2018-8056": [
"44495"
],
"CVE-2018-10188": [
"44496"
],
"CVE-2018-10201": [
"44497"
],
"CVE-2018-9205": [
"44501"
],
"CVE-2018-10109": [
"44502"
],
"CVE-2018-10310": [
"44503"
],
"CVE-2018-10312": [
"44504"
],
"CVE-2018-9137": [
"44511"
],
"CVE-2018-9038": [
"44512"
],
"CVE-2017-14322": [
"44513"
],
"CVE-2018-9245": [
"44515"
],
"CVE-2018-10286": [
"44515"
],
"CVE-2018-10285": [
"44515"
],
"CVE-2018-7602": [
"44542",
"44557"
],
"CVE-2018-8716": [
"44531"
],
"CVE-2018-10255": [
"44535"
],
"CVE-2018-10257": [
"44536"
],
"CVE-2018-10256": [
"44537"
],
"CVE-2018-10259": [
"44538"
],
"CVE-2018-10260": [
"44539"
],
"CVE-2016-10036": [
"44543"
],
"CVE-2018-9160": [
"44545"
],
"CVE-2018-10366": [
"44546"
],
"CVE-2018-10365": [
"44547"
],
"CVE-2018-10321": [
"44551"
],
"CVE-2018-10504": [
"44559"
],
"CVE-2018-10309": [
"44563"
],
"CVE-2018-9302": [
"44567"
],
"CVE-cve 2017-1": [
"44580"
],
"CVE-2018-10371": [
"44585"
],
"CVE-2015-1503": [
"44587"
],
"CVE-2018-10757": [
"44589"
],
"CVE-2018-6023": [
"44606"
],
"CVE-2018-10832": [
"44607"
],
"CVE-2018-10580": [
"44608"
],
"CVE-2018-10314": [
"44613"
],
"CVE-2018-10313": [
"44617"
],
"CVE-2018-10311": [
"44618"
],
"CVE-2018-5430": [
"44623"
],
"CVE-2018-7465": [
"44625"
],
"CVE-2016-2279": [
"44626"
],
"CVE-2018-6563": [
"44631"
],
"CVE-2018-1247": [
"44634"
],
"CVE-2018-11094": [
"44637"
],
"CVE-2016-5809": [
"44640"
],
"CVE-2018-8898": [
"44657"
],
"CVE-2018-9163": [
"44666"
],
"CVE-2015- 5698": [
"44667"
],
"CVE-2013-0663": [
"44678"
],
"CVE-2014-2908": [
"44687"
],
"CVE-2018-11339": [
"44691"
],
"CVE-2018-20448": [
"46067"
],
"CVE-2018-11415": [
"44755"
],
"CVE-2017-10033": [
"44757"
],
"CVE-2018-2791": [
"44752"
],
"CVE-2018-14497": [
"45336"
],
"CVE-2014-3110": [
"44749"
],
"CVE-2018-11445": [
"44763"
],
"CVE-2018-11442": [
"44763"
],
"CVE-2018-11443": [
"44764"
],
"CVE-2018-11444": [
"44765"
],
"CVE-2018-11332": [
"44775"
],
"CVE-2018-11403": [
"44782"
],
"CVE-2018-11404": [
"44783"
],
"CVE-2018-11512": [
"44790"
],
"CVE-2018-11535": [
"44793"
],
"CVE-2018-11523": [
"44794"
],
"CVE-2018-11532": [
"44795"
],
"CVE-2018-11538": [
"44801"
],
"CVE-2018-11522": [
"44803"
],
"CVE-2018-6411": [
"44804"
],
"CVE-2018-6410": [
"44804"
],
"CVE-2018-6409": [
"44804"
],
"CVE-2018-10094": [
"44805"
],
"CVE-2018-11670": [
"44825"
],
"CVE-2018-11671": [
"44826"
],
"CVE-2018-11586": [
"44827"
],
"CVE-2018-11628": [
"44831"
],
"CVE-2018-11715": [
"44833"
],
"CVE-2018-11564": [
"44837"
],
"CVE-2018-11581": [
"44839"
],
"CVE-2018-8718": [
"44843"
],
"CVE-2018-12636": [
"44943"
],
"CVE-2018-10118": [
"44855"
],
"CVE-2018-10088": [
"44864"
],
"CVE-2018-11409": [
"44865"
],
"CVE-2018-12055": [
"44866"
],
"CVE-2018-10969": [
"44867"
],
"CVE-2018-12053": [
"44870"
],
"CVE-2018-12052": [
"44873"
],
"CVE-2018-12054": [
"44874"
],
"CVE-2018-5756": [
"44881"
],
"CVE-2018-5755": [
"44881"
],
"CVE-2018-5754": [
"44881"
],
"CVE-2018-5753": [
"44881"
],
"CVE-2018-5752": [
"44881"
],
"CVE-2018-5751": [
"44881"
],
"CVE-2017-17062": [
"44881"
],
"CVE-2018-12111": [
"44882"
],
"CVE-2018-12114": [
"44887"
],
"CVE-2018-12254": [
"44893"
],
"CVE-2018-12095": [
"44895"
],
"CVE-2018-12094": [
"44897"
],
"CVE-2018-12525": [
"44910"
],
"CVE-2018-12524": [
"44910"
],
"CVE-2018-12523": [
"44910"
],
"CVE-2018-12522": [
"44910"
],
"CVE-2018-10956": [
"44916"
],
"CVE-2018-12602": [
"44918"
],
"CVE-2018-12603": [
"44919"
],
"CVE-2018-12604": [
"44922"
],
"CVE-2018-13109": [
"44982"
],
"CVE-2018-11525": [
"44931"
],
"CVE-2018-12705": [
"44935"
],
"CVE-2018-13032": [
"44938"
],
"CVE-2018-11526": [
"44940"
],
"CVE-2018-12739": [
"44952"
],
"CVE-2018-12912": [
"44953"
],
"CVE-2018-0296": [
"44956",
"47220"
],
"CVE-2018-6961": [
"44959"
],
"CVE-2018-12520": [
"44973"
],
"CVE-2019-7385": [
"46489"
],
"CVE-2018-12908": [
"44977"
],
"CVE-2018-12519": [
"44978"
],
"CVE-2018-12981": [
"45014"
],
"CVE-2018-12980": [
"45014"
],
"CVE-2018-12979": [
"45014"
],
"CVE-2018-8738": [
"44986"
],
"CVE-2019-9082": [
"46488",
"48333"
],
"CVE-2017-3248": [
"44998"
],
"CVE-2018-13849": [
"45003"
],
"CVE-2018-14064": [
"45030"
],
"CVE-2018-14888": [
"45178"
],
"CVE-2018-0710": [
"45015"
],
"CVE-2018-0709": [
"45015"
],
"CVE-2018-0708": [
"45015"
],
"CVE-2018-13981": [
"45016"
],
"CVE-2018-13980": [
"45016"
],
"CVE-2018-15137": [
"45021"
],
"CVE-2018-13989": [
"45022"
],
"CVE-2018-12463": [
"45027"
],
"CVE-2018-13784": [
"45046",
"45047"
],
"CVE-2018-11124": [
"45053"
],
"CVE-2018-13832": [
"45056"
],
"CVE-2018-14392": [
"45057"
],
"CVE-2018-14418": [
"45062"
],
"CVE-2018-13862": [
"45063"
],
"CVE-2018-12465": [
"45083"
],
"CVE-2018-12464": [
"45083"
],
"CVE-2018-14493": [
"45160"
],
"CVE-2018-10618": [
"45076"
],
"CVE-2015-5996": [
"45078"
],
"CVE-2018-13859": [
"45088"
],
"CVE-2018-14328": [
"45094"
],
"CVE-2018-15917": [
"45338"
],
"CVE-2018-15918": [
"45340"
],
"CVE-2014-0030": [
"45341"
],
"CVE-2018-16059": [
"45342"
],
"CVE-2018-14417": [
"45097"
],
"CVE-2018-14728": [
"45103"
],
"CVE-2018-14335": [
"45105"
],
"CVE-2018-14716": [
"45108"
],
"CVE-2018-14029": [
"45127"
],
"CVE-2018-13416": [
"45133"
],
"CVE-2017-15580": [
"45169"
],
"CVE-2018-8096": [
"45136"
],
"CVE-2018-14869": [
"45143"
],
"CVE-2018-13417": [
"45145"
],
"CVE-2018-13415": [
"45146"
],
"CVE-2018-14840": [
"45150"
],
"CVE-2018-7669": [
"45152"
],
"CVE-2018-12090": [
"45153"
],
"CVE-2018-12596": [
"45577"
],
"CVE-2019-8982": [
"45158"
],
"CVE-2018-15534": [
"45240"
],
"CVE-2016-3411": [
"45177"
],
"CVE-2018-1563": [
"45190"
],
"CVE-2018-1513": [
"45190"
],
"CVE-2018-14912": [
"45195"
],
"CVE-2018-11511": [
"45200"
],
"CVE-2018-11510": [
"45200",
"45212"
],
"CVE-2018-11509": [
"45200"
],
"CVE-2018-15142": [
"45202"
],
"CVE-2018-15141": [
"45202"
],
"CVE-2018-15140": [
"45202"
],
"CVE-2018-14059": [
"45208"
],
"CVE-2018-14058": [
"45208"
],
"CVE-2018-14057": [
"45208"
],
"CVE-2018-11502": [
"45224"
],
"CVE-2018-10752": [
"45225"
],
"CVE-2018-15533": [
"45242"
],
"CVE-2018-15608": [
"45254"
],
"CVE-2018-15740": [
"45256"
],
"CVE-2018-15845": [
"45258"
],
"CVE-2018-15884": [
"45264"
],
"CVE-2018-15536": [
"45271"
],
"CVE-2018-15535": [
"45271"
],
"CVE-2018-15877": [
"45274",
"50110"
],
"CVE-2018-18924": [
"45680"
],
"CVE-2018-15745": [
"45296"
],
"CVE-2018-16133": [
"45303"
],
"CVE-2018-12710": [
"45306"
],
"CVE-2018-16134": [
"45309"
],
"CVE-2018-15844": [
"45314"
],
"CVE-2018-16252": [
"45319"
],
"CVE-2018-0715": [
"45348"
],
"CVE-2018-12634": [
"45384"
],
"CVE-2018-16836": [
"45385"
],
"CVE-2018-10763": [
"45386"
],
"CVE-2018-10814": [
"45387"
],
"CVE-2018-1756": [
"45392"
],
"CVE-2018-15596": [
"45393"
],
"CVE-2018-16946": [
"45394"
],
"CVE-2018-1306": [
"45396"
],
"CVE-2018-1322": [
"45400"
],
"CVE-2018-1321": [
"45400"
],
"CVE-2018-10575": [
"45409"
],
"CVE-2018-10576": [
"45409"
],
"CVE-2018-10577": [
"45409"
],
"CVE-2018-17254": [
"45423",
"49627"
],
"CVE-2018-10020": [
"45434"
],
"CVE-2018-16736": [
"45437"
],
"CVE-2018-16283": [
"45438"
],
"CVE-2018-16299": [
"45439"
],
"CVE-2018-16288": [
"45440"
],
"CVE-2018-17255": [
"45445"
],
"CVE-2018-14592": [
"45447"
],
"CVE-2018-17173": [
"45448",
"46795"
],
"CVE-2018-17128": [
"45449"
],
"CVE-2018-17391": [
"45463"
],
"CVE-2018-17379": [
"45464"
],
"CVE-2018-17375": [
"45465"
],
"CVE-2018-17378": [
"45466"
],
"CVE-2018-17377": [
"45468"
],
"CVE-2018-17382": [
"45469"
],
"CVE-2018-17385": [
"45470"
],
"CVE-2018-17384": [
"45473"
],
"CVE-2018-17383": [
"45474"
],
"CVE-2018-17376": [
"45475"
],
"CVE-2018-17397": [
"45476"
],
"CVE-2018-17380": [
"45477"
],
"CVE-2018-17394": [
"45478"
],
"CVE-2018-16659": [
"45500"
],
"CVE-2018-17832": [
"45514"
],
"CVE-2018-17428": [
"45518"
],
"CVE-2018-17593": [
"45525"
],
"CVE-2018-17591": [
"45525"
],
"CVE-2018-17590": [
"45525"
],
"CVE-2018-17588": [
"45525"
],
"CVE-2018-17587": [
"45525"
],
"CVE-2018-17310": [
"45526"
],
"CVE-2018-17313": [
"45526"
],
"CVE-2018-17443": [
"45533"
],
"CVE-2018-17442": [
"45533"
],
"CVE-2018-17441": [
"45533"
],
"CVE-2018-17440": [
"45533"
],
"CVE-2016-8366": [
"45586"
],
"CVE-2016-8380": [
"45590"
],
"CVE-2016-8371": [
"45590"
],
"CVE-2018-17784": [
"45594"
],
"CVE-2014-10029": [
"45595"
],
"CVE-2018-18324": [
"45610"
],
"CVE-2018-18323": [
"45610"
],
"CVE-2018-18322": [
"45610"
],
"CVE-2018-18308": [
"45628"
],
"CVE-2018-18428": [
"45632"
],
"CVE-2018-18437": [
"45668"
],
"CVE-2018-18416": [
"45672"
],
"CVE-2018-10823": [
"45676"
],
"CVE-2018-10824": [
"45677"
],
"CVE-2018-10822": [
"45678"
],
"CVE-2018-18417": [
"45681"
],
"CVE-2018-18419": [
"45686"
],
"CVE-2018-18548": [
"45691"
],
"CVE-2019-9581": [
"46486",
"50594"
],
"CVE-2018-18803": [
"45719"
],
"CVE-2018-18804": [
"45720"
],
"CVE-2018-18805": [
"45721"
],
"CVE-2018-18795": [
"45722"
],
"CVE-2018-18793": [
"45723"
],
"CVE-2018-18794": [
"45724"
],
"CVE-2018-18797": [
"45725"
],
"CVE-2018-18799": [
"45726"
],
"CVE-2018-18798": [
"45727"
],
"CVE-2018-18800": [
"45728"
],
"CVE-2018-18760": [
"45729"
],
"CVE-2018-18801": [
"45730"
],
"CVE-2018-18761": [
"45731"
],
"CVE-2018-18763": [
"45733"
],
"CVE-2018-18762": [
"45734"
],
"CVE-2018-18755": [
"45735"
],
"CVE-2018-18777": [
"45755"
],
"CVE-2018-18776": [
"45755"
],
"CVE-2018-18775": [
"45755"
],
"CVE-2018-15707": [
"45774"
],
"CVE-2018-15705": [
"45774"
],
"CVE-2018-19458": [
"45780"
],
"CVE-2018-18865": [
"45783"
],
"CVE-2018-10517": [
"45793"
],
"CVE-2018-19040": [
"45809"
],
"CVE-2018-19041": [
"45809"
],
"CVE-2018-19042": [
"45809"
],
"CVE-2018-19043": [
"45809"
],
"CVE-2018-18774": [
"45822"
],
"CVE-2018-18773": [
"45822"
],
"CVE-2018-18772": [
"45822"
],
"CVE-2018-19135": [
"45839"
],
"CVE-2018-15768": [
"45852"
],
"CVE-2018-15767": [
"45852"
],
"CVE-2018-18619": [
"45853"
],
"CVE-2018-19246": [
"45861"
],
"CVE-2018-19287": [
"45880"
],
"CVE-2018-19136": [
"45883"
],
"CVE-2018-18923": [
"45902"
],
"CVE-2017-6026": [
"45918"
],
"CVE-2018-8021": [
"45933"
],
"CVE-2018-19616": [
"45937"
],
"CVE-2018-19749": [
"45941"
],
"CVE-2018-11742": [
"45942"
],
"CVE-2018-11741": [
"45942"
],
"CVE-2018-19799": [
"45945"
],
"CVE-2018-19750": [
"45946"
],
"CVE-2018-19751": [
"45947"
],
"CVE-2018-15716": [
"45948"
],
"CVE-2018-19752": [
"45949"
],
"CVE-2018-19782": [
"45954"
],
"CVE-2018-20159": [
"45957"
],
"CVE-2018-19877": [
"45958"
],
"CVE-2018-19126": [
"45964"
],
"CVE-2018-19125": [
"45964"
],
"CVE-2018-19913": [
"45967"
],
"CVE-2018-13134": [
"45970"
],
"CVE-2018-7921": [
"45971"
],
"CVE-2018-7358": [
"45972"
],
"CVE-2018-7357": [
"45972"
],
"CVE-2018-15961": [
"45979"
],
"CVE-2018-7690": [
"45989"
],
"CVE-2018-7691": [
"45990"
],
"CVE-2015-7254": [
"45991"
],
"CVE-2018-19371": [
"46000"
],
"CVE-2018-20166": [
"46011"
],
"CVE-2018-19828": [
"46012"
],
"CVE-2018-19829": [
"46013"
],
"CVE-2018-19933": [
"46014"
],
"CVE-2018-13045": [
"46015"
],
"CVE-2018-1821": [
"46017"
],
"CVE-2018-19138": [
"46036"
],
"CVE-2018-19277": [
"46050"
],
"CVE-2018-20418": [
"46054"
],
"CVE-2018-10008": [
"46060",
"46108"
],
"CVE-2019-5009": [
"46065"
],
"CVE-2018-17997": [
"46079"
],
"CVE-2019-3501": [
"46080"
],
"CVE-2018-20326": [
"46081"
],
"CVE-2018-20526": [
"46085"
],
"CVE-2018-20525": [
"46085"
],
"CVE-2018-20221": [
"46086"
],
"CVE-2014-5395": [
"46092"
],
"CVE-2018-7355": [
"46102"
],
"CVE-2018-14485": [
"46106"
],
"CVE-2019-9622": [
"46109"
],
"CVE-2019-5893": [
"46118"
],
"CVE-2019-6249": [
"46149"
],
"CVE-2019-5722": [
"46163"
],
"CVE-2018-10093": [
"46164"
],
"CVE-2018-13374": [
"46171"
],
"CVE-2018-5782": [
"46174"
],
"CVE-2019-6275": [
"46179"
],
"CVE-2019-6274": [
"46179"
],
"CVE-2019-6273": [
"46179"
],
"CVE-2019-6272": [
"46179"
],
"CVE-2019-6441": [
"46180"
],
"CVE-2019-2413": [
"46187"
],
"CVE-2019-6263": [
"46200"
],
"CVE-2013-6227": [
"46206"
],
"CVE-2018-15710": [
"46221",
"47039"
],
"CVE-2018-15708": [
"46221",
"47039"
],
"CVE-2018-20503": [
"46237"
],
"CVE-2019-6710": [
"46240"
],
"CVE-2019-6780": [
"46247"
],
"CVE-2019-6804": [
"46251"
],
"CVE-2019-6967": [
"46253"
],
"CVE-2019-6716": [
"46254"
],
"CVE-2019-1642": [
"46263"
],
"CVE-2019-6979": [
"46273"
],
"CVE-2018-15657": [
"46305"
],
"CVE-2019-7391": [
"46326"
],
"CVE-2018-19276": [
"46327",
"47792"
],
"CVE-2019-7646": [
"46349"
],
"CVE-2019-6714": [
"46353"
],
"CVE-2019-7541": [
"46366"
],
"CVE-2018-20009": [
"46372"
],
"CVE-2018-20010": [
"46373"
],
"CVE-2018-20011": [
"46374"
],
"CVE-2018-19914": [
"46375"
],
"CVE-2018-19915": [
"46376"
],
"CVE-2018-20556": [
"46377"
],
"CVE-2018-17996": [
"46379"
],
"CVE-2018-14575": [
"46384"
],
"CVE-2019-8341": [
"46386"
],
"CVE-2019-8391": [
"46398"
],
"CVE-2019-8390": [
"46399"
],
"CVE-2019-8387": [
"46400"
],
"CVE-2018-19908": [
"46401"
],
"CVE-2019-8404": [
"46405"
],
"CVE-2019-8394": [
"46413"
],
"CVE-2018-20782": [
"46414"
],
"CVE-2019-8924": [
"46424"
],
"CVE-2019-8923": [
"46424"
],
"CVE-2019-8929": [
"46425"
],
"CVE-2019-8928": [
"46425"
],
"CVE-2019-8927": [
"46425"
],
"CVE-2019-8926": [
"46425"
],
"CVE-2019-8925": [
"46425"
],
"CVE-2019-8937": [
"46429"
],
"CVE-2017-17417": [
"46446"
],
"CVE-2019-3475": [
"46450"
],
"CVE-2019-3474": [
"46450"
],
"CVE-2018-20220": [
"46451"
],
"CVE-2018-20219": [
"46451"
],
"CVE-2018-20218": [
"46451"
],
"CVE-2018-19990": [
"46453"
],
"CVE-2019-9041": [
"46454"
],
"CVE-2019-9184": [
"46467"
],
"CVE-2019-9623": [
"46471"
],
"CVE-2019-7751": [
"46494"
],
"CVE-2019-9553": [
"46495"
],
"CVE-2019-9554": [
"46496"
],
"CVE-2019-9556": [
"46498"
],
"CVE-2018-6671": [
"46518",
"46518"
],
"CVE-2019-9625": [
"46520",
"46520"
],
"CVE-2019-11444": [
"46525"
],
"CVE-2019-11445": [
"46526"
],
"CVE-2018-9276": [
"46527"
],
"CVE-2018-11686": [
"46528"
],
"CVE-2019-9769": [
"46531"
],
"CVE-2019-9618": [
"46537"
],
"CVE-2019-8953": [
"46538"
],
"CVE-2019-9834": [
"46545"
],
"CVE-2014-10079": [
"46549"
],
"CVE-2014-10078": [
"46549"
],
"CVE-2018-1133": [
"46551"
],
"CVE-2019-9647": [
"46557"
],
"CVE-2019-9650": [
"46558"
],
"CVE-2019-6279": [
"46580"
],
"CVE-2019-6282": [
"46581"
],
"CVE-2019-5418": [
"46585"
],
"CVE-2019-7400": [
"46608"
],
"CVE-2019-10009": [
"46611"
],
"CVE-2019-8385": [
"46615"
],
"CVE-2019-10226": [
"46617"
],
"CVE-2019-6965": [
"46620"
],
"CVE-2019-10261": [
"46629"
],
"CVE-2019-7441": [
"46632"
],
"CVE-2019-7440": [
"46633"
],
"CVE-2018-17057": [
"46634"
],
"CVE-2019-9053": [
"46635"
],
"CVE-2019-10008": [
"46659"
],
"CVE-2019-10874": [
"46664"
],
"CVE-2019-9593": [
"46666"
],
"CVE-2019-9592": [
"46666"
],
"CVE-2019-9591": [
"46666"
],
"CVE-2019-10887": [
"46667"
],
"CVE-2019-10893": [
"46669"
],
"CVE-2019-10273": [
"46674"
],
"CVE-2019-11017": [
"46687"
],
"CVE-2019-11446": [
"46691"
],
"CVE-2019-11193": [
"46694"
],
"CVE-2019-9955": [
"46706"
],
"CVE-2019-10945": [
"46710"
],
"CVE-2019-2588": [
"46728"
],
"CVE-2019-2616": [
"46729"
],
"CVE-2019-11374": [
"46738"
],
"CVE-2019-11375": [
"46739"
],
"CVE-2019-11398": [
"46741",
"46977"
],
"CVE-2019-7438": [
"46751"
],
"CVE-2019-11537": [
"46753"
],
"CVE-2019-0186": [
"46759",
"46759"
],
"CVE-2019-11569": [
"46765"
],
"CVE-2019-11415": [
"46768"
],
"CVE-2019-11416": [
"46770"
],
"CVE-2019-11564": [
"46771"
],
"CVE-2019-3799": [
"46772"
],
"CVE-2019-10678": [
"46773"
],
"CVE-2019-10664": [
"46773"
],
"CVE-2019-11429": [
"46784"
],
"CVE-2019-2725": [
"46780",
"46814"
],
"CVE-2019-5420": [
"46785"
],
"CVE-2019-9017": [
"46793"
],
"CVE-2019-3929": [
"46786",
"47924"
],
"CVE-2019-11504": [
"46788"
],
"CVE-2019-9978": [
"46794"
],
"CVE-2019-7286": [
"46803"
],
"CVE-2019-11419": [
"46853"
],
"CVE-2018-10608": [
"46859"
],
"CVE-2014-9415": [
"46865"
],
"CVE-2014-9417": [
"46867"
],
"CVE-2014-9418": [
"46868"
],
"CVE-2019-8622": [
"46888"
],
"CVE-2019-8623": [
"46889"
],
"CVE-2019-8611": [
"46890"
],
"CVE-2019-8591": [
"46891"
],
"CVE-2019-8605": [
"46892",
"47409"
],
"CVE-2019-8613": [
"46913"
],
"CVE-2019-9792": [
"46939"
],
"CVE-2019-9816": [
"46940"
],
"CVE-2019-10529": [
"46941"
],
"CVE-2019-0708": [
"46946",
"47120",
"47416",
"47683"
],
"CVE-2019-5526": [
"46851"
],
"CVE-2014-9416": [
"46866"
],
"CVE-2019-0863": [
"46917"
],
"CVE-2019-0881": [
"46912"
],
"CVE-2019-8565": [
"46914"
],
"CVE-2019-0803": [
"46920"
],
"CVE-2017-1274": [
"46808"
],
"CVE-2019-5786": [
"46812"
],
"CVE-2019-9193": [
"46813"
],
"CVE-2019-12099": [
"46839"
],
"CVE-2019-11231": [
"46880"
],
"CVE-2017-18357": [
"46915"
],
"CVE-2019-0752": [
"46928"
],
"CVE-2019-12137": [
"46932"
],
"CVE-2019-12372": [
"46934"
],
"CVE-2018-20580": [
"46796"
],
"CVE-2019-10685": [
"46804"
],
"CVE-2018-20485": [
"46815"
],
"CVE-2018-20484": [
"46815"
],
"CVE-2019-7652": [
"46820"
],
"CVE-2019-7442": [
"46828"
],
"CVE-2019-11600": [
"46838"
],
"CVE-2018-7841": [
"46846"
],
"CVE-2018-19550": [
"46864"
],
"CVE-2019-12185": [
"46869"
],
"CVE-2019-12195": [
"46882"
],
"CVE-2019-9881": [
"46886"
],
"CVE-2019-9880": [
"46886"
],
"CVE-2019-9879": [
"46886"
],
"CVE-2018-6443": [
"46887"
],
"CVE-2019-12252": [
"46894"
],
"CVE-2019-12189": [
"46895"
],
"CVE-2019-11368": [
"46896"
],
"CVE-2019-11370": [
"46897"
],
"CVE-2019-11369": [
"46898"
],
"CVE-2019-12279": [
"46910"
],
"CVE-2019-12314": [
"46931"
],
"CVE-2019-12347": [
"46936"
],
"CVE-2019-12788": [
"46980"
],
"CVE-cve\u00e2\u0080\u00912019": [
"46972"
],
"CVE-2019-12735": [
"46973"
],
"CVE-2018-19864": [
"46960"
],
"CVE-2019-8352": [
"46969"
],
"CVE-2019-4279": [
"46969"
],
"CVE-2018-20434": [
"46970",
"47044"
],
"CVE-2019-10149": [
"46974",
"46996",
"47307"
],
"CVE-2018-5406": [
"46956"
],
"CVE-2018-5405": [
"46956"
],
"CVE-2018-5404": [
"46956"
],
"CVE-2019-10866": [
"46958"
],
"CVE-2019-12593": [
"46959"
],
"CVE-2019-12538": [
"46963"
],
"CVE-2019-12541": [
"46964"
],
"CVE-2019-12542": [
"46965"
],
"CVE-2019-12543": [
"46966"
],
"CVE-2019-12477": [
"46971"
],
"CVE-2019-12616": [
"46982"
],
"CVE-2019-6588": [
"46983"
],
"CVE-2019-12323": [
"46995"
],
"CVE-2019-11706": [
"47001"
],
"CVE-2019-11704": [
"47002"
],
"CVE-2019-11703": [
"47003"
],
"CVE-2019-11705": [
"47004"
],
"CVE-2019-0959": [
"47028"
],
"CVE-2019-0943": [
"47029"
],
"CVE-2019-11707": [
"47038",
"50691"
],
"CVE-2019-1117": [
"47086"
],
"CVE-2019-1118": [
"47087"
],
"CVE-2019-1127": [
"47088"
],
"CVE-2019-1119": [
"47092"
],
"CVE-2019-1120": [
"47094"
],
"CVE-2019-1128": [
"47095"
],
"CVE-2019-1121": [
"47097"
],
"CVE-2019-1122": [
"47098"
],
"CVE-2019-1123": [
"47099"
],
"CVE-2019-1124": [
"47103"
],
"CVE-2019-2107": [
"47119",
"47157"
],
"CVE-2019-12480": [
"47148"
],
"CVE-2019-8624": [
"47158"
],
"CVE-2019-8649": [
"47162"
],
"CVE-2019-14267": [
"47178"
],
"CVE-2019-8662": [
"47189",
"47608"
],
"CVE-2019-8671": [
"47190"
],
"CVE-2019-8672": [
"47191"
],
"CVE-2019-8647": [
"47192"
],
"CVE-2019-8660": [
"47193"
],
"CVE-2019-8646": [
"47194"
],
"CVE-2019-8661": [
"47207"
],
"CVE-2018-19113": [
"46988"
],
"CVE-2019-12181": [
"47009",
"47072",
"47173"
],
"CVE-2019-8513": [
"47070"
],
"CVE-2019-13494": [
"47105"
],
"CVE-2019-1019": [
"47115"
],
"CVE-2018-12897": [
"47126"
],
"CVE-2019-13272": [
"47133",
"47163",
"47543",
"50541"
],
"CVE-2018-8453": [
"47134"
],
"CVE-2019-1089": [
"47135"
],
"CVE-2017-5899": [
"47172"
],
"CVE-2019-1132": [
"47176"
],
"CVE-2019-13294": [
"46999"
],
"CVE-2019-1821": [
"47016",
"47686"
],
"CVE-2019-12828": [
"47019"
],
"CVE-2019-0232": [
"47073"
],
"CVE-2007-0213": [
"47076"
],
"CVE-2016-2056": [
"47114"
],
"CVE-2018-15133": [
"47129"
],
"CVE-2017-16894": [
"47129"
],
"CVE-2019-13577": [
"47130",
"47137"
],
"CVE-2019-6814": [
"47186"
],
"CVE-2019-11080": [
"46987"
],
"CVE-2019-3778": [
"47000"
],
"CVE-2019-11269": [
"47000"
],
"CVE-2018-20470": [
"47005"
],
"CVE-2018-20469": [
"47006"
],
"CVE-2018-20472": [
"47007"
],
"CVE-2019-13292": [
"47013"
],
"CVE-2019-11354": [
"47021"
],
"CVE-2019-12745": [
"47023"
],
"CVE-2019-12801": [
"47024"
],
"CVE-2019-12744": [
"47022",
"50062"
],
"CVE-2019-12276": [
"47027"
],
"CVE-2019-0285": [
"47061"
],
"CVE-2019-13063": [
"47062"
],
"CVE-2019-13024": [
"47069"
],
"CVE-2019-9701": [
"47071"
],
"CVE-2019-13344": [
"47078"
],
"CVE-2019-13493": [
"47106"
],
"CVE-2019-13491": [
"47107"
],
"CVE-2019-13346": [
"47109"
],
"CVE-2019-13597": [
"47110"
],
"CVE-2019-10349": [
"47111"
],
"CVE-2019-12991": [
"47112"
],
"CVE-2019-12989": [
"47112"
],
"CVE-2019-1943": [
"47118"
],
"CVE-2019-13396": [
"47121"
],
"CVE-2019-13605": [
"47123"
],
"CVE-2019-13360": [
"47123"
],
"CVE-2019-13359": [
"47124"
],
"CVE-2019-13383": [
"47125"
],
"CVE-2018-16763": [
"47138",
"49487",
"50477"
],
"CVE-2019-13029": [
"47146"
],
"CVE-2019-13977": [
"47159"
],
"CVE-2018-1042": [
"47177"
],
"CVE-2019-10267": [
"47179",
"47180"
],
"CVE-2019-10266": [
"47181"
],
"CVE-2019-14328": [
"47182"
],
"CVE-2019-3948": [
"47188"
],
"CVE-2019-2861": [
"47196"
],
"CVE-2019-14221": [
"47206"
],
"CVE-2019-14348": [
"47210"
],
"CVE-2019-14696": [
"47212"
],
"CVE-2019-14312": [
"47214"
],
"CVE-2019-14346": [
"47217"
],
"CVE-2019-12255": [
"47233"
],
"CVE-2019-8690": [
"47237"
],
"CVE-2019-8663": [
"47257"
],
"CVE-2019-8016": [
"47259"
],
"CVE-2019-8017": [
"47260"
],
"CVE-2019-1145": [
"47261"
],
"CVE-2019-1148": [
"47262"
],
"CVE-2019-1144": [
"47263"
],
"CVE-2019-1149": [
"47264"
],
"CVE-2019-1150": [
"47265",
"47267"
],
"CVE-2019-1151": [
"47266"
],
"CVE-2019-1152": [
"47268"
],
"CVE-2019-1153": [
"47269"
],
"CVE-2019-8043": [
"47270"
],
"CVE-2019-8024": [
"47271"
],
"CVE-2019-8050": [
"47272"
],
"CVE-2019-8048": [
"47273"
],
"CVE-2019-8049": [
"47274"
],
"CVE-2019-8041": [
"47275"
],
"CVE-2019-8042": [
"47276"
],
"CVE-2019-8046": [
"47277"
],
"CVE-2019-8045": [
"47278"
],
"CVE-2019-8044": [
"47279"
],
"CVE-2019-8689": [
"47316"
],
"CVE-2019-10709": [
"47322"
],
"CVE-2019-13069": [
"47197"
],
"CVE-2019-13623": [
"47231"
],
"CVE-2019-1170": [
"47306"
],
"CVE-2019-14339": [
"47321"
],
"CVE-2011-2921": [
"47344"
],
"CVE-2019-15104": [
"47227"
],
"CVE-2019-15105": [
"47228"
],
"CVE-2019-15106": [
"47229"
],
"CVE-2019-15107": [
"47230",
"47293"
],
"CVE-2019-9851": [
"47298"
],
"CVE-2019-14378": [
"47320"
],
"CVE-2019-1935": [
"47346"
],
"CVE-2019-1622": [
"47347"
],
"CVE-2019-1620": [
"47347"
],
"CVE-2019-1619": [
"47347"
],
"CVE-2017-16709": [
"47353"
],
"CVE-2019-11539": [
"47354",
"47700"
],
"CVE-2019-15029": [
"47358"
],
"CVE-2019-10669": [
"47375"
],
"CVE-2019-11510": [
"47297"
],
"CVE-2014-4035": [
"47219"
],
"CVE-2019-14804": [
"47221"
],
"CVE-2019-14748": [
"47224"
],
"CVE-2019-14749": [
"47225"
],
"CVE-2019-14750": [
"47226"
],
"CVE-2019-14927": [
"47234"
],
"CVE-2019-14931": [
"47235"
],
"CVE-2019-14974": [
"47247"
],
"CVE-2019-13101": [
"47250"
],
"CVE-2019-14422": [
"47252"
],
"CVE-2018-13379": [
"47287",
"47288"
],
"CVE-2019-14430": [
"47294"
],
"CVE-2019-11013": [
"47301"
],
"CVE-2019-15501": [
"47302"
],
"CVE-2019-15092": [
"47303"
],
"CVE-2019-14470": [
"47304"
],
"CVE-2019-10227": [
"47305"
],
"CVE-2019-15637": [
"47308"
],
"CVE-2019-9083": [
"47310"
],
"CVE-2019-15813": [
"47323",
"48955"
],
"CVE-2019-15814": [
"47324"
],
"CVE-2019-15811": [
"47325"
],
"CVE-2019-10101": [
"47327"
],
"CVE-2019-15081": [
"47331"
],
"CVE-2019-13235": [
"47338"
],
"CVE-2019-13234": [
"47338"
],
"CVE-2019-13236": [
"47339"
],
"CVE-2019-13237": [
"47340"
],
"CVE-2019-14280": [
"47343"
],
"CVE-2019-15889": [
"47350"
],
"CVE-2019-10677": [
"47351"
],
"CVE-2019-16068": [
"47363"
],
"CVE-2019-16072": [
"47364"
],
"CVE-2019-16065": [
"47365"
],
"CVE-2019-16119": [
"47371"
],
"CVE-2019-16117": [
"47372"
],
"CVE-2019-16118": [
"47373"
],
"CVE-2019-1245": [
"47381"
],
"CVE-2019-1244": [
"47382"
],
"CVE-2019-8641": [
"47415",
"47608"
],
"CVE-2019-8717": [
"47479"
],
"CVE-2019-1364": [
"47484"
],
"CVE-2019-1343": [
"47485"
],
"CVE-2019-1344": [
"47486"
],
"CVE-2019-1345": [
"47487"
],
"CVE-2019-1346": [
"47488"
],
"CVE-2019-1347": [
"47489"
],
"CVE-2019-8197": [
"47528"
],
"CVE-2019-8765": [
"47565"
],
"CVE-2019-8820": [
"47590"
],
"CVE-2019-8195": [
"47609"
],
"CVE-2019-8196": [
"47610"
],
"CVE-2019-15794": [
"47692"
],
"CVE-2019-15793": [
"47693"
],
"CVE-2019-15792": [
"47693"
],
"CVE-2019-15791": [
"47693"
],
"CVE-2019-1429": [
"47707"
],
"CVE-2019-1476": [
"47768"
],
"CVE-2019-16451": [
"47769"
],
"CVE-2019-6192": [
"47771"
],
"CVE-2020-0009": [
"47921"
],
"CVE-2020-0610": [
"47964",
"47963"
],
"CVE-2020-0609": [
"47964",
"47963"
],
"CVE-2020-8416": [
"47987"
],
"CVE-2019-1253": [
"47389"
],
"CVE-2019-15943": [
"47454"
],
"CVE-2019-2215": [
"47463",
"48129"
],
"CVE-2019-8452": [
"47471"
],
"CVE-2019-14737": [
"47493"
],
"CVE-2019-14287": [
"47502"
],
"CVE-2019-17624": [
"47507"
],
"CVE-2019-9491": [
"47527"
],
"CVE-2019-3010": [
"47529"
],
"CVE-2019-11660": [
"47580"
],
"CVE-2017-13156": [
"47601"
],
"CVE-2019-1405": [
"47684",
"47805"
],
"CVE-2019-1322": [
"47684",
"47805"
],
"CVE-2019-18862": [
"47703"
],
"CVE-2017-4901": [
"47714"
],
"CVE-2017-4905": [
"47715"
],
"CVE-2019-18276": [
"47726"
],
"CVE-2019-15627": [
"47751"
],
"CVE-2019-11708": [
"47752"
],
"CVE-2019-19241": [
"47779"
],
"CVE-2019-19726": [
"47780",
"47803"
],
"CVE-2019-5596": [
"47829",
"47081"
],
"CVE-2019-1184": [
"47880"
],
"CVE-2019-18194": [
"47897"
],
"CVE-2020-0601": [
"47933"
],
"CVE-2019-1215": [
"47935"
],
"CVE-2019-15742": [
"47944"
],
"CVE-2019-19031": [
"47945"
],
"CVE-2018-5333": [
"47957"
],
"CVE-2019-19363": [
"47962",
"48036"
],
"CVE-2019-19032": [
"47974"
],
"CVE-2018-8413": [
"47975"
],
"CVE-2019-18634": [
"47995"
],
"CVE-2019-5392": [
"47408"
],
"CVE-2019-16724": [
"47412"
],
"CVE-2019-16645": [
"47439"
],
"CVE-2019-1914": [
"47442"
],
"CVE-2019-1913": [
"47442"
],
"CVE-2019-1912": [
"47442"
],
"CVE-2019-11932": [
"47515"
],
"CVE-2019-17662": [
"47519"
],
"CVE-2019-15954": [
"47531"
],
"CVE-2019-10969": [
"47536"
],
"CVE-2019-10963": [
"47536"
],
"CVE-2015-0008": [
"47558"
],
"CVE-2015-0009": [
"47559"
],
"CVE-2019-3978": [
"47566"
],
"CVE-2019-16278": [
"47573",
"47837"
],
"CVE-2019-16662": [
"47602",
"47555"
],
"CVE-2019-7265": [
"47625"
],
"CVE-2019-10849": [
"47629"
],
"CVE-2019-17424": [
"47673"
],
"CVE-2019-11409": [
"47697"
],
"CVE-2019-16113": [
"47699",
"48568",
"48701"
],
"CVE-2019-16702": [
"47750"
],
"CVE-2019-15999": [
"47885"
],
"CVE-2017-3623": [
"47888"
],
"CVE-2019-15039": [
"47891"
],
"CVE-2020-7247": [
"47984",
"48038"
],
"CVE-2019-16197": [
"47384"
],
"CVE-2019-12922": [
"47385"
],
"CVE-2019-16173": [
"47386"
],
"CVE-2019-16172": [
"47386"
],
"CVE-2016-10258": [
"47392"
],
"CVE-2019-16399": [
"47399"
],
"CVE-2019-16531": [
"47403"
],
"CVE-2019-16679": [
"47407"
],
"CVE-2019-1262": [
"47417"
],
"CVE-2019-5485": [
"47420"
],
"CVE-2019-16894": [
"47426"
],
"CVE-2019-16759": [
"47437",
"47447"
],
"CVE-2019-16692": [
"47438"
],
"CVE-2019-12562": [
"47448"
],
"CVE-2019-17080": [
"47457"
],
"CVE-2018-7251": [
"47459"
],
"CVE-2019-17225": [
"47469"
],
"CVE-2019-4013": [
"47470"
],
"CVE-2019-17132": [
"47475"
],
"CVE-2019-13529": [
"47480"
],
"CVE-2019-6971": [
"47483"
],
"CVE-2019-17503": [
"47498"
],
"CVE-2019-17504": [
"47498"
],
"CVE-2019-1759": [
"47501"
],
"CVE-2019-7670": [
"47612"
],
"CVE-2018-12650": [
"47613"
],
"CVE-2019-10846": [
"47614"
],
"CVE-2018-12234": [
"47611"
],
"CVE-2019-17220": [
"47537"
],
"CVE-2019-18418": [
"47544"
],
"CVE-2019-11043": [
"47553",
"48182"
],
"CVE-2019-10475": [
"47598"
],
"CVE-2019-14347": [
"47600"
],
"CVE-2019-7254": [
"47616",
"47618"
],
"CVE-2019-7256": [
"47619"
],
"CVE-2019-7262": [
"47620"
],
"CVE-2019-3398": [
"47621"
],
"CVE-2019-7257": [
"47622"
],
"CVE-2019-7255": [
"47623"
],
"CVE-2019-7269": [
"47624"
],
"CVE-2019-10847": [
"47628"
],
"CVE-2019-10848": [
"47630"
],
"CVE-2019-7671": [
"47633"
],
"CVE-2019-9189": [
"47634"
],
"CVE-2019-3398&": [
"47635"
],
"CVE-2019-7274": [
"47636"
],
"CVE-2019-7273": [
"47639"
],
"CVE-2019-7272": [
"47640"
],
"CVE-2019-7276": [
"47641"
],
"CVE-2018-12653": [
"47643"
],
"CVE-2019-7666": [
"47644"
],
"CVE-2019-18873": [
"47650"
],
"CVE-2019-18396": [
"47651"
],
"CVE-2019-18951": [
"47659"
],
"CVE-2019-16758": [
"47663"
],
"CVE-2019\u00e2\u0080\u0093143": [
"47670",
"47672"
],
"CVE-2019-10092": [
"47688"
],
"CVE-2019-10098": [
"47689"
],
"CVE-2019-17671": [
"47690"
],
"CVE-2017-12945": [
"47722"
],
"CVE-2019-19516": [
"47738"
],
"CVE-2019-5434": [
"47739"
],
"CVE-2019-19576": [
"47749"
],
"CVE-2019-15276": [
"47744"
],
"CVE-2018-9022": [
"47748"
],
"CVE-2018-9021": [
"47748"
],
"CVE-2019-17554": [
"47770"
],
"CVE-2019-19742": [
"47776"
],
"CVE-2019-19731": [
"47777"
],
"CVE-2019-19743": [
"47778"
],
"CVE-2019-19368": [
"47789"
],
"CVE-2019-18935": [
"47793"
],
"CVE-2020-5192": [
"47840"
],
"CVE-2020-5191": [
"47841"
],
"CVE-2019-19844": [
"47879"
],
"CVE-2019-20354": [
"47882"
],
"CVE-2019-2729": [
"47895"
],
"CVE-2020-6756": [
"47899"
],
"CVE-2019-19781": [
"47901",
"47913",
"47930"
],
"CVE-2019-1978": [
"47902"
],
"CVE-2019-18859": [
"47914"
],
"CVE-2019-20204": [
"47925"
],
"CVE-2020-2096": [
"47927"
],
"CVE-2019-16405": [
"47948"
],
"CVE-2020-7246": [
"47954",
"48146",
"50175",
"50944"
],
"CVE-2018-10653": [
"47951"
],
"CVE-2019-16893": [
"47958"
],
"CVE-2020-6170": [
"47961"
],
"CVE-2020-7991": [
"47966"
],
"CVE-2019-19740": [
"47967"
],
"CVE-2020-8425": [
"47973"
],
"CVE-2020-8424": [
"47973"
],
"CVE-2020-7980": [
"47976"
],
"CVE-2019-19509": [
"47982",
"48223"
],
"CVE-2020-8512": [
"47988"
],
"CVE-2020-8547": [
"47989"
],
"CVE-2019-8449": [
"47990"
],
"CVE-2018-7777": [
"47991"
],
"CVE-2020-7949": [
"48031"
],
"CVE-2020-3837": [
"48035"
],
"CVE-2020-9283": [
"48121"
],
"CVE-2020-0796": [
"48216",
"48267",
"48537"
],
"CVE-2020-9375": [
"48255"
],
"CVE-2020-5735": [
"48304"
],
"CVE-2020-3161": [
"48342"
],
"CVE-2020-8617": [
"48521"
],
"CVE-2014-2630": [
"48000"
],
"CVE-2018-11479": [
"48021"
],
"CVE-/2019-1863": [
"48052"
],
"CVE-2019-18915": [
"48057"
],
"CVE-2019-1125": [
"48071"
],
"CVE-2019-1125)": [
"48071"
],
"CVE-2020-0683": [
"48079"
],
"CVE-2019-1458": [
"48180"
],
"CVE-2020-8794": [
"48185",
"48140"
],
"CVE-2020-3950": [
"48235",
"48337"
],
"CVE-2020-2944": [
"48359"
],
"CVE-2020-12242": [
"48387"
],
"CVE-2019-15752": [
"48388"
],
"CVE-2019-3999": [
"48400"
],
"CVE-2020-12608": [
"48448"
],
"CVE-2020-5752": [
"48505",
"49211"
],
"CVE-2020-13866": [
"48573"
],
"CVE-2019-20215": [
"48037"
],
"CVE-2019-0604": [
"48053"
],
"CVE-2019-12518": [
"48092"
],
"CVE-2015-7611": [
"48130"
],
"CVE-2020-8793": [
"48139"
],
"CVE-2020-0688": [
"48153",
"48168"
],
"CVE-2020-8012": [
"48156"
],
"CVE-2020-8657": [
"48169"
],
"CVE-2020-8656": [
"48169",
"48025"
],
"CVE-2020-8655": [
"48169",
"48025"
],
"CVE-2020-8654": [
"48169",
"48025"
],
"CVE-2019-5825": [
"48183"
],
"CVE-2018-17463": [
"48184"
],
"CVE-2020-6418": [
"48186"
],
"CVE-2019-15949": [
"48191"
],
"CVE-2020-10220": [
"48223",
"48208"
],
"CVE-2020-10189": [
"48224"
],
"CVE-2019-15126": [
"48233"
],
"CVE-2020-8515": [
"48268"
],
"CVE-2019-4716": [
"48273"
],
"CVE-2019-20499": [
"48274"
],
"CVE-2020-0646": [
"48275"
],
"CVE-2020-10884": [
"48331"
],
"CVE-2020-10883": [
"48331"
],
"CVE-2020-10882": [
"48331"
],
"CVE-2020-7961": [
"48332"
],
"CVE-2018-20062": [
"48333"
],
"CVE-2020-8644": [
"48335"
],
"CVE-2018-18326": [
"48336"
],
"CVE-2018-18325": [
"48336"
],
"CVE-2018-15812": [
"48336"
],
"CVE-2018-15811": [
"48336"
],
"CVE-2017-9822": [
"48336"
],
"CVE-2019-17558": [
"48338"
],
"CVE-2020-10199": [
"48343",
"49385"
],
"CVE-2020-5849": [
"48353"
],
"CVE-2020-5847": [
"48353"
],
"CVE-2020-6857": [
"48363"
],
"CVE-2016-4437": [
"48410"
],
"CVE-2020-11652": [
"48421"
],
"CVE-2020-11651": [
"48421"
],
"CVE-2020-7209": [
"48483"
],
"CVE-2020-11108": [
"48491",
"48442",
"48443",
"48519"
],
"CVE-2020-2555": [
"48508",
"48320"
],
"CVE-2020-13166": [
"48513"
],
"CVE-2017-15889": [
"48514"
],
"CVE-2020-3956": [
"48540"
],
"CVE-2020-8495": [
"48001"
],
"CVE-2020-8493": [
"48001"
],
"CVE-2019-10716": [
"48002"
],
"CVE-2019-15975": [
"48018"
],
"CVE-2019-15984": [
"48019"
],
"CVE-2019-15976": [
"48019"
],
"CVE-2019-15978": [
"48020"
],
"CVE-2019-15977": [
"48020"
],
"CVE-2019-6146": [
"48029"
],
"CVE-2020-7108": [
"48030"
],
"CVE-2020-8839": [
"48040"
],
"CVE-2020-8825": [
"48042"
],
"CVE-2020-8947": [
"48064"
],
"CVE-2019-7004": [
"48105"
],
"CVE-2019-19774": [
"48119"
],
"CVE-2020-8819": [
"48134"
],
"CVE-2020-10173": [
"48142"
],
"CVE-2020-1938": [
"48143",
"49039"
],
"CVE-2020-8813": [
"48144",
"48145"
],
"CVE-2020-9038": [
"48147"
],
"CVE-2020-8615": [
"48151"
],
"CVE-2019-19143": [
"48152"
],
"CVE-2020-9374": [
"48155"
],
"CVE-2019-19142": [
"48158"
],
"CVE-2020-8778": [
"48162"
],
"CVE-2020-8777": [
"48162"
],
"CVE-2020-8776": [
"48162"
],
"CVE-2020-9372": [
"48204"
],
"CVE-2020-9371": [
"48204"
],
"CVE-2020-10221": [
"48207"
],
"CVE-2020-8866": [
"48209",
"48210"
],
"CVE-2020-8865": [
"48209",
"48210"
],
"CVE-2020-10230": [
"48212"
],
"CVE-2020-8518": [
"48215"
],
"CVE-2020-10387": [
"48220"
],
"CVE-2020-10386": [
"48221"
],
"CVE-2020-10879": [
"48241"
],
"CVE-2020-12704": [
"48244"
],
"CVE-2020-10385": [
"48245"
],
"CVE-2020-5722": [
"48247"
],
"CVE-2020-12707": [
"48250"
],
"CVE-2020-5726": [
"48270"
],
"CVE-2020-11456": [
"48289"
],
"CVE-2019-18426": [
"48295"
],
"CVE-2020-11455": [
"48297"
],
"CVE-2020-11457": [
"48300"
],
"CVE-2019-20085": [
"48311"
],
"CVE-2019-16383": [
"48316"
],
"CVE-2020-12706": [
"48404"
],
"CVE-2019-0235": [
"48408"
],
"CVE-2020-11530": [
"48457"
],
"CVE-2019-15253": [
"48459"
],
"CVE-2019-16112": [
"48462"
],
"CVE-2019-15083": [
"48473"
],
"CVE-2020-13118": [
"48474"
],
"CVE-2019-3025": [
"48477"
],
"CVE-2020-12882": [
"48488"
],
"CVE-2020-13144": [
"48500"
],
"CVE-2020-12261": [
"48516"
],
"CVE-2020-13693": [
"48534"
],
"CVE-2020-3952": [
"48535"
],
"CVE-2020-13448": [
"48536"
],
"CVE-2020-10596": [
"48539"
],
"CVE-2019-17525": [
"48551"
],
"CVE-2019-16294": [
"47393"
],
"CVE-2020-14011": [
"48618"
],
"CVE-2020-14930": [
"48196"
],
"CVE-2020-12712": [
"48587"
],
"CVE-2019-16701": [
"47413"
],
"CVE-2019-16902": [
"47443"
],
"CVE-2019-12765": [
"48198"
],
"CVE-2020-7030": [
"48581"
],
"CVE-2020-13228": [
"48582"
],
"CVE-2020-5515": [
"48590"
],
"CVE-2019-12905": [
"48607"
],
"CVE-2019-12461": [
"48611"
],
"CVE-2019-12460": [
"48612"
],
"CVE-2020-14943": [
"48619"
],
"CVE-2020-13379": [
"48638"
],
"CVE-2020-15956": [
"48731"
],
"CVE-2020-35488": [
"49283"
],
"CVE-2020-0674": [
"49062",
"49863"
],
"CVE-2020-17382": [
"48836"
],
"CVE-2020-15238": [
"48963"
],
"CVE-2020-14425": [
"48982"
],
"CVE-2020-13152": [
"48993"
],
"CVE-2018-9958)": [
"49116"
],
"CVE-2020-6519": [
"49195"
],
"CVE-2020-28169": [
"49363"
],
"CVE-2018-16156": [
"49382"
],
"CVE-2020-7384": [
"49491"
],
"CVE-2021-3156": [
"49521",
"49522"
],
"CVE-2021-3394": [
"49530"
],
"CVE-2021-27928": [
"49765"
],
"CVE-2019-17026": [
"49864"
],
"CVE-2021-21551": [
"49893"
],
"CVE-2020-15261": [
"49925"
],
"CVE-2020-0618": [
"48816"
],
"CVE-2020-15688": [
"48958"
],
"CVE-2020-26887": [
"49293"
],
"CVE-2018-11311": [
"48620"
],
"CVE-2019-16116": [
"48657"
],
"CVE-2020-7115": [
"48661"
],
"CVE-2020-13151": [
"49067"
],
"CVE-2019-0230": [
"49068"
],
"CVE-2020-1472": [
"49071"
],
"CVE-2020-25988": [
"49075"
],
"CVE-2020-16602": [
"49106"
],
"CVE-2019-7214": [
"49216"
],
"CVE-2020-14871": [
"49261",
"49896",
"50039"
],
"CVE-2020-13160": [
"49613"
],
"CVE-2021-26855": [
"49663",
"49637",
"49879",
"49895"
],
"CVE-2020-16040": [
"49745"
],
"CVE-2020-6507": [
"49746"
],
"CVE-2020-12352": [
"49754"
],
"CVE-2020-12351": [
"49754"
],
"CVE-2011-2523": [
"49757"
],
"CVE-2020-24881": [
"49441"
],
"CVE-2020-25901": [
"49299"
],
"CVE-2020-14008": [
"48793"
],
"CVE-2020-6862": [
"48801"
],
"CVE-2020-13260": [
"48807"
],
"CVE-2020-13259": [
"48809"
],
"CVE-2020-25540": [
"48812"
],
"CVE-2020-23835": [
"48813"
],
"CVE-2020-9467": [
"48814"
],
"CVE-2020-11804": [
"48817"
],
"CVE-2020-11803": [
"48817"
],
"CVE-2020-11700": [
"48817"
],
"CVE-2020-11699": [
"48817"
],
"CVE-2019-15715": [
"48818"
],
"CVE-2020-25453": [
"48820"
],
"CVE-2020-15921": [
"48823"
],
"CVE-2018-17431": [
"48825"
],
"CVE-2020-35241": [
"48826"
],
"CVE-2020-15922": [
"48835"
],
"CVE-2020-15930": [
"48837"
],
"CVE-2020-26567": [
"48863"
],
"CVE-2019-19493": [
"48864"
],
"CVE-2020-3452": [
"48871",
"48722",
"49262"
],
"CVE-2020-25762": [
"48889"
],
"CVE-2020-24219": [
"48899"
],
"CVE-2020-24217": [
"48900",
"48901"
],
"CVE-2020-24215": [
"48902"
],
"CVE-2020-24214": [
"48903"
],
"CVE-2020-25270": [
"48905"
],
"CVE-2020-25790": [
"48906"
],
"CVE-2019-17240": [
"48942",
"48746"
],
"CVE-2017-16783": [
"48944"
],
"CVE-2020-5791": [
"48959"
],
"CVE-2020-14864": [
"48964"
],
"CVE-2020-27533": [
"48974"
],
"CVE-2020-25015": [
"49000"
],
"CVE-2020-28328": [
"49001"
],
"CVE-2020-28249": [
"49024"
],
"CVE-2020-28351": [
"49026"
],
"CVE-2020-15255": [
"49027"
],
"CVE-2020-26218": [
"49040"
],
"CVE-2020-15478": [
"49044"
],
"CVE-2020-5295": [
"49045"
],
"CVE-2021-27370": [
"49582"
],
"CVE-2020-5902": [
"48642",
"48711"
],
"CVE-2018-12031": [
"48614"
],
"CVE-2020-15599": [
"48626"
],
"CVE-2020-14947": [
"48634"
],
"CVE-2020-23934": [
"48636"
],
"CVE-2019-3759": [
"48639"
],
"CVE-ve-2020-59": [
"48643"
],
"CVE-2020-14945": [
"48649"
],
"CVE-2020-15046": [
"48652",
"48668"
],
"CVE-2020-14944": [
"48653"
],
"CVE-2019-5029": [
"48654"
],
"CVE-2020-24363": [
"49092"
],
"CVE-2020-11698": [
"48856"
],
"CVE-2020-14946": [
"48666"
],
"CVE-2020-8605": [
"48667"
],
"CVE-2020-14461": [
"48669"
],
"CVE-2020-15600": [
"48679"
],
"CVE-2020-7680": [
"48681"
],
"CVE-2020-15364": [
"48682"
],
"CVE-2020-15363": [
"48682"
],
"CVE-2016-9488": [
"48692"
],
"CVE-2020-15492": [
"48693"
],
"CVE-2019-19985": [
"48698"
],
"CVE-2019-20361": [
"48699"
],
"CVE-2020-11749": [
"48707"
],
"CVE-2020-15050": [
"48708"
],
"CVE-2019-16667": [
"48714"
],
"CVE-2020-8163": [
"48716"
],
"CVE-2020-3187": [
"48723"
],
"CVE-2020-15038": [
"48724"
],
"CVE-2020-8816": [
"48727"
],
"CVE-2020-17506": [
"48744"
],
"CVE-2020-1147": [
"48747"
],
"CVE-2020-24609": [
"48753",
"48785"
],
"CVE-2020-15920": [
"48768"
],
"CVE-2020-24223": [
"48777"
],
"CVE-2020-11819": [
"48784",
"49238"
],
"CVE-2020-25820": [
"49070"
],
"CVE-2020-28092": [
"49072"
],
"CVE-2018-13382": [
"49074"
],
"CVE-2020-28091": [
"49073"
],
"CVE-2020-24365": [
"49079"
],
"CVE-2020-29233": [
"49085"
],
"CVE-2020-7934": [
"49091"
],
"CVE-2020-29475": [
"49093"
],
"CVE-2020-13951": [
"49094"
],
"CVE-2019-12725": [
"49096",
"49862"
],
"CVE-2020-29471": [
"49098"
],
"CVE-2020-29470": [
"49099"
],
"CVE-2020-10963": [
"49112"
],
"CVE-2020-16171": [
"49113"
],
"CVE-2020-24963": [
"49122"
],
"CVE-2020-23972": [
"49129"
],
"CVE-2020-29395": [
"49130"
],
"CVE-2020-29240": [
"49137"
],
"CVE-2020-35313": [
"49154"
],
"CVE-2020-35314": [
"49155"
],
"CVE-2020-14073": [
"49156"
],
"CVE-2020-29469": [
"49164"
],
"CVE-2020-28688": [
"49166"
],
"CVE-2020-28687": [
"49167"
],
"CVE-2020-27423": [
"49173"
],
"CVE-2020-27422": [
"49174"
],
"CVE-2020-25213": [
"49178",
"51224"
],
"CVE-2020-29477": [
"49188"
],
"CVE-2020-28976": [
"49189"
],
"CVE-2020-28977": [
"49189"
],
"CVE-2020-28978": [
"49189"
],
"CVE-2020-2229": [
"49232"
],
"CVE-2020-2230": [
"49237"
],
"CVE-2020-2231": [
"49244"
],
"CVE-2018-19585": [
"49257",
"49334"
],
"CVE-2018-19571": [
"49257",
"49334"
],
"CVE-2020-8639": [
"49561"
],
"CVE-2020-35416": [
"49281"
],
"CVE-2020-25495": [
"49300"
],
"CVE-2020-25494": [
"49301"
],
"CVE-2020-20140": [
"49302"
],
"CVE-2020-20141": [
"49303"
],
"CVE-2020-20142": [
"49304"
],
"CVE-2020-20139": [
"49305"
],
"CVE-2020-35151": [
"49307"
],
"CVE-2020-23839": [
"49726"
],
"CVE-2019-6715&": [
"49317"
],
"CVE-2020-35606": [
"49318"
],
"CVE-2020-35665": [
"49330"
],
"CVE-2019-16223": [
"49338"
],
"CVE-2020-28413": [
"49340"
],
"CVE-2020-35598": [
"49343"
],
"CVE-2020-35437": [
"49346"
],
"CVE-2020-29597": [
"49351"
],
"CVE-2020-35729": [
"49366",
"49474"
],
"CVE-2021-3018": [
"49372"
],
"CVE-2020-35737": [
"49378"
],
"CVE-2019-11229": [
"49383"
],
"CVE-2020-17519": [
"49398"
],
"CVE-2020-35578": [
"49422"
],
"CVE-2021-3129": [
"49424"
],
"CVE-2021-1167": [
"49425"
],
"CVE-2020-35687": [
"49426"
],
"CVE-2020-35749": [
"49450",
"50721"
],
"CVE-2020-23342": [
"49451"
],
"CVE-2021-2109": [
"49461"
],
"CVE-2021-3298": [
"49468"
],
"CVE-2021-3294": [
"49469"
],
"CVE-2021-3186": [
"49478"
],
"CVE-2020-14882": [
"49479"
],
"CVE-2020-25557": [
"49485"
],
"CVE-2020-25538": [
"49485"
],
"CVE-2020-35754": [
"49494"
],
"CVE-2021-3337": [
"49496"
],
"CVE-2021-3317": [
"49511"
],
"CVE-2019-89242": [
"49512"
],
"CVE-2020-23522": [
"49519"
],
"CVE-2021\u00e2\u0080\u0093267": [
"49529"
],
"CVE-2020-18724": [
"49536"
],
"CVE-2020-18723": [
"49537"
],
"CVE-2020-22841": [
"49551"
],
"CVE-2021-3355": [
"49598"
],
"CVE-2021-3378": [
"49600"
],
"CVE-2021-21972": [
"49602",
"50056"
],
"CVE-2020-25787": [
"49606"
],
"CVE-2021-3291": [
"49608"
],
"CVE-2021-27885": [
"49614"
],
"CVE-2020-14181": [
"49633"
],
"CVE-2021-27065": [
"49637"
],
"CVE-2021-26830": [
"49642"
],
"CVE-2021-27695": [
"49649"
],
"CVE-2021-27964": [
"49651"
],
"CVE-2021-28379": [
"49659"
],
"CVE-2019-12962": [
"49669"
],
"CVE-2021-27890": [
"49696"
],
"CVE-2021-27889": [
"49696"
],
"CVE-2021-27946": [
"49699"
],
"CVE-2018-14009": [
"49705"
],
"CVE-2012-6708": [
"49708"
],
"CVE-2020-14209": [
"49711"
],
"CVE-2021-3111": [
"49721"
],
"CVE-2017-15950": [
"49725"
],
"CVE-2021-22986": [
"49738"
],
"CVE-2020-14166": [
"49748"
],
"CVE-2021-30150": [
"49749"
],
"CVE-2020-5377": [
"49750"
],
"CVE-2021-30147": [
"49752"
],
"CVE-2021-30149": [
"49753"
],
"CVE-2020-15160": [
"49755"
],
"CVE-2020-29238": [
"49760"
],
"CVE-2020-35775": [
"49762"
],
"CVE-2021-28142": [
"49763"
],
"CVE-2021-29003": [
"49764"
],
"CVE-2020-11022": [
"49766"
],
"CVE-2020-11023": [
"49767"
],
"CVE-2021-26929": [
"49769"
],
"CVE-2020-15500": [
"49771"
],
"CVE-2021-30637": [
"49772"
],
"CVE-2021-31152": [
"49775"
],
"CVE-2021-3138": [
"49780"
],
"CVE-2021-30044": [
"49781"
],
"CVE-2021-31327": [
"49795"
],
"CVE-2021-30042": [
"49795"
],
"CVE-2021-30039": [
"49795"
],
"CVE-2021-30034": [
"49795"
],
"CVE-2021-30030": [
"49795"
],
"CVE-2021-31329": [
"49795"
],
"CVE-2021-25679": [
"49785"
],
"CVE-2021-25680": [
"49786"
],
"CVE-2021-25681": [
"49787"
],
"CVE-2021-21425": [
"49788"
],
"CVE-2021-28935": [
"49793"
],
"CVE-2021-3318": [
"49799"
],
"CVE-2021-28419": [
"49804"
],
"CVE-2021-29460": [
"49808"
],
"CVE-2020-14295": [
"49810"
],
"CVE-2019-3810": [
"49814"
],
"CVE-2021-27973": [
"49818"
],
"CVE-2021-28242": [
"49840"
],
"CVE-2020-28337": [
"49856"
],
"CVE-2021-31933": [
"49867"
],
"CVE-2018-19422": [
"49876"
],
"CVE-2021-24245": [
"49880"
],
"CVE-2021-33561": [
"49901"
],
"CVE-2021-33562": [
"49901"
],
"CVE-2019-19208": [
"49902"
],
"CVE-2021-24299": [
"49903"
],
"CVE-2018-19423": [
"49907"
],
"CVE-2020-29607": [
"49909"
],
"CVE-2021-33570": [
"49910"
],
"CVE-2020-24949": [
"49911"
],
"CVE-2021-24308": [
"49912"
],
"CVE-2017-14535": [
"49913"
],
"CVE-2017-14537": [
"49914"
],
"CVE-2018-16167": [
"49918"
],
"CVE-2021-3560": [
"50011"
],
"CVE-2021-35448": [
"50047"
],
"CVE-2021-34110": [
"50083"
],
"CVE-2021-22555": [
"50135"
],
"CVE-2021-35312": [
"50184"
],
"CVE-2018-20523": [
"50188"
],
"CVE-2020-5147": [
"50212"
],
"CVE-2020-5147)": [
"50212"
],
"CVE-2020-11107": [
"50337"
],
"CVE-2021-22557": [
"50385"
],
"CVE-2021-43326": [
"50642"
],
"CVE-2021-4034": [
"50689"
],
"CVE-2022-0847": [
"50808"
],
"CVE-2022-25090": [
"50812"
],
"CVE-2022-23909": [
"50852"
],
"CVE-2021-43149": [
"50858"
],
"CVE-2021-22204": [
"50911"
],
"CVE-2021-44595": [
"50912"
],
"CVE-2021-31251": [
"49936"
],
"CVE-2019-6447": [
"50070"
],
"CVE-2021-25155": [
"50133",
"50136"
],
"CVE-2021-25162": [
"50136"
],
"CVE-2021-25161": [
"50136"
],
"CVE-2021-25160": [
"50136"
],
"CVE-2021-25159": [
"50136"
],
"CVE-2021-25158": [
"50136"
],
"CVE-2021-25157": [
"50136"
],
"CVE-2021-25156": [
"50136"
],
"CVE-2021-42165": [
"50351"
],
"CVE-2021-40859": [
"50569"
],
"CVE-2021-38759": [
"50576"
],
"CVE-2021-45043": [
"50588"
],
"CVE-2021-44228": [
"50590",
"50592"
],
"CVE-2019-16516": [
"50618"
],
"CVE-2021-35380": [
"50638"
],
"CVE-2021-43857": [
"50640"
],
"CVE-2022-22836": [
"50652"
],
"CVE-2022-21371": [
"50688"
],
"CVE-2022-25359": [
"50783"
],
"CVE-2022-25089": [
"50798"
],
"CVE-2020-17456": [
"50821"
],
"CVE-2022-24112": [
"50829"
],
"CVE-2022-27226": [
"50832"
],
"CVE-2021-44529": [
"50833"
],
"CVE-2019\u00e2\u0080\u0093919": [
"50847"
],
"CVE-2019-17124": [
"50848"
],
"CVE-2021-36356": [
"50856"
],
"CVE-2021-35064": [
"50856"
],
"CVE-2021-43009": [
"50857"
],
"CVE-2021-46417": [
"50861"
],
"CVE-2021-4039": [
"50870"
],
"CVE-2021-42697": [
"50892"
],
"CVE-cve 2021-4": [
"50897"
],
"CVE-2022-28213": [
"50900"
],
"CVE-2022-29457": [
"50904"
],
"CVE-2021-46378": [
"50906"
],
"CVE-2021-46379": [
"50907"
],
"CVE-2021-44596": [
"50913"
],
"CVE-2022-1388": [
"50932"
],
"CVE-2022-24706": [
"50914"
],
"CVE-2019-13720": [
"50917"
],
"CVE-2022-30286": [
"50918"
],
"CVE-2021-46381": [
"50919"
],
"CVE-2021-43164": [
"50930"
],
"CVE-2021-46422": [
"50936",
"50948"
],
"CVE-2022-29303": [
"50940"
],
"CVE-2021-31762": [
"50126"
],
"CVE-2021-31682": [
"50463"
],
"CVE-2021-22146": [
"50152"
],
"CVE-2020-13927": [
"49927"
],
"CVE-2020-11978": [
"49927"
],
"CVE-2014-8722": [
"49928"
],
"CVE-2021-21337": [
"49930"
],
"CVE-2021-28417": [
"49931"
],
"CVE-2021-28418": [
"49932"
],
"CVE-2021-28420": [
"49935"
],
"CVE-2021-31642": [
"49937"
],
"CVE-2021-27519": [
"49942"
],
"CVE-2021-27520": [
"49943"
],
"CVE-2021-27308": [
"49945"
],
"CVE-2018-6383": [
"49949"
],
"CVE-2021-22911": [
"49960"
],
"CVE-2021-29440": [
"49961"
],
"CVE-2020-24186": [
"49962",
"49967"
],
"CVE-2021-32403": [
"49969"
],
"CVE-2021-33904": [
"49980"
],
"CVE-2019-25046": [
"49981"
],
"CVE-2021-31950": [
"49982"
],
"CVE-2017-9380": [
"49983"
],
"CVE-2021-24174": [
"49984"
],
"CVE-2021-34370": [
"49990"
],
"CVE-2021-34369": [
"49991"
],
"CVE-2020-11060": [
"49992"
],
"CVE-2018-15139": [
"49998",
"50122"
],
"CVE-2021-31159": [
"50027"
],
"CVE-2021-32305": [
"50042"
],
"CVE-2021-24383": [
"50051"
],
"CVE-2021-26078": [
"50068"
],
"CVE-2020-35948": [
"50077"
],
"CVE-2020-7750": [
"50079"
],
"CVE-2021-35956": [
"50080"
],
"CVE-2021-24145": [
"50082"
],
"CVE-2021-24146": [
"50084"
],
"CVE-2021-24155": [
"50093"
],
"CVE-2021-42071": [
"50098"
],
"CVE-2019-14322": [
"50101"
],
"CVE-2018-11784": [
"50118"
],
"CVE-2019-0221": [
"50119"
],
"CVE-2021-42362": [
"50129"
],
"CVE-2021-35464": [
"50131"
],
"CVE-2020-6010": [
"50137"
],
"CVE-2021-37593": [
"50142"
],
"CVE-2021-31761": [
"50144"
],
"CVE-2021-22145": [
"50149"
],
"CVE-2021-29995": [
"50166"
],
"CVE-2020-9496": [
"50178"
],
"CVE-2021-20837": [
"50464"
],
"CVE-2021-36654": [
"50179"
],
"CVE-2020-35848": [
"50185"
],
"CVE-2020-35847": [
"50185"
],
"CVE-2021-37425": [
"50191"
],
"CVE-2021-3441": [
"50227"
],
"CVE-2019-18818": [
"50237",
"50716"
],
"CVE-2019-19609": [
"50238"
],
"CVE-2020-5811": [
"50241"
],
"CVE-2021-34621": [
"50242"
],
"CVE-2021-26084": [
"50243"
],
"CVE-2021-40378": [
"50250"
],
"CVE-2021-40379": [
"50251"
],
"CVE-2021-40380": [
"50252"
],
"CVE-2021-40381": [
"50253"
],
"CVE-2021-40382": [
"50254"
],
"CVE-2021-40651": [
"50259"
],
"CVE-2021-40352": [
"50260"
],
"CVE-2021-39608": [
"50262"
],
"CVE-2021-36260": [
"50441"
],
"CVE-2021-34646": [
"50299"
],
"CVE-2021-29447": [
"50304"
],
"CVE-2019-13358": [
"50316"
],
"CVE-2021-40868": [
"50317"
],
"CVE-2021-40875": [
"50320"
],
"CVE-2021-24169": [
"50324"
],
"CVE-2021-24272": [
"50325"
],
"CVE-2021-24610": [
"50343"
],
"CVE-2021-24276": [
"50344"
],
"CVE-2021-24274": [
"50345"
],
"CVE-2021-24275": [
"50346"
],
"CVE-2021-24287": [
"50349"
],
"CVE-2021-24286": [
"50350"
],
"CVE-2021-41318": [
"50366"
],
"CVE-2021-41381": [
"50371"
],
"CVE-2021-26085": [
"50377"
],
"CVE-2021-26086": [
"50380"
],
"CVE-2021-39327": [
"50382"
],
"CVE-2021-41773": [
"50383",
"50512"
],
"CVE-2021-42053": [
"50393"
],
"CVE-2021-32172": [
"50394"
],
"CVE-2020-10770": [
"50405"
],
"CVE-2021-42013": [
"50406",
"50446",
"50512"
],
"CVE-2021-20031": [
"50414"
],
"CVE-2021-41878": [
"50418"
],
"CVE-2020-11738": [
"50420"
],
"CVE-2018-16060": [
"50422"
],
"CVE-2018-16061": [
"50423"
],
"CVE-2021-41382": [
"50426"
],
"CVE-2021-24719": [
"50427"
],
"CVE-2021-42566": [
"50428"
],
"CVE-2021-42565": [
"50428"
],
"CVE-2021-20034": [
"50430"
],
"CVE-2021-28164": [
"50438"
],
"CVE-2021-24444": [
"50442"
],
"CVE-2021-43339": [
"50468"
],
"CVE-2021-43338": [
"50469"
],
"CVE-2021-34429": [
"50478"
],
"CVE-2021-29156": [
"50480"
],
"CVE-2021-42325": [
"50502"
],
"CVE-2021-43405": [
"50505"
],
"CVE-2021-43136": [
"50513"
],
"CVE-2021-24664": [
"50520"
],
"CVE-2021-43140": [
"50522"
],
"CVE-2021-43617": [
"50525"
],
"CVE-2021-42580": [
"50526"
],
"CVE-2021-35323": [
"50529"
],
"CVE-2021-42840": [
"50531"
],
"CVE-2021-22205": [
"50532"
],
"CVE-2021-43650": [
"50542"
],
"CVE-2021-44655": [
"50560"
],
"CVE-2021-40577": [
"50557"
],
"CVE-2021-44653": [
"50561"
],
"CVE-2021-39316": [
"50564"
],
"CVE-2021-44673": [
"50570"
],
"CVE-2020-23935": [
"50579"
],
"CVE-2021-43798": [
"50581"
],
"CVE-2021-43936": [
"50589"
],
"CVE-2021-44848": [
"50601"
],
"CVE-2021-3817": [
"50609"
],
"CVE-2021-24750": [
"50619"
],
"CVE-2021-39312": [
"50624"
],
"CVE-2021-45425": [
"50626"
],
"CVE-2021-45814": [
"50627"
],
"CVE-2021-44916": [
"50651"
],
"CVE-2021-24563": [
"50655"
],
"CVE-2022-21661": [
"50663"
],
"CVE-2022-23178": [
"50675"
],
"CVE-2022-23046": [
"50684"
],
"CVE-2021-24904": [
"50685"
],
"CVE-2021-24862": [
"50686"
],
"CVE-2021-24946": [
"50687"
],
"CVE-2021-37391": [
"50694"
],
"CVE-2021-24786": [
"50695"
],
"CVE-2021-24926": [
"50697"
],
"CVE-2015-9323": [
"50698"
],
"CVE-2022-0332": [
"50700"
],
"CVE-2017-9841": [
"50702"
],
"CVE-2021-24247": [
"50703"
],
"CVE-2021-24300": [
"50704"
],
"CVE-2021-24488": [
"50705"
],
"CVE-2022-0377": [
"50706"
],
"CVE-2022-22833": [
"50712"
],
"CVE-2022-22832": [
"50713"
],
"CVE-2022-22831": [
"50714"
],
"CVE-2021-46398": [
"50717"
],
"CVE-2022-24263": [
"50718"
],
"CVE-2021-24901": [
"50723"
],
"CVE-2022-0448": [
"50724"
],
"CVE-2022-24223": [
"50727"
],
"CVE-2022-23366": [
"50729"
],
"CVE-2021-24931": [
"50733"
],
"CVE-2021-45901": [
"50741"
],
"CVE-2021-24966": [
"50746"
],
"CVE-2022-0441": [
"50752"
],
"CVE-2022-22909": [
"50754"
],
"CVE-2021-43062": [
"50759"
],
"CVE-2021-24762": [
"50766"
],
"CVE-2022-0557": [
"50768"
],
"CVE-2021-45092": [
"50770"
],
"CVE-2021-46354": [
"50771"
],
"CVE-2021-25076": [
"50772"
],
"CVE-2022-25241": [
"50774"
],
"CVE-2022-24124": [
"50792"
],
"CVE-2021-44665": [
"50794"
],
"CVE-2021-44664": [
"50795"
],
"CVE-2021-46387": [
"50797"
],
"CVE-2022-22947": [
"50799"
],
"CVE-2022-0848": [
"50800"
],
"CVE-2022-0824": [
"50809"
],
"CVE-2022-26965": [
"50826"
],
"CVE-2021-45010": [
"50828"
],
"CVE-2021-40964": [
"50828"
],
"CVE-2021-26599": [
"50839"
],
"CVE-2021-43701": [
"50846"
],
"CVE-2021-24405": [
"50849"
],
"CVE-2021\u00e2\u0080\u0093421": [
"50850"
],
"CVE-2022-1163": [
"50853"
],
"CVE-2022-26180": [
"50854"
],
"CVE-2021-46416": [
"50860"
],
"CVE-2021-46418": [
"50862"
],
"CVE-2021-46419": [
"50863"
],
"CVE-2022-0482": [
"50871"
],
"CVE-2021-42136": [
"50877"
],
"CVE-2022-24181": [
"50881"
],
"CVE-2022-1162": [
"50888"
],
"CVE-2022-1175": [
"50889"
],
"CVE-2021-43481": [
"50893"
],
"CVE-2022-1103": [
"50895"
],
"CVE-2021-31674": [
"50908"
],
"CVE-2021-31673": [
"50909"
],
"CVE-2022-24707": [
"50915"
],
"CVE-2021-45428": [
"50931"
],
"CVE-2022-27412": [
"50920"
],
"CVE-2022-28117": [
"50921"
],
"CVE-2022-27308": [
"50922"
],
"CVE-2022-24734": [
"50924"
],
"CVE-2021-24581": [
"50925"
],
"CVE-2022-28079": [
"50933"
],
"CVE-2022-28080": [
"50934"
],
"CVE-2021-46424": [
"50935"
],
"CVE-2022-29727": [
"50937"
],
"CVE-2022-0967": [
"50941"
],
"CVE-2022-23626": [
"50943"
],
"CVE-2022-30525": [
"50946"
],
"CVE-2022-29298": [
"50950"
],
"CVE-2022-1588": [
"50945"
],
"CVE-2022-1631": [
"50947"
],
"CVE-2022-23854": [
"51028"
],
"CVE-2022-32429": [
"51027"
],
"CVE-2022-37661": [
"51031"
],
"CVE-2022-30075": [
"50962"
],
"CVE-2022-29593": [
"50984"
],
"CVE-2022-29301": [
"50968"
],
"CVE-2022-29299": [
"50967"
],
"CVE-2022-1040": [
"51006"
],
"CVE-2021-4045": [
"51017"
],
"CVE-2022-34047": [
"50991"
],
"CVE-2022-34048": [
"50989"
],
"CVE-2022-34046": [
"50990"
],
"CVE-2022-26134": [
"50952"
],
"CVE-2022-36267": [
"51011"
],
"CVE-2020-20277": [
"51000"
],
"CVE-2022-36446": [
"50998"
],
"CVE-2022-35513": [
"51014"
],
"CVE-2021-23017": [
"50973"
],
"CVE-2020-2038": [
"51005"
],
"CVE-2022-23642": [
"50964"
],
"CVE-2022-36633": [
"51019"
],
"CVE-2022-29296": [
"50955"
],
"CVE-2022-2651": [
"51013"
],
"CVE-2022-30781": [
"51009"
],
"CVE-2021-36711": [
"50979"
],
"CVE-2021-42751": [
"51004"
],
"CVE-2021-42750": [
"51003"
],
"CVE-2022-31325": [
"50965"
],
"CVE-2022-31854": [
"50978"
],
"CVE-2022-34140": [
"51018",
"51002"
],
"CVE-2022-33098": [
"50976"
],
"CVE-2022-24637": [
"51026"
],
"CVE-2020-5844": [
"50961"
],
"CVE-2022-31814": [
"51032"
],
"CVE-2022-31101": [
"51001"
],
"CVE-2022-2551": [
"50992"
],
"CVE-2022-2552": [
"50993"
],
"CVE-2022-2941": [
"51020"
],
"CVE-2022-2840": [
"51024"
],
"CVE-2022-29548": [
"50970"
],
"CVE-2022-35411": [
"50983"
],
"CVE-2022-31188": [
"51030"
],
"CVE-2022-35899": [
"50985"
],
"CVE-2022-37197": [
"51029"
],
"CVE-2022-24562": [
"50974"
],
"CVE-2022-31886": [
"50957"
],
"CVE-2022-31885": [
"50956"
],
"CVE-2021-37589": [
"50958"
],
"CVE-2022-2591": [
"51438"
],
"CVE-2022-30076": [
"51335"
],
"CVE-2022-45297": [
"51154"
],
"CVE-2022-36664": [
"51055"
],
"CVE-2022-35583": [
"51039"
],
"CVE-2022-35543": [
"51200"
],
"CVE-2022-41441": [
"51118"
],
"CVE-2022-47076": [
"51539"
],
"CVE-2022-47075": [
"51539"
],
"CVE-2022-40319": [
"51149"
],
"CVE-2022-39195": [
"51148"
],
"CVE-2020-11798": [
"51308"
],
"CVE-2023-26692": [
"51347"
],
"CVE-2024-24747": [
"51976"
],
"CVE-2023-0744": [
"51257"
],
"CVE-2023-34927": [
"51961"
],
"CVE-2024-27620": [
"51869"
],
"CVE-2022-35919": [
"51734"
],
"CVE-2023-32751": [
"51497"
],
"CVE-2023-32750": [
"51498"
],
"CVE-2023-32749": [
"51496"
],
"CVE-2022-40946": [
"51053"
],
"CVE-2022-41333": [
"51326"
],
"CVE-2023-24709": [
"51356"
],
"CVE-2022-46770": [
"51157"
],
"CVE-2023-36355": [
"51561"
],
"CVE-2023-30350": [
"51414"
],
"CVE-2023-26609": [
"51294"
],
"CVE-2022-45701": [
"51269"
],
"CVE-2022-46552": [
"51243"
],
"CVE-2020-5330": [
"51248"
],
"CVE-2019-15993": [
"51248"
],
"CVE-2023-0830": [
"51266"
],
"CVE-2024-27356": [
"51942"
],
"CVE-2022-28171": [
"51607"
],
"CVE-2023-6538": [
"51915"
],
"CVE-2023-3710": [
"51885"
],
"CVE-2022-44149": [
"51195"
],
"CVE-2023-25187": [
"51535"
],
"CVE-2023-27823": [
"51444"
],
"CVE-2023-27100": [
"51352"
],
"CVE-2023-48974": [
"51963"
],
"CVE-2023-29849": [
"51378"
],
"CVE-2023-29848": [
"51377"
],
"CVE-2023-0943": [
"51280"
],
"CVE-2023-46022": [
"51912"
],
"CVE-2023-31698": [
"51476"
],
"CVE-2023-38836": [
"51741"
],
"CVE-2022-3552": [
"51108"
],
"CVE-2023-36163": [
"51581"
],
"CVE-2022-35155": [
"51054"
],
"CVE-2023-39362": [
"51740"
],
"CVE-2022-46169": [
"51166"
],
"CVE-2022-2846": [
"51241"
],
"CVE-2023-39115": [
"51656"
],
"CVE-2023-31714": [
"51383"
],
"CVE-2023-24787": [
"51319"
],
"CVE-2023-31699": [
"51477"
],
"CVE-2023-25440": [
"51478"
],
"CVE-2022-48110": [
"51260"
],
"CVE-2023-4708": [
"51729"
],
"CVE-2023-7137": [
"51880"
],
"CVE-2023-29809": [
"51422"
],
"CVE-2023-3244": [
"51809"
],
"CVE-2023-3244)": [
"51809"
],
"CVE-2023-29983": [
"51417"
],
"CVE-2021-46360": [
"51060"
],
"CVE-2022-44877": [
"51250"
],
"CVE-2023-4407": [
"51701"
],
"CVE-2023-37759": [
"51688"
],
"CVE-2024-24496": [
"51954"
],
"CVE-2024-24495": [
"51953"
],
"CVE-2024-24494": [
"51952"
],
"CVE-2024-25832": [
"51868"
],
"CVE-2024-25830": [
"51868"
],
"CVE-2022-24632": [
"51145"
],
"CVE-2022-24630": [
"51145"
],
"CVE-2022-24629": [
"51145"
],
"CVE-2022-24627": [
"51145"
],
"CVE-2022-28368": [
"51270"
],
"CVE-2023-37569": [
"51673"
],
"CVE-2022-3141": [
"51043"
],
"CVE-2023-30868": [
"51507"
],
"CVE-2023-0455": [
"51492"
],
"CVE-2023-39147": [
"51639"
],
"CVE-2023-39796": [
"51985"
],
"CVE-2023-30256": [
"51465"
],
"CVE-2023-34635": [
"51610"
],
"CVE-2023-37269": [
"51591"
],
"CVE-2022-4395": [
"51959"
],
"CVE-2023-2636": [
"51632"
],
"CVE-2023-3452)": [
"51826"
],
"CVE-2022-4953": [
"51716"
],
"CVE-2023-2796": [
"51658"
],
"CVE-2023-3219": [
"51659"
],
"CVE-2023-4278": [
"51735"
],
"CVE-2023-37979": [
"51644"
],
"CVE-2020-11027": [
"51531"
],
"CVE-2021-24499": [
"51510"
],
"CVE-2022-1565": [
"51122"
],
"CVE-2022-4297": [
"51560"
],
"CVE-2022-25148": [
"51711"
],
"CVE-2023-3320": [
"51533"
],
"CVE-2022-48177": [
"51346"
],
"CVE-2022-48178": [
"51345"
],
"CVE-2022-48197": [
"51198"
],
"CVE-2024-32113": [
"52020"
],
"CVE-2022-35914": [
"52023"
],
"CVE-2024-34241": [
"52018"
],
"CVE-2024-33559": [
"52019"
],
"CVE-2023-26602": [
"52033"
],
"CVE-2023-27636": [
"52035"
],
"CVE-2022-23409": [
"52034"
],
"CVE-2021-38283": [
"52032"
],
"CVE-2024-28999": [
"52055"
],
"CVE-2024-40422": [
"52066"
]
} ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359319.0
pyexploitdb-0.3.21/pyexploitdb/edbidToCve.json 0000644 0001751 0001751 00005134501 15164352527 021077 0 ustar 00runner runner {
"9": [
"CVE-2003-0132"
],
"37060": [],
"11": [
"CVE-2003-0132"
],
"13": [],
"17": [],
"22": [
"CVE-2003-0276"
],
"35": [
"CVE-2003-0226"
],
"38": [
"CVE-2003-0245"
],
"59": [
"CVE-2003-0567"
],
"60": [
"CVE-2003-0567"
],
"61": [
"CVE-2003-0605"
],
"62": [
"CVE-2003-0567"
],
"65": [
"CVE-2003-0232"
],
"68": [
"CVE-2003-0619"
],
"73": [
"CVE-2002-1487"
],
"82": [],
"94": [],
"111": [
"CVE-2003-0717"
],
"113": [
"CVE-2003-0714"
],
"115": [
"CVE-2003-0854"
],
"146": [
"CVE-2003-0543"
],
"147": [
"CVE-2004-2099"
],
"148": [],
"153": [
"CVE-2003-0818"
],
"161": [
"CVE-2004-0345"
],
"170": [
"CVE-2004-0176"
],
"176": [
"CVE-2004-0120"
],
"185": [],
"195": [
"CVE-2000-0972"
],
"212": [
"CVE-2000-0699"
],
"214": [
"CVE-2000-0305"
],
"233": [
"CVE-2001-0095"
],
"235": [
"CVE-2001-0095"
],
"236": [],
"238": [],
"240": [],
"241": [
"CVE-2001-0136"
],
"244": [
"CVE-2001-0136"
],
"251": [
"CVE-2001-0040"
],
"262": [],
"264": [
"CVE-2001-0486"
],
"274": [
"CVE-2004-0424"
],
"276": [
"CVE-2004-0230"
],
"291": [
"CVE-2004-0230"
],
"298": [],
"299": [
"CVE-2004-0445"
],
"306": [
"CVE-2004-0554"
],
"312": [
"CVE-2004-0683"
],
"324": [
"CVE-2000-0418",
"CVE-1999-0128"
],
"329": [
"CVE-1999-0224"
],
"343": [
"CVE-1999-0116"
],
"345": [],
"354": [],
"356": [],
"357": [
"CVE-2004-0735"
],
"358": [
"CVE-2004-0740"
],
"360": [
"CVE-2004-0493"
],
"362": [],
"363": [
"CVE-2004-2045"
],
"365": [
"CVE-2004-0484"
],
"366": [
"CVE-2004-0728"
],
"370": [
"CVE-2004-1705"
],
"371": [
"CVE-2004-0493"
],
"376": [
"CVE-2004-2434"
],
"383": [
"CVE-2002-0741"
],
"385": [
"CVE-2003-0717"
],
"403": [],
"419": [
"CVE-2004-1727"
],
"420": [
"CVE-2004-1739"
],
"422": [
"CVE-2004-1745"
],
"423": [
"CVE-2004-1744"
],
"427": [
"CVE-2004-1642"
],
"428": [],
"429": [
"CVE-2004-1751"
],
"433": [
"CVE-2004-1664"
],
"463": [
"CVE-2004-1675"
],
"468": [
"CVE-2004-1688"
],
"471": [
"CVE-2004-1696"
],
"474": [
"CVE-2004-0200"
],
"477": [
"CVE-2004-1698"
],
"551": [
"CVE-2004-2517"
],
"562": [
"CVE-2004-1560"
],
"571": [
"CVE-2004-1587"
],
"578": [
"CVE-2004-0574"
],
"585": [
"CVE-2003-0718"
],
"593": [
"CVE-2006-2027"
],
"594": [],
"599": [],
"603": [
"CVE-2004-1493"
],
"604": [
"CVE-2004-1619"
],
"605": [
"CVE-2004-1207"
],
"606": [
"CVE-2004-2151"
],
"607": [],
"611": [],
"625": [],
"626": [
"CVE-2004-1109"
],
"628": [],
"634": [],
"649": [
"CVE-2004-1118"
],
"651": [
"CVE-2004-1539"
],
"653": [
"CVE-2004-1542"
],
"655": [
"CVE-2004-1195",
"CVE-2004-1194"
],
"662": [],
"664": [
"CVE-2004-1135"
],
"665": [
"CVE-2004-1208"
],
"667": [],
"671": [],
"672": [
"CVE-2004-1216",
"CVE-2004-1215",
"CVE-2004-1214"
],
"677": [
"CVE-2004-0575"
],
"679": [
"CVE-2004-1220"
],
"682": [],
"683": [
"CVE-2004-1395"
],
"685": [
"CVE-2004-1016"
],
"686": [
"CVE-2004-1137"
],
"687": [
"CVE-2004-2496"
],
"688": [],
"690": [
"CVE-2004-1333"
],
"691": [],
"692": [
"CVE-2004-1335"
],
"700": [],
"721": [
"CVE-2004-1305"
],
"736": [
"CVE-2005-0280"
],
"738": [],
"742": [],
"743": [],
"755": [
"CVE-2005-0382"
],
"762": [
"CVE-2005-0122"
],
"770": [],
"780": [
"CVE-2005-0325"
],
"782": [],
"783": [
"CVE-2005-0330"
],
"789": [],
"797": [
"CVE-2005-0636",
"CVE-2005-0339"
],
"799": [
"CVE-2005-0340"
],
"810": [
"CVE-2005-0370",
"CVE-2005-0369"
],
"813": [
"CVE-2005-0430"
],
"815": [
"CVE-2005-2535"
],
"817": [
"CVE-2005-0436",
"CVE-2005-0435"
],
"838": [
"CVE-2004-0465"
],
"841": [
"CVE-2005-0568"
],
"842": [
"CVE-2005-0256"
],
"843": [
"CVE-2005-0575"
],
"849": [
"CVE-2005-0621"
],
"852": [
"CVE-2005-0633"
],
"855": [
"CVE-2004-0942"
],
"856": [
"CVE-2005-0681"
],
"861": [
"CVE-2005-1649",
"CVE-2005-0688"
],
"867": [],
"869": [],
"874": [
"CVE-2005-0739"
],
"880": [],
"882": [
"CVE-2005-0768"
],
"886": [],
"887": [
"CVE-2005-0804"
],
"888": [],
"891": [],
"893": [
"CVE-2005-0847"
],
"899": [],
"904": [],
"908": [],
"911": [
"CVE-2005-0916"
],
"916": [
"CVE-2005-1013"
],
"931": [
"CVE-2005-0554"
],
"941": [
"CVE-2005-1165",
"CVE-2005-1164"
],
"942": [
"CVE-2005-0688",
"CVE-2005-0048",
"CVE-2004-1060",
"CVE-2004-0790",
"CVE-2004-0230"
],
"946": [],
"948": [
"CVE-2004-0790"
],
"956": [
"CVE-2005-1280"
],
"957": [
"CVE-2005-1279"
],
"958": [
"CVE-2005-1279"
],
"959": [
"CVE-2005-1278"
],
"978": [],
"983": [
"CVE-2005-1667"
],
"984": [
"CVE-2005-1470"
],
"40381": [],
"988": [
"CVE-2005-1603"
],
"998": [
"CVE-2005-1589"
],
"999": [
"CVE-2005-1261"
],
"1000": [],
"1008": [
"CVE-2005-0356"
],
"1024": [],
"1025": [],
"1027": [
"CVE-2005-1812"
],
"1037": [
"CVE-2005-1267"
],
"1056": [],
"1063": [],
"1064": [],
"1065": [
"CVE-2005-0045"
],
"1067": [],
"1072": [],
"1090": [
"CVE-2005-2141"
],
"1093": [
"CVE-2005-2208"
],
"1094": [],
"1100": [],
"1101": [
"CVE-2005-2287"
],
"1104": [
"CVE-2005-2307"
],
"1105": [
"CVE-2005-2295"
],
"1107": [
"CVE-2005-2305"
],
"1109": [],
"1110": [],
"1116": [
"CVE-2005-1219"
],
"1121": [
"CVE-2005-2426"
],
"1126": [
"CVE-2005-2472"
],
"1127": [
"CVE-2006-7167"
],
"1129": [
"CVE-2005-2479"
],
"1137": [],
"1143": [
"CVE-2005-2303",
"CVE-2005-1218"
],
"41796": [
"CVE-2017-2482"
],
"1153": [
"CVE-2005-2581"
],
"1156": [
"CVE-2005-2639"
],
"1157": [],
"1158": [
"CVE-2001-1021"
],
"1159": [
"CVE-2004-2513",
"CVE-2004-1211"
],
"1160": [],
"1162": [
"CVE-2005-1931"
],
"1163": [
"CVE-2005-2083"
],
"1164": [
"CVE-2005-2472"
],
"1165": [
"CVE-2005-2085"
],
"1166": [
"CVE-2005-2085"
],
"1175": [],
"1176": [
"CVE-2005-2719"
],
"1192": [],
"1196": [],
"1199": [
"CVE-2004-2029"
],
"1204": [],
"1212": [],
"1213": [],
"1218": [],
"1220": [
"CVE-2004-2534"
],
"1222": [
"CVE-2005-3002"
],
"1233": [],
"1235": [
"CVE-2005-3064"
],
"1239": [
"CVE-2005-3135"
],
"1246": [],
"1251": [
"CVE-2005-3294",
"CVE-2001-1156"
],
"1253": [],
"1254": [
"CVE-2005-4718"
],
"1255": [
"CVE-2005-4718"
],
"1256": [
"CVE-2005-3120"
],
"1257": [],
"1266": [
"CVE-2005-3243"
],
"1268": [],
"1269": [
"CVE-2005-2120"
],
"1271": [
"CVE-2005-2120"
],
"1274": [
"CVE-2005-3475"
],
"1276": [],
"1281": [
"CVE-2005-3493"
],
"1282": [],
"1283": [
"CVE-2005-3492",
"CVE-2005-3491"
],
"1284": [
"CVE-2005-3485"
],
"1285": [
"CVE-2005-3488",
"CVE-2005-3487",
"CVE-2005-3486"
],
"1286": [
"CVE-2005-3483"
],
"1287": [],
"1327": [
"CVE-2005-3640"
],
"1328": [
"CVE-2005-3644"
],
"1331": [
"CVE-2005-3591"
],
"1336": [
"CVE-2005-3589"
],
"1338": [
"CVE-2005-3774"
],
"1339": [
"CVE-2005-3812"
],
"1341": [
"CVE-2005-2119"
],
"1343": [
"CVE-2005-2124"
],
"1345": [
"CVE-2005-3929"
],
"1346": [
"CVE-2005-2124",
"CVE-2005-2123",
"CVE-2005-0803"
],
"1353": [
"CVE-2005-3992"
],
"1362": [],
"1368": [],
"1371": [
"CVE-2005-4216"
],
"1372": [],
"1376": [
"CVE-2005-4360"
],
"1377": [
"CVE-2005-4360"
],
"1389": [],
"1390": [
"CVE-2005-4584"
],
"1394": [],
"1396": [],
"1409": [
"CVE-2005-3187"
],
"1411": [
"CVE-2006-0179"
],
"1416": [
"CVE-2006-0355"
],
"1422": [
"CVE-2006-0357"
],
"1423": [],
"1424": [
"CVE-2006-0328"
],
"1447": [
"CVE-2006-0354"
],
"1464": [
"CVE-2002-0256"
],
"1473": [
"CVE-2006-0671"
],
"1475": [
"CVE-2006-0544"
],
"1483": [
"CVE-2006-0734",
"CVE-2003-1325"
],
"1488": [
"CVE-2006-0564",
"CVE-2009-0133"
],
"1489": [
"CVE-2006-0888"
],
"1496": [
"CVE-2005-4723"
],
"1500": [
"CVE-2006-0006"
],
"1517": [
"CVE-2006-1090",
"CVE-2006-0865"
],
"1531": [],
"1535": [
"CVE-2006-1010"
],
"1540": [
"CVE-2006-0900"
],
"1551": [],
"1552": [
"CVE-2006-2226"
],
"1557": [
"CVE-2006-0047"
],
"1558": [],
"1559": [
"CVE-2006-1103",
"CVE-2006-1102",
"CVE-2006-1101",
"CVE-2006-1100"
],
"1560": [
"CVE-2006-1101"
],
"1564": [
"CVE-2006-1147",
"CVE-2006-1146",
"CVE-2006-1145"
],
"1572": [
"CVE-2006-1206"
],
"1573": [
"CVE-2006-1224"
],
"1593": [],
"1598": [],
"1599": [
"CVE-2006-0021"
],
"1601": [
"CVE-2006-1364"
],
"1603": [
"CVE-2006-0021"
],
"1604": [],
"1613": [],
"1614": [],
"1615": [
"CVE-2006-1540"
],
"1622": [
"CVE-2006-0323"
],
"1633": [
"CVE-2005-2856"
],
"1634": [],
"1641": [
"CVE-2008-1110",
"CVE-2006-1664"
],
"1642": [],
"1643": [],
"1651": [],
"1657": [
"CVE-2006-7051"
],
"1667": [],
"1671": [],
"1688": [],
"1708": [
"CVE-2006-2012"
],
"1709": [
"CVE-2006-1999",
"CVE-2006-1998"
],
"1712": [],
"1715": [
"CVE-2006-2019"
],
"1716": [
"CVE-2006-1993"
],
"1718": [
"CVE-2006-2108"
],
"1721": [
"CVE-2006-2107"
],
"1743": [
"CVE-2006-2180"
],
"1746": [
"CVE-2006-2222"
],
"1748": [
"CVE-2006-2225"
],
"1749": [
"CVE-2006-2242"
],
"1754": [
"CVE-2006-2254"
],
"1757": [
"CVE-2006-2242"
],
"1758": [
"CVE-2006-7007"
],
"1775": [
"CVE-2006-7031"
],
"1781": [
"CVE-2006-2402",
"CVE-2006-2401",
"CVE-2006-2400",
"CVE-2006-2399"
],
"1782": [
"CVE-2006-2393"
],
"1783": [
"CVE-2006-2555",
"CVE-2006-2554"
],
"1784": [
"CVE-2006-2412",
"CVE-2006-2411",
"CVE-2006-2410",
"CVE-2006-2409",
"CVE-2006-2408"
],
"1792": [
"CVE-2006-2413"
],
"1801": [
"CVE-2006-2458"
],
"1802": [],
"1815": [],
"1819": [
"CVE-2006-2587"
],
"1820": [
"CVE-2006-2575"
],
"1838": [
"CVE-2006-1388",
"CVE-2006-1359",
"CVE-2006-1245",
"CVE-2006-1192",
"CVE-2006-1191",
"CVE-2006-1190",
"CVE-2006-1189",
"CVE-2006-1188",
"CVE-2006-1186",
"CVE-2006-1185"
],
"1852": [
"CVE-2006-2802"
],
"1856": [],
"1867": [
"CVE-2006-2723"
],
"1880": [
"CVE-2006-2444"
],
"1894": [
"CVE-2006-2971"
],
"1927": [
"CVE-2006-3086"
],
"1935": [
"CVE-2006-3228"
],
"1937": [
"CVE-2006-3199"
],
"1947": [],
"1949": [
"CVE-2006-6750"
],
"1967": [
"CVE-2006-2379"
],
"1972": [
"CVE-2006-3353"
],
"1976": [
"CVE-2006-3400",
"CVE-2006-3325",
"CVE-2006-3324"
],
"1977": [
"CVE-2006-3401",
"CVE-2006-3325"
],
"1980": [
"CVE-2006-3546"
],
"1984": [
"CVE-2006-3912"
],
"1989": [
"CVE-2006-3471"
],
"1990": [],
"2000": [
"CVE-2006-3524"
],
"2001": [
"CVE-2006-3493"
],
"2037": [
"CVE-2006-3668"
],
"2039": [
"CVE-2006-5162"
],
"2051": [
"CVE-2006-0058"
],
"2057": [
"CVE-2006-3942",
"CVE-2006-1315",
"CVE-2006-1314"
],
"2059": [],
"2073": [
"CVE-2006-3879"
],
"2124": [
"CVE-2006-4455"
],
"2147": [
"CVE-2006-4455"
],
"2156": [],
"2160": [
"CVE-2006-4192"
],
"2176": [
"CVE-2006-4464"
],
"2179": [],
"2180": [],
"2194": [
"CVE-2006-7210"
],
"2195": [],
"2204": [
"CVE-2006-7210"
],
"2208": [],
"2210": [
"CVE-2006-7210"
],
"2238": [],
"2244": [],
"2245": [
"CVE-2006-4364"
],
"2246": [
"CVE-2009-3962",
"CVE-2006-4523"
],
"2302": [],
"2303": [],
"2334": [
"CVE-2006-4781"
],
"2400": [],
"2444": [
"CVE-2006-4924"
],
"2515": [],
"2523": [
"CVE-2006-5296"
],
"2524": [
"CVE-2006-4516"
],
"2541": [
"CVE-2006-5482"
],
"2542": [
"CVE-2006-5483"
],
"2571": [
"CVE-2006-5391"
],
"2586": [
"CVE-2006-5295"
],
"2587": [
"CVE-2006-4182"
],
"2597": [
"CVE-2006-5444"
],
"2625": [
"CVE-2006-5551"
],
"2629": [
"CVE-2006-5559"
],
"2639": [
"CVE-2006-5550"
],
"2650": [
"CVE-2006-5552"
],
"2672": [
"CVE-2006-5614"
],
"2682": [
"CVE-2006-5614"
],
"2695": [
"CVE-2006-5633"
],
"2700": [
"CVE-2006-5710"
],
"2708": [
"CVE-2006-5567"
],
"2715": [
"CVE-2006-5728"
],
"2716": [
"CVE-2006-5850"
],
"2730": [],
"2734": [
"CVE-2006-5826"
],
"2735": [
"CVE-2006-5789"
],
"2783": [
"CVE-2006-6884"
],
"2787": [
"CVE-2008-5431"
],
"2854": [],
"2855": [
"CVE-2006-6183"
],
"2857": [],
"2860": [
"CVE-2006-6261"
],
"2861": [
"CVE-2006-6250"
],
"2874": [
"CVE-2006-6652"
],
"2879": [
"CVE-2006-6296"
],
"2892": [
"CVE-2006-6352"
],
"2893": [
"CVE-2006-6293"
],
"2900": [
"CVE-2006-3441",
"CVE-2006-3440"
],
"2901": [
"CVE-2006-6564"
],
"2910": [
"CVE-2006-5646"
],
"2911": [
"CVE-2006-5647"
],
"2912": [
"CVE-2006-5645"
],
"2914": [
"CVE-2006-6565",
"CVE-2006-6564"
],
"2915": [
"CVE-2006-6538"
],
"2916": [],
"2922": [
"CVE-2006-6628",
"CVE-2006-6561"
],
"2926": [
"CVE-2006-6558"
],
"2928": [
"CVE-2006-6563"
],
"2929": [],
"2934": [
"CVE-2006-6624"
],
"2935": [
"CVE-2006-6601"
],
"2942": [
"CVE-2006-6643"
],
"2946": [
"CVE-2006-6659"
],
"2947": [
"CVE-2006-6719"
],
"2949": [
"CVE-2006-6651"
],
"2952": [
"CVE-2006-6673"
],
"2954": [
"CVE-2006-6660"
],
"2961": [],
"2966": [
"CVE-2006-6759"
],
"2967": [
"CVE-2006-6696"
],
"2972": [
"CVE-2006-6724"
],
"2978": [
"CVE-2006-6751"
],
"2985": [
"CVE-2006-6775"
],
"3013": [
"CVE-2006-6723"
],
"3023": [
"CVE-2006-6811"
],
"3030": [
"CVE-2006-6847"
],
"3034": [
"CVE-2006-6855"
],
"3038": [
"CVE-2006-6853"
],
"3041": [
"CVE-2006-6827"
],
"3042": [
"CVE-2006-6885"
],
"3052": [
"CVE-2006-6797"
],
"3056": [
"CVE-2007-0138",
"CVE-2006-6910"
],
"3069": [
"CVE-2007-0017"
],
"3078": [
"CVE-2007-0120"
],
"3080": [
"CVE-2007-0051"
],
"3098": [
"CVE-2007-0148"
],
"3101": [
"CVE-2007-0126"
],
"3110": [
"CVE-2007-0197"
],
"3111": [
"CVE-2006-4071"
],
"3112": [
"CVE-2007-0228"
],
"3119": [
"CVE-2007-0256"
],
"3126": [
"CVE-2007-0311"
],
"3127": [
"CVE-2006-0441"
],
"3128": [
"CVE-2007-0338"
],
"3130": [
"CVE-2007-0236"
],
"3138": [
"CVE-2003-1318"
],
"3139": [
"CVE-2007-0344"
],
"3142": [
"CVE-2007-0356"
],
"3151": [
"CVE-2007-0355"
],
"3155": [
"CVE-2007-0371"
],
"3157": [
"CVE-2007-0429"
],
"3160": [
"CVE-2007-0020"
],
"3166": [
"CVE-2007-0021"
],
"3167": [
"CVE-2007-0430"
],
"3182": [
"CVE-2007-0548"
],
"3190": [
"CVE-2007-0562"
],
"3193": [
"CVE-2007-0031"
],
"3200": [
"CVE-2007-0464"
],
"3204": [
"CVE-2007-0444"
],
"3223": [
"CVE-2007-0347"
],
"3224": [
"CVE-2007-0686"
],
"3229": [
"CVE-2007-0643"
],
"3230": [
"CVE-2007-0710",
"CVE-2007-0614",
"CVE-2007-0613"
],
"3248": [
"CVE-2007-0816"
],
"3254": [
"CVE-2007-0766"
],
"3257": [
"CVE-2007-0756"
],
"3272": [
"CVE-2007-0811"
],
"3276": [
"CVE-2007-0825"
],
"3277": [
"CVE-2007-0790"
],
"3289": [
"CVE-2007-0886"
],
"3290": [
"CVE-2007-0887"
],
"3304": [],
"3306": [
"CVE-2007-0955"
],
"3307": [
"CVE-2007-0976"
],
"3308": [
"CVE-2007-0955"
],
"3331": [
"CVE-2007-1014"
],
"3341": [
"CVE-2007-1080",
"CVE-2007-1075"
],
"3343": [
"CVE-2007-1079"
],
"3347": [
"CVE-2007-1082"
],
"3350": [
"CVE-2007-1162"
],
"3362": [
"CVE-2006-5276"
],
"3385": [
"CVE-2007-1195"
],
"3392": [
"CVE-2007-1294"
],
"3394": [
"CVE-2007-1383"
],
"3396": [
"CVE-2007-1286"
],
"3399": [
"CVE-2007-1251"
],
"3404": [
"CVE-2007-1381"
],
"3407": [
"CVE-2007-1306"
],
"3415": [],
"3418": [
"CVE-2007-1373"
],
"3419": [
"CVE-2007-1347"
],
"3421": [
"CVE-2007-1403"
],
"3430": [
"CVE-2007-1377"
],
"3432": [
"CVE-2007-1404"
],
"3433": [
"CVE-2007-1402"
],
"3434": [
"CVE-2007-1398"
],
"3441": [
"CVE-2007-0005"
],
"3444": [
"CVE-2007-0217"
],
"3453": [],
"3461": [],
"3464": [
"CVE-2007-1569"
],
"3514": [
"CVE-2007-1501"
],
"3526": [
"CVE-2007-1542"
],
"3527": [
"CVE-2007-1578"
],
"3535": [
"CVE-2007-1590"
],
"3547": [
"CVE-2007-1648"
],
"3566": [
"CVE-2007-1561"
],
"3586": [
"CVE-2007-1711"
],
"3602": [
"CVE-2007-1675"
],
"3606": [],
"3674": [
"CVE-2007-2367"
],
"3684": [
"CVE-2007-0038",
"CVE-2007-1765"
],
"3690": [
"CVE-2007-1911",
"CVE-2007-1910"
],
"3693": [
"CVE-2007-1912"
],
"3709": [],
"3715": [],
"3726": [],
"3768": [
"CVE-2007-2180"
],
"3769": [
"CVE-2007-2187"
],
"3770": [
"CVE-2007-2186"
],
"3782": [],
"3784": [
"CVE-2007-2274"
],
"3788": [
"CVE-2007-1690"
],
"3789": [
"CVE-2007-1691"
],
"3790": [
"CVE-2007-2678"
],
"3791": [
"CVE-2007-2270"
],
"3792": [
"CVE-2007-2270"
],
"3807": [
"CVE-2007-2362"
],
"3819": [
"CVE-2007-2497"
],
"3826": [
"CVE-2007-2494"
],
"3830": [
"CVE-2007-2495"
],
"3836": [
"CVE-2007-2496"
],
"3845": [
"CVE-2007-2588"
],
"3851": [
"CVE-2007-1669"
],
"3866": [
"CVE-2007-2563"
],
"3871": [],
"3873": [
"CVE-2007-2526"
],
"3883": [
"CVE-2007-2585"
],
"3890": [],
"3891": [
"CVE-2007-2623"
],
"3898": [
"CVE-2007-2656"
],
"3910": [
"CVE-2007-2657"
],
"3917": [
"CVE-2007-2658"
],
"3921": [
"CVE-2007-2648"
],
"3926": [
"CVE-2007-1531"
],
"3929": [
"CVE-2007-2726"
],
"3930": [
"CVE-2007-2722"
],
"3937": [
"CVE-2007-2744"
],
"3939": [
"CVE-2007-2772"
],
"3940": [
"CVE-2007-2772"
],
"3945": [
"CVE-2007-2761"
],
"3965": [],
"3969": [
"CVE-2007-2827"
],
"3973": [
"CVE-2007-2903"
],
"3976": [
"CVE-2007-2884"
],
"3977": [
"CVE-2007-2884"
],
"3978": [
"CVE-2007-2888"
],
"3979": [
"CVE-2007-2895"
],
"3986": [
"CVE-2007-2946"
],
"4009": [
"CVE-2007-3169"
],
"4011": [
"CVE-2007-2980"
],
"4012": [
"CVE-2007-2981"
],
"4017": [
"CVE-2007-3006"
],
"4033": [
"CVE-2007-3098"
],
"4038": [],
"4044": [
"CVE-2007-2237"
],
"4046": [
"CVE-2007-3159"
],
"4047": [
"CVE-2007-3157"
],
"4056": [
"CVE-2007-3162"
],
"4058": [
"CVE-2007-3161"
],
"4067": [
"CVE-2007-3282"
],
"4118": [
"CVE-2007-3410"
],
"4120": [
"CVE-2007-3488"
],
"4121": [
"CVE-2007-3490"
],
"4126": [
"CVE-2007-3548"
],
"4137": [
"CVE-2007-3554"
],
"4148": [
"CVE-2007-3608",
"CVE-2007-3607",
"CVE-2007-3605"
],
"4149": [
"CVE-2007-3608",
"CVE-2007-3607",
"CVE-2007-3606"
],
"4168": [
"CVE-2007-3655"
],
"4175": [
"CVE-2007-3790"
],
"4181": [
"CVE-2007-3806"
],
"4196": [
"CVE-2007-3764"
],
"4205": [
"CVE-2007-3956"
],
"4215": [
"CVE-2007-3958"
],
"4216": [
"CVE-2007-3957"
],
"4227": [
"CVE-2007-4033"
],
"4249": [
"CVE-2007-3763"
],
"4251": [
"CVE-2006-4301"
],
"4260": [
"CVE-2007-4255"
],
"4272": [
"CVE-2007-4286"
],
"4281": [
"CVE-2007-4366"
],
"4285": [
"CVE-2007-4382"
],
"4288": [],
"4289": [
"CVE-2004-2466"
],
"4293": [
"CVE-2007-4441"
],
"4294": [
"CVE-2007-4440"
],
"4297": [
"CVE-2007-4459"
],
"4298": [
"CVE-2007-4459"
],
"4304": [
"CVE-2007-4507"
],
"4318": [
"CVE-2007-4586"
],
"4319": [
"CVE-2007-4553"
],
"4335": [
"CVE-2007-4391"
],
"4337": [
"CVE-2007-3034"
],
"4344": [
"CVE-2007-4646"
],
"4347": [
"CVE-2007-6113"
],
"4359": [
"CVE-2007-2394"
],
"4369": [
"CVE-2007-4790"
],
"4373": [
"CVE-2007-4821"
],
"4375": [
"CVE-2007-4816"
],
"4379": [
"CVE-2007-4814"
],
"4403": [
"CVE-2007-4911"
],
"4409": [
"CVE-2007-4916"
],
"4426": [
"CVE-2007-5036"
],
"4432": [
"CVE-2007-5019"
],
"4474": [
"CVE-2007-5257"
],
"4479": [
"CVE-2007-5219"
],
"4498": [
"CVE-2007-5300"
],
"4532": [
"CVE-2007-5467"
],
"4535": [
"CVE-2007-5467",
"CVE-2007-5466"
],
"4540": [
"CVE-2007-4980"
],
"4559": [],
"4560": [],
"4569": [
"CVE-2007-5082"
],
"4600": [
"CVE-2007-5824"
],
"4601": [
"CVE-2008-5010",
"CVE-2007-5365"
],
"4610": [
"CVE-2007-5911"
],
"4613": [
"CVE-2007-5941"
],
"4615": [],
"4624": [
"CVE-2007-4684"
],
"4648": [
"CVE-2007-6166"
],
"4682": [
"CVE-2007-6236"
],
"4683": [
"CVE-2007-6235",
"CVE-2007-4904"
],
"4688": [
"CVE-2007-6262"
],
"4689": [
"CVE-2007-6261"
],
"4690": [
"CVE-2007-6276"
],
"4692": [
"CVE-2007-5583"
],
"4716": [
"CVE-2007-6327"
],
"4717": [
"CVE-2007-6326"
],
"4723": [
"CVE-2007-6359"
],
"4732": [
"CVE-2007-6015"
],
"4742": [
"CVE-2007-6473"
],
"4748": [
"CVE-2007-6457"
],
"4757": [
"CVE-2007-6506"
],
"4773": [
"CVE-2006-4343"
],
"4801": [
"CVE-2007-6605"
],
"4829": [
"CVE-2008-0090"
],
"4856": [
"CVE-2008-7203"
],
"4878": [
"CVE-2008-0127"
],
"4881": [
"CVE-2007-0634"
],
"4885": [
"CVE-2008-0234"
],
"4893": [
"CVE-2008-0352"
],
"4911": [
"CVE-2008-0324"
],
"4931": [
"CVE-2008-0379"
],
"4935": [
"CVE-2008-0384"
],
"4978": [],
"4997": [],
"5036": [
"CVE-2008-0702"
],
"5043": [
"CVE-2008-0624",
"CVE-2008-0623"
],
"5044": [
"CVE-2008-0590"
],
"5054": [
"CVE-2008-0680"
],
"5063": [
"CVE-2008-0619"
],
"5067": [
"CVE-2008-0661"
],
"5085": [
"CVE-2008-0747"
],
"5086": [
"CVE-2008-0748"
],
"5110": [
"CVE-2008-0778"
],
"5122": [],
"5142": [
"CVE-2008-1138"
],
"5151": [
"CVE-2008-0830"
],
"5152": [
"CVE-2007-5958"
],
"5184": [
"CVE-2008-5160"
],
"5191": [
"CVE-2008-0177"
],
"5201": [
"CVE-2008-1127"
],
"5210": [],
"5217": [
"CVE-2008-7136",
"CVE-2008-7135"
],
"5225": [
"CVE-2008-1307"
],
"5229": [
"CVE-2008-1322",
"CVE-2008-1321",
"CVE-2008-1320"
],
"5235": [
"CVE-2008-1275"
],
"5258": [
"CVE-2008-1480"
],
"5261": [],
"5268": [],
"5270": [
"CVE-2008-1478"
],
"5306": [
"CVE-2008-1501"
],
"5307": [
"CVE-2008-1558"
],
"5316": [],
"5321": [],
"5327": [],
"5341": [
"CVE-2008-1713"
],
"5343": [
"CVE-2008-1855"
],
"5344": [],
"5349": [
"CVE-2008-1709",
"CVE-2008-0250"
],
"5354": [
"CVE-2008-6519"
],
"5396": [
"CVE-2008-3544"
],
"5427": [
"CVE-2008-1910"
],
"5438": [],
"5453": [
"CVE-2008-1912"
],
"5455": [
"CVE-2008-6583"
],
"5458": [
"CVE-2008-1878"
],
"5460": [
"CVE-2008-1898"
],
"5472": [
"CVE-2008-1973"
],
"5515": [
"CVE-2008-2069"
],
"5547": [
"CVE-2008-0927"
],
"5561": [
"CVE-2008-1801"
],
"5585": [
"CVE-2008-1802"
],
"5679": [],
"5682": [
"CVE-2008-2511"
],
"5687": [
"CVE-2008-2549"
],
"5709": [
"CVE-2008-2573"
],
"5712": [
"CVE-2008-4189",
"CVE-2008-1105"
],
"5718": [
"CVE-2008-4193"
],
"5727": [
"CVE-2008-2631"
],
"5749": [
"CVE-2008-2119"
],
"5814": [
"CVE-2007-5962"
],
"5817": [
"CVE-2008-2922"
],
"5843": [
"CVE-2008-6742"
],
"5851": [
"CVE-2008-2959"
],
"5918": [
"CVE-2008-0071"
],
"5968": [
"CVE-2008-7182",
"CVE-2008-2859"
],
"6029": [],
"6043": [
"CVE-2008-2304"
],
"6046": [
"CVE-2008-3210"
],
"6059": [
"CVE-2008-3208"
],
"6072": [],
"6077": [
"CVE-2008-3269"
],
"6083": [
"CVE-2008-3209"
],
"6090": [
"CVE-2008-3242"
],
"6101": [
"CVE-2008-2595"
],
"6103": [
"CVE-2008-3360"
],
"6120": [],
"6129": [],
"6174": [
"CVE-2008-3447"
],
"6181": [
"CVE-2008-3493"
],
"6196": [
"CVE-2008-3571"
],
"6201": [
"CVE-2008-3578"
],
"6216": [
"CVE-2008-3702"
],
"6218": [
"CVE-2008-3431"
],
"6237": [
"CVE-2008-3680"
],
"6239": [
"CVE-2008-3443"
],
"6240": [
"CVE-2008-4321"
],
"6244": [
"CVE-2008-3704"
],
"6251": [
"CVE-2008-7107"
],
"6252": [
"CVE-2008-3732"
],
"6253": [
"CVE-2008-3733"
],
"6257": [
"CVE-2008-3795",
"CVE-2008-3734"
],
"6262": [
"CVE-2008-3761"
],
"6293": [
"CVE-2008-3794"
],
"6319": [
"CVE-2008-3879"
],
"6326": [
"CVE-2008-7053"
],
"6327": [
"CVE-2008-7103"
],
"6330": [
"CVE-2008-1083"
],
"6345": [
"CVE-2008-3892"
],
"6353": [
"CVE-2008-6995"
],
"6365": [],
"6372": [
"CVE-2008-6998"
],
"6386": [
"CVE-2008-6997"
],
"6391": [],
"6394": [
"CVE-2008-4380"
],
"6424": [
"CVE-2008-4071"
],
"6434": [],
"6458": [
"CVE-2008-4136"
],
"6459": [
"CVE-2008-4135"
],
"6463": [
"CVE-2008-4114"
],
"6471": [
"CVE-2008-4116"
],
"6472": [
"CVE-2008-4042"
],
"6474": [
"CVE-2008-2005"
],
"6481": [
"CVE-2008-2032"
],
"6493": [
"CVE-2008-7014"
],
"6496": [
"CVE-2008-1141"
],
"6497": [
"CVE-2008-4363"
],
"6498": [
"CVE-2008-4363"
],
"6515": [
"CVE-2008-4362"
],
"6554": [
"CVE-2008-4340"
],
"6560": [
"CVE-2009-0259",
"CVE-2008-4841"
],
"6565": [
"CVE-2008-5072"
],
"6581": [
"CVE-2008-5666"
],
"6582": [
"CVE-2008-4295"
],
"6588": [
"CVE-2008-4327"
],
"6609": [],
"6614": [
"CVE-2008-4324"
],
"6615": [],
"6616": [
"CVE-2008-4323"
],
"6619": [
"CVE-2007-5348"
],
"6622": [
"CVE-2008-4682"
],
"6647": [
"CVE-2008-4451"
],
"6651": [
"CVE-2008-4452"
],
"6654": [
"CVE-2008-4449"
],
"6658": [
"CVE-2008-5667"
],
"6660": [
"CVE-2008-4500"
],
"6668": [
"CVE-2008-5884"
],
"6671": [
"CVE-2008-4510"
],
"6672": [
"CVE-2008-5937"
],
"6673": [
"CVE-2008-5870"
],
"6689": [
"CVE-2008-5712",
"CVE-2008-4514"
],
"6704": [
"CVE-2008-5712",
"CVE-2008-4514"
],
"6716": [
"CVE-2008-3013"
],
"6717": [
"CVE-2008-5666"
],
"6718": [
"CVE-2008-5698"
],
"6719": [],
"6726": [],
"6732": [
"CVE-2008-2245"
],
"6738": [
"CVE-2008-4572"
],
"6741": [
"CVE-2008-5626"
],
"6742": [
"CVE-2008-6186"
],
"6752": [
"CVE-2008-4588"
],
"6753": [
"CVE-2008-6082"
],
"6756": [
"CVE-2008-4558"
],
"6761": [
"CVE-2008-4729"
],
"6775": [
"CVE-2008-4619"
],
"6800": [
"CVE-2008-4762"
],
"6805": [
"CVE-2008-2469"
],
"6812": [
"CVE-2008-4762"
],
"6815": [
"CVE-2008-6175"
],
"6824": [
"CVE-2008-4250"
],
"6832": [
"CVE-2008-4748"
],
"6834": [
"CVE-2008-6829",
"CVE-2008-2031"
],
"6838": [
"CVE-2008-6791"
],
"6863": [
"CVE-2008-1311"
],
"6926": [
"CVE-2008-5045"
],
"7060": [
"CVE-2008-6605"
],
"7088": [
"CVE-2008-6252"
],
"7090": [
"CVE-2008-6953"
],
"7091": [],
"7099": [
"CVE-2008-2214"
],
"7100": [
"CVE-2008-2292"
],
"7109": [
"CVE-2008-6938"
],
"7126": [
"CVE-2008-5492"
],
"7150": [
"CVE-2008-5183"
],
"7178": [
"CVE-2008-5409"
],
"7207": [
"CVE-2008-7079"
],
"7209": [
"CVE-2008-5282"
],
"7213": [
"CVE-2008-5282"
],
"7219": [],
"7220": [
"CVE-2008-7065"
],
"7226": [],
"7249": [
"CVE-2008-7074"
],
"7262": [
"CVE-2008-5180"
],
"7296": [
"CVE-2008-5406"
],
"7297": [
"CVE-2008-5405"
],
"7307": [
"CVE-2008-5383"
],
"7314": [
"CVE-2008-7078"
],
"7330": [
"CVE-2008-5314"
],
"7358": [
"CVE-2008-6496"
],
"7362": [
"CVE-2008-6363"
],
"7387": [
"CVE-2008-6497"
],
"7401": [
"CVE-2008-5660"
],
"7405": [
"CVE-2008-5079"
],
"7431": [
"CVE-2008-4255"
],
"7454": [],
"7460": [],
"7467": [],
"7520": [
"CVE-2008-5081"
],
"7535": [],
"7554": [
"CVE-2009-2953",
"CVE-2008-5715"
],
"7555": [
"CVE-2008-6393"
],
"7556": [
"CVE-2008-5731"
],
"7564": [
"CVE-2008-6897"
],
"7571": [
"CVE-2008-5753"
],
"7578": [
"CVE-2008-5722"
],
"7585": [
"CVE-2008-5745"
],
"7589": [
"CVE-2008-5754"
],
"7592": [
"CVE-2008-5756"
],
"7632": [],
"7634": [
"CVE-2009-0490"
],
"7637": [
"CVE-2009-0491"
],
"7643": [],
"7647": [
"CVE-2009-0177"
],
"7649": [
"CVE-2009-3429"
],
"7652": [
"CVE-2009-3429"
],
"7673": [
"CVE-2009-0070"
],
"7685": [],
"7693": [],
"7694": [],
"7696": [
"CVE-2009-0833"
],
"7708": [
"CVE-2009-0175"
],
"7709": [
"CVE-2009-0174"
],
"7710": [],
"7720": [
"CVE-2009-0119"
],
"7721": [],
"7737": [
"CVE-2009-0266",
"CVE-2009-0262"
],
"7742": [
"CVE-2009-0263"
],
"7750": [],
"7751": [],
"7756": [],
"7776": [],
"7785": [],
"7790": [],
"7799": [],
"7812": [],
"7822": [
"CVE-2008-3834"
],
"7823": [],
"7852": [
"CVE-2009-0349"
],
"7854": [],
"7857": [
"CVE-2009-0350"
],
"7865": [
"CVE-2009-0304"
],
"7869": [
"CVE-2009-0298"
],
"7882": [],
"7887": [
"CVE-2004-0964"
],
"7889": [],
"7890": [],
"7902": [
"CVE-2009-0323"
],
"7904": [],
"7906": [],
"7934": [],
"7942": [
"CVE-2009-0443"
],
"7943": [],
"7962": [],
"7985": [
"CVE-2009-0410"
],
"7986": [
"CVE-2009-0183"
],
"7990": [
"CVE-2009-0388"
],
"7995": [
"CVE-2009-0546"
],
"8008": [
"CVE-2009-0680"
],
"8013": [],
"8021": [
"CVE-2009-0478"
],
"8024": [
"CVE-2009-0388"
],
"8051": [
"CVE-2009-0649"
],
"8058": [
"CVE-2009-0659",
"CVE-2009-0650"
],
"8077": [
"CVE-2009-0075"
],
"8084": [],
"8090": [],
"8091": [
"CVE-2009-0071"
],
"8099": [
"CVE-2009-0658"
],
"8102": [],
"8106": [],
"8125": [
"CVE-2008-6775"
],
"8129": [
"CVE-2009-0192"
],
"8135": [
"CVE-2009-0885"
],
"8148": [
"CVE-2009-0751"
],
"8156": [],
"8163": [
"CVE-2009-0537"
],
"8180": [
"CVE-2009-1059",
"CVE-2009-1058",
"CVE-2009-1057",
"CVE-2009-1028"
],
"8187": [],
"8190": [
"CVE-2009-0879"
],
"8205": [],
"8212": [
"CVE-2009-0967"
],
"8213": [
"CVE-2009-1045"
],
"8219": [],
"8224": [
"CVE-2009-1040"
],
"8225": [
"CVE-2009-1022"
],
"8232": [],
"8241": [
"CVE-2009-1902"
],
"8245": [],
"8259": [],
"8260": [
"CVE-2009-1152"
],
"8262": [
"CVE-2009-1236"
],
"8263": [
"CVE-2009-1237"
],
"8264": [
"CVE-2009-1237"
],
"8265": [
"CVE-2009-1238"
],
"8281": [
"CVE-2009-1217"
],
"8285": [
"CVE-2009-1169"
],
"8294": [
"CVE-2008-5626"
],
"8300": [],
"8306": [
"CVE-2009-1232"
],
"8308": [
"CVE-2009-1210"
],
"8310": [],
"8313": [
"CVE-2009-1227"
],
"8314": [
"CVE-2009-1209"
],
"8320": [
"CVE-2009-1234"
],
"8325": [
"CVE-2009-1233"
],
"8333": [],
"8335": [],
"8337": [],
"8344": [
"CVE-2009-0172"
],
"8345": [],
"8352": [],
"8356": [],
"8358": [],
"8360": [],
"8370": [
"CVE-2009-1497"
],
"8378": [],
"8390": [
"CVE-2009-1370"
],
"8391": [],
"8393": [],
"8402": [
"CVE-2009-1330",
"CVE-2009-1329",
"CVE-2009-1328",
"CVE-2009-1327",
"CVE-2009-1326",
"CVE-2009-1325",
"CVE-2009-1324"
],
"8403": [
"CVE-2009-1330",
"CVE-2009-1329",
"CVE-2009-1328",
"CVE-2009-1327",
"CVE-2009-1326",
"CVE-2009-1325",
"CVE-2009-1324"
],
"8404": [
"CVE-2009-1330",
"CVE-2009-1329",
"CVE-2009-1328",
"CVE-2009-1327",
"CVE-2009-1326",
"CVE-2009-1325",
"CVE-2009-1324"
],
"8405": [
"CVE-2009-1330",
"CVE-2009-1329",
"CVE-2009-1328",
"CVE-2009-1327",
"CVE-2009-1326",
"CVE-2009-1325",
"CVE-2009-1324"
],
"8406": [
"CVE-2009-0687"
],
"8407": [
"CVE-2009-1330",
"CVE-2009-1329",
"CVE-2009-1328",
"CVE-2009-1327",
"CVE-2009-1326",
"CVE-2009-1325",
"CVE-2009-1324"
],
"8429": [],
"8430": [
"CVE-2009-0687"
],
"8434": [
"CVE-2009-1352"
],
"8445": [
"CVE-2009-1331"
],
"8447": [
"CVE-2009-1353"
],
"8451": [
"CVE-2009-1351"
],
"8452": [
"CVE-2009-1356"
],
"8462": [
"CVE-2009-1257"
],
"8465": [],
"8466": [
"CVE-2009-1511"
],
"8467": [],
"8469": [
"CVE-2008-5904"
],
"8479": [
"CVE-2009-0553"
],
"8484": [
"CVE-2009-4932"
],
"8485": [],
"8489": [
"CVE-2009-1437"
],
"8490": [],
"8500": [],
"8507": [
"CVE-2009-0991"
],
"8511": [],
"8512": [],
"8522": [],
"8523": [
"CVE-2009-1517"
],
"8524": [],
"8526": [
"CVE-2009-1647"
],
"8531": [
"CVE-2009-1627"
],
"8542": [
"CVE-2009-1516"
],
"8544": [],
"8568": [
"CVE-2009-4758"
],
"8573": [
"CVE-2009-1514"
],
"8578": [
"CVE-2009-4754"
],
"8581": [
"CVE-2009-0687"
],
"8584": [
"CVE-2009-4753"
],
"8588": [
"CVE-2009-4756"
],
"8597": [
"CVE-2009-1478"
],
"8598": [],
"8601": [
"CVE-2009-4757"
],
"8606": [
"CVE-2009-1602"
],
"8607": [
"CVE-2009-4759"
],
"8611": [
"CVE-2009-1592"
],
"8617": [
"CVE-2009-2568"
],
"8625": [
"CVE-2009-1644"
],
"8644": [
"CVE-2009-1660"
],
"8646": [],
"8650": [
"CVE-2009-1668"
],
"8665": [
"CVE-2009-1672",
"CVE-2009-1671"
],
"8669": [
"CVE-2009-1574"
],
"8677": [
"CVE-2009-1817"
],
"8695": [
"CVE-2009-1789"
],
"8712": [],
"8720": [
"CVE-2009-1379"
],
"8721": [],
"8722": [],
"8767": [
"CVE-2009-1831"
],
"8777": [
"CVE-2009-1830"
],
"8794": [
"CVE-2009-1827"
],
"8798": [
"CVE-2008-3529"
],
"8822": [
"CVE-2009-1828"
],
"8826": [],
"8832": [
"CVE-2009-1915"
],
"8837": [
"CVE-2009-1944"
],
"8842": [
"CVE-2009-1955"
],
"8862": [
"CVE-2009-0955"
],
"8873": [
"CVE-2009-1386"
],
"8899": [],
"8940": [],
"8955": [],
"8957": [],
"8960": [],
"8964": [
"CVE-2009-2256"
],
"8971": [
"CVE-2009-2173"
],
"8976": [],
"8982": [
"CVE-2009-2286"
],
"8991": [],
"9006": [
"CVE-2009-0714"
],
"9007": [
"CVE-2009-0714"
],
"9029": [
"CVE-2009-2484"
],
"9033": [
"CVE-2009-2403"
],
"9061": [
"CVE-2009-2384"
],
"9067": [
"CVE-2009-2305"
],
"9071": [],
"9084": [
"CVE-2009-1830"
],
"9085": [],
"9090": [
"CVE-2009-3812"
],
"9100": [
"CVE-2009-2433"
],
"9102": [
"CVE-2009-3717"
],
"9113": [
"CVE-2009-3812"
],
"9114": [
"CVE-2009-3859"
],
"9116": [
"CVE-2009-4588"
],
"9123": [],
"9124": [],
"9131": [
"CVE-2009-3947"
],
"9133": [
"CVE-2009-3857"
],
"9134": [
"CVE-2009-2649"
],
"9139": [
"CVE-2009-3948"
],
"9141": [],
"9147": [
"CVE-2009-3807"
],
"9157": [
"CVE-2009-2550"
],
"9158": [
"CVE-2009-2479"
],
"9160": [
"CVE-2009-2535"
],
"9163": [
"CVE-2009-1136"
],
"9167": [
"CVE-2009-3811"
],
"9168": [],
"9169": [],
"9170": [],
"9173": [
"CVE-2009-2650"
],
"9175": [],
"9178": [
"CVE-2009-3808"
],
"9189": [],
"9192": [],
"9198": [
"CVE-2009-2534",
"CVE-2009-2533"
],
"9200": [
"CVE-2009-3536"
],
"9206": [],
"9212": [
"CVE-2009-3809"
],
"9213": [
"CVE-2009-3810"
],
"9220": [
"CVE-2009-2896"
],
"9222": [],
"9228": [],
"9240": [
"CVE-2007-4924"
],
"9241": [
"CVE-2007-4897"
],
"9242": [],
"9253": [
"CVE-2009-2655"
],
"9264": [],
"9265": [
"CVE-2009-0692"
],
"9268": [],
"9277": [],
"9295": [
"CVE-2009-2620"
],
"9300": [
"CVE-2009-0696"
],
"9304": [],
"9317": [],
"9323": [
"CVE-2009-2715"
],
"9345": [],
"9359": [],
"9361": [],
"9362": [
"CVE-2009-2764"
],
"9364": [
"CVE-2009-4867"
],
"9368": [
"CVE-2009-4863"
],
"9373": [],
"9376": [],
"9381": [],
"9382": [
"CVE-2009-2917"
],
"9392": [
"CVE-2009-4553"
],
"9393": [],
"9401": [],
"9411": [],
"9417": [
"CVE-2009-3020"
],
"9423": [],
"9427": [],
"9429": [],
"9442": [],
"9446": [],
"9449": [
"CVE-2009-2918"
],
"9454": [],
"9455": [
"CVE-2009-3019"
],
"9457": [
"CVE-2009-3213"
],
"9467": [
"CVE-2009-2961"
],
"9478": [
"CVE-2007-3340"
],
"9480": [
"CVE-2009-3967"
],
"9487": [
"CVE-2009-3969"
],
"9496": [],
"9506": [],
"9507": [],
"9514": [],
"9515": [],
"9516": [],
"9517": [
"CVE-2009-3038"
],
"9528": [],
"9537": [
"CVE-2009-2966"
],
"9539": [
"CVE-2009-5134"
],
"9546": [
"CVE-2009-3253"
],
"9547": [
"CVE-2009-3115"
],
"9549": [],
"9554": [],
"9561": [
"CVE-2009-3170"
],
"9573": [],
"9584": [],
"9585": [],
"9587": [
"CVE-2009-2521"
],
"9594": [
"CVE-2009-3103"
],
"9597": [],
"9606": [
"CVE-2009-3272"
],
"9607": [
"CVE-2009-4775"
],
"9617": [
"CVE-2009-2958",
"CVE-2009-2957"
],
"9620": [
"CVE-2009-3201"
],
"9621": [],
"9622": [
"CVE-2009-5141"
],
"9626": [],
"9642": [
"CVE-2009-3111"
],
"9646": [
"CVE-2009-3322"
],
"9657": [
"CVE-2009-3663"
],
"9664": [
"CVE-2009-3545"
],
"9666": [
"CVE-2009-3271"
],
"9667": [],
"9668": [],
"9670": [],
"9671": [
"CVE-2009-3574"
],
"9672": [],
"9677": [
"CVE-2008-7162"
],
"9682": [
"CVE-2009-3244"
],
"9683": [
"CVE-2009-3863"
],
"9684": [],
"9685": [
"CVE-2008-6447"
],
"9686": [
"CVE-2008-5032"
],
"9689": [
"CVE-2009-3449"
],
"9691": [
"CVE-2009-4656"
],
"9695": [
"CVE-2009-4661"
],
"9701": [],
"9707": [
"CVE-2009-4659"
],
"9717": [
"CVE-2009-4658",
"CVE-2009-4657"
],
"9731": [],
"9734": [
"CVE-2009-4661"
],
"9804": [
"CVE-2009-3643"
],
"9806": [
"CVE-2009-3693"
],
"9811": [],
"9814": [],
"9815": [
"CVE-2009-3484"
],
"9817": [],
"9823": [],
"9845": [],
"9852": [
"CVE-2009-4051"
],
"9871": [],
"9874": [
"CVE-2009-4587"
],
"9879": [
"CVE-2009-3744"
],
"9881": [
"CVE-2009-3837"
],
"9901": [],
"9956": [
"CVE-2009-5098"
],
"9969": [
"CVE-2009-3641"
],
"9971": [],
"9980": [
"CVE-2009-3749"
],
"9987": [
"CVE-2009-3704"
],
"9999": [],
"10004": [
"CVE-2009-3591"
],
"10005": [
"CVE-2009-3103"
],
"10017": [
"CVE-2009-3888"
],
"10022": [
"CVE-2009-3621"
],
"10062": [],
"10068": [
"CVE-2009-2514"
],
"10073": [],
"10077": [],
"10078": [],
"33476": [],
"10091": [],
"10092": [
"CVE-2009-4171"
],
"10100": [
"CVE-2007-1580"
],
"10102": [
"CVE-2009-4186"
],
"10103": [],
"10104": [
"CVE-2009-4108",
"CVE-2009-4048"
],
"10106": [
"CVE-2009-3522"
],
"10160": [],
"10163": [
"CVE-2009-4654"
],
"10164": [
"CVE-2009-4114"
],
"10171": [],
"10176": [
"CVE-2009-3840"
],
"10182": [],
"10184": [
"CVE-2009-0689"
],
"10185": [
"CVE-2009-0689"
],
"10186": [
"CVE-2009-0689"
],
"10187": [
"CVE-2009-0689"
],
"10190": [
"CVE-2009-4118"
],
"10202": [
"CVE-2009-3726"
],
"10203": [
"CVE-2009-1284"
],
"10204": [],
"10205": [
"CVE-2009-2285"
],
"10206": [
"CVE-2009-2473"
],
"10208": [],
"10210": [],
"40301": [],
"40302": [],
"40305": [],
"10221": [
"CVE-2009-4108",
"CVE-2009-4048"
],
"10223": [
"CVE-2009-4105"
],
"10229": [
"CVE-2008-4864"
],
"10237": [
"CVE-2000-0470"
],
"10242": [
"CVE-2009-4017"
],
"10243": [],
"10257": [],
"10303": [],
"10327": [],
"10333": [],
"10334": [],
"10338": [
"CVE-2009-4413",
"CVE-2009-3305"
],
"10343": [],
"10349": [
"CVE-2009-3586"
],
"10352": [],
"10377": [
"CVE-2009-3840"
],
"10469": [],
"14034": [],
"10489": [],
"40306": [],
"40307": [
"CVE-2016-4227"
],
"10553": [
"CVE-2004-1585"
],
"10580": [],
"10593": [],
"10603": [
"CVE-2006-6184"
],
"10617": [],
"10634": [],
"10650": [
"CVE-2008-0747"
],
"10651": [],
"10820": [],
"10825": [],
"10826": [],
"10829": [],
"10840": [],
"10842": [],
"10870": [],
"10879": [],
"10881": [],
"10902": [],
"10904": [],
"10907": [],
"10908": [],
"10909": [],
"10947": [],
"10960": [],
"11009": [
"CVE-2010-0317"
],
"11020": [],
"11021": [],
"11034": [],
"11043": [],
"11044": [],
"11052": [],
"11053": [],
"11062": [],
"11064": [],
"11065": [],
"11070": [
"CVE-2010-0278"
],
"11084": [],
"11095": [],
"11103": [],
"11106": [],
"11117": [],
"11125": [],
"11130": [],
"11131": [],
"11132": [],
"11133": [],
"11142": [],
"11145": [],
"11149": [],
"11150": [],
"11165": [],
"11176": [],
"11180": [],
"11182": [
"CVE-2010-0187"
],
"11190": [],
"11192": [],
"11195": [],
"11196": [],
"11197": [],
"11209": [],
"11214": [],
"11217": [],
"11227": [],
"11228": [],
"11233": [],
"11234": [],
"11245": [],
"11247": [],
"11248": [],
"11254": [],
"11260": [],
"11265": [],
"11266": [],
"11273": [
"CVE-2010-0496"
],
"11276": [],
"11288": [
"CVE-2010-0304"
],
"11291": [],
"11320": [],
"11332": [],
"11338": [],
"11342": [],
"11343": [],
"11347": [],
"11351": [
"CVE-2010-0453"
],
"11363": [],
"11374": [],
"11391": [],
"11392": [],
"11397": [],
"11407": [],
"11426": [],
"11427": [],
"11432": [],
"11438": [],
"11451": [],
"11467": [],
"11469": [],
"11470": [],
"11472": [],
"11492": [],
"11499": [],
"11520": [],
"11529": [
"CVE-2009-3960"
],
"11531": [
"CVE-2010-0718"
],
"11532": [],
"11533": [],
"11534": [],
"11535": [],
"11536": [],
"11537": [],
"11540": [],
"11541": [],
"11546": [],
"11552": [],
"11556": [],
"11567": [
"CVE-2010-1029"
],
"11574": [
"CVE-2010-1029"
],
"11590": [],
"11597": [
"CVE-2010-1544"
],
"11601": [],
"11608": [],
"11617": [],
"11622": [
"CVE-2010-1349"
],
"11628": [],
"11630": [],
"11632": [],
"11633": [],
"11639": [],
"11644": [],
"11652": [],
"11669": [],
"11670": [],
"11705": [],
"11706": [],
"11714": [],
"11717": [],
"11724": [],
"11728": [],
"14367": [
"CVE-2010-2782"
],
"11734": [],
"11736": [],
"11763": [],
"11769": [
"CVE-2010-1226"
],
"11770": [],
"11792": [],
"11803": [],
"11809": [],
"11810": [],
"11827": [],
"11838": [
"CVE-2010-1131"
],
"11839": [],
"11842": [],
"11855": [],
"11861": [],
"11878": [
"CVE-2010-1174"
],
"11880": [
"CVE-2010-0619"
],
"11890": [
"CVE-2010-1179"
],
"11891": [
"CVE-2010-1176"
],
"11893": [],
"11930": [
"CVE-2009-1642"
],
"11932": [],
"11955": [],
"11959": [],
"11966": [],
"11975": [
"CVE-2011-5165"
],
"11977": [],
"11984": [],
"11985": [],
"12000": [],
"12001": [],
"12010": [],
"12011": [],
"12025": [],
"12027": [],
"12030": [
"CVE-2010-5289"
],
"12032": [
"CVE-2010-0805"
],
"12072": [],
"12073": [],
"12074": [],
"12079": [
"CVE-2008-5180"
],
"12080": [],
"12081": [
"CVE-2010-5300"
],
"12093": [],
"12095": [],
"12096": [],
"12104": [],
"12109": [
"CVE-2009-2754",
"CVE-2009-2753"
],
"12110": [],
"12131": [
"CVE-2010-1316"
],
"12154": [],
"12161": [],
"12165": [],
"12188": [
"CVE-2009-3732"
],
"12201": [],
"12204": [],
"12205": [],
"12206": [],
"12207": [],
"12208": [],
"12217": [
"CVE-2010-1159"
],
"12228": [],
"12229": [],
"12240": [
"CVE-2010-1687"
],
"15732": [
"CVE-2010-4259"
],
"12243": [],
"12252": [
"CVE-2010-1460"
],
"12258": [
"CVE-2010-0017"
],
"12259": [],
"12273": [
"CVE-2010-0477",
"CVE-2010-0476",
"CVE-2010-0270",
"CVE-2010-0269"
],
"12274": [
"CVE-2010-1318"
],
"12294": [],
"12297": [],
"12302": [
"CVE-2010-1033"
],
"12314": [],
"12324": [],
"12334": [
"CVE-2010-0740"
],
"12336": [
"CVE-2010-1894",
"CVE-2010-1735"
],
"12337": [
"CVE-2010-1734"
],
"12341": [],
"12344": [],
"12356": [],
"12375": [
"CVE-2010-0105"
],
"12382": [
"CVE-2006-0888"
],
"12401": [],
"12408": [
"CVE-2008-5821"
],
"12422": [],
"12425": [
"CVE-2010-0050"
],
"12431": [],
"12437": [],
"12457": [],
"12477": [],
"12482": [
"CVE-2010-2028"
],
"12487": [
"CVE-2010-1131"
],
"12491": [],
"12492": [],
"12493": [],
"12494": [],
"12508": [],
"12509": [
"CVE-2009-3270",
"CVE-2008-7246",
"CVE-2008-7245",
"CVE-2008-7244"
],
"12518": [
"CVE-2010-0028"
],
"12524": [
"CVE-2009-3103"
],
"12527": [],
"12529": [],
"12530": [
"CVE-2010-2028"
],
"12531": [],
"12541": [],
"12546": [],
"12554": [],
"12555": [],
"12564": [
"CVE-2010-0816"
],
"12578": [
"CVE-2010-1280"
],
"12588": [],
"12602": [],
"12603": [],
"12604": [
"CVE-2005-3294"
],
"12605": [
"CVE-2007-1683"
],
"12650": [],
"12652": [],
"12653": [],
"12655": [],
"28049": [],
"28050": [
"CVE-2013-2470"
],
"28051": [],
"12683": [
"CVE-2010-2115"
],
"12687": [],
"12698": [],
"12704": [],
"12740": [
"CVE-2010-2102"
],
"12741": [],
"12751": [
"CVE-2010-1296"
],
"12752": [
"CVE-2010-1296"
],
"12753": [
"CVE-2010-1296"
],
"12762": [
"CVE-2010-1938"
],
"12774": [],
"12775": [],
"12816": [],
"12852": [],
"12853": [],
"40087": [
"CVE-2016-4135"
],
"40088": [
"CVE-2016-4136"
],
"40089": [
"CVE-2016-4137"
],
"40090": [
"CVE-2016-4138"
],
"40095": [
"CVE-2016-4205"
],
"18615": [
"CVE-2012-5329"
],
"15498": [],
"13774": [],
"13775": [],
"13817": [
"CVE-2010-2321"
],
"13823": [],
"13824": [],
"13825": [],
"13836": [
"CVE-2010-2310"
],
"13837": [],
"13838": [],
"13870": [],
"13871": [
"CVE-2010-2332"
],
"13872": [],
"13876": [
"CVE-2010-2330"
],
"13887": [],
"13888": [
"CVE-2010-2505"
],
"13906": [
"CVE-2010-2351"
],
"13919": [],
"13920": [
"CVE-2010-2349"
],
"13921": [
"CVE-2010-3885",
"CVE-2010-3227"
],
"13934": [
"CVE-2010-2439"
],
"13939": [],
"13958": [],
"13959": [],
"13965": [
"CVE-2010-2440"
],
"14003": [
"CVE-2010-2020"
],
"14010": [
"CVE-2010-1930",
"CVE-2010-1929"
],
"14012": [
"CVE-2010-2435"
],
"14032": [],
"14036": [],
"14037": [],
"14266": [],
"14071": [],
"14072": [],
"14083": [],
"14295": [
"CVE-2010-3886"
],
"14099": [],
"14102": [],
"14121": [
"CVE-2010-2204"
],
"14156": [
"CVE-2010-2549"
],
"14175": [],
"14185": [
"CVE-2010-2156"
],
"14236": [],
"14268": [
"CVE-2010-2621"
],
"14286": [],
"14282": [],
"14290": [],
"15307": [],
"14344": [],
"14346": [],
"14349": [],
"14372": [],
"14379": [
"CVE-2010-2777"
],
"14380": [],
"14408": [],
"14413": [],
"14414": [],
"14422": [
"CVE-2010-1205"
],
"14424": [],
"14452": [],
"14477": [],
"14484": [],
"14504": [
"CVE-2010-2932"
],
"14511": [],
"14525": [],
"14515": [],
"14517": [],
"14533": [
"CVE-2010-5075"
],
"14537": [
"CVE-2010-2008"
],
"14545": [],
"14555": [],
"14573": [
"CVE-2010-2482"
],
"14582": [],
"14587": [],
"14584": [],
"14593": [],
"14594": [
"CVE-2010-1173"
],
"14597": [],
"14601": [],
"14607": [
"CVE-2010-2550"
],
"14608": [
"CVE-2010-1897"
],
"14609": [
"CVE-2010-2561"
],
"14611": [
"CVE-2010-1894"
],
"14613": [],
"14620": [],
"14621": [],
"14624": [],
"14625": [],
"14634": [],
"14642": [
"CVE-2010-2862"
],
"14646": [
"CVE-2007-3336"
],
"14666": [
"CVE-2010-1888"
],
"14667": [
"CVE-2010-1889"
],
"14668": [],
"14669": [
"CVE-2010-1887"
],
"14670": [
"CVE-2010-1890"
],
"14671": [],
"14687": [],
"14678": [],
"14679": [],
"14683": [],
"14685": [],
"14689": [],
"14690": [],
"14695": [],
"14698": [],
"14699": [],
"14705": [],
"14711": [],
"14713": [],
"14761": [],
"14767": [],
"14824": [],
"14832": [],
"14840": [],
"14843": [
"CVE-2010-1818"
],
"14852": [],
"14858": [],
"14869": [
"CVE-2010-0519"
],
"14866": [],
"14882": [],
"14883": [],
"14892": [],
"14904": [],
"14909": [],
"14916": [
"CVE-2010-2703"
],
"14928": [],
"14937": [],
"14938": [
"CVE-2007-3162"
],
"14947": [],
"14949": [
"CVE-2010-1199"
],
"14967": [
"CVE-2010-1813"
],
"14971": [
"CVE-2010-1900"
],
"14974": [],
"14987": [
"CVE-2010-3396"
],
"14990": [],
"14992": [
"CVE-2010-3000"
],
"15008": [],
"15017": [],
"15019": [
"CVE-2010-1248"
],
"15193": [],
"15027": [
"CVE-2010-1214"
],
"15032": [],
"15034": [],
"15035": [
"CVE-2010-0520"
],
"15054": [],
"15061": [],
"15062": [],
"15065": [
"CVE-2010-1248",
"CVE-2010-0824"
],
"15076": [
"CVE-2010-2866"
],
"15112": [
"CVE-2010-2553"
],
"15086": [
"CVE-2010-2168"
],
"15088": [],
"15096": [
"CVE-2010-0480"
],
"15103": [],
"15104": [
"CVE-2010-2752"
],
"15122": [
"CVE-2010-2553"
],
"15131": [],
"15148": [
"CVE-2010-1245"
],
"15158": [
"CVE-2010-2738"
],
"15167": [
"CVE-2010-1899"
],
"15188": [],
"15212": [
"CVE-2010-3631"
],
"15214": [],
"15215": [
"CVE-2010-2632"
],
"15598": [],
"15229": [],
"15242": [
"CVE-2010-2745"
],
"15243": [],
"15245": [
"CVE-2010-3503"
],
"15248": [
"CVE-2010-4371"
],
"15250": [],
"15263": [],
"15264": [],
"15257": [],
"15258": [],
"15259": [
"CVE-2010-4142"
],
"15260": [],
"15261": [
"CVE-2010-4057",
"CVE-2010-4056",
"CVE-2010-4055"
],
"15262": [
"CVE-2010-3329"
],
"15267": [],
"15273": [],
"15283": [],
"15302": [],
"15301": [],
"15293": [
"CVE-2010-2891"
],
"15297": [],
"15305": [],
"15306": [],
"15319": [],
"15334": [],
"15426": [
"CVE-2010-3639"
],
"15341": [
"CVE-2010-3765"
],
"15342": [
"CVE-2010-3765"
],
"15346": [],
"15356": [],
"15378": [],
"15380": [],
"15383": [],
"15384": [],
"15394": [],
"15393": [],
"15407": [],
"15408": [],
"15411": [],
"15418": [
"CVE-2010-3962"
],
"15419": [
"CVE-2010-4091"
],
"15420": [],
"15422": [
"CVE-2007-0548"
],
"15428": [],
"15429": [],
"15431": [
"CVE-2010-3709"
],
"15432": [],
"15433": [],
"15434": [],
"15435": [],
"15436": [],
"15444": [],
"15494": [],
"15495": [],
"15458": [],
"15463": [
"CVE-2010-4711"
],
"15464": [
"CVE-2010-4717"
],
"15467": [
"CVE-2010-3678"
],
"15474": [
"CVE-2010-3894"
],
"15476": [
"CVE-2010-3899"
],
"15482": [],
"15491": [
"CVE-2010-1840"
],
"15493": [],
"15504": [
"CVE-2010-4230"
],
"15508": [
"CVE-2010-4234"
],
"15514": [],
"15558": [],
"15580": [],
"15581": [],
"15582": [],
"15583": [],
"15613": [],
"15619": [
"CVE-2010-4243",
"CVE-2010-3858"
],
"15622": [
"CVE-2010-4249"
],
"15628": [],
"15632": [],
"15635": [],
"16012": [],
"15649": [],
"15657": [],
"15669": [],
"15670": [],
"15671": [],
"15674": [],
"15676": [
"CVE-2010-4300"
],
"15694": [],
"15695": [],
"15697": [],
"15698": [],
"15705": [],
"15707": [
"CVE-2010-4557"
],
"15708": [
"CVE-2010-3971"
],
"15722": [
"CVE-2010-4409"
],
"15803": [
"CVE-2010-3972"
],
"15738": [],
"15739": [],
"15750": [],
"15758": [
"CVE-2010-3944"
],
"15767": [
"CVE-2010-4597"
],
"15786": [],
"15787": [],
"15788": [],
"15792": [],
"15794": [],
"15796": [],
"15805": [],
"15821": [],
"15839": [
"CVE-2010-4701"
],
"15845": [],
"15851": [],
"15860": [
"CVE-2005-3294"
],
"15894": [
"CVE-2010-2744"
],
"15897": [
"CVE-2011-0502"
],
"15898": [
"CVE-2010-4538"
],
"15905": [],
"15925": [],
"15935": [
"CVE-2010-4051",
"CVE-2010-4052"
],
"15940": [
"CVE-2011-0514"
],
"15946": [],
"15959": [],
"15973": [
"CVE-2010-4301"
],
"15974": [
"CVE-2010-4254"
],
"15986": [
"CVE-2011-0507"
],
"15988": [
"CVE-2011-0489"
],
"15992": [
"CVE-2011-0517"
],
"15998": [
"CVE-2011-0515"
],
"16002": [],
"16021": [
"CVE-2011-0652"
],
"16022": [],
"16023": [],
"16035": [],
"16038": [],
"16040": [
"CVE-2010-4709"
],
"16042": [],
"16064": [],
"16068": [],
"16079": [],
"16084": [],
"16095": [
"CVE-2011-0901",
"CVE-2011-0900"
],
"16108": [
"CVE-2011-0522"
],
"16120": [],
"16121": [],
"16129": [
"CVE-2011-1137"
],
"16166": [
"CVE-2011-0654"
],
"16150": [],
"16180": [],
"16182": [
"CVE-2011-0420"
],
"16193": [],
"16204": [],
"16190": [
"CVE-2011-0917"
],
"16191": [
"CVE-2010-4323"
],
"16192": [
"CVE-2010-4328"
],
"16254": [],
"16203": [],
"16216": [],
"16230": [],
"16234": [
"CVE-2010-4227"
],
"16237": [],
"16248": [],
"16255": [],
"16260": [],
"16261": [
"CVE-2011-0708"
],
"16262": [
"CVE-2011-0045"
],
"16263": [
"CVE-2010-4165"
],
"16270": [
"CVE-2011-0762"
],
"16284": [
"CVE-2004-0397"
],
"16365": [
"CVE-2005-1983"
],
"41793": [
"CVE-2017-2474"
],
"16657": [
"CVE-2009-4265"
],
"41798": [
"CVE-2017-2489"
],
"16790": [
"CVE-2004-0313"
],
"16929": [
"CVE-2009-3699"
],
"16939": [],
"16943": [],
"16944": [],
"16945": [],
"16952": [
"CVE-2010-4165"
],
"16960": [],
"16966": [
"CVE-2011-1092"
],
"16973": [
"CVE-2010-4077"
],
"16979": [],
"16986": [],
"16996": [],
"17004": [
"CVE-2011-0421"
],
"17019": [
"CVE-2011-1525"
],
"17020": [
"CVE-2010-4228"
],
"17021": [],
"17023": [],
"17025": [
"CVE-2011-1564",
"CVE-2011-1563"
],
"17032": [],
"17033": [],
"17045": [],
"17070": [],
"17071": [],
"17072": [],
"17074": [],
"17075": [],
"17145": [],
"17087": [],
"17089": [],
"17097": [
"CVE-2011-1547"
],
"17120": [
"CVE-2011-1071"
],
"17133": [],
"17140": [],
"17142": [],
"17143": [],
"17159": [],
"17160": [],
"17161": [],
"17162": [],
"17163": [],
"17164": [],
"17188": [
"CVE-2011-1206"
],
"17201": [
"CVE-2012-2386"
],
"17222": [
"CVE-2011-1761"
],
"17227": [
"CVE-2011-0978"
],
"17266": [],
"17278": [
"CVE-2011-0614"
],
"17273": [],
"17274": [],
"17287": [],
"17291": [],
"17298": [],
"17305": [],
"17351": [],
"17353": [],
"18716": [],
"17363": [],
"17372": [
"CVE-2011-2194"
],
"17455": [],
"17387": [],
"17396": [
"CVE-2011-2641"
],
"17398": [],
"17399": [],
"17400": [],
"17401": [
"CVE-2011-1872"
],
"17405": [],
"17421": [],
"17458": [
"CVE-2011-1865"
],
"17461": [
"CVE-2011-1866"
],
"17463": [],
"17471": [],
"17476": [
"CVE-2009-2521"
],
"17509": [],
"17497": [],
"17501": [],
"17512": [],
"17544": [
"CVE-2011-0041"
],
"17549": [],
"17567": [
"CVE-2011-0222"
],
"17569": [],
"17580": [],
"17582": [],
"17583": [],
"17601": [],
"17610": [
"CVE-2010-3609"
],
"17618": [],
"17620": [],
"17638": [],
"17642": [],
"17643": [
"CVE-2011-1276"
],
"17658": [
"CVE-2011-2900"
],
"17664": [],
"17676": [],
"17696": [
"CVE-2014-5329",
"CVE-2011-3192"
],
"17712": [
"CVE-2011-2131"
],
"17718": [],
"17742": [],
"42604": [
"CVE-2017-1130"
],
"17769": [
"CVE-2011-2918"
],
"17772": [
"CVE-2012-0242",
"CVE-2012-0241"
],
"17781": [],
"17785": [],
"17795": [],
"17796": [],
"21788": [],
"17806": [],
"17815": [],
"21785": [],
"17830": [
"CVE-2011-1248"
],
"17831": [
"CVE-2011-1984"
],
"17835": [
"CVE-2011-3486"
],
"17836": [
"CVE-2011-3488"
],
"17837": [
"CVE-2011-3494"
],
"17838": [
"CVE-2011-3493"
],
"17839": [
"CVE-2011-3501"
],
"17841": [
"CVE-2011-3492"
],
"17842": [
"CVE-2011-3499",
"CVE-2011-3498",
"CVE-2011-3491"
],
"17843": [
"CVE-2011-3489"
],
"17844": [
"CVE-2011-3497",
"CVE-2011-3496",
"CVE-2011-3495",
"CVE-2011-3490"
],
"17856": [
"CVE-2011-5166"
],
"17878": [],
"17879": [],
"17885": [],
"17889": [],
"17890": [],
"17896": [
"CVE-2011-4045",
"CVE-2011-4044",
"CVE-2011-4043",
"CVE-2011-4042"
],
"17901": [
"CVE-2011-0182"
],
"17903": [],
"17908": [
"CVE-2011-4062",
"CVE-2011-3633"
],
"17918": [
"CVE-2011-2443"
],
"17928": [],
"17929": [
"CVE-2011-2841"
],
"17930": [],
"17931": [],
"17933": [],
"17963": [
"CVE-2011-4883",
"CVE-2011-4882",
"CVE-2011-4881",
"CVE-2011-4880"
],
"17964": [],
"17965": [
"CVE-2011-4871"
],
"17978": [
"CVE-2011-2003"
],
"17981": [
"CVE-2011-1965"
],
"17982": [],
"18006": [],
"18007": [],
"18008": [],
"18011": [],
"18014": [],
"18017": [],
"18019": [],
"18023": [],
"18024": [
"CVE-2011-1985"
],
"18025": [],
"18043": [],
"40298": [],
"18028": [],
"18029": [],
"18030": [],
"18049": [
"CVE-2011-4520",
"CVE-2011-4519",
"CVE-2011-4518"
],
"18052": [],
"18078": [],
"18106": [],
"18107": [],
"18119": [
"CVE-2011-5012"
],
"18120": [],
"18112": [
"CVE-2012-5049",
"CVE-2012-5048"
],
"18116": [],
"18124": [],
"18140": [],
"18159": [
"CVE-2011-5129"
],
"18165": [
"CVE-2011-4532",
"CVE-2011-4531",
"CVE-2011-4530",
"CVE-2011-4529"
],
"18166": [
"CVE-2011-4879",
"CVE-2011-4878",
"CVE-2011-4877",
"CVE-2011-4876",
"CVE-2011-4875"
],
"18173": [
"CVE-2011-5173"
],
"18188": [
"CVE-2011-4720"
],
"18200": [],
"18196": [
"CVE-2011-4040"
],
"18199": [],
"18220": [
"CVE-2011-5171"
],
"18221": [
"CVE-2014-5329",
"CVE-2011-3192"
],
"18223": [],
"18225": [
"CVE-2011-5033"
],
"18257": [
"CVE-2011-5233"
],
"18254": [
"CVE-2011-5043"
],
"18256": [
"CVE-2012-0025",
"CVE-2011-5232"
],
"18268": [],
"18269": [
"CVE-2011-5049"
],
"18270": [],
"18271": [],
"18272": [],
"18275": [
"CVE-2011-5046"
],
"18278": [],
"18285": [],
"18295": [
"CVE-2011-4362"
],
"18296": [
"CVE-2011-4885"
],
"19024": [],
"18305": [
"CVE-2011-4885"
],
"18309": [
"CVE-2012-0904"
],
"18318": [],
"18977": [],
"18978": [],
"18327": [
"CVE-2011-4191"
],
"18328": [
"CVE-2011-4191"
],
"18336": [
"CVE-2012-0902"
],
"18337": [
"CVE-2012-6044"
],
"18339": [
"CVE-2012-6042"
],
"18351": [
"CVE-2011-4191"
],
"18370": [
"CVE-2012-0781",
"CVE-2011-4153"
],
"18378": [
"CVE-2012-0207"
],
"18976": [],
"18399": [],
"18698": [],
"18427": [
"CVE-2012-5324"
],
"18436": [
"CVE-2012-0809"
],
"18440": [],
"18453": [
"CVE-2012-1008"
],
"18454": [
"CVE-2012-1009"
],
"18457": [],
"18458": [],
"18460": [
"CVE-2012-0830"
],
"18461": [],
"18463": [],
"18469": [],
"18475": [],
"18481": [],
"18488": [],
"18489": [],
"18490": [],
"18491": [],
"18493": [
"CVE-2012-0292"
],
"18507": [],
"18512": [],
"18524": [
"CVE-2012-1783"
],
"18541": [
"CVE-2012-1465"
],
"18546": [
"CVE-2011-4189"
],
"18552": [],
"18600": [],
"18601": [],
"18579": [
"CVE-2012-1502"
],
"18584": [
"CVE-2012-1774"
],
"18586": [],
"18587": [],
"18602": [],
"18606": [
"CVE-2012-0002"
],
"18705": [
"CVE-2012-2210"
],
"18628": [],
"18629": [],
"18630": [],
"18633": [
"CVE-2012-2027"
],
"18636": [
"CVE-2012-4865"
],
"18637": [
"CVE-2012-4864"
],
"18641": [
"CVE-2012-0284"
],
"18643": [
"CVE-2015-6750",
"CVE-2012-5002"
],
"18654": [],
"18661": [
"CVE-2012-1904"
],
"18665": [],
"18671": [
"CVE-2012-5905"
],
"18717": [],
"18688": [
"CVE-2012-0407",
"CVE-2012-0406"
],
"18691": [],
"18692": [
"CVE-2012-5917"
],
"18719": [],
"18771": [],
"18734": [
"CVE-2012-2277",
"CVE-2012-2276"
],
"18739": [
"CVE-2012-0278"
],
"18751": [
"CVE-2012-4330",
"CVE-2012-4329"
],
"18754": [],
"18755": [
"CVE-2011-1249"
],
"18756": [
"CVE-2012-2131",
"CVE-2012-2110"
],
"18757": [
"CVE-2012-2396"
],
"18758": [
"CVE-2012-1593"
],
"18765": [
"CVE-2012-4335",
"CVE-2012-4334",
"CVE-2012-4333",
"CVE-2012-4330",
"CVE-2012-4329"
],
"18774": [],
"18776": [],
"18777": [
"CVE-2012-0163"
],
"18799": [
"CVE-2012-4057"
],
"18795": [
"CVE-2012-2442"
],
"18816": [
"CVE-2012-3845"
],
"18817": [
"CVE-2012-6050"
],
"18819": [],
"18864": [],
"18851": [
"CVE-2012-6048"
],
"18852": [],
"18853": [
"CVE-2012-2612",
"CVE-2012-2611",
"CVE-2012-2514",
"CVE-2012-2513",
"CVE-2012-2512",
"CVE-2012-2511",
"CVE-2011-1516"
],
"18855": [
"CVE-2012-1184"
],
"18879": [],
"18877": [],
"18878": [
"CVE-2012-3797",
"CVE-2012-3796",
"CVE-2012-3795",
"CVE-2012-3794",
"CVE-2012-3793",
"CVE-2012-3792"
],
"18890": [],
"18909": [],
"18894": [
"CVE-2012-0181"
],
"18902": [
"CVE-2012-2940"
],
"18903": [],
"18910": [],
"18916": [
"CVE-2012-0289"
],
"18918": [
"CVE-2012-2393"
],
"18919": [
"CVE-2012-3826",
"CVE-2012-3825",
"CVE-2012-2392"
],
"18920": [
"CVE-2012-2394"
],
"18926": [],
"18931": [],
"18945": [
"CVE-2012-3816"
],
"18946": [],
"18940": [],
"18952": [],
"18956": [
"CVE-2012-2763"
],
"18958": [
"CVE-2012-0985"
],
"18962": [],
"18964": [],
"18972": [],
"19000": [],
"19034": [],
"19046": [
"CVE-1999-1015"
],
"19049": [],
"19064": [
"CVE-2012-1493"
],
"19075": [],
"19076": [],
"19082": [
"CVE-1999-1442"
],
"19085": [
"CVE-1999-1441"
],
"19089": [],
"19098": [
"CVE-2012-0677"
],
"19103": [
"CVE-1999-0015"
],
"19385": [],
"19117": [
"CVE-1999-0513"
],
"19130": [],
"19137": [
"CVE-2009-0695",
"CVE-2009-0693"
],
"19413": [
"CVE-1999-0918"
],
"19391": [
"CVE-2011-4222",
"CVE-2011-4221",
"CVE-2011-4220"
],
"19392": [
"CVE-2011-4222",
"CVE-2011-4221",
"CVE-2011-4220"
],
"19161": [
"CVE-1999-1423"
],
"19181": [],
"19182": [],
"19183": [],
"19184": [],
"19389": [
"CVE-2012-1831"
],
"19388": [
"CVE-2012-1830"
],
"19207": [
"CVE-1999-1033"
],
"19212": [
"CVE-1999-1030"
],
"19225": [
"CVE-1999-0771"
],
"19228": [],
"19230": [
"CVE-1999-1028"
],
"19238": [
"CVE-1999-0288"
],
"19241": [
"CVE-1999-0804"
],
"19250": [
"CVE-1999-0460"
],
"19265": [],
"19271": [
"CVE-1999-0451"
],
"19272": [
"CVE-1999-0400"
],
"19278": [
"CVE-1999-1408"
],
"19282": [],
"19289": [],
"19290": [],
"19301": [
"CVE-1999-1018"
],
"19308": [],
"19410": [
"CVE-1999-0441"
],
"19326": [
"CVE-1999-0417"
],
"19328": [],
"19331": [],
"19332": [],
"19333": [],
"19334": [],
"19335": [
"CVE-2012-0282"
],
"19336": [
"CVE-2012-0277"
],
"19337": [
"CVE-2012-0276"
],
"19338": [
"CVE-2012-0276"
],
"19340": [
"CVE-2012-2614"
],
"19357": [
"CVE-1999-1399"
],
"19368": [],
"19372": [
"CVE-1999-0562"
],
"19382": [],
"19377": [
"CVE-1999-1557"
],
"19378": [],
"19379": [
"CVE-1999-1046"
],
"19380": [
"CVE-1999-1551"
],
"19393": [
"CVE-2011-4222",
"CVE-2011-4221",
"CVE-2011-4220"
],
"29039": [],
"19409": [
"CVE-2012-4357",
"CVE-2012-4356",
"CVE-2012-4355",
"CVE-2012-4354",
"CVE-2012-4353",
"CVE-2012-3815"
],
"19414": [
"CVE-1999-0918"
],
"19415": [
"CVE-1999-0918"
],
"19416": [
"CVE-1999-0752"
],
"19423": [
"CVE-1999-1518"
],
"19436": [
"CVE-1999-0770"
],
"19441": [
"CVE-1999-0683"
],
"19445": [
"CVE-1999-0681"
],
"19446": [],
"19453": [],
"19456": [],
"19457": [
"CVE-1999-0867"
],
"19463": [
"CVE-1999-0746"
],
"19471": [
"CVE-1999-1016"
],
"19477": [
"CVE-1999-1515"
],
"19482": [
"CVE-2012-3236"
],
"19483": [
"CVE-2012-3585"
],
"19488": [
"CVE-2000-0489"
],
"19489": [],
"19505": [
"CVE-1999-0912"
],
"19507": [
"CVE-1999-0908"
],
"19513": [
"CVE-1999-1533"
],
"19531": [
"CVE-1999-0063"
],
"19536": [
"CVE-1999-0045"
],
"19541": [],
"19562": [
"CVE-1999-0931"
],
"19563": [],
"19564": [
"CVE-1999-0905"
],
"19569": [
"CVE-1999-0950"
],
"19571": [
"CVE-1999-1532"
],
"19575": [],
"19577": [
"CVE-1999-0980"
],
"19578": [
"CVE-1999-0980"
],
"19675": [
"CVE-1999-0986"
],
"19596": [
"CVE-1999-0904"
],
"19605": [
"CVE-2012-3375"
],
"19615": [
"CVE-1999-0848"
],
"19616": [],
"19619": [
"CVE-1999-1539"
],
"19624": [
"CVE-1999-1519"
],
"19635": [],
"19636": [],
"19638": [
"CVE-1999-0999"
],
"19639": [
"CVE-1999-0844"
],
"19640": [
"CVE-1999-0844"
],
"19664": [
"CVE-1999-0838"
],
"19666": [
"CVE-1999-0991"
],
"19681": [
"CVE-2000-0032"
],
"19687": [
"CVE-2000-0001"
],
"19695": [
"CVE-2000-0014"
],
"19701": [
"CVE-1999-1109"
],
"19702": [
"CVE-2000-0043"
],
"19703": [
"CVE-2000-0011"
],
"19711": [
"CVE-2000-0056"
],
"19716": [],
"19720": [
"CVE-2000-0049"
],
"19725": [
"CVE-2000-0075"
],
"19740": [
"CVE-2000-0131"
],
"19744": [
"CVE-2000-0146"
],
"19746": [
"CVE-2000-0152"
],
"19748": [
"CVE-2000-0139"
],
"19750": [
"CVE-2000-0142"
],
"19755": [
"CVE-2000-0166"
],
"19759": [
"CVE-2000-0211"
],
"19760": [
"CVE-2000-0212"
],
"19766": [
"CVE-2000-0221"
],
"19772": [
"CVE-2012-6303"
],
"19777": [
"CVE-2012-1858"
],
"19780": [
"CVE-2000-0204"
],
"19782": [
"CVE-2000-0179"
],
"19783": [
"CVE-1999-0744"
],
"19799": [
"CVE-2000-0168"
],
"19806": [
"CVE-2000-0198"
],
"19807": [
"CVE-2000-0198"
],
"19810": [
"CVE-2000-0239"
],
"19817": [],
"19818": [
"CVE-2000-0227"
],
"19820": [
"CVE-2000-0243"
],
"19827": [
"CVE-2000-0232"
],
"19963": [],
"19834": [
"CVE-2000-0280"
],
"19835": [
"CVE-2000-0278"
],
"19843": [
"CVE-2000-0262"
],
"19850": [
"CVE-2000-0286",
"CVE-2000-0263"
],
"19853": [
"CVE-2000-0256"
],
"19854": [
"CVE-2000-0257"
],
"19856": [
"CVE-2000-0272"
],
"19960": [
"CVE-2012-1744"
],
"19866": [],
"19869": [
"CVE-2000-1198"
],
"19870": [
"CVE-2000-0338"
],
"19880": [
"CVE-2000-0324"
],
"19884": [
"CVE-2000-0341"
],
"19885": [
"CVE-2003-0336",
"CVE-2000-0342"
],
"19896": [
"CVE-2000-0440"
],
"19899": [
"CVE-2000-0426"
],
"19907": [
"CVE-2000-0408"
],
"19919": [
"CVE-1999-0416"
],
"19920": [
"CVE-2000-0395"
],
"19923": [
"CVE-2000-0417"
],
"19965": [
"CVE-2000-0444"
],
"19938": [
"CVE-2000-0463"
],
"19940": [
"CVE-2000-0394"
],
"19941": [
"CVE-2000-0394"
],
"19950": [
"CVE-2000-0453"
],
"19961": [
"CVE-2012-1770"
],
"19962": [
"CVE-2012-1769"
],
"19974": [
"CVE-2000-0495"
],
"19977": [
"CVE-2000-0474"
],
"19982": [],
"19984": [
"CVE-2000-0476"
],
"19986": [],
"19987": [],
"19988": [],
"19994": [
"CVE-2000-0482"
],
"19996": [
"CVE-2000-0538"
],
"20005": [
"CVE-2000-0377"
],
"20006": [
"CVE-2000-0377"
],
"20015": [
"CVE-2000-0473"
],
"20016": [
"CVE-2000-0480"
],
"20017": [
"CVE-2000-0484"
],
"20020": [
"CVE-2000-0501"
],
"20023": [
"CVE-2000-0504"
],
"20025": [
"CVE-2000-0508"
],
"20026": [
"CVE-2000-0531"
],
"20039": [
"CVE-2000-0601"
],
"20047": [
"CVE-2000-0581"
],
"20049": [
"CVE-2000-0582"
],
"20050": [],
"20051": [
"CVE-2000-0569"
],
"20052": [
"CVE-2000-0570"
],
"20054": [
"CVE-2000-0571"
],
"20069": [
"CVE-2000-0648"
],
"20071": [
"CVE-2000-1078"
],
"20072": [
"CVE-2000-0669"
],
"20080": [
"CVE-2000-0626"
],
"20090": [
"CVE-2000-0636"
],
"20094": [
"CVE-2000-0624"
],
"20098": [
"CVE-2000-0655"
],
"20099": [
"CVE-2000-0656"
],
"20100": [
"CVE-2000-0644"
],
"20101": [
"CVE-2000-0645"
],
"20102": [
"CVE-2000-0647"
],
"43147": [
"CVE-2017-9675"
],
"20167": [
"CVE-2011-2702"
],
"20175": [
"CVE-2000-1002",
"CVE-2000-0708"
],
"20178": [
"CVE-2000-0766"
],
"20192": [
"CVE-2000-0880"
],
"20217": [
"CVE-2000-0829"
],
"20219": [
"CVE-2000-0830"
],
"20221": [
"CVE-2000-0833"
],
"20225": [
"CVE-2000-1021"
],
"20226": [
"CVE-2012-3549"
],
"20228": [
"CVE-2000-1035"
],
"20229": [
"CVE-2000-0848"
],
"20233": [
"CVE-2000-0908"
],
"20239": [
"CVE-2000-1058"
],
"20254": [],
"20255": [],
"20271": [
"CVE-2000-0914"
],
"20272": [
"CVE-1999-0926",
"CVE-1999-0925"
],
"20282": [
"CVE-2000-0953"
],
"20289": [
"CVE-2000-0983"
],
"20295": [],
"20304": [
"CVE-1999-0970"
],
"20307": [
"CVE-2000-0991"
],
"20310": [
"CVE-2000-0167"
],
"20311": [
"CVE-2000-0971"
],
"20323": [
"CVE-2000-0984"
],
"20328": [
"CVE-2000-0989"
],
"20331": [
"CVE-1999-0193"
],
"20332": [
"CVE-1999-0193"
],
"20336": [
"CVE-2000-1025"
],
"43153": [
"CVE-2017-11861"
],
"20373": [
"CVE-2000-1028"
],
"20376": [],
"20379": [
"CVE-2000-0299"
],
"20388": [
"CVE-2000-0887"
],
"20400": [],
"21041": [],
"20403": [
"CVE-2000-0897"
],
"20432": [
"CVE-2000-1129"
],
"20437": [
"CVE-1999-0153 "
],
"20438": [
"CVE-1999-0153"
],
"20439": [
"CVE-1999-0153"
],
"20440": [
"CVE-1999-0153"
],
"20464": [],
"20470": [
"CVE-2001-0052"
],
"20473": [
"CVE-2001-0041"
],
"20479": [],
"20484": [
"CVE-1999-0178"
],
"20487": [
"CVE-2001-0049"
],
"20494": [
"CVE-2001-0026"
],
"20508": [
"CVE-1999-0140"
],
"20509": [
"CVE-2001-0080"
],
"20515": [],
"20518": [
"CVE-2001-0097"
],
"20531": [
"CVE-2001-0122"
],
"20532": [
"CVE-2001-0007"
],
"20534": [
"CVE-2001-0177"
],
"20535": [
"CVE-2001-0172"
],
"20536": [
"CVE-2001-0136"
],
"20705": [
"CVE-2012-2612",
"CVE-2012-2611",
"CVE-2012-2514",
"CVE-2012-2513",
"CVE-2012-2512",
"CVE-2012-2511"
],
"20552": [
"CVE-2001-0322"
],
"20558": [
"CVE-1999-0107"
],
"20561": [
"CVE-1999-0144"
],
"20562": [
"CVE-1999-0144"
],
"20564": [
"CVE-1999-0294"
],
"20566": [
"CVE-1999-0431"
],
"20613": [
"CVE-2001-0324"
],
"20644": [
"CVE-2001-0270"
],
"20589": [
"CVE-2001-0184"
],
"20596": [
"CVE-2001-0006"
],
"20610": [],
"20634": [
"CVE-2001-0302"
],
"20641": [
"CVE-2001-0277"
],
"20650": [
"CVE-2001-0298"
],
"20654": [
"CVE-2001-0564"
],
"20655": [
"CVE-2001-0647"
],
"20656": [],
"20659": [
"CVE-2001-0697"
],
"20662": [
"CVE-2001-0171"
],
"20664": [
"CVE-2001-0151"
],
"20681": [
"CVE-2001-0460"
],
"20682": [],
"20696": [
"CVE-2001-0584"
],
"20728": [],
"20734": [
"CVE-2001-0375"
],
"20735": [
"CVE-2001-0579"
],
"20736": [
"CVE-2001-0578"
],
"20737": [
"CVE-2001-0575"
],
"20739": [
"CVE-2001-0576"
],
"20742": [
"CVE-2001-0577"
],
"20747": [
"CVE-2001-0419"
],
"20750": [
"CVE-2001-0432"
],
"20753": [
"CVE-2001-0390"
],
"20763": [
"CVE-2001-0239"
],
"20770": [
"CVE-2001-0385"
],
"20771": [
"CVE-2001-0386"
],
"20779": [],
"20783": [
"CVE-2001-0675"
],
"20784": [],
"20792": [
"CVE-2001-0442"
],
"20802": [
"CVE-1999-0281"
],
"20810": [
"CVE-1999-0016"
],
"20811": [
"CVE-1999-0016"
],
"20812": [
"CVE-1999-0016"
],
"20813": [
"CVE-1999-0016"
],
"20814": [
"CVE-1999-0016"
],
"20821": [
"CVE-2001-0741"
],
"20824": [
"CVE-2001-0566"
],
"20827": [
"CVE-2001-0580"
],
"20828": [
"CVE-2001-0581"
],
"20830": [
"CVE-2001-0558"
],
"20834": [
"CVE-2001-0563"
],
"20844": [
"CVE-2001-0649"
],
"20845": [
"CVE-2001-0646"
],
"20846": [
"CVE-2001-0336"
],
"20847": [
"CVE-2001-0740"
],
"20852": [
"CVE-2001-0746"
],
"20853": [
"CVE-2001-0746"
],
"20854": [],
"20870": [],
"20883": [
"CVE-2001-0616"
],
"20904": [
"CVE-2001-1263"
],
"20907": [
"CVE-2001-0348"
],
"20917": [],
"20955": [],
"20922": [
"CVE-2001-0706"
],
"20930": [
"CVE-2001-0500"
],
"20946": [
"CVE-2001-0702"
],
"20949": [
"CVE-2001-0703"
],
"20952": [
"CVE-2001-1078"
],
"20957": [],
"20971": [
"CVE-2012-4170"
],
"20973": [
"CVE-2001-1083"
],
"20989": [
"CVE-2001-1243"
],
"20991": [
"CVE-2001-1243"
],
"20997": [
"CVE-2001-1244"
],
"21006": [],
"21012": [
"CVE-1999-1569"
],
"40421": [
"CVE-2016-4275"
],
"21016": [],
"21028": [
"CVE-2001-1097"
],
"40420": [],
"21040": [
"CVE-2001-1055"
],
"21042": [
"CVE-2001-1289"
],
"21047": [
"CVE-2001-1122"
],
"21048": [],
"21074": [
"CVE-2001-0965"
],
"21077": [
"CVE-2001-1133"
],
"21092": [
"CVE-2001-1064"
],
"40419": [],
"21099": [
"CVE-2001-1518"
],
"21103": [
"CVE-2001-1137"
],
"21122": [
"CVE-2001-0907"
],
"21123": [
"CVE-2001-0663"
],
"21126": [
"CVE-2001-0830"
],
"21131": [
"CVE-2001-1560"
],
"21147": [],
"21141": [
"CVE-2001-0852"
],
"21143": [],
"21162": [
"CVE-2001-0932"
],
"21163": [
"CVE-2001-0932"
],
"21167": [
"CVE-2001-1559"
],
"21170": [
"CVE-2001-0952"
],
"21171": [
"CVE-2001-0951"
],
"21172": [
"CVE-2001-0951"
],
"21174": [
"CVE-2001-1184"
],
"21175": [
"CVE-2001-1184"
],
"21177": [
"CVE-2001-1186"
],
"40757": [
"CVE-2015-0040"
],
"21181": [
"CVE-2001-1491",
"CVE-2001-1490",
"CVE-2001-1489"
],
"21202": [],
"21213": [
"CVE-2002-0115"
],
"21224": [
"CVE-2012-3221"
],
"21228": [
"CVE-2002-0128"
],
"21232": [],
"21234": [
"CVE-2002-0135"
],
"21236": [
"CVE-2002-0140"
],
"21237": [
"CVE-2002-0201"
],
"21240": [
"CVE-2002-2105"
],
"21245": [
"CVE-2002-1712"
],
"21246": [
"CVE-2002-1712"
],
"21261": [
"CVE-2002-2071"
],
"21262": [
"CVE-2002-0227"
],
"21275": [
"CVE-2002-1773"
],
"21293": [
"CVE-2002-0289"
],
"21296": [
"CVE-2002-0013"
],
"21305": [
"CVE-2002-0336"
],
"21306": [
"CVE-2002-0335"
],
"21307": [
"CVE-2002-0338"
],
"21326": [
"CVE-2012-0271"
],
"21333": [],
"21336": [
"CVE-2002-0448"
],
"21337": [
"CVE-2002-0406"
],
"21338": [
"CVE-2002-0431"
],
"21345": [
"CVE-2002-0454"
],
"21346": [
"CVE-2002-0461"
],
"21366": [],
"21419": [],
"21379": [
"CVE-2002-0552"
],
"21387": [
"CVE-2002-0595"
],
"21388": [
"CVE-2002-0597"
],
"21389": [
"CVE-2002-0597"
],
"21404": [
"CVE-2002-1714"
],
"21409": [
"CVE-2002-0741"
],
"21413": [
"CVE-2002-0748"
],
"21416": [],
"21428": [],
"21429": [
"CVE-2002-0606"
],
"21431": [
"CVE-2000-1193"
],
"21432": [
"CVE-2002-0106"
],
"21465": [
"CVE-2002-2315"
],
"21471": [
"CVE-2002-0894"
],
"21472": [
"CVE-2002-0886"
],
"21476": [
"CVE-2002-1827"
],
"21477": [
"CVE-2002-1827"
],
"21481": [
"CVE-2002-1831"
],
"21482": [
"CVE-2002-0900"
],
"21498": [
"CVE-2002-0876"
],
"21508": [],
"21512": [
"CVE-2002-0913"
],
"21518": [],
"21523": [
"CVE-2011-1613"
],
"21531": [],
"21534": [
"CVE-2002-0936"
],
"21536": [
"CVE-2002-0937"
],
"21537": [
"CVE-2002-1891"
],
"21539": [
"CVE-2002-2338"
],
"21540": [
"CVE-2002-0186"
],
"21544": [
"CVE-2002-1766"
],
"21556": [
"CVE-2002-1705"
],
"21561": [
"CVE-2002-1071"
],
"21569": [
"CVE-2002-0859"
],
"21572": [
"CVE-2002-0964"
],
"21575": [
"CVE-2002-0653"
],
"21580": [
"CVE-2002-1013"
],
"21593": [],
"21594": [
"CVE-2002-1029"
],
"21598": [],
"21600": [
"CVE-2002-1023"
],
"21612": [
"CVE-2002-1043"
],
"21620": [
"CVE-2002-1028"
],
"21632": [
"CVE-2002-2309"
],
"21634": [
"CVE-2002-1059"
],
"21637": [
"CVE-2002-1072"
],
"21644": [
"CVE-2002-2325"
],
"21645": [],
"21653": [
"CVE-2002-2306"
],
"21655": [
"CVE-2002-0813"
],
"21656": [
"CVE-2002-2149"
],
"21657": [
"CVE-2002-1426"
],
"21673": [
"CVE-2002-1077"
],
"21694": [
"CVE-2002-2174"
],
"21703": [],
"21712": [
"CVE-2002-1444"
],
"21736": [],
"21737": [],
"21739": [
"CVE-2012-6307"
],
"21741": [
"CVE-2012-4988"
],
"21746": [
"CVE-2002-0724"
],
"21747": [
"CVE-2002-0724"
],
"21756": [
"CVE-2002-1811"
],
"21770": [
"CVE-2002-1101"
],
"21775": [
"CVE-2002-2370"
],
"21782": [],
"21789": [
"CVE-2002-2164"
],
"21791": [
"CVE-2002-1501"
],
"21792": [
"CVE-2002-1828"
],
"21795": [
"CVE-2002-1489"
],
"21813": [
"CVE-2002-1486"
],
"21816": [
"CVE-2002-1486"
],
"21819": [
"CVE-2002-1487"
],
"21821": [
"CVE-2002-1488"
],
"21823": [
"CVE-2002-1486"
],
"21824": [],
"21826": [],
"21828": [
"CVE-2002-1147"
],
"21830": [],
"21854": [
"CVE-2002-1850"
],
"21889": [
"CVE-2012-5470"
],
"21907": [
"CVE-2002-1522"
],
"21908": [
"CVE-2002-1522"
],
"21909": [
"CVE-2002-1522"
],
"21911": [
"CVE-2002-0386"
],
"21915": [
"CVE-2002-2336"
],
"33403": [
"CVE-2009-4462"
],
"21935": [
"CVE-2002-1897"
],
"21938": [
"CVE-2002-1907"
],
"21939": [
"CVE-2002-1906"
],
"21941": [
"CVE-2002-1905"
],
"21943": [
"CVE-2002-1911"
],
"21949": [
"CVE-2002-1169"
],
"21951": [
"CVE-2002-1561"
],
"21952": [
"CVE-2002-1561"
],
"21953": [
"CVE-2002-1561"
],
"21954": [
"CVE-2002-1561"
],
"21963": [
"CVE-2002-1542"
],
"21965": [
"CVE-2002-1539"
],
"21971": [
"CVE-2002-2379"
],
"21972": [
"CVE-2002-1862"
],
"21973": [
"CVE-2002-1945"
],
"21975": [
"CVE-2002-1236"
],
"21978": [
"CVE-2002-1865"
],
"21981": [
"CVE-2002-1663"
],
"21982": [
"CVE-2002-1248"
],
"21984": [
"CVE-2002-1983"
],
"21985": [
"CVE-2002-1320"
],
"21986": [],
"21991": [],
"22006": [
"CVE-2012-4750"
],
"22010": [
"CVE-2002-2385"
],
"22011": [
"CVE-2002-1220"
],
"22019": [
"CVE-2002-2404"
],
"22031": [
"CVE-2002-1322"
],
"22033": [],
"22053": [
"CVE-2002-2258"
],
"22056": [
"CVE-2002-2295"
],
"22059": [],
"22060": [
"CVE-2002-2300"
],
"22061": [
"CVE-2002-1580"
],
"22062": [],
"22068": [
"CVE-2002-2272"
],
"22074": [],
"22079": [],
"22081": [
"CVE-2002-2232"
],
"22100": [],
"22105": [
"CVE-2002-1380"
],
"22110": [],
"22117": [
"CVE-2003-1263"
],
"22118": [
"CVE-2003-1263"
],
"22119": [
"CVE-2003-1275"
],
"22121": [
"CVE-2003-1266"
],
"22122": [
"CVE-2003-1266"
],
"22123": [
"CVE-2003-1266"
],
"22124": [
"CVE-2003-1266"
],
"22132": [],
"22155": [],
"22154": [],
"22162": [],
"22172": [
"CVE-2003-1342"
],
"22183": [
"CVE-2003-1354"
],
"22191": [],
"22196": [],
"22197": [
"CVE-2003-0056"
],
"22207": [],
"22214": [],
"22215": [],
"22220": [
"CVE-2003-1369"
],
"22221": [
"CVE-2003-1368"
],
"22223": [
"CVE-2003-1431"
],
"22230": [],
"22232": [
"CVE-2001-0909"
],
"22237": [],
"22239": [
"CVE-2003-1387"
],
"22240": [
"CVE-2003-1397"
],
"22243": [
"CVE-2003-1445"
],
"22245": [
"CVE-2003-1407"
],
"22249": [
"CVE-2003-0087"
],
"22250": [
"CVE-1999-1566"
],
"22255": [],
"22258": [],
"22259": [
"CVE-2003-1450"
],
"22273": [
"CVE-2003-0107"
],
"22286": [],
"22287": [
"CVE-2003-1419"
],
"22290": [
"CVE-2003-1355"
],
"22294": [
"CVE-2003-0108"
],
"22302": [],
"22303": [],
"22330": [],
"22333": [],
"22334": [],
"22310": [],
"22328": [],
"22345": [
"CVE-2003-0125"
],
"22352": [],
"22358": [],
"22359": [],
"22360": [],
"22370": [
"CVE-2003-0128"
],
"22390": [],
"22395": [],
"22397": [
"CVE-2012-5409"
],
"22401": [],
"22402": [],
"22406": [
"CVE-2012-4515",
"CVE-2012-4514",
"CVE-2012-4513",
"CVE-2012-4512"
],
"22407": [],
"22415": [],
"22417": [
"CVE-2003-0220"
],
"22419": [
"CVE-2003-0166"
],
"22420": [],
"22425": [
"CVE-2003-0166"
],
"22426": [
"CVE-2003-0166"
],
"22433": [],
"22435": [],
"22440": [],
"22441": [],
"22446": [],
"22447": [
"CVE-2003-0169"
],
"22460": [
"CVE-2003-1364"
],
"22464": [],
"22467": [],
"22483": [],
"22494": [],
"22502": [],
"22503": [],
"22505": [
"CVE-2003-1054"
],
"22508": [
"CVE-2003-0211"
],
"22512": [],
"22514": [],
"22516": [],
"22518": [],
"22527": [],
"22535": [],
"22536": [],
"22537": [
"CVE-2003-0390"
],
"22550": [
"CVE-2003-1396"
],
"22551": [
"CVE-2003-1472"
],
"22552": [
"CVE-2003-1097"
],
"22553": [
"CVE-2003-0117"
],
"22560": [
"CVE-2003-1478"
],
"22561": [
"CVE-2003-1461"
],
"22568": [
"CVE-2003-0263"
],
"22569": [
"CVE-2003-0263"
],
"22576": [],
"22581": [
"CVE-2003-0280"
],
"22582": [
"CVE-2003-0280"
],
"22585": [
"CVE-2003-0290"
],
"22586": [
"CVE-2003-0290"
],
"22587": [
"CVE-2003-0276"
],
"22591": [],
"22596": [],
"22602": [
"CVE-2003-0293"
],
"22608": [
"CVE-2003-0314"
],
"22610": [
"CVE-2003-0315"
],
"22619": [
"CVE-2003-0195"
],
"22621": [],
"22624": [],
"22629": [],
"22634": [
"CVE-2003-0372"
],
"22637": [
"CVE-2003-0371"
],
"22638": [],
"22647": [],
"22650": [
"CVE-2003-0409"
],
"22653": [],
"22655": [],
"22660": [],
"22666": [],
"22667": [],
"22668": [],
"22670": [
"CVE-2003-0226"
],
"22679": [],
"22680": [],
"22681": [
"CVE-2009-5022"
],
"22685": [],
"40411": [
"CVE-2016-5725"
],
"22690": [],
"22694": [],
"22700": [],
"22701": [],
"22706": [],
"22707": [],
"22718": [
"CVE-2003-1032"
],
"22739": [
"CVE-2012-2619"
],
"22749": [],
"22757": [],
"22759": [],
"22774": [],
"22780": [],
"22788": [],
"22789": [],
"22790": [],
"22794": [],
"22796": [],
"22797": [],
"22800": [
"CVE-2003-0487"
],
"22801": [
"CVE-2003-0487"
],
"22802": [
"CVE-2003-0487"
],
"22803": [
"CVE-2003-0487"
],
"22814": [],
"22816": [
"CVE-2003-0470"
],
"22817": [],
"22822": [],
"22823": [],
"22825": [],
"22831": [
"CVE-2003-0723"
],
"22839": [
"CVE-2003-0478"
],
"22844": [],
"22846": [
"CVE-2003-0508"
],
"22850": [],
"22855": [
"CVE-2012-3755"
],
"22859": [],
"22875": [],
"22876": [],
"22878": [],
"22897": [],
"22899": [],
"22900": [],
"22902": [
"CVE-2012-5533"
],
"22904": [
"CVE-2012-0698"
],
"22945": [],
"22947": [],
"22949": [
"CVE-2003-0562"
],
"22950": [],
"22952": [
"CVE-2003-0625"
],
"22957": [
"CVE-2003-0231"
],
"22962": [
"CVE-2003-0511"
],
"22918": [],
"22920": [],
"22926": [
"CVE-2003-0595"
],
"22935": [],
"22938": [
"CVE-2012-4409"
],
"22970": [],
"23003": [],
"22978": [],
"22981": [
"CVE-2003-0540"
],
"22982": [
"CVE-2003-0540"
],
"40406": [
"CVE-2016-3357"
],
"22983": [],
"22987": [],
"22991": [],
"22999": [],
"40405": [
"CVE-2016-5310",
"CVE-2016-5309"
],
"23042": [],
"23048": [],
"23050": [
"CVE-2003-1321"
],
"23051": [],
"23053": [],
"23056": [
"CVE-2003-0760"
],
"23075": [
"CVE-2012-5611"
],
"23076": [
"CVE-2012-5612"
],
"23078": [
"CVE-2012-5614"
],
"23086": [],
"23087": [
"CVE-2003-0757"
],
"23088": [],
"23089": [],
"23090": [],
"23101": [],
"23102": [
"CVE-2003-0762"
],
"23107": [
"CVE-2012-6470"
],
"23112": [
"CVE-2003-0758"
],
"23116": [
"CVE-2003-0706"
],
"23117": [
"CVE-2003-0766"
],
"23118": [
"CVE-2003-0766"
],
"23124": [
"CVE-2003-0765"
],
"23130": [],
"23138": [
"CVE-2003-0780"
],
"23139": [],
"23142": [],
"23145": [
"CVE-1999-0284"
],
"23146": [
"CVE-1999-0284"
],
"23150": [],
"23165": [],
"23166": [
"CVE-2003-1158"
],
"23167": [
"CVE-1999-0393"
],
"23169": [],
"23170": [
"CVE-2003-0831"
],
"23172": [],
"23177": [],
"23181": [],
"23190": [],
"23191": [],
"23200": [],
"23201": [
"CVE-2013-1868"
],
"23215": [],
"23216": [],
"23231": [],
"23234": [],
"23235": [],
"23236": [
"CVE-2003-0840"
],
"23239": [
"CVE-2003-0864"
],
"23240": [
"CVE-2003-1512"
],
"23241": [
"CVE-2003-1512"
],
"23242": [
"CVE-2003-1518"
],
"23245": [
"CVE-2003-0866"
],
"23246": [
"CVE-2012-5340"
],
"23248": [
"CVE-2013-1773"
],
"23254": [
"CVE-2012-5451"
],
"23263": [
"CVE-2003-0870"
],
"23267": [
"CVE-2003-1177"
],
"23273": [
"CVE-2003-1505"
],
"23274": [
"CVE-2003-0853"
],
"23276": [
"CVE-2003-0896"
],
"23388": [],
"23389": [],
"23279": [],
"23280": [],
"23314": [
"CVE-2003-1143"
],
"23288": [],
"23292": [
"CVE-2003-1134"
],
"23293": [
"CVE-2003-1135"
],
"23305": [
"CVE-2003-0899"
],
"23310": [],
"23311": [
"CVE-2003-1191"
],
"23325": [
"CVE-2003-1165"
],
"23337": [
"CVE-2001-1259"
],
"23339": [],
"23347": [
"CVE-2003-1050"
],
"23348": [
"CVE-2003-1050"
],
"23349": [
"CVE-2003-1050"
],
"23361": [
"CVE-2012-6007",
"CVE-2012-5992",
"CVE-2012-5991"
],
"23374": [
"CVE-2003-0376"
],
"23375": [
"CVE-2003-0795"
],
"23390": [],
"23391": [
"CVE-2003-0967"
],
"23392": [],
"43151": [
"CVE-2017-8751"
],
"23393": [],
"23394": [],
"23412": [],
"23452": [
"CVE-2003-1029"
],
"23427": [],
"23431": [],
"23438": [],
"23442": [
"CVE-2003-1006"
],
"23444": [],
"23460": [],
"23468": [],
"23469": [],
"23480": [],
"23496": [],
"23693": [
"CVE-2004-2082"
],
"23501": [
"CVE-2003-1200"
],
"23504": [
"CVE-2003-1041"
],
"23505": [],
"23506": [],
"23508": [
"CVE-2004-1792"
],
"23512": [
"CVE-2004-1781"
],
"23692": [
"CVE-2004-2081"
],
"23523": [],
"23524": [],
"23530": [],
"23534": [],
"23538": [],
"23539": [],
"23540": [
"CVE-2004-0164"
],
"23543": [],
"23556": [],
"23565": [],
"23567": [],
"23568": [],
"23569": [],
"23574": [
"CVE-2012-5875"
],
"23584": [
"CVE-2004-0095"
],
"23590": [
"CVE-2004-2120"
],
"23595": [
"CVE-2004-2117"
],
"23602": [],
"23614": [
"CVE-2004-2129"
],
"23686": [
"CVE-2004-0276"
],
"23689": [
"CVE-2004-0282"
],
"23690": [
"CVE-2004-0084"
],
"23633": [
"CVE-2003-1207"
],
"23638": [
"CVE-2004-0244"
],
"23641": [
"CVE-2004-0247"
],
"23642": [
"CVE-2004-0247"
],
"23648": [
"CVE-2004-0245"
],
"23654": [
"CVE-2004-0255"
],
"23656": [],
"23660": [
"CVE-2004-0277"
],
"23662": [
"CVE-2004-2077"
],
"23664": [
"CVE-2004-2086"
],
"23665": [
"CVE-2004-0264"
],
"23667": [
"CVE-2004-0270"
],
"23672": [
"CVE-2004-2078"
],
"23681": [
"CVE-2004-0268"
],
"23700": [
"CVE-2004-0298"
],
"23701": [
"CVE-2004-0287"
],
"23708": [
"CVE-2004-0286"
],
"23709": [
"CVE-2004-0286"
],
"23713": [],
"23715": [
"CVE-2004-0295"
],
"23716": [
"CVE-2004-0299"
],
"23731": [
"CVE-2004-0325"
],
"23750": [
"CVE-2004-2368"
],
"23752": [],
"23755": [
"CVE-2004-2371"
],
"23757": [],
"23760": [
"CVE-2004-0330"
],
"23761": [
"CVE-2004-0330"
],
"23762": [
"CVE-2004-0330"
],
"23769": [
"CVE-2004-2675"
],
"23778": [],
"23779": [
"CVE-2012-5667"
],
"23780": [],
"23786": [
"CVE-2004-2549"
],
"23787": [
"CVE-2004-2375"
],
"23788": [],
"23789": [],
"23793": [
"CVE-2004-0361"
],
"23799": [
"CVE-2004-1805"
],
"23805": [
"CVE-2004-2360"
],
"23830": [],
"23902": [
"CVE-2004-2449"
],
"23839": [
"CVE-2004-2366"
],
"23842": [
"CVE-2004-2367"
],
"23846": [
"CVE-2004-0375"
],
"23850": [],
"23876": [
"CVE-2004-1854"
],
"23884": [
"CVE-2004-1866"
],
"23896": [
"CVE-2004-0386"
],
"23900": [],
"23904": [
"CVE-2004-2451"
],
"23911": [],
"23912": [],
"23915": [],
"23916": [
"CVE-2004-1903"
],
"23917": [
"CVE-2004-1904"
],
"23918": [],
"23919": [
"CVE-2004-1910"
],
"23920": [
"CVE-2004-1906"
],
"23923": [],
"23925": [
"CVE-2004-1907"
],
"23927": [],
"23943": [
"CVE-2004-1919"
],
"23944": [],
"23945": [
"CVE-2013-0722",
"CVE-2012-0722"
],
"23946": [],
"23999": [
"CVE-2004-0179"
],
"24000": [
"CVE-2004-1944"
],
"24002": [],
"24010": [
"CVE-2004-0389"
],
"24011": [
"CVE-2004-1940"
],
"24013": [
"CVE-2004-2505"
],
"24022": [
"CVE-2012-5877",
"CVE-2012-5876"
],
"24023": [],
"24029": [
"CVE-2004-1992"
],
"24042": [],
"24051": [
"CVE-2004-0214"
],
"24066": [
"CVE-2004-1973"
],
"24070": [],
"24078": [
"CVE-2004-1983"
],
"24080": [
"CVE-2004-0437"
],
"24095": [
"CVE-2004-2003"
],
"24096": [
"CVE-2004-2005"
],
"24103": [
"CVE-2004-2727"
],
"24107": [],
"24110": [],
"24111": [],
"24112": [],
"24119": [
"CVE-2004-0479"
],
"24128": [
"CVE-2004-2022"
],
"24130": [
"CVE-2004-2286"
],
"24135": [],
"24142": [
"CVE-2004-2037"
],
"24143": [
"CVE-2004-2344"
],
"24144": [
"CVE-2004-2035"
],
"24145": [
"CVE-2004-2033"
],
"24146": [
"CVE-2004-2033"
],
"24147": [
"CVE-2004-2033"
],
"24150": [],
"40399": [
"CVE-2016-7084"
],
"24170": [],
"24178": [],
"24181": [],
"24195": [],
"24208": [],
"24209": [],
"24211": [],
"24222": [
"CVE-2004-0605"
],
"24233": [
"CVE-2004-0618"
],
"24242": [],
"24243": [
"CVE-2004-0668"
],
"24247": [],
"24248": [],
"24267": [],
"24275": [
"CVE-2004-2280"
],
"24281": [],
"24282": [
"CVE-2004-2519"
],
"24283": [
"CVE-2004-2520"
],
"24288": [],
"40398": [
"CVE-2016-7083"
],
"24305": [],
"24319": [],
"24343": [],
"24344": [],
"24346": [
"CVE-2004-0722"
],
"24351": [
"CVE-2004-2646"
],
"24352": [
"CVE-2004-2647"
],
"24355": [],
"24358": [],
"24360": [
"CVE-2004-1701"
],
"24362": [
"CVE-2004-1714"
],
"24386": [
"CVE-2004-1728"
],
"24388": [
"CVE-2004-2277"
],
"24394": [],
"24395": [],
"24411": [
"CVE-2004-1748"
],
"24412": [],
"24416": [
"CVE-2004-1643"
],
"24423": [],
"24426": [],
"24437": [],
"24448": [
"CVE-2013-1638"
],
"24450": [
"CVE-2011-0418"
],
"24463": [
"CVE-2012-4914"
],
"24468": [],
"24511": [
"CVE-2013-1592"
],
"24474": [
"CVE-2013-0658"
],
"24485": [
"CVE-2013-0008"
],
"24486": [],
"24487": [
"CVE-2013-0249"
],
"24556": [
"CVE-2013-7280"
],
"24569": [],
"24634": [
"CVE-2005-4316"
],
"24580": [],
"24586": [],
"24590": [
"CVE-2004-0751"
],
"24592": [],
"24593": [
"CVE-2004-1681"
],
"24594": [
"CVE-2004-1681"
],
"24595": [
"CVE-2004-1681"
],
"24596": [
"CVE-2004-1681"
],
"24597": [],
"24599": [
"CVE-2004-0558"
],
"24605": [],
"24610": [
"CVE-2004-1691"
],
"24618": [],
"24619": [
"CVE-2004-1695"
],
"24620": [],
"24621": [
"CVE-2004-1699"
],
"24635": [
"CVE-2005-4316"
],
"24636": [
"CVE-2005-4316"
],
"24637": [
"CVE-2005-4316"
],
"24639": [],
"24640": [],
"24668": [],
"24677": [
"CVE-2005-4869"
],
"24679": [],
"24684": [
"CVE-2004-2184"
],
"24691": [],
"24696": [
"CVE-2004-0816"
],
"24699": [
"CVE-2004-1623"
],
"24705": [],
"24708": [],
"24710": [
"CVE-2004-2592"
],
"24715": [],
"24726": [],
"24733": [],
"24738": [],
"24741": [],
"24743": [],
"24747": [
"CVE-2013-1828"
],
"24755": [],
"24756": [],
"24761": [],
"24763": [
"CVE-2004-1029"
],
"24854": [
"CVE-2004-1018"
],
"24770": [
"CVE-2004-0953"
],
"24775": [],
"24776": [],
"24777": [
"CVE-2004-1074"
],
"24778": [],
"24780": [],
"24781": [],
"24812": [],
"24788": [],
"24793": [],
"24799": [],
"24804": [],
"24805": [],
"24807": [
"CVE-2004-2761"
],
"24809": [],
"24815": [],
"24818": [],
"24828": [
"CVE-2004-1491"
],
"24839": [],
"24841": [],
"24843": [],
"24855": [
"CVE-2004-1018"
],
"24865": [
"CVE-2012-1663"
],
"24866": [],
"24880": [],
"24896": [],
"24917": [],
"24918": [],
"24940": [],
"24930": [
"CVE-2013-2760"
],
"27433": [
"CVE-2006-1245"
],
"24968": [],
"24951": [
"CVE-2013-0238"
],
"24952": [
"CVE-2006-6184"
],
"24962": [],
"24966": [
"CVE-2013-2419",
"CVE-2013-2416"
],
"24972": [],
"25004": [
"CVE-2004-1291"
],
"25007": [],
"25012": [
"CVE-2004-1269"
],
"25017": [],
"25046": [
"CVE-2004-2652"
],
"25047": [
"CVE-2004-2652"
],
"25056": [],
"25061": [
"CVE-2004-1150"
],
"25063": [
"CVE-2005-0312"
],
"25070": [
"CVE-2005-0199"
],
"25075": [],
"25076": [
"CVE-2005-0245"
],
"25077": [
"CVE-2005-0101"
],
"25081": [],
"25082": [],
"25083": [],
"25085": [],
"25107": [],
"25124": [
"CVE-2003-1085"
],
"25128": [],
"25135": [],
"25140": [
"CVE-2012-4886"
],
"25164": [],
"25165": [],
"25171": [],
"40819": [],
"40820": [],
"25218": [
"CVE-2005-0779"
],
"25219": [],
"25231": [
"CVE-2005-0803"
],
"25234": [
"CVE-2005-0815"
],
"25255": [
"CVE-2005-0848"
],
"25259": [
"CVE-2005-0852"
],
"25268": [
"CVE-2005-0904"
],
"25277": [
"CVE-2005-0895"
],
"25281": [
"CVE-2005-0903"
],
"25287": [
"CVE-2005-0750"
],
"25295": [
"CVE-2013-4631",
"CVE-2013-4630"
],
"25303": [
"CVE-2005-0468"
],
"25322": [],
"25326": [
"CVE-2005-0979"
],
"25329": [
"CVE-2005-0984"
],
"25334": [
"CVE-2005-0989"
],
"25353": [
"CVE-2005-0986"
],
"25363": [],
"25364": [
"CVE-2005-1086"
],
"25383": [
"CVE-2005-0048"
],
"25387": [
"CVE-2004-0791"
],
"25388": [
"CVE-2004-1060"
],
"25389": [
"CVE-2004-0790"
],
"25393": [
"CVE-2005-1078"
],
"25402": [],
"25408": [],
"25418": [],
"25429": [
"CVE-2005-1125"
],
"25439": [
"CVE-2005-1184"
],
"25443": [],
"25465": [
"CVE-2005-1061"
],
"25470": [
"CVE-2005-1204"
],
"25472": [
"CVE-2013-0145"
],
"25499": [
"CVE-2013-2028"
],
"25525": [],
"25527": [
"CVE-2005-1275"
],
"25584": [
"CVE-2005-1402"
],
"25611": [
"CVE-2013-3661",
"CVE-2013-3660",
"CVE-2013-3130"
],
"25629": [
"CVE-2005-1666"
],
"25631": [
"CVE-2005-1666"
],
"25633": [
"CVE-2005-1655"
],
"25647": [
"CVE-2005-1263"
],
"25658": [
"CVE-2005-1618"
],
"25680": [
"CVE-2005-1718"
],
"25692": [
"CVE-2005-1703"
],
"25699": [
"CVE-2005-1741"
],
"25711": [],
"25712": [],
"25714": [],
"25719": [],
"25736": [
"CVE-2005-1801"
],
"25737": [],
"25752": [
"CVE-2005-1807"
],
"25757": [],
"25782": [],
"25791": [
"CVE-2005-1899"
],
"25807": [],
"25809": [],
"25837": [
"CVE-2013-3724"
],
"26292": [
"CVE-2005-3077"
],
"25852": [
"CVE-2013-2765"
],
"25911": [
"CVE-2005-2078"
],
"25921": [],
"25936": [],
"25943": [
"CVE-2005-2239"
],
"25962": [],
"25967": [
"CVE-2005-2242"
],
"25972": [],
"25974": [
"CVE-2013-0984"
],
"25991": [
"CVE-2005-1988"
],
"25992": [
"CVE-2005-2308"
],
"26005": [],
"26010": [
"CVE-2008-1610"
],
"26076": [
"CVE-2003-0001"
],
"26128": [
"CVE-2005-2594"
],
"26130": [],
"26133": [],
"26137": [],
"26138": [
"CVE-2013-1606"
],
"26139": [
"CVE-2005-2103"
],
"26145": [
"CVE-2005-2577"
],
"26173": [
"CVE-2013-3543"
],
"26194": [
"CVE-2005-2767"
],
"26214": [
"CVE-2013-6079"
],
"26216": [
"CVE-2005-2844"
],
"26219": [
"CVE-2005-2850"
],
"26220": [
"CVE-2005-2898"
],
"26233": [
"CVE-2005-2841"
],
"26248": [
"CVE-2005-2800"
],
"26249": [
"CVE-2005-2904"
],
"26251": [],
"26271": [
"CVE-2005-3018"
],
"26301": [
"CVE-2005-2804"
],
"26331": [
"CVE-2005-3206"
],
"26322": [],
"26325": [
"CVE-2005-4720"
],
"26336": [
"CVE-2005-3207"
],
"26340": [
"CVE-2005-2661"
],
"26341": [
"CVE-2005-1979"
],
"26342": [
"CVE-2005-3262"
],
"26382": [
"CVE-2005-2973"
],
"26413": [],
"26450": [],
"26457": [
"CVE-2005-4717"
],
"26489": [
"CVE-2005-2709"
],
"26517": [
"CVE-2014-2671"
],
"26519": [],
"26526": [],
"26548": [
"CVE-2005-3774"
],
"26555": [],
"26557": [
"CVE-2013-4695"
],
"26558": [
"CVE-2013-4694"
],
"26575": [
"CVE-2005-3813"
],
"26578": [],
"26601": [
"CVE-2005-3862"
],
"26648": [
"CVE-2005-3857"
],
"26665": [
"CVE-2005-3934"
],
"26666": [
"CVE-2005-3694"
],
"26690": [
"CVE-2005-3981"
],
"26710": [
"CVE-2013-2160"
],
"26733": [],
"26749": [
"CVE-2005-3807"
],
"26754": [
"CVE-2005-4093"
],
"26762": [
"CVE-2005-4134"
],
"26769": [
"CVE-2005-4131"
],
"26776": [
"CVE-2005-4194"
],
"26779": [
"CVE-2005-4209"
],
"26802": [
"CVE-2013-2784"
],
"26811": [
"CVE-2005-3808"
],
"26816": [
"CVE-2005-4296"
],
"26825": [],
"26833": [],
"26834": [
"CVE-2005-4276"
],
"26835": [
"CVE-2005-4275"
],
"26869": [],
"26886": [
"CVE-2013-4123"
],
"26887": [
"CVE-2013-1950"
],
"26891": [],
"26892": [],
"26915": [],
"26922": [
"CVE-2005-4466"
],
"26951": [
"CVE-2014-2671",
"CVE-2013-4858"
],
"26967": [
"CVE-2005-4503"
],
"26971": [
"CVE-2005-4504"
],
"26985": [],
"27010": [],
"27026": [],
"27031": [
"CVE-2005-3358"
],
"27043": [
"CVE-2013-4890"
],
"27047": [
"CVE-2013-2576"
],
"27049": [
"CVE-2013-2577"
],
"27050": [
"CVE-2013-3174"
],
"27051": [
"CVE-2006-0143"
],
"27055": [
"CVE-2006-0030"
],
"27069": [
"CVE-2005-2340"
],
"27082": [],
"27089": [
"CVE-2006-0359"
],
"27090": [
"CVE-2006-0359"
],
"27094": [],
"27101": [
"CVE-2006-0306"
],
"27108": [
"CVE-2006-0304"
],
"27113": [],
"27131": [
"CVE-2013-0699"
],
"27140": [
"CVE-2005-4676"
],
"27144": [
"CVE-2006-0468"
],
"27145": [
"CVE-2006-0528"
],
"27159": [
"CVE-2006-0539"
],
"27171": [
"CVE-2006-0647"
],
"27196": [
"CVE-2006-0717"
],
"27210": [
"CVE-2006-0738"
],
"27211": [
"CVE-2006-0737"
],
"27212": [
"CVE-2006-0710"
],
"27232": [
"CVE-2006-0797"
],
"27241": [
"CVE-2006-0784"
],
"27246": [
"CVE-2006-0836"
],
"27253": [],
"27257": [
"CVE-2006-0884"
],
"27258": [
"CVE-2006-0911"
],
"27273": [],
"27292": [],
"27317": [
"CVE-2013-5578"
],
"27329": [
"CVE-2006-0925"
],
"27365": [
"CVE-2006-1046"
],
"27377": [
"CVE-2006-1159"
],
"27407": [
"CVE-2006-1214"
],
"27418": [
"CVE-2006-1240"
],
"27420": [
"CVE-2006-1194"
],
"27421": [
"CVE-2006-1275"
],
"27425": [
"CVE-2006-1269"
],
"27460": [
"CVE-2006-0323"
],
"27474": [
"CVE-2006-1356"
],
"27476": [
"CVE-2006-1510"
],
"27727": [
"CVE-2006-1992"
],
"27547": [
"CVE-2006-1593"
],
"27553": [],
"27566": [
"CVE-2006-1618"
],
"27581": [
"CVE-2006-0053"
],
"27635": [],
"27639": [
"CVE-2006-1900"
],
"27640": [
"CVE-2006-1900"
],
"27641": [
"CVE-2006-1834"
],
"27969": [
"CVE-2006-2875"
],
"27971": [
"CVE-2006-3637"
],
"27668": [
"CVE-2006-1941"
],
"27670": [
"CVE-2006-1905"
],
"27700": [
"CVE-2013-6283"
],
"27714": [
"CVE-2006-1982"
],
"27715": [
"CVE-2006-1985"
],
"27723": [
"CVE-2006-1931"
],
"27730": [],
"27745": [
"CVE-2006-2111"
],
"27749": [],
"27762": [
"CVE-2006-2024"
],
"27764": [
"CVE-2006-2025"
],
"27765": [
"CVE-2006-2026"
],
"27856": [
"CVE-2006-2362"
],
"27775": [
"CVE-2013-4776"
],
"27778": [
"CVE-2013-4124"
],
"27790": [
"CVE-2006-2277"
],
"27791": [
"CVE-2006-2230"
],
"27850": [
"CVE-2006-2297"
],
"27875": [
"CVE-2013-5575"
],
"27882": [
"CVE-2006-2426"
],
"27901": [],
"27903": [
"CVE-2006-2480"
],
"27906": [],
"27914": [
"CVE-2006-2646"
],
"27915": [],
"27925": [
"CVE-2006-2629"
],
"27930": [
"CVE-2006-2766"
],
"27942": [
"CVE-2013-4982",
"CVE-2013-4981",
"CVE-2013-4980"
],
"40907": [
"CVE-2013-3111"
],
"27993": [
"CVE-2006-2661"
],
"27981": [
"CVE-2006-2906"
],
"28001": [
"CVE-2006-2374"
],
"28026": [
"CVE-2006-3081"
],
"28065": [],
"28077": [
"CVE-2006-3082"
],
"28079": [],
"28080": [
"CVE-2013-5716"
],
"28087": [
"CVE-2006-3014"
],
"28099": [
"CVE-2006-3298"
],
"28100": [
"CVE-2006-2310"
],
"28103": [
"CVE-2006-3277"
],
"28135": [
"CVE-2006-1470"
],
"28144": [],
"28145": [
"CVE-2006-3354"
],
"28160": [
"CVE-2006-3355"
],
"28164": [
"CVE-2006-3472"
],
"28165": [
"CVE-2006-3372"
],
"28169": [
"CVE-2006-3427"
],
"28182": [],
"28194": [
"CVE-2006-3510"
],
"28196": [
"CVE-2006-3513"
],
"28197": [
"CVE-2006-3512"
],
"28202": [
"CVE-2006-3511"
],
"28207": [
"CVE-2006-3591"
],
"28213": [
"CVE-2006-3605"
],
"28220": [
"CVE-2006-3672"
],
"28222": [
"CVE-2006-3653"
],
"28227": [],
"28228": [
"CVE-2006-3787"
],
"28230": [
"CVE-2006-3687"
],
"28232": [
"CVE-2006-3696"
],
"28234": [
"CVE-2006-3469"
],
"28237": [],
"28395": [],
"28244": [
"CVE-2006-3729"
],
"28246": [
"CVE-2006-3910"
],
"28252": [
"CVE-2006-3899"
],
"28256": [
"CVE-2006-3898"
],
"28257": [
"CVE-2006-3746"
],
"28258": [
"CVE-2006-3944"
],
"28259": [
"CVE-2006-3897"
],
"28263": [
"CVE-2006-3880"
],
"28265": [
"CVE-2006-3915"
],
"28266": [
"CVE-2006-4029"
],
"28271": [],
"28277": [],
"28286": [
"CVE-2006-3943"
],
"28293": [],
"28299": [],
"28301": [
"CVE-2006-7066"
],
"40639": [],
"28338": [
"CVE-2013-5745"
],
"28341": [],
"28343": [
"CVE-2006-7065"
],
"28345": [
"CVE-2006-4126"
],
"28348": [
"CVE-2006-4018"
],
"28358": [
"CVE-2006-3468"
],
"28361": [
"CVE-2006-4024"
],
"28367": [
"CVE-2006-4089"
],
"28369": [
"CVE-2006-4374"
],
"28375": [],
"28380": [
"CVE-2006-4253"
],
"28381": [
"CVE-2006-4138"
],
"28383": [
"CVE-2006-4144"
],
"28384": [
"CVE-2006-4197"
],
"28386": [
"CVE-2006-3121"
],
"28387": [
"CVE-2006-4193"
],
"28389": [
"CVE-2006-4193"
],
"28391": [
"CVE-2006-4261"
],
"28401": [
"CVE-2006-4494"
],
"28420": [
"CVE-2006-4495"
],
"28421": [
"CVE-2006-4301"
],
"28463": [],
"28451": [],
"28469": [
"CVE-2006-4541"
],
"28491": [
"CVE-2006-4611"
],
"28513": [
"CVE-2006-5033"
],
"28521": [
"CVE-2006-4384"
],
"28542": [
"CVE-2006-4832"
],
"28561": [],
"28578": [
"CVE-2006-4866"
],
"28588": [
"CVE-2006-4855"
],
"28648": [
"CVE-2006-4178"
],
"28650": [],
"28666": [
"CVE-2006-5058"
],
"28726": [
"CVE-2006-4343"
],
"28679": [],
"28683": [
"CVE-2013-5680"
],
"28735": [
"CVE-2006-5177"
],
"28739": [
"CVE-2006-5196"
],
"28775": [
"CVE-2006-6692"
],
"28785": [
"CVE-2006-7157"
],
"30208": [
"CVE-2013-4988"
],
"28811": [
"CVE-2013-6114"
],
"28812": [],
"28813": [],
"28816": [
"CVE-2006-7139"
],
"28822": [
"CVE-2006-5395"
],
"28834": [],
"28852": [],
"28855": [
"CVE-2013-7409"
],
"28860": [
"CVE-2006-5568"
],
"40374": [],
"28880": [],
"28894": [
"CVE-2006-5721"
],
"28895": [
"CVE-2006-5701"
],
"28897": [],
"28911": [
"CVE-2006-5726"
],
"28912": [
"CVE-2006-5757"
],
"28948": [
"CVE-2006-5836"
],
"28957": [
"CVE-2011-3918"
],
"29007": [
"CVE-2006-6015"
],
"29036": [
"CVE-2006-7235"
],
"29148": [],
"29076": [
"CVE-2006-6027"
],
"29144": [
"CVE-2006-6062"
],
"29161": [
"CVE-2006-6062"
],
"29164": [],
"29170": [
"CVE-2006-6340"
],
"29172": [],
"29204": [
"CVE-2006-6652"
],
"29229": [
"CVE-2006-6310"
],
"29236": [
"CVE-2006-6311"
],
"29285": [
"CVE-2006-6601"
],
"29286": [
"CVE-2006-6602"
],
"29287": [
"CVE-2006-6619"
],
"29295": [
"CVE-2006-6659"
],
"29296": [
"CVE-2006-6660"
],
"29297": [],
"29305": [
"CVE-2006-6752"
],
"29307": [],
"29310": [],
"29473": [
"CVE-2007-0247"
],
"29362": [
"CVE-2006-6810"
],
"40960": [
"CVE-2014-4138"
],
"29387": [],
"29399": [
"CVE-2007-0103"
],
"29402": [
"CVE-2007-0113"
],
"29406": [
"CVE-2007-0165"
],
"29441": [
"CVE-2007-0229"
],
"29443": [
"CVE-2007-0256"
],
"29444": [
"CVE-2007-0168"
],
"29445": [
"CVE-2013-7280"
],
"29447": [
"CVE-2007-0264"
],
"29452": [
"CVE-2007-0267"
],
"29454": [],
"29455": [],
"29458": [
"CVE-2007-0235"
],
"29461": [
"CVE-2007-0342"
],
"29463": [],
"29470": [
"CVE-2006-6767"
],
"29502": [],
"29503": [],
"29509": [
"CVE-2007-0462"
],
"30046": [
"CVE-2007-5332"
],
"30020": [
"CVE-2007-2583"
],
"30023": [],
"30024": [
"CVE-2007-2645"
],
"29520": [
"CVE-2007-0010"
],
"29523": [
"CVE-2007-0463"
],
"29531": [
"CVE-2007-0768"
],
"29532": [
"CVE-2007-0465"
],
"29535": [
"CVE-2007-0466"
],
"29536": [
"CVE-2007-0612"
],
"29540": [
"CVE-2007-0634"
],
"39839": [
"CVE-2016-1848"
],
"29683": [
"CVE-2007-0001"
],
"29545": [],
"29546": [],
"29551": [
"CVE-2007-0646"
],
"29553": [
"CVE-2007-0647"
],
"29554": [
"CVE-2007-0645"
],
"29555": [
"CVE-2007-0644"
],
"29558": [
"CVE-2007-0708"
],
"29577": [
"CVE-2007-0911"
],
"29607": [
"CVE-2007-1029"
],
"29613": [],
"29616": [
"CVE-2007-1008"
],
"29617": [
"CVE-2007-1037"
],
"29618": [
"CVE-2007-1037"
],
"29620": [
"CVE-2007-1071"
],
"29671": [
"CVE-2013-6356"
],
"29791": [],
"29659": [
"CVE-2007-1090"
],
"29660": [],
"29664": [],
"30187": [
"CVE-2007-3009"
],
"30188": [],
"29692": [
"CVE-2007-1285"
],
"29693": [
"CVE-2006-1549"
],
"29707": [],
"29713": [
"CVE-2007-1308"
],
"29716": [
"CVE-2007-1327"
],
"29717": [
"CVE-2007-1371"
],
"29720": [
"CVE-2007-1362"
],
"29721": [
"CVE-2007-1397"
],
"29723": [],
"29724": [
"CVE-2007-1420"
],
"29738": [
"CVE-2007-1492"
],
"29740": [
"CVE-2007-1657"
],
"29743": [
"CVE-2007-1476"
],
"29767": [
"CVE-2007-1586"
],
"29781": [
"CVE-2007-1388"
],
"29787": [
"CVE-2007-1772"
],
"30110": [
"CVE-2007-2894"
],
"30139": [
"CVE-2007-3086"
],
"30160": [
"CVE-2007-2237"
],
"30163": [
"CVE-2007-1685"
],
"30167": [
"CVE-2007-3151"
],
"29800": [],
"29803": [],
"29809": [
"CVE-2007-1804"
],
"29810": [
"CVE-2007-1793"
],
"29813": [
"CVE-2007-1531"
],
"29816": [
"CVE-2007-1942"
],
"29818": [
"CVE-2007-1943"
],
"29819": [
"CVE-2007-1948"
],
"29823": [
"CVE-2007-1001"
],
"29826": [
"CVE-2007-1357"
],
"29937": [
"CVE-2007-2434"
],
"29850": [
"CVE-2007-2059"
],
"29860": [
"CVE-2007-2083"
],
"29867": [
"CVE-2007-2210"
],
"29875": [
"CVE-2007-2195"
],
"29896": [
"CVE-2007-2565"
],
"29900": [
"CVE-2007-2293"
],
"29901": [
"CVE-2007-2293"
],
"29916": [
"CVE-2007-1861"
],
"29919": [],
"29920": [],
"29926": [],
"29934": [],
"29939": [
"CVE-2007-2437"
],
"29940": [
"CVE-2007-2671"
],
"29942": [
"CVE-2007-2487"
],
"29943": [
"CVE-2007-2506"
],
"29949": [
"CVE-2007-2536"
],
"30080": [
"CVE-2007-2878"
],
"30091": [],
"30104": [
"CVE-2007-2964"
],
"30193": [
"CVE-2007-3284"
],
"30194": [],
"30224": [
"CVE-2007-3334"
],
"30233": [
"CVE-2007-3398"
],
"30251": [
"CVE-2007-3473"
],
"30252": [
"CVE-2007-3492"
],
"30255": [
"CVE-2007-3479"
],
"40743": [],
"30308": [],
"30314": [
"CVE-2007-3638"
],
"30791": [
"CVE-2007-6103"
],
"30395": [
"CVE-2013-6420"
],
"30397": [
"CVE-2013-5058"
],
"30401": [
"CVE-2007-4033"
],
"30413": [
"CVE-2013-7185"
],
"31464": [],
"30414": [
"CVE-2013-7184"
],
"30422": [],
"30430": [
"CVE-2007-4321"
],
"30444": [
"CVE-2007-4229"
],
"30455": [],
"30462": [
"CVE-2007-4288"
],
"30494": [
"CVE-2007-1749"
],
"30497": [
"CVE-2007-4358"
],
"30498": [],
"30500": [
"CVE-2007-4391"
],
"30506": [
"CVE-2007-4430"
],
"30512": [
"CVE-2007-4463"
],
"30513": [
"CVE-2007-4442"
],
"30517": [
"CVE-2007-4498"
],
"30519": [
"CVE-2007-4508"
],
"30524": [
"CVE-2007-4531"
],
"30526": [
"CVE-2007-4533"
],
"30527": [
"CVE-2007-4535"
],
"30528": [
"CVE-2007-4534"
],
"30529": [
"CVE-2006-7222"
],
"30530": [
"CVE-2007-4553"
],
"30538": [],
"30540": [
"CVE-2007-4638"
],
"30542": [
"CVE-2007-4639"
],
"30544": [
"CVE-2007-4635"
],
"30550": [],
"30566": [
"CVE-2007-4754"
],
"30574": [
"CVE-2007-4838"
],
"30578": [
"CVE-2007-4938"
],
"30579": [
"CVE-2007-4939"
],
"32400": [
"CVE-2008-5839"
],
"31913": [],
"32705": [],
"30580": [
"CVE-2007-4941"
],
"30584": [
"CVE-2007-4915"
],
"30590": [
"CVE-2007-4964"
],
"30592": [
"CVE-2007-4965"
],
"30593": [
"CVE-2007-4916"
],
"30619": [
"CVE-2007-5133"
],
"30628": [
"CVE-2007-5256"
],
"30644": [
"CVE-2007-5265"
],
"30646": [
"CVE-2007-5198"
],
"30648": [
"CVE-2007-5301"
],
"30797": [],
"30672": [
"CVE-2007-5464"
],
"30679": [
"CVE-2007-5637"
],
"30805": [],
"30688": [],
"30702": [],
"30713": [],
"30714": [],
"30724": [
"CVE-2007-5740"
],
"30744": [
"CVE-2007-5925"
],
"30749": [],
"30753": [
"CVE-2007-5984"
],
"30756": [],
"30760": [
"CVE-2007-6039"
],
"30761": [
"CVE-2007-6005"
],
"30763": [
"CVE-2007-6000"
],
"40602": [
"CVE-2016-7190"
],
"30766": [
"CVE-2007-4476"
],
"30767": [
"CVE-2007-4812"
],
"40604": [
"CVE-2016-7189"
],
"30776": [
"CVE-2007-6036"
],
"30779": [
"CVE-2007-6041"
],
"30974": [
"CVE-2008-0095"
],
"30812": [],
"30814": [],
"30825": [],
"30832": [
"CVE-2007-6228"
],
"30837": [
"CVE-2007-6227"
],
"30840": [
"CVE-2007-6273"
],
"30856": [],
"30885": [],
"30894": [
"CVE-2007-6454"
],
"30895": [
"CVE-2007-6341"
],
"30896": [
"CVE-2007-6509"
],
"30898": [
"CVE-2007-5849"
],
"30902": [
"CVE-2007-4567"
],
"30903": [],
"30906": [
"CVE-2007-6510"
],
"30922": [
"CVE-2007-6537"
],
"30956": [
"CVE-2007-6609"
],
"30934": [
"CVE-2007-6558"
],
"30936": [
"CVE-2007-6699"
],
"30942": [
"CVE-2007-6731"
],
"30943": [
"CVE-2007-6631"
],
"30985": [
"CVE-2007-6613"
],
"30989": [
"CVE-2008-0132"
],
"30990": [
"CVE-2008-0151"
],
"30991": [
"CVE-2008-0153"
],
"31002": [
"CVE-2008-0225"
],
"31014": [],
"31018": [],
"31021": [
"CVE-2008-0298"
],
"31054": [
"CVE-2007-6697"
],
"31057": [
"CVE-2008-0729"
],
"31100": [
"CVE-2008-0633"
],
"31102": [],
"31105": [
"CVE-2008-5281"
],
"31114": [
"CVE-2007-5659"
],
"31122": [
"CVE-2008-0944"
],
"31128": [
"CVE-2008-5284"
],
"31136": [
"CVE-2008-0756"
],
"31138": [
"CVE-2008-0763"
],
"31139": [
"CVE-2008-0764"
],
"31148": [
"CVE-2008-0755"
],
"31150": [],
"31306": [
"CVE-2008-4999"
],
"31307": [
"CVE-2008-0985"
],
"31168": [],
"31176": [
"CVE-2013-6040"
],
"31177": [
"CVE-2013-6040"
],
"31178": [
"CVE-2013-6040"
],
"31305": [
"CVE-2014-0038"
],
"31271": [
"CVE-2008-0912"
],
"31203": [],
"31205": [
"CVE-2008-5105"
],
"31218": [
"CVE-2008-0852"
],
"31220": [
"CVE-2006-2465"
],
"31222": [
"CVE-2013-5791"
],
"31223": [
"CVE-2013-6674"
],
"31232": [
"CVE-2008-7031"
],
"40356": [
"CVE-2016-4231"
],
"31333": [
"CVE-2008-1215"
],
"31330": [
"CVE-2008-7126"
],
"40355": [
"CVE-2016-4232"
],
"31285": [
"CVE-2008-5280"
],
"31300": [
"CVE-2008-1055"
],
"31301": [
"CVE-2008-1054"
],
"31302": [
"CVE-2008-1052"
],
"31308": [
"CVE-2008-0986"
],
"31310": [
"CVE-2008-1365"
],
"31323": [],
"31327": [],
"31338": [
"CVE-2008-1303"
],
"31343": [
"CVE-2008-1193"
],
"31360": [
"CVE-2008-1277"
],
"31361": [
"CVE-2008-0118"
],
"31363": [
"CVE-2008-1471"
],
"31376": [],
"31378": [
"CVE-2008-1278"
],
"31381": [],
"31394": [
"CVE-2008-0532"
],
"31696": [],
"31461": [
"CVE-2014-0980"
],
"31399": [
"CVE-2008-1357"
],
"31403": [
"CVE-2008-1353"
],
"31429": [
"CVE-2014-1684"
],
"31440": [
"CVE-2008-1289"
],
"31444": [],
"31478": [
"CVE-2008-2092"
],
"31522": [],
"31542": [],
"31984": [],
"31550": [
"CVE-2008-1391"
],
"31552": [
"CVE-2008-1561"
],
"31553": [
"CVE-2008-1562"
],
"31554": [
"CVE-2008-1563"
],
"31563": [
"CVE-2008-1690"
],
"31585": [
"CVE-2008-1084"
],
"31592": [],
"31593": [],
"31594": [
"CVE-2008-1762"
],
"31607": [
"CVE-2008-1854"
],
"31615": [
"CVE-2014-0050"
],
"31619": [
"CVE-2008-2006"
],
"31620": [
"CVE-2008-1035"
],
"31627": [
"CVE-2008-1996"
],
"31629": [
"CVE-2008-1842"
],
"31635": [],
"31656": [
"CVE-2008-1920"
],
"31707": [
"CVE-2008-1979"
],
"31710": [],
"31711": [],
"40825": [],
"31713": [
"CVE-2008-2040"
],
"31728": [
"CVE-2008-2106"
],
"31748": [
"CVE-2008-2111"
],
"31761": [],
"31762": [],
"31763": [
"CVE-2014-10001"
],
"31785": [],
"31791": [],
"40849": [],
"31815": [
"CVE-2008-1767"
],
"31817": [
"CVE-2008-2419"
],
"31818": [
"CVE-2007-5962"
],
"31819": [
"CVE-2007-5962"
],
"31856": [],
"31872": [
"CVE-2008-2542"
],
"31876": [
"CVE-2008-0953"
],
"31877": [
"CVE-2007-5607"
],
"31878": [
"CVE-2008-0952"
],
"31879": [
"CVE-2007-5610"
],
"31884": [],
"31889": [
"CVE-2008-2703"
],
"31899": [],
"31914": [],
"31915": [],
"31919": [
"CVE-2008-6702"
],
"31931": [
"CVE-2008-6712"
],
"31932": [
"CVE-2008-2748"
],
"31934": [
"CVE-2008-2752"
],
"31957": [
"CVE-2008-6713"
],
"31958": [
"CVE-2008-6670"
],
"31964": [
"CVE-2008-3116"
],
"31965": [
"CVE-2008-2365"
],
"31966": [
"CVE-2008-2365"
],
"31968": [
"CVE-2008-7185"
],
"32095": [
"CVE-2008-3263"
],
"31979": [],
"31998": [
"CVE-2008-6703"
],
"31999": [
"CVE-2008-2943"
],
"32000": [
"CVE-2008-2952"
],
"32006": [
"CVE-2008-3140"
],
"32009": [
"CVE-2008-3024"
],
"32018": [],
"32019": [
"CVE-2008-3162"
],
"32054": [],
"32056": [],
"32086": [
"CVE-2008-3286"
],
"32104": [
"CVE-2008-3314"
],
"32105": [],
"32112": [],
"32125": [
"CVE-2008-3396"
],
"32127": [
"CVE-2008-3409"
],
"32136": [
"CVE-2008-2321"
],
"32192": [],
"32193": [
"CVE-2008-5120"
],
"32194": [
"CVE-2008-3607"
],
"32195": [
"CVE-2008-3606"
],
"32208": [
"CVE-2014-0983",
"CVE-2014-0982",
"CVE-2014-0981"
],
"32222": [
"CVE-2008-4310",
"CVE-2008-3656"
],
"32229": [
"CVE-2008-3676"
],
"32248": [
"CVE-2008-3533"
],
"32256": [],
"32332": [
"CVE-2014-2087"
],
"32292": [
"CVE-2008-3790"
],
"32294": [
"CVE-2008-5232"
],
"32304": [
"CVE-2008-2930"
],
"32305": [],
"32310": [
"CVE-2008-4041"
],
"32311": [
"CVE-2008-7061"
],
"32329": [],
"32333": [
"CVE-2014-1287"
],
"32335": [],
"32341": [
"CVE-2008-3950"
],
"32348": [
"CVE-2008-3963"
],
"32350": [
"CVE-2008-2326"
],
"32356": [
"CVE-2008-7009"
],
"32362": [
"CVE-2008-7015"
],
"32381": [
"CVE-2008-4166"
],
"32384": [
"CVE-2008-4302"
],
"32386": [
"CVE-2008-7011"
],
"32420": [],
"32428": [
"CVE-2008-7025"
],
"32435": [],
"32451": [
"CVE-2008-3832"
],
"32452": [
"CVE-2008-4546"
],
"32454": [
"CVE-2008-4409"
],
"32471": [],
"32472": [],
"32477": [
"CVE-2014-2671"
],
"32478": [
"CVE-2014-2671"
],
"32481": [
"CVE-2014-2671"
],
"32482": [
"CVE-2014-2671"
],
"32483": [
"CVE-2014-2671"
],
"32519": [
"CVE-2014-2668"
],
"32513": [],
"32514": [],
"32522": [],
"32534": [
"CVE-2008-4864"
],
"32550": [
"CVE-2008-4800"
],
"32551": [
"CVE-2008-4907"
],
"32573": [
"CVE-2008-5044"
],
"32581": [
"CVE-2008-5102"
],
"32583": [
"CVE-2008-6122"
],
"32587": [
"CVE-2008-5492"
],
"32596": [
"CVE-2008-5185"
],
"32657": [],
"32763": [
"CVE-2009-0341"
],
"40993": [],
"32675": [
"CVE-2008-2382"
],
"32682": [
"CVE-2008-5713"
],
"32688": [],
"32692": [],
"32694": [
"CVE-2008-5821"
],
"32695": [
"CVE-2008-5821"
],
"32696": [],
"32697": [],
"32702": [
"CVE-2014-3976"
],
"32704": [],
"32706": [],
"32707": [],
"32712": [
"CVE-2009-0120"
],
"32715": [],
"32726": [
"CVE-2009-0241"
],
"32740": [],
"32749": [
"CVE-2008-2955"
],
"32754": [
"CVE-2013-6799"
],
"32755": [],
"32761": [
"CVE-2009-0321"
],
"32769": [
"CVE-2009-0754"
],
"32772": [
"CVE-2009-0734"
],
"32774": [
"CVE-2009-0769"
],
"32775": [
"CVE-2009-0746"
],
"32800": [
"CVE-2009-0756",
"CVE-2009-0755"
],
"32815": [
"CVE-2009-0028"
],
"32817": [
"CVE-2009-0744"
],
"32824": [],
"32836": [
"CVE-2009-0821"
],
"32838": [
"CVE-2009-0819"
],
"32849": [
"CVE-2009-0922"
],
"32856": [
"CVE-2008-4610"
],
"32857": [
"CVE-2008-4610"
],
"32860": [
"CVE-2009-1219"
],
"32865": [],
"32881": [],
"32899": [
"CVE-2010-5300"
],
"32902": [
"CVE-2009-1335"
],
"32926": [
"CVE-2014-2851"
],
"32939": [
"CVE-2009-1435"
],
"32949": [],
"32951": [],
"32956": [],
"33337": [],
"32961": [
"CVE-2009-1313"
],
"32964": [
"CVE-2009-1415"
],
"33077": [
"CVE-2009-2446"
],
"32995": [
"CVE-2009-1490"
],
"33015": [
"CVE-2009-1961"
],
"33017": [
"CVE-2009-3431"
],
"33018": [],
"33020": [
"CVE-2009-0949"
],
"33031": [
"CVE-2009-2044"
],
"33036": [
"CVE-2009-2108"
],
"33037": [],
"33040": [
"CVE-2009-2174"
],
"33041": [
"CVE-2009-1959"
],
"33042": [
"CVE-2009-2043"
],
"33043": [
"CVE-2009-1914"
],
"33049": [
"CVE-2009-2285"
],
"33056": [
"CVE-2013-1612"
],
"33058": [
"CVE-2009-0689"
],
"33059": [
"CVE-2009-2617"
],
"33062": [
"CVE-2009-2419"
],
"33073": [
"CVE-2013-5211"
],
"33080": [
"CVE-2009-1963"
],
"33083": [
"CVE-2009-1970"
],
"33086": [],
"33088": [
"CVE-2009-1897"
],
"33350": [
"CVE-2009-4171"
],
"33348": [],
"33579": [],
"33096": [],
"33099": [],
"33100": [],
"33101": [
"CVE-2009-2464"
],
"33104": [],
"33105": [],
"33133": [
"CVE-2009-1868"
],
"33134": [
"CVE-2009-1869"
],
"33584": [],
"33148": [
"CVE-2009-2767"
],
"33173": [],
"33174": [],
"33175": [],
"33176": [
"CVE-2009-2732"
],
"33182": [],
"33183": [],
"33184": [],
"33185": [],
"33193": [
"CVE-2009-3043"
],
"33205": [],
"33216": [],
"33220": [
"CVE-2009-3662"
],
"33221": [],
"33222": [
"CVE-2009-3241"
],
"33223": [
"CVE-2009-3243"
],
"33224": [
"CVE-2009-3242"
],
"33225": [],
"33228": [
"CVE-2009-3234"
],
"33230": [
"CVE-2009-4880"
],
"33233": [
"CVE-2009-4637"
],
"33235": [
"CVE-2009-2817"
],
"33710": [],
"33251": [],
"33269": [
"CVE-2009-3591"
],
"33271": [
"CVE-2009-3707"
],
"33280": [],
"33283": [
"CVE-2009-2983"
],
"33289": [
"CVE-2009-3613"
],
"33306": [
"CVE-2009-3641"
],
"33312": [
"CVE-2009-0689"
],
"33314": [
"CVE-2009-3382"
],
"33318": [],
"33319": [],
"33591": [
"CVE-2010-0295"
],
"33592": [],
"33328": [
"CVE-2014-2085",
"CVE-2014-2084"
],
"33332": [
"CVE-2014-3443"
],
"33335": [
"CVE-2014-3216"
],
"33384": [
"CVE-2014-5116"
],
"33386": [],
"33397": [
"CVE-2009-4019"
],
"33398": [
"CVE-2009-4019"
],
"33472": [],
"33479": [
"CVE-2009-0689"
],
"33480": [
"CVE-2009-0689"
],
"33483": [
"CVE-2010-0313"
],
"33495": [],
"33581": [
"CVE-2010-0303"
],
"33583": [],
"33506": [
"CVE-2010-0071"
],
"33635": [
"CVE-2010-0437"
],
"33524": [],
"33527": [],
"33531": [
"CVE-2010-0359"
],
"33532": [],
"33533": [],
"33640": [],
"40913": [],
"33549": [],
"33556": [
"CVE-2013-4074"
],
"33559": [],
"33560": [
"CVE-2010-0388"
],
"33571": [
"CVE-2010-0442"
],
"33585": [
"CVE-2010-0307"
],
"33587": [],
"33607": [],
"33608": [],
"33625": [
"CVE-2010-1130"
],
"33713": [
"CVE-2014-4643"
],
"33677": [
"CVE-2010-1128"
],
"33672": [],
"33707": [],
"33708": [],
"33838": [],
"33711": [],
"33719": [],
"33729": [
"CVE-2010-0733"
],
"33733": [],
"33735": [],
"33737": [],
"33755": [
"CVE-2010-0397"
],
"33770": [
"CVE-2010-1042"
],
"33775": [],
"33778": [],
"33800": [
"CVE-2010-0166"
],
"33801": [
"CVE-2010-0167"
],
"33804": [
"CVE-2014-4334"
],
"33819": [],
"33849": [],
"33850": [
"CVE-2010-1152"
],
"33860": [
"CVE-2014-0282"
],
"34145": [
"CVE-2010-2089"
],
"33876": [],
"33879": [],
"33886": [
"CVE-2010-1437"
],
"40096": [
"CVE-2016-4204"
],
"40097": [
"CVE-2016-4203"
],
"40098": [
"CVE-2016-4208"
],
"34102": [
"CVE-2014-4927"
],
"33965": [
"CVE-2010-0552"
],
"33966": [
"CVE-2010-0553"
],
"33968": [],
"33924": [],
"33926": [],
"33943": [],
"33951": [
"CVE-2014-5349"
],
"33973": [],
"33977": [],
"34010": [
"CVE-2014-2782",
"CVE-2014-2777",
"CVE-2014-2776",
"CVE-2014-2775",
"CVE-2014-2773",
"CVE-2014-2772",
"CVE-2014-2771",
"CVE-2014-2770",
"CVE-2014-2769",
"CVE-2014-2768",
"CVE-2014-2767",
"CVE-2014-2766",
"CVE-2014-2765",
"CVE-2014-2764",
"CVE-2014-2763",
"CVE-2014-2761",
"CVE-2014-2760",
"CVE-2014-2759",
"CVE-2014-2758",
"CVE-2014-2757",
"CVE-2014-2756",
"CVE-2014-2755",
"CVE-2014-2754",
"CVE-2014-2753",
"CVE-2014-1805",
"CVE-2014-1804",
"CVE-2014-1803",
"CVE-2014-1802",
"CVE-2014-1800",
"CVE-2014-1799",
"CVE-2014-1797",
"CVE-2014-1796",
"CVE-2014-1795",
"CVE-2014-1794",
"CVE-2014-1792",
"CVE-2014-1791",
"CVE-2014-1790",
"CVE-2014-1789",
"CVE-2014-1788",
"CVE-2014-1786",
"CVE-2014-1785",
"CVE-2014-1784",
"CVE-2014-1783",
"CVE-2014-1782",
"CVE-2014-1781",
"CVE-2014-1780",
"CVE-2014-1779",
"CVE-2014-1778",
"CVE-2014-1777",
"CVE-2014-1775",
"CVE-2014-1774",
"CVE-2014-1773",
"CVE-2014-1772",
"CVE-2014-1771",
"CVE-2014-1770",
"CVE-2014-1769",
"CVE-2014-1766",
"CVE-2014-1764",
"CVE-2014-1762",
"CVE-2014-0282"
],
"34027": [],
"34028": [],
"34051": [],
"34058": [
"CVE-2010-2159"
],
"34069": [],
"34090": [
"CVE-2014-7192"
],
"34093": [],
"34094": [],
"34340": [],
"34129": [],
"34133": [
"CVE-2014-0226"
],
"34135": [],
"34158": [],
"34151": [],
"34162": [
"CVE-2014-2973"
],
"34164": [],
"34172": [],
"34203": [
"CVE-2014-3136"
],
"34227": [],
"34228": [],
"34233": [],
"34248": [],
"34249": [
"CVE-2012-6083"
],
"34251": [],
"34261": [],
"34270": [],
"34278": [
"CVE-2010-2630"
],
"34279": [
"CVE-2010-2631"
],
"34528": [],
"34281": [],
"34306": [],
"34307": [],
"34309": [
"CVE-2010-0916"
],
"34348": [
"CVE-2010-0211"
],
"34355": [],
"34356": [
"CVE-2009-5018"
],
"34359": [],
"34360": [],
"34364": [],
"34368": [],
"34375": [
"CVE-2008-7258"
],
"34394": [],
"34395": [],
"34403": [],
"34404": [],
"34427": [
"CVE-2010-2939"
],
"34428": [],
"34442": [],
"34457": [],
"34458": [
"CVE-2014-1815"
],
"34460": [],
"34463": [],
"34480": [],
"34502": [],
"34505": [
"CVE-2010-3680"
],
"34506": [
"CVE-2010-3682"
],
"34510": [
"CVE-2010-3683"
],
"35592": [],
"34520": [
"CVE-2010-3681"
],
"34521": [
"CVE-2010-3679"
],
"34522": [
"CVE-2010-3676"
],
"34530": [],
"34540": [
"CVE-2014-2973"
],
"34588": [],
"34603": [],
"34602": [
"CVE-2010-3325"
],
"34698": [],
"34720": [],
"34729": [],
"34752": [],
"34767": [],
"34855": [],
"34857": [
"CVE-2014-7222",
"CVE-2014-7221"
],
"34872": [],
"34889": [],
"34938": [],
"34953": [
"CVE-2010-3879"
],
"34980": [
"CVE-2010-4715"
],
"35013": [
"CVE-2010-4250"
],
"35000": [
"CVE-2014-0995"
],
"35058": [],
"40099": [
"CVE-2016-4207"
],
"40100": [
"CVE-2016-4206"
],
"40101": [
"CVE-2016-4201"
],
"40102": [
"CVE-2016-4179"
],
"40103": [
"CVE-2016-4175"
],
"35061": [
"CVE-2010-4052"
],
"35081": [
"CVE-2014-6277"
],
"35086": [],
"35105": [
"CVE-2014-9448"
],
"35153": [],
"35154": [],
"35158": [],
"35162": [
"CVE-2010-4543"
],
"35163": [
"CVE-2011-0403"
],
"35164": [
"CVE-2010-4645"
],
"35173": [],
"35178": [],
"35179": [],
"35182": [],
"35202": [],
"35217": [],
"35240": [
"CVE-2011-1159"
],
"35244": [],
"35279": [],
"35302": [],
"35304": [
"CVE-2010-4476"
],
"35326": [],
"35339": [],
"35342": [
"CVE-2014-9349"
],
"35345": [
"CVE-2014-9350"
],
"35354": [
"CVE-2011-0420"
],
"35358": [],
"35359": [
"CVE-2014-8768"
],
"35363": [
"CVE-2014-10011"
],
"35369": [],
"35379": [
"CVE-2014-8652"
],
"35382": [
"CVE-2014-8507"
],
"35403": [
"CVE-2011-1083"
],
"35404": [
"CVE-2011-1082"
],
"35413": [
"CVE-2014-9034"
],
"35414": [
"CVE-2014-9034"
],
"35415": [
"CVE-2014-9016"
],
"35432": [
"CVE-2011-1143"
],
"35437": [],
"35445": [
"CVE-2011-1081"
],
"35465": [],
"35478": [
"CVE-2010-1677"
],
"35483": [
"CVE-2011-1467"
],
"35484": [
"CVE-2011-1470"
],
"35485": [
"CVE-2011-1471"
],
"35486": [
"CVE-2011-1468"
],
"35487": [
"CVE-2011-1468"
],
"35489": [
"CVE-2010-4777"
],
"35502": [],
"35507": [],
"35530": [],
"35531": [],
"35532": [],
"35539": [
"CVE-2014-9218"
],
"35552": [],
"35553": [],
"35580": [
"CVE-2014-6395"
],
"35589": [
"CVE-2014-9456",
"CVE-2014-1004"
],
"35600": [
"CVE-2011-1479"
],
"35613": [],
"35622": [],
"35637": [],
"35656": [],
"35654": [],
"35725": [
"CVE-2011-0761"
],
"35738": [
"CVE-2011-0419"
],
"35753": [],
"35771": [],
"35772": [],
"35773": [],
"35774": [],
"35804": [],
"35820": [
"CVE-2011-2183"
],
"35827": [],
"35828": [],
"35842": [
"CVE-2014-10003"
],
"35849": [],
"35856": [],
"35859": [
"CVE-2015-2055"
],
"35869": [],
"35870": [
"CVE-2015-1362"
],
"35873": [
"CVE-2011-1956"
],
"35876": [],
"35889": [],
"35895": [],
"35913": [
"CVE-2014-0997"
],
"35935": [],
"35938": [
"CVE-2014-8612",
"CVE-2014-0998"
],
"35939": [],
"35951": [
"CVE-2015-0235"
],
"35957": [
"CVE-2009-4067"
],
"36007": [
"CVE-2011-2956"
],
"36022": [],
"36024": [],
"36037": [
"CVE-2011-2132"
],
"36070": [
"CVE-2011-3182"
],
"36071": [],
"36092": [
"CVE-2011-2975"
],
"36128": [
"CVE-2011-3483"
],
"36152": [
"CVE-2015-0555"
],
"36158": [
"CVE-2015-0273"
],
"36190": [
"CVE-2015-5895"
],
"36198": [
"CVE-2011-3596"
],
"36211": [
"CVE-2011-2007"
],
"36234": [],
"36247": [],
"36260": [],
"36266": [
"CVE-2014-9322"
],
"36267": [
"CVE-2014-4943"
],
"36268": [
"CVE-2014-3631"
],
"36271": [],
"36285": [
"CVE-2011-2013"
],
"36288": [
"CVE-2011-3336"
],
"36300": [],
"36309": [],
"36334": [
"CVE-2015-2790"
],
"36335": [
"CVE-2015-2790"
],
"36336": [
"CVE-2015-0081"
],
"36361": [],
"36377": [
"CVE-2011-5009"
],
"36378": [
"CVE-2011-5009"
],
"36405": [],
"36388": [],
"36392": [
"CVE-2015-2291"
],
"36403": [
"CVE-2011-4162"
],
"36404": [
"CVE-2009-5029"
],
"36783": [
"CVE-2015-2572"
],
"36422": [
"CVE-2015-2281"
],
"36425": [
"CVE-2011-2189"
],
"36427": [],
"36431": [],
"36433": [],
"36443": [
"CVE-2011-4684"
],
"40453": [
"CVE-2016-2776"
],
"36545": [
"CVE-2012-0045"
],
"36570": [
"CVE-2012-0221"
],
"36622": [],
"36633": [
"CVE-2012-0067"
],
"36662": [],
"36669": [
"CVE-2012-0840"
],
"36682": [
"CVE-2012-0788"
],
"36741": [
"CVE-2015-0240"
],
"36743": [
"CVE-2014-7822"
],
"36773": [
"CVE-2015-1635"
],
"36776": [
"CVE-2015-1635"
],
"36788": [
"CVE-2015-0493",
"CVE-2015-0474"
],
"36789": [
"CVE-2012-0789"
],
"36799": [],
"36814": [
"CVE-2015-1100"
],
"36825": [],
"36840": [],
"36841": [],
"36847": [],
"36868": [
"CVE-2012-4999"
],
"36869": [
"CVE-2012-0200"
],
"36881": [],
"36896": [],
"36903": [],
"36906": [
"CVE-2015-0252"
],
"36969": [],
"36972": [
"CVE-2012-5329"
],
"37014": [],
"37036": [],
"37051": [],
"37053": [
"CVE-2015-3456"
],
"37061": [],
"37068": [],
"37124": [],
"37149": [],
"37160": [],
"37187": [],
"37188": [],
"37199": [],
"37218": [
"CVE-2012-2926"
],
"37239": [],
"37249": [
"CVE-2015-3205"
],
"37299": [],
"37300": [],
"37306": [
"CVE-2012-2385"
],
"37267": [],
"37268": [],
"41889": [],
"37286": [],
"37287": [],
"37291": [],
"37561": [],
"37326": [],
"37327": [],
"37343": [],
"37346": [],
"37347": [
"CVE-2015-3110"
],
"37348": [
"CVE-2015-3112",
"CVE-2015-3111"
],
"37386": [],
"37566": [
"CVE-2012-3450"
],
"37456": [],
"37458": [],
"37462": [],
"37463": [],
"37471": [],
"37477": [
"CVE-2012-2738"
],
"37478": [],
"37480": [],
"37487": [
"CVE-2012-2138"
],
"37546": [],
"37517": [
"CVE-2013-0230",
"CVE-2013-0229"
],
"37518": [],
"37525": [],
"37526": [],
"37538": [
"CVE-2012-3571"
],
"37558": [],
"37562": [],
"37568": [],
"37593": [],
"37607": [],
"37608": [],
"37612": [],
"37639": [],
"37640": [],
"37660": [],
"37663": [
"CVE-2015-2153"
],
"37669": [],
"37673": [],
"37685": [],
"37692": [
"CVE-2006-0138"
],
"37706": [
"CVE-2015-3246",
"CVE-2015-3245"
],
"37711": [],
"37717": [],
"37718": [],
"37719": [],
"37721": [
"CVE-2015-5477"
],
"37723": [
"CVE-2015-5477"
],
"37727": [],
"37728": [],
"37747": [],
"37739": [
"CVE-2015-5696"
],
"37741": [],
"37743": [],
"37759": [],
"37763": [],
"37764": [
"CVE-2015-2444"
],
"37766": [
"CVE-2015-1265"
],
"37775": [],
"37776": [],
"37777": [],
"37783": [
"CVE-2012-4412"
],
"38001": [],
"37798": [],
"37810": [],
"37839": [
"CVE-2015-3042"
],
"37843": [
"CVE-2015-3087"
],
"37844": [
"CVE-2015-3088"
],
"37845": [
"CVE-2015-3089"
],
"37846": [
"CVE-2015-3093"
],
"37847": [
"CVE-2015-3106"
],
"37848": [
"CVE-2015-3118"
],
"37849": [
"CVE-2015-3124"
],
"37850": [
"CVE-2015-3107"
],
"37852": [
"CVE-2015-5134"
],
"37853": [
"CVE-2015-3080"
],
"37854": [
"CVE-2015-5130"
],
"37855": [
"CVE-2015-5539"
],
"37856": [
"CVE-2015-5131"
],
"37857": [
"CVE-2015-5132"
],
"37858": [
"CVE-2015-5133"
],
"37859": [
"CVE-2015-5540"
],
"37860": [
"CVE-2015-3128"
],
"37861": [
"CVE-2015-5127"
],
"37862": [
"CVE-2015-3134"
],
"37863": [],
"37864": [
"CVE-2015-3137"
],
"37865": [
"CVE-2015-5551"
],
"37866": [
"CVE-2015-5544"
],
"37867": [
"CVE-2015-5545"
],
"37868": [
"CVE-2015-5546"
],
"37869": [
"CVE-2015-5547"
],
"37870": [
"CVE-2015-5548"
],
"37871": [
"CVE-2015-5550"
],
"37872": [
"CVE-2015-5549"
],
"37873": [
"CVE-2015-5556"
],
"37874": [
"CVE-2015-5555"
],
"37875": [
"CVE-2015-4430"
],
"37876": [
"CVE-2015-5554"
],
"37877": [
"CVE-2015-5557"
],
"37878": [
"CVE-2015-5558"
],
"37879": [
"CVE-2015-4432"
],
"37880": [
"CVE-2015-5118"
],
"37881": [
"CVE-2015-5562"
],
"37882": [
"CVE-2015-5560"
],
"37883": [
"CVE-2015-5561"
],
"37884": [
"CVE-2015-5563"
],
"37893": [],
"37897": [],
"37905": [
"CVE-2012-3819"
],
"37908": [
"CVE-2015-7767"
],
"37909": [],
"37910": [
"CVE-2015-2469"
],
"37911": [
"CVE-2015-2431"
],
"37912": [
"CVE-2015-2468"
],
"37913": [
"CVE-2015-2467"
],
"37914": [
"CVE-2015-2464"
],
"37915": [
"CVE-2015-2463"
],
"37916": [
"CVE-2015-2462"
],
"37917": [
"CVE-2015-2461"
],
"37918": [
"CVE-2015-2456"
],
"37919": [
"CVE-2015-2455"
],
"37920": [
"CVE-2015-2432"
],
"37921": [
"CVE-2015-2460"
],
"37922": [
"CVE-2015-2459"
],
"37923": [
"CVE-2015-2458"
],
"37924": [
"CVE-2015-2470"
],
"37954": [],
"37957": [],
"37966": [
"CVE-2015-0065"
],
"37967": [
"CVE-2015-0064"
],
"37976": [],
"37980": [
"CVE-2012-5672"
],
"37981": [],
"37984": [],
"37986": [],
"37990": [
"CVE-2015-3214"
],
"37997": [],
"38014": [],
"38021": [],
"38028": [],
"38031": [],
"38032": [],
"38038": [],
"38052": [],
"38053": [],
"38054": [
"CVE-2015-5465"
],
"38055": [
"CVE-2015-5466"
],
"38059": [],
"38072": [],
"38085": [],
"38108": [
"CVE-2014-9208"
],
"38120": [
"CVE-2015-6834"
],
"38121": [],
"38122": [
"CVE-2015-6834"
],
"38123": [
"CVE-2015-6835"
],
"38125": [],
"38132": [
"CVE-2012-5375"
],
"38145": [
"CVE-2015-6908"
],
"38146": [],
"38165": [],
"38177": [],
"38205": [],
"38208": [],
"38214": [
"CVE-2015-2523"
],
"38215": [
"CVE-2015-2520"
],
"38216": [
"CVE-2015-2521"
],
"38217": [
"CVE-2015-2510"
],
"38225": [
"CVE-2015-6923"
],
"38240": [],
"38249": [
"CVE-2013-0229"
],
"38259": [],
"38262": [
"CVE-2015-3798"
],
"38263": [
"CVE-2015-3796"
],
"38264": [
"CVE-2015-3783"
],
"38265": [
"CVE-2015-1722"
],
"38266": [
"CVE-2015-2366"
],
"38267": [
"CVE-2015-2365"
],
"38268": [
"CVE-2015-1727"
],
"38269": [
"CVE-2015-1726"
],
"38270": [
"CVE-2015-1725"
],
"38271": [
"CVE-2015-1725"
],
"38272": [
"CVE-2015-1724"
],
"38273": [
"CVE-2015-1723"
],
"38274": [
"CVE-2015-1721"
],
"38275": [
"CVE-2015-1722"
],
"38276": [
"CVE-2015-2511"
],
"38277": [
"CVE-2015-2518"
],
"38278": [
"CVE-2015-2517"
],
"38279": [
"CVE-2015-2507"
],
"38280": [
"CVE-2015-2512"
],
"38281": [],
"38282": [],
"38283": [],
"38284": [],
"38285": [],
"38286": [],
"38288": [],
"38307": [
"CVE-2015-2512"
],
"38317": [],
"38336": [],
"38337": [],
"38344": [
"CVE-2015-3073"
],
"38348": [
"CVE-2015-5568"
],
"38364": [],
"38365": [],
"38392": [
"CVE-2013-1861"
],
"38399": [],
"38404": [],
"38405": [],
"38419": [],
"38420": [
"CVE-2013-6166"
],
"38421": [
"CVE-2013-1847"
],
"38422": [
"CVE-2013-1884"
],
"38442": [],
"38444": [],
"38475": [],
"38465": [
"CVE-2013-3301"
],
"38483": [],
"38485": [],
"38490": [
"CVE-2015-7645"
],
"38493": [],
"38498": [],
"38538": [],
"38555": [
"CVE-2015-7892"
],
"38556": [
"CVE-2015-7890"
],
"38557": [
"CVE-2015-7891"
],
"38558": [
"CVE-2015-7889"
],
"38564": [],
"38566": [
"CVE-2015-3036"
],
"38580": [
"CVE-2015-2554"
],
"38589": [],
"38595": [
"CVE-2013-3792"
],
"38610": [
"CVE-2015-7898"
],
"38611": [
"CVE-2015-7897"
],
"38612": [
"CVE-2015-7896"
],
"38613": [
"CVE-2015-7895"
],
"38614": [
"CVE-2015-7894"
],
"38615": [],
"38616": [],
"38617": [],
"38618": [],
"38620": [],
"38622": [
"CVE-2013-2218"
],
"38623": [
"CVE-2013-3299"
],
"38626": [],
"38650": [],
"39374": [
"CVE-2015-7047"
],
"38659": [],
"38662": [],
"38681": [],
"38685": [],
"38687": [],
"38701": [],
"38702": [],
"38703": [],
"38705": [],
"38710": [],
"38711": [],
"38713": [
"CVE-2015-6104"
],
"38714": [
"CVE-2015-6103"
],
"38734": [],
"38735": [],
"38736": [],
"38747": [
"CVE-2013-5657"
],
"38758": [],
"38759": [],
"38760": [],
"38761": [],
"38763": [
"CVE-2015-6763"
],
"38771": [],
"38778": [],
"38779": [],
"38787": [
"CVE-2015-7622"
],
"38788": [
"CVE-2015-4877"
],
"38789": [
"CVE-2015-4878"
],
"38791": [],
"38793": [
"CVE-2015-6098"
],
"38794": [
"CVE-2015-6102"
],
"38795": [
"CVE-2015-6101"
],
"38796": [
"CVE-2015-6100"
],
"38798": [
"CVE-2013-6167"
],
"38854": [
"CVE-2012-6151"
],
"38857": [],
"38858": [],
"38878": [],
"38909": [
"CVE-2013-6890"
],
"38916": [],
"38917": [
"CVE-2015-7039"
],
"38930": [],
"38931": [],
"38932": [],
"38933": [],
"38934": [],
"38939": [],
"38940": [],
"39095": [],
"38969": [
"CVE-2015-7647"
],
"38970": [
"CVE-2015-7648"
],
"38972": [
"CVE-2015-6152"
],
"38978": [],
"38979": [],
"38980": [],
"38992": [],
"38993": [],
"38994": [
"CVE-2015-8739"
],
"38995": [
"CVE-2015-8732"
],
"38996": [
"CVE-2015-8731"
],
"38997": [
"CVE-2015-8736"
],
"38998": [
"CVE-2015-8735"
],
"38999": [
"CVE-2015-8730"
],
"39000": [
"CVE-2015-8728"
],
"39001": [
"CVE-2015-8729"
],
"39002": [
"CVE-2015-8727"
],
"39003": [
"CVE-2015-8740",
"CVE-2015-8725"
],
"39004": [
"CVE-2015-8726"
],
"39005": [
"CVE-2015-8723"
],
"39006": [],
"39019": [
"CVE-2015-8046"
],
"39020": [
"CVE-2015-7652"
],
"39021": [
"CVE-2015-8044"
],
"39022": [
"CVE-2015-8043"
],
"40105": [
"CVE-2016-4176"
],
"40104": [
"CVE-2016-4177"
],
"39025": [
"CVE-2015-6171"
],
"39026": [
"CVE-2015-6174"
],
"39027": [
"CVE-2015-6173"
],
"39037": [],
"39039": [
"CVE-2015-8664"
],
"39040": [
"CVE-2015-8410"
],
"39041": [
"CVE-2015-8411"
],
"39042": [
"CVE-2015-8412"
],
"39043": [
"CVE-2015-8413"
],
"39044": [
"CVE-2015-8420"
],
"39045": [
"CVE-2015-8421"
],
"39046": [
"CVE-2015-8422"
],
"39047": [
"CVE-2015-8423"
],
"39048": [
"CVE-2015-8424"
],
"39049": [
"CVE-2015-8425"
],
"39050": [
"CVE-2015-8427"
],
"39051": [
"CVE-2015-8428"
],
"39052": [
"CVE-2015-8429"
],
"39053": [
"CVE-2015-8430"
],
"39054": [
"CVE-2015-8431"
],
"39055": [],
"39056": [],
"39067": [],
"39070": [],
"39072": [
"CVE-2015-8434"
],
"39073": [
"CVE-2013-7183"
],
"39076": [
"CVE-2015-8733"
],
"39077": [
"CVE-2015-8724"
],
"39082": [
"CVE-2015-8617"
],
"39091": [],
"39092": [],
"39103": [],
"39125": [],
"39144": [],
"39225": [],
"39226": [],
"39158": [],
"39162": [
"CVE-2015-6787"
],
"39163": [
"CVE-2015-6787"
],
"39164": [],
"39165": [
"CVE-2015-6787"
],
"39169": [
"CVE-2015-7945",
"CVE-2015-7944"
],
"39177": [
"CVE-2014-3441"
],
"39180": [
"CVE-2014-3442"
],
"39181": [
"CVE-2014-3212"
],
"39182": [
"CVE-2014-3444"
],
"39183": [
"CVE-2014-3736"
],
"39373": [
"CVE-2015-7047"
],
"39208": [],
"39216": [],
"39219": [
"CVE-2015-8636"
],
"39220": [
"CVE-2015-8635"
],
"39221": [
"CVE-2015-8634"
],
"39229": [
"CVE-2015-8396"
],
"39232": [
"CVE-2016-0015"
],
"39233": [
"CVE-2016-0016"
],
"39242": [],
"39371": [
"CVE-2015-7047"
],
"39372": [
"CVE-2015-7108"
],
"39274": [
"CVE-2006-2961"
],
"39275": [],
"39305": [
"CVE-2016-1879"
],
"39375": [
"CVE-2015-7047"
],
"39308": [
"CVE-2015-0569"
],
"39315": [
"CVE-2014-6435"
],
"39321": [],
"39322": [],
"39323": [],
"39324": [],
"39325": [],
"39326": [],
"39327": [],
"39329": [],
"39330": [],
"39331": [],
"39353": [],
"39357": [
"CVE-2015-7084"
],
"39358": [
"CVE-2016-1721"
],
"39359": [
"CVE-2016-1719"
],
"39360": [
"CVE-2016-1719"
],
"39361": [
"CVE-2016-1719"
],
"39362": [
"CVE-2016-1719"
],
"39363": [
"CVE-2016-1719"
],
"39364": [
"CVE-2016-1719"
],
"39365": [
"CVE-2015-7110"
],
"39366": [
"CVE-2015-7084"
],
"39367": [
"CVE-2016-1720"
],
"39368": [
"CVE-2015-7077"
],
"39369": [
"CVE-2015-7106"
],
"39370": [
"CVE-2015-7078"
],
"39376": [
"CVE-2015-7068"
],
"39377": [
"CVE-2015-7047"
],
"39378": [
"CVE-2015-7083"
],
"39379": [
"CVE-2015-7112"
],
"39380": [
"CVE-2015-6996"
],
"39381": [
"CVE-2015-6995"
],
"39393": [],
"39395": [],
"39396": [],
"39397": [],
"39398": [],
"39400": [],
"39401": [],
"39403": [],
"39406": [],
"39424": [],
"39425": [],
"39426": [],
"39428": [],
"39429": [
"CVE-2016-0951"
],
"39430": [
"CVE-2016-0952"
],
"39431": [
"CVE-2016-0953"
],
"39444": [],
"39445": [],
"39447": [],
"39452": [],
"39454": [
"CVE-2015-7547"
],
"39460": [
"CVE-2016-0965"
],
"39461": [
"CVE-2016-0985"
],
"39462": [
"CVE-2016-0984"
],
"39463": [
"CVE-2016-0974"
],
"39464": [],
"39465": [
"CVE-2016-0971"
],
"39466": [
"CVE-2016-0967"
],
"39467": [
"CVE-2016-0964"
],
"39470": [],
"39471": [],
"39472": [],
"39475": [
"CVE-2015-8285"
],
"39476": [
"CVE-2015-8644"
],
"39482": [],
"39483": [],
"39484": [],
"39487": [
"CVE-2016-2399"
],
"39490": [],
"39491": [
"CVE-2016-1839"
],
"39492": [],
"39493": [
"CVE-2016-1838"
],
"39494": [],
"39502": [],
"39503": [],
"39504": [],
"39505": [],
"39509": [],
"39512": [],
"39516": [],
"39517": [],
"39518": [],
"39529": [],
"39530": [
"CVE-2016-3986"
],
"39533": [
"CVE-2016-0954"
],
"39537": [
"CVE-2016-3140"
],
"39538": [
"CVE-2016-3139"
],
"39539": [
"CVE-2016-2782"
],
"39540": [
"CVE-2015-7566"
],
"39542": [],
"39541": [
"CVE-2016-3136"
],
"39543": [],
"39544": [
"CVE-2015-7515"
],
"39545": [
"CVE-2016-3134",
"CVE-2016-3135"
],
"39546": [],
"39550": [
"CVE-2016-2851"
],
"39551": [
"CVE-2016-2563"
],
"39555": [
"CVE-2016-2184"
],
"39556": [
"CVE-2016-2188"
],
"39557": [],
"39560": [
"CVE-2016-0121"
],
"39561": [
"CVE-2016-0120"
],
"39562": [
"CVE-2016-0108"
],
"39565": [],
"39570": [
"CVE-2016-1885"
],
"39600": [],
"39601": [],
"39602": [],
"39603": [],
"39604": [],
"39605": [],
"39606": [],
"39607": [
"CVE-2016-1749"
],
"39608": [
"CVE-2016-1002"
],
"39609": [
"CVE-2016-1001"
],
"39610": [
"CVE-2016-1000"
],
"39611": [
"CVE-2016-0999"
],
"39612": [
"CVE-2016-0998"
],
"39613": [
"CVE-2016-0997"
],
"39614": [
"CVE-2016-1755"
],
"39615": [
"CVE-2016-1741"
],
"39616": [
"CVE-2016-1744"
],
"39627": [],
"39629": [],
"39633": [
"CVE-2016-1767"
],
"39634": [
"CVE-2016-1768"
],
"39635": [
"CVE-2016-1769"
],
"39638": [
"CVE-2016-2385"
],
"39644": [],
"39647": [
"CVE-2016-0094"
],
"39648": [
"CVE-2016-0093"
],
"39649": [
"CVE-2015-8048"
],
"39650": [
"CVE-2015-8426"
],
"39651": [],
"39652": [
"CVE-2015-5574"
],
"39653": [],
"39654": [],
"39657": [
"CVE-2016-2233"
],
"39663": [
"CVE-2016-0111"
],
"39669": [
"CVE-2016-3672"
],
"39685": [
"CVE-2016-2417"
],
"39686": [
"CVE-2016-0846"
],
"39699": [],
"39706": [],
"39712": [
"CVE-2016-0143"
],
"39713": [],
"39733": [],
"39740": [
"CVE-2016-0151"
],
"39743": [
"CVE-2016-0145"
],
"39747": [],
"39748": [],
"39749": [],
"39750": [],
"39767": [
"CVE-2016-3718",
"CVE-2016-3717",
"CVE-2016-3716",
"CVE-2016-3715",
"CVE-2016-3714"
],
"39768": [
"CVE-2016-2107"
],
"39770": [
"CVE-2016-4535"
],
"39773": [
"CVE-2016-4558"
],
"39774": [],
"39775": [],
"39776": [],
"39778": [
"CVE-2016-1013"
],
"39779": [
"CVE-2016-1011"
],
"39782": [],
"39785": [],
"39789": [],
"39966": [],
"39795": [],
"39796": [],
"39797": [],
"39799": [
"CVE-2016-1077"
],
"39800": [],
"39801": [
"CVE-2016-0801"
],
"39802": [],
"39812": [],
"39819": [],
"39824": [
"CVE-2016-1102"
],
"39825": [
"CVE-2016-1104"
],
"39826": [
"CVE-2016-1103"
],
"39827": [
"CVE-2016-1101"
],
"39828": [
"CVE-2016-1096"
],
"39829": [
"CVE-2016-1105"
],
"39830": [
"CVE-2016-4108"
],
"39831": [
"CVE-2016-1106"
],
"39832": [
"CVE-2016-0168"
],
"39833": [
"CVE-2016-0169"
],
"39834": [
"CVE-2016-0170"
],
"39835": [
"CVE-2016-2208"
],
"39842": [],
"39846": [],
"39857": [
"CVE-2016-1606"
],
"39859": [],
"39860": [],
"39861": [],
"39862": [],
"39863": [],
"39867": [
"CVE-2015-4870"
],
"39873": [],
"39875": [],
"39877": [],
"39882": [],
"39906": [],
"39915": [],
"39920": [
"CVE-2016-1846"
],
"39921": [
"CVE-2016-2494"
],
"39922": [
"CVE-2016-1794"
],
"39923": [
"CVE-2016-1793"
],
"39924": [
"CVE-2016-1813"
],
"39925": [
"CVE-2016-1803"
],
"39926": [
"CVE-2016-1821"
],
"39927": [
"CVE-2016-1823"
],
"39928": [
"CVE-2016-1819"
],
"39929": [
"CVE-2016-1807"
],
"39930": [
"CVE-2016-1861"
],
"39939": [],
"39940": [],
"39941": [],
"39942": [],
"39943": [],
"39944": [],
"39947": [],
"39959": [
"CVE-2016-0171"
],
"39960": [
"CVE-2016-0173"
],
"39961": [],
"39986": [],
"39990": [
"CVE-2016-3216"
],
"39991": [
"CVE-2016-3220"
],
"39993": [
"CVE-2016-3219"
],
"39994": [
"CVE-2016-0199"
],
"40014": [],
"40031": [
"CVE-2016-2207"
],
"40032": [
"CVE-2016-2210"
],
"40034": [
"CVE-2016-3644"
],
"40035": [
"CVE-2016-3645"
],
"40036": [
"CVE-2016-3646"
],
"40037": [
"CVE-2016-2209"
],
"40038": [],
"40073": [],
"40074": [],
"40183": [],
"40182": [],
"40310": [
"CVE-2016-4229"
],
"40181": [],
"40155": [
"CVE-2016-5399"
],
"40184": [],
"40192": [],
"40194": [
"CVE-2016-6504"
],
"40195": [
"CVE-2016-6512"
],
"40196": [
"CVE-2016-6503"
],
"40197": [
"CVE-2016-6505"
],
"40198": [],
"40199": [],
"40208": [],
"40230": [
"CVE-2016-5847",
"CVE-2016-5845"
],
"40238": [
"CVE-2016-3316"
],
"40243": [
"CVE-2013-2842"
],
"40253": [
"CVE-2016-3288"
],
"40255": [
"CVE-2016-3301"
],
"40256": [
"CVE-2016-3303"
],
"40257": [
"CVE-2016-3304"
],
"40308": [
"CVE-2016-4226"
],
"40289": [],
"40291": [
"CVE-2016-6855"
],
"40309": [
"CVE-2016-4228"
],
"40311": [
"CVE-2016-4230"
],
"40313": [],
"40314": [],
"40315": [],
"40316": [],
"40317": [],
"40318": [],
"40319": [],
"40320": [],
"40321": [],
"40329": [],
"40439": [],
"40449": [],
"40502": [
"CVE-2016-5348"
],
"40508": [
"CVE-2016-1464"
],
"40509": [
"CVE-2016-1415"
],
"40510": [
"CVE-2016-4273"
],
"40515": [
"CVE-2016-6689"
],
"40524": [],
"40536": [],
"43596": [],
"43710": [
"CVE-2018-0769"
],
"43713": [
"CVE-2017-11914"
],
"43715": [
"CVE-2018-0774"
],
"43717": [
"CVE-2018-0775"
],
"43718": [
"CVE-2018-0777"
],
"43720": [
"CVE-2018-0780"
],
"43723": [
"CVE-2018-0776"
],
"43776": [
"CVE-2017-12718"
],
"45335": [],
"43780": [
"CVE-2017-13878"
],
"43826": [
"CVE-2005-1806"
],
"43854": [],
"43856": [
"CVE-2018-5319"
],
"43891": [
"CVE-2014-1201"
],
"40570": [],
"40592": [],
"40593": [],
"40598": [
"CVE-2016-3209"
],
"40599": [
"CVE-2016-7182"
],
"40600": [
"CVE-2016-0070"
],
"40601": [
"CVE-2016-3376"
],
"40603": [
"CVE-2016-7194"
],
"40605": [
"CVE-2016-3386"
],
"40617": [
"CVE-2016-9018"
],
"40618": [],
"40632": [],
"40647": [],
"40648": [],
"40635": [],
"40638": [],
"40649": [
"CVE-2016-5228"
],
"40652": [
"CVE-2016-1863"
],
"40654": [
"CVE-2016-4669"
],
"40656": [
"CVE-2016-7386"
],
"40657": [
"CVE-2016-7385"
],
"40658": [
"CVE-2016-7390"
],
"40659": [
"CVE-2016-7387"
],
"40661": [
"CVE-2016-7391"
],
"40662": [
"CVE-2016-8811"
],
"40663": [
"CVE-2016-8806"
],
"40664": [
"CVE-2016-8809"
],
"40665": [
"CVE-2016-8810"
],
"40666": [
"CVE-2016-8808"
],
"40667": [
"CVE-2016-8805"
],
"40668": [
"CVE-2016-8807"
],
"40685": [
"CVE-2014-4141"
],
"40687": [],
"40691": [],
"40695": [],
"40696": [],
"40697": [],
"40699": [],
"40703": [],
"40722": [],
"40731": [
"CVE-2016-6828"
],
"40744": [
"CVE-2016-7237"
],
"40745": [
"CVE-2016-7255"
],
"40747": [
"CVE-2016-3325"
],
"40748": [
"CVE-2016-3324"
],
"40761": [],
"40762": [],
"40766": [
"CVE-2016-7216"
],
"40773": [
"CVE-2016-7240"
],
"40787": [
"CVE-2016-7203"
],
"40779": [
"CVE-2016-9332"
],
"40784": [
"CVE-2016-7201"
],
"40785": [
"CVE-2016-7200"
],
"40786": [
"CVE-2016-7202"
],
"40790": [
"CVE-2016-9150"
],
"40793": [
"CVE-2016-7202"
],
"40797": [
"CVE-2016-3247"
],
"40798": [
"CVE-2015-2482"
],
"40806": [
"CVE-2016-7434"
],
"40814": [],
"40815": [],
"40828": [],
"40893": [
"CVE-2013-1309"
],
"40894": [
"CVE-2013-1306"
],
"40840": [
"CVE-2015-7855"
],
"40841": [
"CVE-2015-0050"
],
"40843": [],
"40844": [
"CVE-2013-3120"
],
"40845": [
"CVE-2016-0063"
],
"40866": [],
"40875": [
"CVE-2016-7241"
],
"40876": [],
"40878": [
"CVE-2015-6168"
],
"40879": [
"CVE-2013-0019"
],
"40880": [
"CVE-2016-3222"
],
"40883": [],
"40885": [],
"40886": [],
"40888": [
"CVE-2016-6515"
],
"40896": [],
"40899": [
"CVE-2016-7054"
],
"40905": [],
"40906": [
"CVE-2016-7626"
],
"40909": [
"CVE-2016-8740"
],
"40910": [],
"40914": [],
"40915": [
"CVE-2016-7866"
],
"40925": [],
"40922": [],
"40923": [
"CVE-2013-3143"
],
"40926": [],
"40927": [],
"40928": [],
"40929": [],
"40933": [],
"40935": [
"CVE-2013-0090"
],
"40944": [
"CVE-2013-6627"
],
"40945": [
"CVE-2016-6772"
],
"40946": [
"CVE-2014-1785"
],
"40947": [
"CVE-2016-7286"
],
"40948": [
"CVE-2016-7287"
],
"40952": [
"CVE-2016-7617"
],
"40954": [
"CVE-2016-7633"
],
"40955": [
"CVE-2016-7612"
],
"40958": [
"CVE-2016-7661"
],
"40959": [
"CVE-2016-7660"
],
"40964": [],
"40965": [],
"40985": [],
"40994": [],
"40996": [],
"41008": [
"CVE-2017-2930"
],
"41012": [
"CVE-2017-2930"
],
"41018": [],
"41025": [
"CVE-2016-5108"
],
"41030": [
"CVE-2016-10079"
],
"41042": [
"CVE-2016-9899"
],
"41142": [],
"41145": [
"CVE-2017-3241"
],
"41160": [],
"41161": [],
"41163": [
"CVE-2017-2370"
],
"41164": [
"CVE-2017-2353"
],
"41165": [
"CVE-2017-2360"
],
"41192": [
"CVE-2017-3730"
],
"41211": [],
"41212": [],
"41213": [
"CVE-2017-2362"
],
"41214": [],
"41215": [
"CVE-2017-2369"
],
"41216": [
"CVE-2017-2373"
],
"41218": [],
"41219": [],
"41222": [],
"41232": [],
"41278": [
"CVE-2017-5850"
],
"41363": [
"CVE-2017-0038"
],
"41350": [
"CVE-2017-5972"
],
"41351": [],
"41352": [],
"41353": [],
"41354": [
"CVE-2017-0411"
],
"41355": [
"CVE-2017-0412"
],
"41357": [
"CVE-2016-7288"
],
"41364": [
"CVE-2017-0312"
],
"41365": [
"CVE-2017-0313"
],
"41367": [
"CVE-2017-5881"
],
"41369": [
"CVE-2017-3807"
],
"41417": [],
"41418": [],
"41419": [],
"41420": [
"CVE-2017-2992"
],
"41421": [
"CVE-2017-2988"
],
"41422": [
"CVE-2017-2985"
],
"41423": [
"CVE-2017-2986"
],
"41425": [
"CVE-2017-5358"
],
"41426": [
"CVE-2017-5359"
],
"41434": [],
"41454": [
"CVE-2017-0037"
],
"41457": [
"CVE-2017-6074"
],
"41474": [],
"41475": [
"CVE-2017-6371"
],
"41537": [
"CVE-2017-6019"
],
"41547": [
"CVE-2017-6427"
],
"41565": [
"CVE-2017-6552"
],
"41596": [
"CVE-2017-6367"
],
"41601": [
"CVE-2017-6444"
],
"41608": [
"CVE-2017-2931"
],
"41609": [
"CVE-2017-2932"
],
"41610": [
"CVE-2017-2933"
],
"41611": [
"CVE-2017-2934"
],
"41612": [
"CVE-2017-2935"
],
"41615": [
"CVE-2016-7274"
],
"41620": [
"CVE-2017-6880"
],
"43352": [],
"43354": [
"CVE-2017-15049"
],
"43355": [
"CVE-2017-15048"
],
"43367": [
"CVE-2017-11903"
],
"43368": [
"CVE-2017-11793"
],
"43369": [
"CVE-2017-11890"
],
"43370": [
"CVE-2017-11907"
],
"43371": [
"CVE-2017-11855"
],
"43372": [
"CVE-2017-11906"
],
"43373": [
"CVE-2017-5717"
],
"43380": [],
"43466": [
"CVE-2017-11893"
],
"43467": [
"CVE-2017-11909"
],
"43468": [
"CVE-2017-11911"
],
"43391": [
"CVE-2017-17849"
],
"43401": [],
"43403": [
"CVE-2017-15667"
],
"43406": [
"CVE-2017-17932"
],
"43410": [],
"43415": [],
"43432": [],
"43446": [
"CVE-2018-0744"
],
"43451": [
"CVE-2017-15662"
],
"43452": [
"CVE-2017-15663"
],
"43453": [
"CVE-2017-15664"
],
"43454": [
"CVE-2017-15665"
],
"43456": [],
"43471": [
"CVE-2018-0746"
],
"43490": [],
"43491": [
"CVE-2018-0758"
],
"43501": [
"CVE-2017-8798"
],
"43513": [
"CVE-2017-13209"
],
"43514": [
"CVE-2018-0748"
],
"43515": [
"CVE-2018-0751"
],
"43516": [
"CVE-2018-0752"
],
"43517": [
"CVE-2018-0749"
],
"43521": [
"CVE-2017-7154"
],
"43522": [
"CVE-2018-0767"
],
"43547": [
"CVE-2018-5282"
],
"43548": [],
"41623": [
"CVE-2017-0070"
],
"41629": [],
"41637": [],
"41639": [
"CVE-2017-7183"
],
"43903": [
"CVE-2018-6191"
],
"43904": [
"CVE-2018-5759"
],
"43923": [
"CVE-2018-4090"
],
"43930": [],
"43937": [
"CVE-2018-4089"
],
"43938": [],
"43968": [
"CVE-2018-6389"
],
"42341": [],
"43972": [
"CVE-2018-6317"
],
"43986": [
"CVE-2018-0101"
],
"43992": [
"CVE-2017-17090"
],
"43996": [
"CVE-2017-13236"
],
"43998": [],
"44007": [
"CVE-2018-4083"
],
"44035": [
"CVE-2018-6323"
],
"44046": [
"CVE-2017-18019"
],
"44053": [
"CVE-2017-15649"
],
"44057": [
"CVE-2017-10355"
],
"44075": [
"CVE-2018-0770"
],
"44076": [
"CVE-2018-0860"
],
"44077": [
"CVE-2018-0840"
],
"44078": [
"CVE-2018-0834"
],
"44079": [
"CVE-2018-0835"
],
"44080": [
"CVE-2018-0838"
],
"44081": [
"CVE-2018-0837"
],
"44082": [],
"44083": [],
"44084": [],
"44096": [],
"44099": [
"CVE-2018-1041"
],
"44103": [
"CVE-2015-5374"
],
"44142": [],
"41643": [],
"41645": [
"CVE-2017-0103"
],
"41646": [
"CVE-2017-0085"
],
"41647": [
"CVE-2017-0108"
],
"41648": [
"CVE-2017-0084"
],
"41649": [
"CVE-2017-0086"
],
"41650": [
"CVE-2017-0087"
],
"41651": [
"CVE-2017-0088"
],
"41652": [
"CVE-2017-0089"
],
"41653": [
"CVE-2017-0090"
],
"41654": [
"CVE-2017-0072"
],
"41655": [
"CVE-2017-0128",
"CVE-2017-0127",
"CVE-2017-0126",
"CVE-2017-0125",
"CVE-2017-0124",
"CVE-2017-0123",
"CVE-2017-0122",
"CVE-2017-0121",
"CVE-2017-0120",
"CVE-2017-0119",
"CVE-2017-0118",
"CVE-2017-0117",
"CVE-2017-0116",
"CVE-2017-0115",
"CVE-2017-0114",
"CVE-2017-0113",
"CVE-2017-0112",
"CVE-2017-0111",
"CVE-2017-0092",
"CVE-2017-0091",
"CVE-2017-0083"
],
"41656": [
"CVE-2017-0060"
],
"41657": [
"CVE-2017-0061"
],
"41658": [
"CVE-2017-0062"
],
"41659": [
"CVE-2017-0063"
],
"41660": [
"CVE-2017-5404"
],
"41661": [
"CVE-2017-0059"
],
"41667": [],
"41668": [
"CVE-2017-6192"
],
"41669": [
"CVE-2017-6193"
],
"41670": [
"CVE-2017-6191"
],
"41791": [
"CVE-2017-2472"
],
"41792": [
"CVE-2017-2473"
],
"41797": [
"CVE-2017-2483"
],
"41794": [
"CVE-2017-2478"
],
"41826": [
"CVE-2017-7185"
],
"41778": [
"CVE-2017-2456"
],
"41781": [
"CVE-2017-7397"
],
"41790": [
"CVE-2017-2443"
],
"42223": [
"CVE-2017-8470"
],
"42750": [
"CVE-2017-8678"
],
"41916": [],
"42459": [
"CVE-2017-8644"
],
"41715": [],
"41734": [],
"41737": [],
"41741": [
"CVE-2017-2446"
],
"41742": [
"CVE-2017-2446"
],
"41743": [
"CVE-2017-2447"
],
"41752": [
"CVE-2017-7285"
],
"41755": [],
"41756": [],
"41767": [
"CVE-2012-4530"
],
"41768": [
"CVE-2012-0031"
],
"41769": [
"CVE-2011-4415",
"CVE-2011-3607"
],
"41806": [
"CVE-2017-0561"
],
"41807": [
"CVE-2017-2454"
],
"41809": [
"CVE-2017-2455"
],
"41810": [
"CVE-2017-2459"
],
"41811": [
"CVE-2017-2460"
],
"41812": [
"CVE-2017-2466"
],
"41813": [
"CVE-2017-2471"
],
"41814": [
"CVE-2017-2476"
],
"41823": [
"CVE-2017-3195"
],
"42088": [
"CVE-2017-8540"
],
"41851": [
"CVE-2017-7456"
],
"41867": [
"CVE-2017-2470"
],
"41868": [
"CVE-2017-2468"
],
"41869": [
"CVE-2017-2469"
],
"41879": [
"CVE-2017-0058"
],
"41880": [
"CVE-2017-0167"
],
"41891": [
"CVE-2017-0147",
"CVE-2017-0146",
"CVE-2017-0148",
"CVE-2017-0145",
"CVE-2017-0144",
"CVE-2017-0143"
],
"41893": [],
"41898": [
"CVE-2017-7938"
],
"41905": [
"CVE-2017-3561"
],
"41906": [
"CVE-2017-3575"
],
"41911": [],
"41931": [
"CVE-2017-2464"
],
"41932": [
"CVE-2017-3587"
],
"41941": [
"CVE-2017-0202"
],
"41945": [],
"41949": [],
"41954": [
"CVE-2017-3599"
],
"41957": [],
"41965": [
"CVE-2017-10003"
],
"41974": [
"CVE-2017-8779"
],
"41981": [],
"41982": [],
"41983": [],
"41984": [
"CVE-2017-2800"
],
"41991": [
"CVE-2017-8852"
],
"41993": [
"CVE-2017-7478"
],
"42001": [
"CVE-2017-8926"
],
"42002": [
"CVE-2017-8927"
],
"42006": [
"CVE-2017-0258"
],
"42007": [
"CVE-2017-0259"
],
"42008": [
"CVE-2017-0245"
],
"42009": [
"CVE-2017-0220",
"CVE-2017-0175"
],
"42014": [
"CVE-2017-6982"
],
"42017": [
"CVE-2017-3068"
],
"42018": [
"CVE-2017-3061"
],
"42019": [
"CVE-2017-3064"
],
"42021": [
"CVE-2017-0214"
],
"42027": [],
"42081": [
"CVE-2017-8538",
"CVE-2017-8537",
"CVE-2017-8536",
"CVE-2017-8535"
],
"42040": [],
"42046": [
"CVE-2017-2509"
],
"42047": [
"CVE-2017-2516"
],
"42048": [
"CVE-2017-9150"
],
"42049": [
"CVE-2017-2522"
],
"42050": [
"CVE-2017-2523"
],
"42051": [
"CVE-2017-2524"
],
"42052": [
"CVE-2017-2527"
],
"42054": [
"CVE-2017-2501"
],
"42055": [],
"42056": [
"CVE-2017-6978"
],
"42063": [
"CVE-2017-2514"
],
"42070": [],
"42071": [
"CVE-2017-5447"
],
"42072": [
"CVE-2017-5465"
],
"42073": [],
"42092": [
"CVE-2017-8541"
],
"42103": [
"CVE-2017-2521"
],
"42104": [
"CVE-2017-2531"
],
"42108": [],
"42110": [],
"42112": [],
"42115": [
"CVE-2017-9430"
],
"42123": [
"CVE-2017-9353"
],
"42124": [
"CVE-2017-9347"
],
"42135": [
"CVE-2017-2671"
],
"42136": [
"CVE-2017-7472"
],
"42137": [
"CVE-2017-6542"
],
"42138": [
"CVE-2017-5991"
],
"42139": [
"CVE-2017-6060"
],
"42140": [
"CVE-2017-4916"
],
"42144": [],
"42147": [
"CVE-2017-8871"
],
"42148": [
"CVE-2017-9128",
"CVE-2017-9127",
"CVE-2017-9126",
"CVE-2017-9125",
"CVE-2017-9124",
"CVE-2017-9123",
"CVE-2017-9122"
],
"42162": [
"CVE-2016-9813"
],
"42169": [],
"42170": [],
"42171": [],
"42182": [],
"42188": [
"CVE-2017-7005"
],
"42189": [
"CVE-2017-6980"
],
"42190": [
"CVE-2017-2547"
],
"42191": [
"CVE-2017-6984"
],
"42198": [
"CVE-2017-9750"
],
"42199": [
"CVE-2017-9746"
],
"42200": [
"CVE-2017-9747"
],
"42201": [
"CVE-2017-9749"
],
"42202": [
"CVE-2017-9748"
],
"42203": [
"CVE-2017-9742"
],
"42204": [
"CVE-2017-9756"
],
"42207": [
"CVE-2017-9130",
"CVE-2017-9129"
],
"42210": [
"CVE-2017-8484"
],
"42211": [
"CVE-2017-8487"
],
"42212": [
"CVE-2017-8488"
],
"42213": [
"CVE-2017-8489"
],
"42214": [
"CVE-2017-8490"
],
"42215": [
"CVE-2017-8491"
],
"42216": [
"CVE-2017-8492"
],
"42217": [
"CVE-2017-8469"
],
"42218": [
"CVE-2017-8462"
],
"42219": [
"CVE-2017-0299"
],
"42220": [
"CVE-2017-8482"
],
"42224": [
"CVE-2017-8471"
],
"42225": [
"CVE-2017-8472"
],
"42226": [
"CVE-2017-8473"
],
"42227": [],
"42228": [
"CVE-2017-8485"
],
"42229": [
"CVE-2017-8476"
],
"42230": [
"CVE-2017-8477"
],
"42231": [
"CVE-2017-8478"
],
"42232": [
"CVE-2017-8479"
],
"42233": [
"CVE-2017-8480"
],
"42234": [
"CVE-2017-0283"
],
"42235": [
"CVE-2017-0284"
],
"42236": [
"CVE-2017-0285"
],
"42237": [
"CVE-2017-0282"
],
"42238": [
"CVE-2017-0286"
],
"42239": [
"CVE-2017-0287"
],
"42240": [
"CVE-2017-0289"
],
"42241": [
"CVE-2017-0288"
],
"42242": [
"CVE-2017-8481"
],
"42243": [
"CVE-2017-8483"
],
"42244": [
"CVE-2017-0300"
],
"42245": [],
"42246": [
"CVE-2017-8496"
],
"42247": [
"CVE-2017-3076"
],
"42248": [
"CVE-2017-3077"
],
"42249": [
"CVE-2017-3078"
],
"42253": [],
"42258": [
"CVE-2017-9869"
],
"42259": [
"CVE-2017-9872"
],
"42260": [
"CVE-2017-1297"
],
"42264": [
"CVE-2017-8558"
],
"42272": [
"CVE-2017-10003"
],
"42277": [
"CVE-2017-1084"
],
"42278": [
"CVE-2017-1084"
],
"42279": [
"CVE-2017-1085"
],
"42285": [],
"42286": [],
"42294": [
"CVE-2017-5637"
],
"42299": [
"CVE-2017-10688"
],
"42300": [
"CVE-2017-9936"
],
"42301": [
"CVE-2017-9147"
],
"42302": [],
"42336": [
"CVE-2017-8594"
],
"42337": [
"CVE-2017-8618"
],
"42338": [
"CVE-2017-8564"
],
"42360": [
"CVE-2017-7048"
],
"42361": [
"CVE-2017-7043"
],
"42362": [
"CVE-2017-7039"
],
"42363": [
"CVE-2017-7049"
],
"42364": [
"CVE-2017-7042"
],
"42365": [
"CVE-2017-7046"
],
"42366": [
"CVE-2017-7041"
],
"42367": [
"CVE-2017-7040"
],
"42373": [
"CVE-2017-7018"
],
"42374": [],
"42375": [
"CVE-2017-7064"
],
"42376": [
"CVE-2017-7056"
],
"42377": [],
"42386": [
"CVE-2016-2226"
],
"42389": [
"CVE-2017-9260",
"CVE-2017-9259",
"CVE-2017-9258"
],
"42390": [
"CVE-2017-9412",
"CVE-2017-9411",
"CVE-2017-9410"
],
"42391": [
"CVE-2017-9614"
],
"42396": [
"CVE-2017-11330"
],
"42397": [
"CVE-2017-11331"
],
"42398": [
"CVE-2017-11359",
"CVE-2017-11358",
"CVE-2017-11332"
],
"42399": [
"CVE-2017-11735",
"CVE-2017-11333"
],
"42400": [
"CVE-2017-11548"
],
"42409": [
"CVE-2017-11552"
],
"42411": [],
"42433": [
"CVE-2017-11664",
"CVE-2017-11663",
"CVE-2017-11662",
"CVE-2017-11661"
],
"42445": [
"CVE-2017-8652"
],
"42451": [],
"42464": [
"CVE-2017-8656"
],
"42465": [
"CVE-2017-8641"
],
"42466": [
"CVE-2017-8636"
],
"42467": [
"CVE-2017-8636"
],
"42468": [
"CVE-2017-8636"
],
"42469": [
"CVE-2017-8645"
],
"42470": [
"CVE-2017-8646"
],
"42471": [
"CVE-2017-8635"
],
"42472": [],
"42473": [
"CVE-2017-8548"
],
"42474": [
"CVE-2017-8634"
],
"42475": [
"CVE-2017-8671"
],
"42476": [
"CVE-2017-8640"
],
"42477": [
"CVE-2017-8670"
],
"42478": [
"CVE-2017-8636"
],
"42479": [
"CVE-2017-8601"
],
"42480": [
"CVE-2017-3106"
],
"42481": [
"CVE-2017-8657"
],
"42483": [],
"42486": [],
"42495": [],
"42546": [
"CVE-2017-12954",
"CVE-2017-12953",
"CVE-2017-12952",
"CVE-2017-12951",
"CVE-2017-12950"
],
"42518": [
"CVE-2017-12786",
"CVE-2017-12785",
"CVE-2017-12787"
],
"42600": [
"CVE-2016-10504"
],
"42602": [
"CVE-2017-1129"
],
"42652": [
"CVE-2017-14266"
],
"42666": [
"CVE-2017-7061"
],
"42747": [
"CVE-2017-8684"
],
"42741": [
"CVE-2017-8680"
],
"42742": [
"CVE-2017-8681"
],
"42743": [
"CVE-2017-8708"
],
"42744": [
"CVE-2017-8682"
],
"42746": [
"CVE-2017-8683"
],
"42748": [
"CVE-2017-8685"
],
"42749": [
"CVE-2017-8687"
],
"42758": [
"CVE-2017-8731"
],
"42759": [
"CVE-2017-8734"
],
"42762": [
"CVE-2017-10002"
],
"42763": [
"CVE-2017-8729"
],
"42764": [
"CVE-2017-8740"
],
"42765": [
"CVE-2017-11764"
],
"42766": [
"CVE-2017-8755"
],
"42781": [
"CVE-2017-11281"
],
"42782": [
"CVE-2017-11281"
],
"42783": [
"CVE-2017-11282"
],
"42917": [],
"42920": [
"CVE-2017-14089"
],
"42932": [
"CVE-2017-14489"
],
"42941": [
"CVE-2017-14491"
],
"42942": [
"CVE-2017-14492"
],
"42943": [
"CVE-2017-14493"
],
"42944": [
"CVE-2017-14494"
],
"42945": [
"CVE-2017-14495"
],
"42946": [
"CVE-2017-14496"
],
"42955": [
"CVE-2017-7117"
],
"42970": [
"CVE-2017-14939"
],
"42962": [
"CVE-2017-15035"
],
"42969": [
"CVE-2017-1129"
],
"44273": [],
"42994": [],
"42995": [
"CVE-2017-0199"
],
"42997": [
"CVE-2017-11823"
],
"42998": [
"CVE-2017-11799"
],
"42999": [
"CVE-2017-11809"
],
"43000": [
"CVE-2017-11802"
],
"43001": [
"CVE-2017-11785"
],
"43010": [],
"43107": [],
"43014": [
"CVE-2017-15595"
],
"43020": [
"CVE-2017-7783"
],
"43026": [
"CVE-2017-15223"
],
"43058": [
"CVE-2017-15921",
"CVE-2017-15920"
],
"43060": [],
"43111": [
"CVE-2017-16353",
"CVE-2017-16352"
],
"43115": [
"CVE-2017-16513"
],
"43116": [],
"43119": [
"CVE-2017-16249"
],
"43120": [
"CVE-2017-12969"
],
"43124": [],
"43131": [
"CVE-2017-11810"
],
"43133": [
"CVE-2017-16642"
],
"43135": [],
"43144": [
"CVE-2017-15271",
"CVE-2017-15270"
],
"43152": [
"CVE-2017-11811"
],
"43154": [
"CVE-2017-11873"
],
"43161": [
"CVE-2017-13849"
],
"43164": [
"CVE-2017-16902"
],
"43165": [
"CVE-2017-11831"
],
"43166": [
"CVE-2017-13796"
],
"43167": [
"CVE-2017-13792"
],
"43168": [
"CVE-2017-13797"
],
"43169": [
"CVE-2017-13795"
],
"43170": [
"CVE-2017-13785"
],
"43171": [
"CVE-2017-13784"
],
"43172": [
"CVE-2017-13783"
],
"43173": [
"CVE-2017-13802"
],
"43174": [
"CVE-2017-13794"
],
"43175": [
"CVE-2017-13798"
],
"43176": [
"CVE-2017-13791"
],
"43464": [
"CVE-2017-13216"
],
"43178": [
"CVE-2017-16994"
],
"43180": [
"CVE-2017-11839"
],
"43181": [
"CVE-2017-11841"
],
"43182": [
"CVE-2017-11870"
],
"43183": [
"CVE-2017-11840"
],
"43184": [
"CVE-2017-16944"
],
"43185": [
"CVE-2017-16952"
],
"43186": [
"CVE-2017-16951"
],
"43189": [],
"43194": [
"CVE-2017-15118"
],
"43470": [
"CVE-2018-0745"
],
"43199": [
"CVE-2017-10004"
],
"43469": [
"CVE-2017-11918"
],
"43207": [],
"43208": [],
"43229": [],
"43233": [
"CVE-2017-17085"
],
"43234": [
"CVE-2017-8824"
],
"43317": [
"CVE-2017-17538"
],
"43320": [
"CVE-2017-13861"
],
"43321": [
"CVE-2017-13865"
],
"43319": [
"CVE-2017-13869"
],
"43318": [
"CVE-2017-13855"
],
"43322": [
"CVE-2017-17095"
],
"43325": [
"CVE-2017-13876"
],
"43326": [
"CVE-2017-13847"
],
"43327": [
"CVE-2017-13875"
],
"43328": [
"CVE-2017-13867"
],
"43344": [
"CVE-2017-17088"
],
"44146": [
"CVE-2018-0832"
],
"44153": [
"CVE-2018-0866"
],
"44154": [
"CVE-2018-7254",
"CVE-2018-7254"
],
"44178": [],
"44179": [],
"44180": [],
"44181": [
"CVE-2018-7286"
],
"44182": [],
"44183": [],
"44184": [
"CVE-2018-7284"
],
"44189": [
"CVE-2018-0833"
],
"44190": [],
"44197": [],
"44211": [
"CVE-2016-1886"
],
"44212": [
"CVE-2016-1887"
],
"44213": [
"CVE-2016-4657"
],
"44215": [
"CVE-2018-4087"
],
"44221": [
"CVE-2018-7449"
],
"44222": [
"CVE-2018-7583"
],
"44235": [
"CVE-2016-7608"
],
"44238": [
"CVE-2016-1827"
],
"44236": [
"CVE-2017-2388"
],
"44247": [
"CVE-2018-6794"
],
"44251": [
"CVE-2018-7264"
],
"44254": [],
"44255": [
"CVE-2018-7658"
],
"44257": [],
"44258": [],
"44259": [],
"44260": [],
"44264": [
"CVE-2018-10001"
],
"44265": [
"CVE-2018-10001"
],
"44268": [
"CVE-2017-9417"
],
"44271": [
"CVE-2018-7582"
],
"44291": [
"CVE-2017-13253"
],
"44301": [
"CVE-2016-6187"
],
"44304": [
"CVE-2017-16994"
],
"44305": [
"CVE-2017-10004"
],
"44308": [
"CVE-2018-0894"
],
"44309": [
"CVE-2018-0895"
],
"44310": [
"CVE-2018-0897"
],
"44311": [
"CVE-2018-0901"
],
"44312": [
"CVE-2018-0891"
],
"44316": [],
"44326": [
"CVE-2017-13262",
"CVE-2017-13261",
"CVE-2017-13260",
"CVE-2017-13258"
],
"44327": [
"CVE-2017-13262",
"CVE-2017-13261",
"CVE-2017-13260",
"CVE-2017-13258"
],
"44332": [
"CVE-2018-1218"
],
"44333": [],
"44338": [],
"44372": [],
"44375": [
"CVE-2018-9115"
],
"44394": [
"CVE-2018-6064"
],
"44395": [],
"44396": [
"CVE-2018-0934",
"CVE-2018-0933"
],
"44397": [
"CVE-2018-0934"
],
"44402": [
"CVE-2018-0986"
],
"44404": [
"CVE-2018-0935"
],
"44427": [
"CVE-2018-4121"
],
"44428": [
"CVE-2018-9842"
],
"44442": [],
"44451": [
"CVE-2018-0171"
],
"44456": [],
"44458": [
"CVE-2018-0975"
],
"44459": [
"CVE-2018-0969"
],
"44460": [
"CVE-2018-0970"
],
"44461": [
"CVE-2018-0971"
],
"44462": [
"CVE-2018-0972"
],
"44463": [
"CVE-2018-0973"
],
"44464": [
"CVE-2018-0974"
],
"44465": [
"CVE-2018-0968"
],
"44466": [
"CVE-2018-0966"
],
"44467": [],
"44468": [],
"44490": [],
"44491": [],
"44494": [],
"44500": [
"CVE-2018-10253"
],
"44519": [],
"44514": [
"CVE-2017-8311"
],
"44521": [],
"44525": [],
"44526": [
"CVE-2018-4936"
],
"44527": [
"CVE-2018-4935"
],
"44528": [
"CVE-2018-4934"
],
"44529": [
"CVE-2018-4937"
],
"44530": [],
"44533": [],
"44540": [],
"44541": [],
"44558": [],
"44561": [
"CVE-2018-4139"
],
"44562": [
"CVE-2018-4206"
],
"44566": [
"CVE-2018-4200"
],
"44572": [],
"44579": [],
"44593": [],
"44600": [
"CVE-2018-10809"
],
"44605": [],
"44610": [
"CVE-2018-10828"
],
"44615": [
"CVE-2018-10830"
],
"44619": [
"CVE-2018-11034"
],
"44629": [],
"44641": [],
"44653": [
"CVE-2018-0980"
],
"44693": [
"CVE-2014-5074"
],
"44694": [
"CVE-2018-0953"
],
"44695": [
"CVE-2018-3639"
],
"46068": [],
"46069": [],
"44717": [],
"44721": [
"CVE-2016-3963"
],
"44724": [
"CVE-2018-10751"
],
"44758": [
"CVE-2018-0946"
],
"44759": [
"CVE-2018-5159"
],
"44768": [],
"44802": [
"CVE-2015-2177"
],
"44817": [
"CVE-2018-8133"
],
"44821": [],
"44832": [
"CVE-2018-11412"
],
"44944": [
"CVE-2018-12904"
],
"44946": [
"CVE-2018-8002"
],
"44846": [
"CVE-2018-7584"
],
"44847": [
"CVE-2018-4230"
],
"44848": [
"CVE-2018-4243"
],
"44849": [
"CVE-2018-4241"
],
"44876": [
"CVE-2018-11646"
],
"44857": [],
"44859": [
"CVE-2018-4222"
],
"44860": [
"CVE-2018-6092"
],
"44861": [
"CVE-2018-4218"
],
"44862": [
"CVE-2018-6130"
],
"44863": [
"CVE-2018-6129"
],
"44894": [],
"44908": [
"CVE-2018-12453"
],
"44909": [
"CVE-2018-12327"
],
"44914": [
"CVE-2018-8208"
],
"44915": [
"CVE-2018-8214"
],
"44925": [
"CVE-2018-12617"
],
"44927": [],
"44934": [
"CVE-2018-12706"
],
"44958": [],
"44962": [],
"44965": [
"CVE-2018-10594"
],
"45106": [
"CVE-2018-10906"
],
"44972": [
"CVE-2018-12938"
],
"44994": [
"CVE-2018-0491"
],
"45011": [
"CVE-2018-8145"
],
"45012": [
"CVE-2018-8139"
],
"45013": [
"CVE-2018-8229"
],
"45017": [
"CVE-2018-10018"
],
"45032": [],
"45033": [
"CVE-2018-13405"
],
"45059": [],
"45060": [],
"45061": [],
"45064": [
"CVE-2018-14336"
],
"45082": [
"CVE-2018-13458",
"CVE-2018-13457",
"CVE-2018-13441"
],
"45077": [],
"45087": [
"CVE-2017-17849"
],
"45091": [
"CVE-2018-20658"
],
"45092": [],
"45095": [],
"45098": [
"CVE-2018-6126"
],
"45102": [],
"45104": [],
"45110": [],
"45112": [],
"45121": [],
"45122": [],
"45123": [],
"45168": [],
"45162": [],
"45174": [
"CVE-2018-12584"
],
"45182": [],
"45186": [],
"45187": [],
"45191": [],
"45199": [
"CVE-2018-15181"
],
"45203": [
"CVE-2018-15172"
],
"45204": [],
"45207": [],
"45211": [],
"45213": [
"CVE-2018-8288"
],
"45214": [
"CVE-2018-8279"
],
"45215": [
"CVE-2018-8291"
],
"45216": [],
"45217": [
"CVE-2018-8298"
],
"45219": [
"CVE-2013-0662"
],
"45222": [],
"45223": [],
"45226": [],
"45229": [],
"45238": [],
"45239": [],
"45241": [],
"45245": [],
"45246": [],
"45249": [],
"45251": [],
"45257": [],
"45261": [],
"45263": [
"CVE-2018-15120"
],
"45268": [
"CVE-2018-12827"
],
"45275": [],
"45277": [],
"45279": [
"CVE-2018-8353"
],
"45281": [],
"45282": [],
"45285": [],
"45294": [],
"45295": [],
"45297": [],
"45298": [],
"45299": [],
"45300": [],
"45301": [],
"45302": [],
"45304": [],
"45311": [],
"45315": [],
"45316": [],
"45317": [
"CVE-2018-15839"
],
"45318": [],
"45320": [],
"45321": [],
"45324": [],
"45357": [],
"45380": [],
"45376": [],
"45381": [],
"45382": [],
"45383": [],
"45388": [],
"45389": [],
"45390": [],
"45391": [
"CVE-2018-4240"
],
"45397": [],
"45398": [],
"45404": [],
"45405": [],
"45410": [],
"45413": [],
"45414": [],
"45419": [],
"45420": [],
"45421": [],
"45424": [],
"45431": [
"CVE-2018-8384"
],
"45432": [
"CVE-2018-8355"
],
"45435": [
"CVE-2018-8449"
],
"45436": [
"CVE-2018-8410"
],
"45457": [],
"45443": [
"CVE-2018-16071"
],
"45444": [
"CVE-2018-16083"
],
"45450": [],
"45453": [],
"45455": [],
"45480": [
"CVE-2018-4314"
],
"45481": [
"CVE-2018-4312"
],
"45482": [
"CVE-2018-4306"
],
"45483": [
"CVE-2018-4328"
],
"45484": [
"CVE-2018-4323"
],
"45485": [
"CVE-2018-4315"
],
"45486": [
"CVE-2018-4317"
],
"45488": [
"CVE-2018-4318"
],
"45489": [
"CVE-2018-4197"
],
"45493": [],
"45494": [],
"45527": [],
"45624": [
"CVE-2018-8411"
],
"45544": [],
"45547": [
"CVE-2018-18065",
"CVE-2015-5621"
],
"45557": [],
"45558": [
"CVE-2018-9515"
],
"45576": [],
"45571": [
"CVE-2018-8466"
],
"45572": [
"CVE-2018-8467"
],
"45579": [],
"45641": [],
"45644": [],
"45647": [],
"45648": [],
"45649": [],
"45650": [],
"45651": [],
"45652": [],
"45679": [],
"45670": [],
"45694": [
"CVE-2018-18557"
],
"45705": [],
"45708": [],
"45711": [],
"45714": [
"CVE-2018-15686"
],
"45716": [
"CVE-2018-10712",
"CVE-2018-10711",
"CVE-2018-10710",
"CVE-2018-10709"
],
"45732": [
"CVE-2018-18759"
],
"45746": [],
"45749": [],
"45750": [],
"45759": [],
"45760": [],
"45761": [],
"45762": [],
"45769": [],
"45770": [],
"46485": [
"CVE-2019-0539"
],
"45772": [],
"45781": [],
"45786": [
"CVE-2018-4384"
],
"45787": [
"CVE-2018-4367"
],
"45788": [
"CVE-2018-4366"
],
"45792": [],
"45797": [],
"45800": [],
"45806": [],
"45814": [],
"45819": [],
"45823": [],
"45824": [
"CVE-2017-10000"
],
"45829": [
"CVE-2018-15437"
],
"45850": [],
"45859": [],
"45869": [],
"45884": [],
"45885": [],
"45887": [],
"45889": [],
"45891": [],
"45901": [],
"45910": [
"CVE-2018-4416"
],
"45911": [
"CVE-2018-4382"
],
"45912": [
"CVE-2018-4386"
],
"45919": [],
"45923": [
"CVE-2018-8544"
],
"45924": [
"CVE-2018-8552"
],
"45931": [],
"45934": [],
"45936": [
"CVE-2018-8474"
],
"45950": [],
"45951": [
"CVE-2018-19627"
],
"45956": [],
"45966": [],
"45968": [],
"45982": [],
"45983": [],
"45984": [
"CVE-2018-4438"
],
"45993": [],
"45996": [],
"46001": [
"CVE-2018-8631"
],
"46002": [],
"46026": [],
"46003": [],
"46004": [],
"46022": [
"CVE-2018-8625"
],
"46023": [
"CVE-2018-8619"
],
"46030": [],
"46038": [],
"46042": [],
"46048": [
"CVE-2018-1160"
],
"46057": [],
"46062": [],
"46063": [],
"46064": [],
"46071": [
"CVE-2018-4443"
],
"46072": [
"CVE-2018-4441"
],
"46078": [],
"46087": [],
"46088": [],
"46089": [],
"46096": [],
"46099": [],
"46101": [
"CVE-2018-8269"
],
"46105": [],
"46124": [],
"46125": [],
"46126": [],
"46127": [],
"46128": [],
"46129": [],
"46130": [],
"46165": [
"CVE-2018-13042"
],
"46170": [],
"46175": [
"CVE-2019-6443"
],
"46176": [
"CVE-2019-6444"
],
"46177": [
"CVE-2019-6445"
],
"46178": [
"CVE-2019-6442"
],
"46181": [],
"46183": [
"CVE-2018-4442"
],
"46184": [
"CVE-2019-0570"
],
"46194": [],
"46195": [],
"46196": [],
"46197": [],
"46198": [],
"46199": [],
"46202": [
"CVE-2018-8617"
],
"46203": [
"CVE-2019-0567",
"CVE-2019-0539"
],
"46204": [
"CVE-2019-0539"
],
"46205": [
"CVE-2019-0568"
],
"46208": [
"CVE-2018-11508"
],
"46216": [],
"46236": [],
"46246": [
"CVE-2019-6706"
],
"46248": [
"CVE-2019-6225"
],
"46261": [
"CVE-2019-6973"
],
"46272": [],
"46278": [],
"46284": [],
"46285": [
"CVE-2019-6209"
],
"46286": [],
"46287": [],
"46289": [],
"46291": [],
"46292": [],
"46293": [],
"46294": [],
"46295": [],
"46296": [
"CVE-2019-6208"
],
"46297": [
"CVE-2019-6218"
],
"46298": [
"CVE-2019-6214"
],
"46299": [
"CVE-2019-6205"
],
"46300": [
"CVE-2019-6213"
],
"46304": [],
"46309": [],
"46312": [],
"46313": [],
"46314": [],
"46321": [],
"46322": [],
"46332": [],
"46337": [
"CVE-2019-9599"
],
"46338": [],
"46343": [],
"46564": [],
"46356": [
"CVE-2019-2000"
],
"46357": [
"CVE-2019-1999"
],
"46358": [
"CVE-2018-19524"
],
"46484": [],
"46439": [],
"46367": [],
"46371": [],
"46378": [],
"46380": [
"CVE-2019-9601"
],
"46381": [
"CVE-2019-9831"
],
"46382": [],
"46383": [],
"46385": [],
"46388": [
"CVE-2019-6974"
],
"46390": [],
"46391": [],
"46403": [],
"46409": [],
"46410": [],
"46411": [],
"46412": [],
"46417": [],
"46421": [],
"46422": [],
"46430": [],
"46432": [],
"46433": [
"CVE-2019-6224"
],
"46434": [],
"46435": [],
"46442": [],
"46443": [
"CVE-2019-9833"
],
"46445": [
"CVE-2019-9832"
],
"46448": [
"CVE-2019-6215"
],
"46458": [],
"46464": [
"CVE-2019-9600"
],
"46465": [
"CVE-2019-8375",
"CVE-2019-8375"
],
"46470": [],
"46472": [],
"46473": [],
"46474": [],
"46475": [],
"46476": [],
"46477": [
"CVE-2019-9162"
],
"46478": [],
"46502": [
"CVE-2019-9213"
],
"46503": [
"CVE-2019-2025"
],
"46504": [
"CVE-2019-2023"
],
"46529": [
"CVE-2016-4578"
],
"46532": [],
"46533": [],
"46534": [
"CVE-2019-9649"
],
"46535": [
"CVE-2019-9648"
],
"46553": [],
"46554": [],
"46565": [
"CVE-2019-5797"
],
"46566": [
"CVE-2019-5796"
],
"46567": [
"CVE-2019-0768"
],
"46568": [
"CVE-2019-0667"
],
"46569": [
"CVE-2019-0612"
],
"46570": [
"CVE-2019-5789"
],
"46571": [
"CVE-2019-5788"
],
"46589": [
"CVE-2019-9768"
],
"46594": [
"CVE-2019-7303"
],
"46604": [
"CVE-2019-0808"
],
"46605": [
"CVE-2019-9810"
],
"46613": [
"CVE-2019-9791"
],
"46621": [],
"46626": [],
"46646": [
"CVE-2019-9813"
],
"46647": [
"CVE-2019-8506"
],
"46648": [
"CVE-2019-8514"
],
"46649": [
"CVE-2019-8518"
],
"46650": [
"CVE-2019-8558"
],
"46651": [],
"46652": [],
"46653": [],
"46656": [],
"46702": [],
"46703": [],
"46708": [],
"46709": [],
"46711": [],
"46720": [
"CVE-2018-11492"
],
"46721": [],
"46722": [
"CVE-2019-2697"
],
"46723": [
"CVE-2019-2698"
],
"46726": [
"CVE-2018-16517"
],
"46732": [],
"46733": [
"CVE-2019-7181"
],
"46735": [],
"46743": [
"CVE-2019-3842"
],
"46744": [],
"46745": [],
"46749": [],
"46750": [],
"46752": [
"CVE-2019-7439"
],
"46754": [],
"46757": [],
"46758": [],
"46760": [
"CVE-2019-3844",
"CVE-2019-3843"
],
"46778": [],
"46781": [
"CVE-2019-11599"
],
"3": [
"CVE-2003-0127"
],
"4": [
"CVE-2003-1055"
],
"12": [
"CVE-2003-0127"
],
"15": [
"CVE-2003-0171"
],
"21": [
"CVE-2003-1452"
],
"29": [
"CVE-2003-0281",
"CVE-2002-2087"
],
"31": [
"CVE-2003-0289"
],
"32": [
"CVE-2003-0306"
],
"40": [],
"52": [],
"71": [
"CVE-2003-0454"
],
"72": [
"CVE-2003-0611"
],
"75": [
"CVE-2003-0645"
],
"79": [
"CVE-2003-1030"
],
"91": [
"CVE-2003-0740"
],
"93": [],
"104": [
"CVE-2003-0783"
],
"106": [
"CVE-2003-0759"
],
"114": [
"CVE-2003-0609"
],
"118": [
"CVE-2003-0955"
],
"120": [],
"122": [
"CVE-2003-0659"
],
"125": [
"CVE-2003-0955"
],
"129": [
"CVE-2003-0961"
],
"131": [
"CVE-2003-0961"
],
"134": [
"CVE-2003-0090"
],
"140": [
"CVE-2004-0074"
],
"141": [
"CVE-2003-0985"
],
"142": [
"CVE-2003-0985"
],
"144": [
"CVE-2004-0064"
],
"145": [
"CVE-2003-0985"
],
"152": [
"CVE-2004-2093"
],
"154": [
"CVE-2004-0077"
],
"160": [
"CVE-2004-0077"
],
"172": [],
"178": [
"CVE-2000-0949"
],
"180": [],
"182": [
"CVE-2000-1125"
],
"183": [
"CVE-2000-0987"
],
"184": [
"CVE-2000-1125"
],
"186": [],
"193": [
"CVE-2000-1009"
],
"197": [
"CVE-2000-0844"
],
"199": [],
"200": [
"CVE-1999-0034"
],
"202": [
"CVE-2000-1103"
],
"203": [
"CVE-2000-1096"
],
"205": [],
"206": [
"CVE-2000-1009"
],
"207": [],
"209": [
"CVE-2000-0844"
],
"210": [
"CVE-2000-0844"
],
"215": [
"CVE-2000-0844"
],
"216": [
"CVE-2001-0066"
],
"217": [
"CVE-2000-1134"
],
"218": [],
"219": [],
"221": [],
"222": [],
"229": [
"CVE-1999-1008"
],
"231": [],
"243": [
"CVE-2000-0993"
],
"245": [
"CVE-2000-1028"
],
"247": [],
"249": [
"CVE-2000-0844"
],
"250": [
"CVE-2001-0115"
],
"252": [
"CVE-1999-0821"
],
"255": [
"CVE-2000-0170"
],
"256": [
"CVE-1999-1371"
],
"257": [
"CVE-2001-0110"
],
"258": [
"CVE-2001-0170"
],
"259": [
"CVE-2002-1616"
],
"260": [
"CVE-2001-0112"
],
"261": [
"CVE-1999-1185",
"CVE-1999-1041"
],
"265": [
"CVE-2000-0795"
],
"270": [
"CVE-2001-0485"
],
"271": [
"CVE-2003-0908"
],
"272": [
"CVE-2004-0333"
],
"273": [
"CVE-2004-0524"
],
"281": [
"CVE-2002-1614"
],
"285": [],
"286": [
"CVE-2001-0221"
],
"287": [
"CVE-2001-0220"
],
"288": [],
"290": [
"CVE-2001-0169"
],
"302": [],
"317": [
"CVE-2001-0170"
],
"319": [],
"320": [
"CVE-1999-0034"
],
"321": [
"CVE-2000-0218"
],
"322": [
"CVE-1999-0040"
],
"325": [
"CVE-2000-1220"
],
"328": [
"CVE-1999-0315",
"CVE-1999-0110"
],
"330": [],
"331": [
"CVE-1999-0040"
],
"332": [
"CVE-1999-1191"
],
"333": [
"CVE-1999-0112"
],
"334": [
"CVE-1999-0027"
],
"335": [
"CVE-1999-0064"
],
"336": [
"CVE-1999-0036"
],
"337": [],
"338": [
"CVE-1999-0126"
],
"339": [
"CVE-1999-1483"
],
"341": [
"CVE-1999-1158"
],
"350": [
"CVE-2004-0213"
],
"351": [
"CVE-2004-0213"
],
"352": [
"CVE-2004-0213"
],
"353": [
"CVE-2004-0212"
],
"355": [
"CVE-2004-0213"
],
"367": [
"CVE-2004-0824"
],
"368": [
"CVE-2004-0212"
],
"369": [
"CVE-2004-0557"
],
"374": [
"CVE-2004-0557"
],
"375": [
"CVE-2004-0415"
],
"381": [
"CVE-2004-2532"
],
"388": [
"CVE-2004-0733"
],
"393": [
"CVE-2004-0597"
],
"394": [
"CVE-2006-6563"
],
"395": [
"CVE-2004-0636"
],
"396": [
"CVE-2000-0574"
],
"401": [
"CVE-1999-1497"
],
"405": [],
"411": [
"CVE-2002-1337"
],
"417": [
"CVE-2004-0524"
],
"434": [],
"438": [
"CVE-2004-0806"
],
"466": [],
"469": [
"CVE-2004-0806"
],
"470": [
"CVE-2004-1689"
],
"476": [],
"479": [],
"482": [
"CVE-2001-0979"
],
"558": [],
"559": [
"CVE-2004-0964"
],
"560": [],
"579": [],
"586": [],
"587": [
"CVE-2004-0940"
],
"591": [
"CVE-2004-1484"
],
"600": [
"CVE-2004-0990"
],
"601": [
"CVE-2004-0110"
],
"602": [
"CVE-2004-0510"
],
"624": [
"CVE-2004-1073"
],
"629": [
"CVE-2004-2442",
"CVE-2004-1096",
"CVE-2004-0937",
"CVE-2004-0936",
"CVE-2004-0935",
"CVE-2004-0934",
"CVE-2004-0933",
"CVE-2004-0932"
],
"657": [],
"669": [
"CVE-2004-0548"
],
"680": [
"CVE-2005-1307"
],
"684": [],
"694": [
"CVE-2004-1254"
],
"695": [],
"698": [
"CVE-2004-1326"
],
"699": [
"CVE-2004-1330"
],
"701": [
"CVE-2004-1054"
],
"713": [
"CVE-2003-0834"
],
"714": [
"CVE-2003-0834"
],
"715": [
"CVE-2004-0360"
],
"718": [
"CVE-2004-0497"
],
"739": [],
"741": [],
"744": [
"CVE-2004-1235"
],
"749": [
"CVE-2004-0894"
],
"756": [
"CVE-2005-0021"
],
"758": [
"CVE-2005-0043"
],
"760": [],
"763": [],
"766": [
"CVE-2005-0193"
],
"769": [],
"776": [],
"778": [
"CVE-2004-1235"
],
"779": [
"CVE-2010-0788"
],
"788": [
"CVE-2005-3533"
],
"791": [
"CVE-2005-0156"
],
"792": [
"CVE-2005-0155"
],
"793": [
"CVE-2005-0342"
],
"795": [],
"796": [],
"798": [
"CVE-2005-0422"
],
"803": [
"CVE-2005-0421"
],
"811": [],
"816": [],
"824": [],
"833": [
"CVE-2005-0517"
],
"834": [
"CVE-2005-0518"
],
"835": [
"CVE-2005-0521"
],
"836": [],
"837": [
"CVE-2005-0522"
],
"839": [
"CVE-2005-0506"
],
"844": [
"CVE-2005-0518"
],
"846": [
"CVE-2005-0619"
],
"848": [
"CVE-2005-0619"
],
"863": [
"CVE-2005-0455"
],
"876": [
"CVE-2005-0666"
],
"877": [
"CVE-2005-0385"
],
"884": [
"CVE-2005-0823"
],
"885": [
"CVE-2005-0823"
],
"890": [],
"895": [
"CVE-2004-1235"
],
"896": [
"CVE-2005-0716"
],
"898": [
"CVE-2004-1054"
],
"905": [
"CVE-2005-1009"
],
"912": [
"CVE-2005-1098"
],
"913": [
"CVE-2005-1019"
],
"914": [
"CVE-2005-1019"
],
"918": [
"CVE-2005-1094"
],
"919": [],
"920": [
"CVE-2005-1097"
],
"924": [],
"926": [
"CVE-2005-1294",
"CVE-2005-0750"
],
"927": [
"CVE-2005-0944"
],
"929": [
"CVE-2005-0944"
],
"932": [],
"933": [],
"935": [],
"936": [
"CVE-2005-1092"
],
"937": [],
"938": [
"CVE-2005-0063"
],
"950": [],
"951": [
"CVE-2005-0944"
],
"963": [
"CVE-2005-1424"
],
"964": [
"CVE-2005-1414"
],
"965": [
"CVE-2005-1411"
],
"966": [
"CVE-2005-1418"
],
"971": [
"CVE-2005-1371"
],
"972": [
"CVE-2005-1394"
],
"973": [
"CVE-2005-1396"
],
"974": [
"CVE-2005-1396"
],
"997": [],
"1001": [],
"1009": [
"CVE-2005-0021"
],
"1019": [
"CVE-2005-0047"
],
"1029": [],
"1032": [
"CVE-2005-1905"
],
"1034": [
"CVE-2004-1465"
],
"1043": [
"CVE-2005-1725"
],
"1044": [
"CVE-2005-0263"
],
"1045": [
"CVE-2005-0262"
],
"1046": [
"CVE-2005-2236",
"CVE-2005-2232"
],
"1073": [
"CVE-2005-2072"
],
"1074": [
"CVE-2005-2072"
],
"1085": [],
"1086": [],
"1087": [],
"1091": [
"CVE-2005-2210"
],
"1092": [],
"1119": [],
"1128": [],
"1154": [
"CVE-2005-3533"
],
"1161": [
"CVE-2005-1372"
],
"1168": [
"CVE-2005-2694"
],
"1170": [
"CVE-2001-0989"
],
"1173": [
"CVE-2005-2866"
],
"1174": [
"CVE-2005-2868"
],
"1181": [],
"1182": [
"CVE-2003-0609"
],
"1185": [
"CVE-2005-1842"
],
"1186": [
"CVE-2005-1843"
],
"1187": [
"CVE-2005-2772"
],
"1197": [],
"1198": [
"CVE-2005-0551"
],
"1215": [
"CVE-2003-0948",
"CVE-2003-0947"
],
"1229": [
"CVE-2005-3098"
],
"1230": [
"CVE-2005-3098"
],
"1248": [],
"1267": [
"CVE-2005-2943"
],
"1297": [
"CVE-2006-3546",
"CVE-2005-3546"
],
"1299": [
"CVE-2005-3503"
],
"1300": [
"CVE-2005-3346"
],
"1310": [],
"1311": [],
"1316": [
"CVE-2005-3566"
],
"1347": [
"CVE-2005-3928"
],
"1360": [
"CVE-2005-4076"
],
"1397": [
"CVE-2005-0736"
],
"1402": [
"CVE-2006-0072"
],
"1403": [
"CVE-2005-4620"
],
"1404": [
"CVE-2005-4620"
],
"1406": [
"CVE-2006-0097"
],
"1407": [
"CVE-2005-2827"
],
"1412": [
"CVE-2006-0176"
],
"1415": [
"CVE-2006-0176"
],
"1425": [],
"1445": [],
"1449": [
"CVE-2006-0331"
],
"1455": [
"CVE-2006-0287"
],
"1465": [],
"1470": [
"CVE-2009-0133",
"CVE-2006-0564"
],
"1479": [
"CVE-2006-0620"
],
"1481": [
"CVE-2006-0623"
],
"1490": [
"CVE-2009-0133",
"CVE-2006-0564"
],
"1495": [
"CVE-2006-0564",
"CVE-2009-0133"
],
"1518": [],
"1534": [
"CVE-2005-2934"
],
"1545": [
"CVE-2005-2713"
],
"40340": [],
"1554": [
"CVE-2005-1544"
],
"1555": [
"CVE-2006-1043"
],
"1577": [
"CVE-2005-2925"
],
"1579": [
"CVE-2006-1183"
],
"1584": [
"CVE-2005-0058"
],
"1591": [
"CVE-2006-1542"
],
"1596": [
"CVE-2006-0745"
],
"1624": [],
"1625": [],
"1719": [
"CVE-2006-2505",
"CVE-2006-2081"
],
"1772": [
"CVE-2006-2316"
],
"1806": [
"CVE-2006-2494"
],
"40336": [],
"1831": [
"CVE-2006-2656"
],
"1910": [
"CVE-2006-2373"
],
"1911": [
"CVE-2006-2374",
"CVE-2006-2373"
],
"1917": [
"CVE-2006-2909"
],
"1924": [],
"1944": [
"CVE-2006-3059"
],
"1958": [],
"1962": [],
"1973": [],
"1978": [],
"1985": [
"CVE-2006-3912"
],
"1986": [],
"1988": [],
"1992": [
"CVE-2006-3912"
],
"1999": [],
"2004": [
"CVE-2006-2451"
],
"2005": [
"CVE-2006-2451"
],
"2006": [
"CVE-2006-2451"
],
"2011": [
"CVE-2006-2451"
],
"2013": [],
"2015": [
"CVE-2006-3693"
],
"2016": [
"CVE-2006-3693"
],
"2031": [
"CVE-2006-2451"
],
"2056": [
"CVE-2006-0026"
],
"2065": [
"CVE-2006-3814"
],
"2067": [
"CVE-2006-3824"
],
"2091": [],
"2094": [
"CVE-2006-4046"
],
"2106": [],
"2107": [],
"2108": [],
"2111": [
"CVE-2005-0716"
],
"2144": [],
"2152": [],
"2193": [
"CVE-2006-4020"
],
"2241": [
"CVE-2006-3824"
],
"2242": [
"CVE-1999-1587"
],
"2264": [
"CVE-2006-6410"
],
"2278": [
"CVE-2006-2439"
],
"2284": [
"CVE-2006-4676"
],
"2286": [
"CVE-2006-4359"
],
"2330": [
"CVE-2006-4655"
],
"2331": [
"CVE-2006-4655"
],
"2332": [
"CVE-2006-4655"
],
"2338": [
"CVE-2006-4789"
],
"2360": [
"CVE-2006-4655"
],
"2404": [
"CVE-2006-4438"
],
"2412": [
"CVE-2006-3444"
],
"2463": [
"CVE-2006-4392"
],
"2464": [
"CVE-2006-4392"
],
"2466": [
"CVE-2006-5014"
],
"2492": [],
"2543": [
"CVE-2006-4842"
],
"2565": [],
"2569": [
"CVE-2006-4842"
],
"2580": [],
"2581": [
"CVE-2006-5379"
],
"2633": [
"CVE-2006-5557"
],
"2634": [
"CVE-2006-5557"
],
"2635": [
"CVE-2006-5558"
],
"2636": [
"CVE-2006-5556"
],
"2641": [
"CVE-2006-4842"
],
"2676": [
"CVE-2006-4926"
],
"2737": [
"CVE-2006-5851"
],
"2738": [
"CVE-2006-5852"
],
"2788": [
"CVE-2006-6131"
],
"40380": [],
"2815": [
"CVE-2006-6063"
],
"2821": [],
"2824": [
"CVE-2006-6063"
],
"2872": [
"CVE-2006-6251"
],
"2873": [
"CVE-2006-6287"
],
"2880": [
"CVE-2009-0450",
"CVE-2006-6396",
"CVE-2006-6199"
],
"2950": [
"CVE-2006-6665"
],
"3024": [
"CVE-2006-6696"
],
"3070": [
"CVE-2007-0017"
],
"3071": [],
"3087": [
"CVE-2007-0117"
],
"3088": [
"CVE-2007-0117"
],
"3094": [
"CVE-2007-0085"
],
"3102": [
"CVE-2007-0162"
],
"3131": [
"CVE-2007-1881"
],
"3149": [
"CVE-2007-0427",
"CVE-2007-0352"
],
"3154": [
"CVE-2007-0368"
],
"3156": [
"CVE-2007-0019"
],
"3159": [
"CVE-2007-0427"
],
"3173": [],
"3176": [],
"3177": [],
"3178": [
"CVE-2006-3698"
],
"3179": [
"CVE-2006-0586"
],
"3181": [
"CVE-2007-0023"
],
"3213": [
"CVE-2007-0602"
],
"3219": [
"CVE-2007-0467"
],
"3220": [
"CVE-2006-5854"
],
"3260": [
"CVE-2007-0515"
],
"3273": [
"CVE-2007-0805"
],
"3330": [
"CVE-2006-6563"
],
"3333": [
"CVE-2006-6563"
],
"3342": [
"CVE-2007-1041"
],
"3349": [
"CVE-2007-1074"
],
"3356": [
"CVE-2007-1057"
],
"3369": [
"CVE-2007-1041"
],
"3383": [
"CVE-2007-1189"
],
"3384": [
"CVE-2006-7098"
],
"3386": [
"CVE-2007-1227"
],
"3413": [
"CVE-2007-1380"
],
"3414": [
"CVE-2007-0908"
],
"3417": [
"CVE-2007-1411"
],
"3424": [
"CVE-2007-1375"
],
"3426": [
"CVE-2007-1376"
],
"3427": [
"CVE-2007-1376"
],
"3429": [
"CVE-2007-1382"
],
"3431": [
"CVE-2007-1401"
],
"3439": [
"CVE-2007-1413"
],
"3440": [
"CVE-2007-1399"
],
"3442": [
"CVE-2007-1412"
],
"3451": [],
"3460": [
"CVE-2007-1584"
],
"3479": [
"CVE-2007-1521"
],
"3480": [
"CVE-2007-1522"
],
"3488": [
"CVE-2007-1475"
],
"3499": [
"CVE-2007-1484"
],
"3517": [
"CVE-2007-1584"
],
"3525": [
"CVE-2007-1582"
],
"3529": [
"CVE-2007-1581"
],
"3559": [
"CVE-2007-1649"
],
"3571": [
"CVE-2007-1700"
],
"3572": [
"CVE-2007-1701"
],
"3576": [
"CVE-2007-1709"
],
"3578": [
"CVE-2007-1719"
],
"3587": [
"CVE-2007-1734",
"CVE-2007-1730"
],
"3593": [
"CVE-2007-1735"
],
"3595": [
"CVE-2007-1734",
"CVE-2007-1730"
],
"3617": [
"CVE-2007-1765",
"CVE-2007-0038"
],
"3647": [
"CVE-2007-0038",
"CVE-2007-1765"
],
"3648": [
"CVE-2007-1867"
],
"3649": [],
"3652": [
"CVE-2007-1765",
"CVE-2007-0038"
],
"3664": [
"CVE-2007-1738"
],
"3688": [
"CVE-2007-1215",
"CVE-2007-1213",
"CVE-2007-1212",
"CVE-2007-1211",
"CVE-2007-0038",
"CVE-2006-5758",
"CVE-2006-5586"
],
"3692": [
"CVE-2007-1867"
],
"3695": [
"CVE-2007-0038",
"CVE-2007-1765"
],
"3727": [
"CVE-2007-2062"
],
"3730": [],
"3755": [
"CVE-2007-1215",
"CVE-2007-1213",
"CVE-2007-1212",
"CVE-2007-1211",
"CVE-2007-0038",
"CVE-2006-5758",
"CVE-2006-5586"
],
"3757": [
"CVE-2004-0733"
],
"3772": [
"CVE-2007-2192"
],
"3776": [
"CVE-2007-2193"
],
"3777": [
"CVE-2007-2194"
],
"3779": [
"CVE-2007-2209"
],
"3793": [
"CVE-2007-2244"
],
"3797": [
"CVE-2007-2284"
],
"3798": [
"CVE-2007-2283"
],
"3801": [
"CVE-2007-2356"
],
"3811": [
"CVE-2007-2363"
],
"3812": [
"CVE-2007-2366",
"CVE-2007-2365"
],
"3823": [
"CVE-2007-2498"
],
"3856": [
"CVE-2007-2576"
],
"3888": [
"CVE-2007-2356"
],
"3897": [],
"3912": [
"CVE-2007-2666"
],
"3975": [
"CVE-2007-2761"
],
"3985": [
"CVE-2007-0752"
],
"4001": [
"CVE-2007-2888"
],
"4002": [
"CVE-2007-2888"
],
"4013": [
"CVE-2007-0753"
],
"4024": [
"CVE-2007-3068"
],
"4028": [
"CVE-2007-3048"
],
"4051": [
"CVE-2007-0016"
],
"4080": [
"CVE-2007-3294"
],
"40465": [
"CVE-2016-6434"
],
"4165": [
"CVE-2007-3681"
],
"4172": [
"CVE-2007-1000"
],
"4178": [
"CVE-2007-3673"
],
"4203": [
"CVE-2007-3855"
],
"4204": [
"CVE-2007-1413"
],
"4218": [
"CVE-2007-4010"
],
"4229": [
"CVE-2007-4032"
],
"4231": [
"CVE-2007-3333"
],
"4232": [
"CVE-2007-4003"
],
"4233": [
"CVE-2007-4004"
],
"4236": [],
"4252": [
"CVE-2007-4140"
],
"4257": [
"CVE-2007-4191"
],
"4262": [
"CVE-2007-4257"
],
"4263": [
"CVE-2007-4257"
],
"4270": [
"CVE-2007-4255"
],
"4274": [
"CVE-2007-1413"
],
"4302": [
"CVE-2007-4441"
],
"4303": [
"CVE-2007-4441"
],
"4311": [
"CVE-2007-4528"
],
"4314": [
"CVE-2007-4596"
],
"4325": [],
"4345": [
"CVE-2007-4648"
],
"4354": [
"CVE-2007-4735"
],
"4355": [
"CVE-2007-4734"
],
"4361": [
"CVE-2007-4776"
],
"4364": [
"CVE-2007-4803"
],
"4392": [
"CVE-2007-3997"
],
"4431": [
"CVE-2007-4776"
],
"4460": [
"CVE-2007-4573"
],
"4515": [],
"4516": [],
"4517": [
"CVE-2007-5447"
],
"4531": [
"CVE-2007-5487"
],
"4553": [
"CVE-2007-5653"
],
"4564": [
"CVE-2007-5508"
],
"4570": [
"CVE-2007-5511"
],
"4571": [
"CVE-2007-5511"
],
"4572": [
"CVE-2007-5511"
],
"4583": [
"CVE-2007-5709"
],
"4584": [
"CVE-2007-2217"
],
"4612": [
"CVE-2006-4254"
],
"4625": [
"CVE-2007-6026"
],
"4698": [
"CVE-2007-6211"
],
"4701": [
"CVE-2007-6402"
],
"4702": [
"CVE-2007-6401"
],
"4703": [
"CVE-2007-6403"
],
"4749": [
"CVE-2007-6478"
],
"4751": [],
"4756": [],
"4759": [
"CVE-2007-3876"
],
"4839": [
"CVE-2006-6288"
],
"4892": [
"CVE-2008-1709",
"CVE-2008-0250"
],
"4938": [
"CVE-2008-0392"
],
"4994": [],
"4995": [],
"4996": [],
"4998": [
"CVE-2008-0493"
],
"5004": [
"CVE-2008-0573"
],
"5032": [],
"5077": [
"CVE-2007-0949"
],
"5092": [
"CVE-2008-0600",
"CVE-2008-0010",
"CVE-2008-0009"
],
"5093": [
"CVE-2008-0600",
"CVE-2008-0010",
"CVE-2008-0009"
],
"5107": [
"CVE-2008-0108",
"CVE-2008-0105",
"CVE-2007-0216"
],
"5141": [
"CVE-2008-1141"
],
"5143": [
"CVE-2008-1139"
],
"5144": [
"CVE-2008-1140"
],
"5167": [
"CVE-2007-3103"
],
"5227": [
"CVE-2007-5225"
],
"5250": [
"CVE-2008-1881"
],
"5287": [
"CVE-2008-0117",
"CVE-2008-0116",
"CVE-2008-0115",
"CVE-2008-0114",
"CVE-2008-0112",
"CVE-2008-0111",
"CVE-2008-0081"
],
"5320": [
"CVE-2008-0118",
"CVE-2008-0113"
],
"5346": [
"CVE-2008-0069"
],
"5355": [
"CVE-2008-1343",
"CVE-2008-0310"
],
"5356": [
"CVE-2008-6558"
],
"5357": [
"CVE-2008-6559"
],
"5424": [
"CVE-2007-5301"
],
"5442": [
"CVE-2008-1087",
"CVE-2008-1083"
],
"5462": [],
"5479": [
"CVE-2008-1765"
],
"5492": [
"CVE-2008-1912"
],
"5498": [
"CVE-2008-1769",
"CVE-2008-1489",
"CVE-2008-0984",
"CVE-2008-0296",
"CVE-2008-0295",
"CVE-2008-0073",
"CVE-2007-6681"
],
"5518": [
"CVE-2008-1084"
],
"5584": [],
"5625": [],
"5667": [
"CVE-2008-1881"
],
"5837": [
"CVE-2008-5121"
],
"5951": [
"CVE-2008-2427"
],
"5979": [],
"6030": [
"CVE-2008-3182"
],
"6031": [
"CVE-2008-3148"
],
"6032": [
"CVE-2008-2950"
],
"6039": [
"CVE-2008-3182"
],
"6106": [
"CVE-2008-5755"
],
"6157": [
"CVE-2008-3408"
],
"6188": [
"CVE-2007-2363"
],
"6322": [
"CVE-2008-3877"
],
"6329": [
"CVE-2007-3006"
],
"6333": [
"CVE-2008-4087"
],
"6337": [
"CVE-2008-2936"
],
"6389": [
"CVE-2008-4470"
],
"6705": [],
"6757": [
"CVE-2008-3464"
],
"6787": [
"CVE-2008-4434"
],
"6798": [
"CVE-2008-4686",
"CVE-2008-4654"
],
"6825": [
"CVE-2008-4686",
"CVE-2008-4654"
],
"6831": [
"CVE-2008-4779"
],
"6851": [
"CVE-2008-4210"
],
"6994": [
"CVE-2008-2992"
],
"7006": [
"CVE-2008-2992"
],
"7051": [
"CVE-2008-5036"
],
"7054": [
"CVE-2008-5049"
],
"7129": [],
"7135": [
"CVE-2008-5680",
"CVE-2008-5178"
],
"7171": [
"CVE-2008-5625",
"CVE-2006-3011"
],
"7177": [],
"40988": [],
"7264": [],
"7309": [
"CVE-2008-5405"
],
"7313": [
"CVE-2008-5394"
],
"7329": [
"CVE-2008-5405"
],
"7334": [],
"7347": [],
"7393": [],
"7492": [
"CVE-2008-5664"
],
"7501": [
"CVE-2008-5416",
"CVE-2008-4270"
],
"7503": [],
"7516": [
"CVE-2008-5724"
],
"7533": [
"CVE-2008-5725"
],
"7536": [
"CVE-2008-5735"
],
"7547": [
"CVE-2008-5735"
],
"7550": [
"CVE-2008-5377"
],
"7577": [
"CVE-2008-3877"
],
"7581": [],
"7582": [
"CVE-2008-5755"
],
"7608": [
"CVE-2008-5868"
],
"7618": [
"CVE-2008-4113"
],
"7646": [
"CVE-2008-5498"
],
"7651": [
"CVE-2009-3429"
],
"7654": [
"CVE-2009-3429"
],
"7655": [],
"7656": [],
"7661": [],
"7662": [],
"7671": [],
"7675": [
"CVE-2008-3984"
],
"7676": [
"CVE-2008-3983"
],
"7677": [],
"7681": [],
"7684": [],
"7688": [],
"7692": [],
"7695": [
"CVE-2009-0182"
],
"7702": [],
"7707": [],
"7713": [
"CVE-2009-0174"
],
"7714": [
"CVE-2009-0174"
],
"7715": [
"CVE-2009-0174"
],
"7727": [
"CVE-2009-0133",
"CVE-2006-0564"
],
"7745": [],
"7765": [],
"7839": [
"CVE-2009-0261"
],
"7843": [],
"7848": [],
"7853": [],
"7855": [],
"7856": [],
"7888": [
"CVE-2004-0964"
],
"7923": [],
"7929": [],
"7957": [],
"7958": [
"CVE-2009-0476"
],
"7973": [
"CVE-2009-0476"
],
"7974": [
"CVE-2009-0476"
],
"7975": [
"CVE-2009-0450"
],
"7994": [],
"8010": [
"CVE-2009-0546"
],
"8055": [
"CVE-2009-0641"
],
"8067": [
"CVE-2009-0390"
],
"8074": [
"CVE-2008-3979"
],
"8108": [],
"8121": [
"CVE-2009-0812"
],
"8126": [
"CVE-2009-0350"
],
"8137": [
"CVE-2009-0885"
],
"8138": [],
"8158": [],
"8159": [],
"8162": [],
"8171": [],
"8174": [],
"8175": [],
"8176": [
"CVE-2008-3733"
],
"8177": [],
"8178": [],
"8179": [],
"8189": [],
"8193": [],
"8201": [
"CVE-2009-0837"
],
"8214": [],
"8231": [
"CVE-2009-1039"
],
"8233": [],
"8234": [],
"8235": [],
"8236": [
"CVE-2009-1071"
],
"8242": [],
"8246": [],
"8249": [
"CVE-2009-1068"
],
"8250": [],
"8251": [
"CVE-2009-1068"
],
"8261": [
"CVE-2009-1041"
],
"8266": [
"CVE-2009-1235"
],
"8267": [
"CVE-2004-0964"
],
"8270": [
"CVE-2009-1063"
],
"8274": [],
"8275": [],
"8280": [],
"8299": [],
"8301": [],
"8303": [
"CVE-2009-0360"
],
"8311": [],
"8312": [
"CVE-2007-4803"
],
"8322": [
"CVE-2009-0686"
],
"8343": [
"CVE-2009-1260",
"CVE-2009-1257"
],
"8369": [
"CVE-2009-1337"
],
"8371": [],
"8401": [],
"8410": [
"CVE-2009-1326"
],
"8411": [
"CVE-2009-1327"
],
"8412": [
"CVE-2009-1324"
],
"8413": [
"CVE-2009-1328"
],
"8416": [
"CVE-2009-1325"
],
"8420": [
"CVE-2008-5754"
],
"8426": [],
"8427": [
"CVE-2009-1330",
"CVE-2009-1329"
],
"8444": [],
"8456": [
"CVE-2009-0981"
],
"8470": [
"CVE-2009-1759"
],
"8478": [
"CVE-2009-1185"
],
"8519": [
"CVE-2009-1437"
],
"8520": [
"CVE-2009-1437"
],
"8527": [
"CVE-2009-1449"
],
"8534": [
"CVE-2009-0036"
],
"8535": [],
"8536": [
"CVE-2009-1627"
],
"8540": [
"CVE-2009-1627"
],
"8541": [],
"8572": [
"CVE-2009-1185"
],
"8580": [
"CVE-2009-4755"
],
"8582": [],
"8583": [
"CVE-2009-4754"
],
"8589": [],
"8590": [
"CVE-2009-4756"
],
"8591": [
"CVE-2009-4756"
],
"8592": [
"CVE-2009-4756"
],
"8594": [
"CVE-2009-4761"
],
"8595": [
"CVE-2009-0927"
],
"8612": [
"CVE-2009-1586"
],
"8620": [
"CVE-2009-2568"
],
"8624": [
"CVE-2009-1643"
],
"8628": [
"CVE-2009-1646"
],
"8629": [
"CVE-2009-1642"
],
"8630": [
"CVE-2009-1642"
],
"8631": [
"CVE-2009-1641"
],
"8632": [
"CVE-2009-1641"
],
"8633": [
"CVE-2009-1645"
],
"8634": [
"CVE-2009-1645"
],
"8637": [
"CVE-2009-1586"
],
"8640": [
"CVE-2009-1644"
],
"8641": [],
"8656": [
"CVE-2009-1674",
"CVE-2009-1608"
],
"8657": [],
"8660": [
"CVE-2009-1667"
],
"8661": [
"CVE-2009-1667"
],
"8662": [
"CVE-2009-1667"
],
"8663": [
"CVE-2009-5137"
],
"8670": [
"CVE-2009-1744",
"CVE-2009-1743"
],
"8673": [
"CVE-2009-1527"
],
"8678": [],
"8698": [
"CVE-2009-1815"
],
"8701": [
"CVE-2009-1815"
],
"8770": [
"CVE-2009-1831"
],
"8772": [
"CVE-2009-1831"
],
"8780": [
"CVE-2009-4676",
"CVE-2009-4668"
],
"8782": [
"CVE-2009-1824"
],
"8783": [
"CVE-2009-1831"
],
"8789": [],
"8799": [],
"8833": [],
"8863": [],
"8875": [
"CVE-2009-2450"
],
"8881": [
"CVE-2009-2261"
],
"8896": [],
"8983": [
"CVE-2009-4832"
],
"9034": [
"CVE-2009-2485"
],
"9038": [
"CVE-2009-2485"
],
"9047": [
"CVE-2009-2566"
],
"9060": [
"CVE-2009-2364"
],
"9064": [
"CVE-2009-2363",
"CVE-2009-2362"
],
"9070": [
"CVE-2009-2363",
"CVE-2009-2362"
],
"9072": [],
"9082": [
"CVE-2008-3531"
],
"9083": [
"CVE-2009-1046"
],
"9097": [],
"9104": [
"CVE-2009-2375"
],
"9135": [
"CVE-2008-4190"
],
"9136": [],
"9142": [],
"9146": [],
"9148": [],
"9149": [],
"9152": [
"CVE-2009-2363",
"CVE-2009-2362"
],
"9172": [
"CVE-2009-2550"
],
"9177": [],
"9186": [],
"9190": [],
"9191": [
"CVE-2009-1897"
],
"9199": [
"CVE-2009-2564"
],
"9207": [
"CVE-2009-1894"
],
"9208": [
"CVE-2009-1894"
],
"9215": [],
"9216": [],
"9221": [],
"9223": [
"CVE-2009-2564"
],
"9229": [],
"9234": [],
"40297": [],
"9272": [],
"9286": [],
"9291": [],
"9298": [],
"9299": [],
"9301": [
"CVE-2009-2653"
],
"9302": [
"CVE-2009-2286"
],
"9305": [],
"9306": [],
"9321": [
"CVE-2009-3429"
],
"9329": [
"CVE-2006-6199"
],
"9343": [],
"9346": [],
"9352": [
"CVE-2009-2847"
],
"9354": [],
"9360": [
"CVE-2009-0450",
"CVE-2006-6199"
],
"9363": [
"CVE-2005-4605"
],
"9366": [],
"9375": [],
"9377": [
"CVE-2009-4549"
],
"9379": [],
"9386": [
"CVE-2015-7985"
],
"9409": [],
"9412": [
"CVE-2009-3428"
],
"9418": [
"CVE-2009-3428"
],
"9420": [
"CVE-2009-3428"
],
"9426": [],
"9428": [
"CVE-2009-2934"
],
"9435": [
"CVE-2009-2692"
],
"9436": [
"CVE-2009-2692"
],
"9458": [],
"9466": [],
"9476": [],
"9477": [
"CVE-2009-2692"
],
"9479": [
"CVE-2009-2692"
],
"9483": [
"CVE-2009-3214",
"CVE-2009-4088",
"CVE-2009-4089"
],
"9486": [
"CVE-2009-4964"
],
"9488": [],
"9489": [],
"9492": [],
"9495": [
"CVE-2009-4962"
],
"9501": [
"CVE-2009-0490"
],
"9509": [],
"9513": [
"CVE-2009-3001"
],
"9519": [
"CVE-2009-3214"
],
"9520": [],
"9521": [
"CVE-2009-3002"
],
"9536": [
"CVE-2009-2934"
],
"9540": [],
"9542": [
"CVE-2009-2698"
],
"9543": [
"CVE-2009-3002"
],
"9545": [
"CVE-2009-2692"
],
"9548": [
"CVE-2009-3254"
],
"9550": [
"CVE-2009-0812"
],
"9551": [
"CVE-2009-2650"
],
"9560": [
"CVE-2009-1643"
],
"9567": [],
"9568": [
"CVE-2009-3058"
],
"9574": [
"CVE-2009-2698"
],
"9575": [
"CVE-2009-2698"
],
"9579": [
"CVE-2009-0927"
],
"9580": [],
"9581": [],
"9589": [
"CVE-2007-4734"
],
"9595": [],
"9598": [
"CVE-2009-2692"
],
"9608": [],
"9610": [
"CVE-2009-3221"
],
"9618": [],
"9619": [],
"9624": [
"CVE-2009-3670"
],
"9627": [],
"9628": [
"CVE-2009-1071"
],
"9641": [
"CVE-2009-2692"
],
"9645": [
"CVE-2009-2669"
],
"9655": [
"CVE-2009-4107"
],
"9659": [
"CVE-2009-3338"
],
"9661": [],
"9680": [],
"9687": [],
"9688": [
"CVE-2006-2043"
],
"9709": [
"CVE-2009-3233"
],
"9807": [
"CVE-2009-3489"
],
"9831": [],
"9842": [],
"9844": [
"CVE-2009-3547"
],
"9859": [
"CVE-2009-3527"
],
"9860": [],
"9865": [
"CVE-2009-2994"
],
"9866": [
"CVE-2009-3709",
"CVE-2009-3708"
],
"9882": [],
"9884": [
"CVE-2009-3805"
],
"9894": [],
"9895": [],
"9955": [
"CVE-2009-4607"
],
"9970": [],
"9973": [
"CVE-2009-3692"
],
"9974": [
"CVE-2009-3170"
],
"9983": [],
"9984": [],
"9985": [],
"14273": [
"CVE-2010-0832"
],
"9988": [
"CVE-2009-3489"
],
"9990": [
"CVE-2009-2990"
],
"9991": [
"CVE-2009-3709",
"CVE-2009-3708"
],
"10009": [
"CVE-2009-0184"
],
"10010": [],
"10018": [
"CVE-2009-3547"
],
"10038": [],
"10039": [],
"10044": [],
"10060": [],
"10072": [],
"10076": [
"CVE-2009-3281"
],
"33426": [],
"10084": [
"CVE-2009-4556"
],
"10201": [
"CVE-2009-4781"
],
"10207": [
"CVE-2009-2267"
],
"10211": [
"CVE-2009-3576"
],
"10213": [
"CVE-2009-3578"
],
"10226": [
"CVE-2009-4097"
],
"10240": [],
"10244": [
"CVE-2009-4117"
],
"10255": [
"CVE-2009-4147",
"CVE-2009-4146"
],
"10264": [],
"10265": [],
"10266": [],
"10267": [],
"10268": [],
"10280": [
"CVE-2009-3170"
],
"10281": [
"CVE-2009-4195"
],
"10295": [
"CVE-2009-4148"
],
"10296": [
"CVE-2009-2626"
],
"10298": [
"CVE-2009-4251"
],
"10313": [],
"10319": [
"CVE-2009-4265"
],
"10320": [],
"10321": [
"CVE-2009-0133",
"CVE-2006-0564"
],
"10322": [
"CVE-2009-0490"
],
"10323": [],
"10326": [],
"10332": [
"CVE-2009-4265"
],
"10335": [],
"10339": [],
"10344": [
"CVE-2009-4195"
],
"10345": [],
"10346": [],
"10353": [
"CVE-2009-0476"
],
"10359": [],
"10363": [],
"10371": [],
"10373": [],
"10374": [],
"10392": [],
"10396": [],
"10423": [
"CVE-2009-1326"
],
"10475": [],
"10484": [
"CVE-2009-4452"
],
"10487": [
"CVE-2009-4454"
],
"10544": [
"CVE-2009-1839"
],
"10556": [],
"10557": [
"CVE-2007-4652",
"CVE-2006-5178"
],
"10563": [],
"10577": [],
"10595": [
"CVE-2008-3408"
],
"10596": [],
"10602": [
"CVE-2009-1330"
],
"10613": [],
"10618": [
"CVE-2009-4324"
],
"10619": [
"CVE-2009-1330"
],
"10620": [],
"10628": [],
"10642": [],
"10646": [
"CVE-2009-1667"
],
"10664": [],
"14158": [],
"10744": [
"CVE-2009-2650"
],
"10745": [
"CVE-2009-5109"
],
"10747": [
"CVE-2009-5109"
],
"10748": [],
"10759": [],
"10782": [
"CVE-2009-5109"
],
"10786": [],
"10787": [],
"10797": [],
"10827": [
"CVE-2009-4656"
],
"10920": [],
"10936": [],
"11010": [],
"11029": [],
"11046": [],
"11079": [
"CVE-2009-0476"
],
"11093": [],
"11109": [],
"11112": [],
"11139": [],
"11146": [
"CVE-2010-2004"
],
"11152": [],
"11154": [
"CVE-2010-2004"
],
"11161": [],
"11171": [],
"11174": [
"CVE-2010-0364"
],
"11191": [],
"11199": [
"CVE-2010-0232"
],
"11202": [],
"11205": [],
"11208": [],
"11219": [],
"11229": [],
"11232": [],
"11255": [],
"11256": [],
"11264": [
"CVE-2009-4606"
],
"11267": [],
"11281": [
"CVE-2010-1591"
],
"11314": [],
"11315": [],
"11317": [],
"11331": [],
"11333": [],
"11364": [],
"11372": [],
"11379": [
"CVE-2009-0546"
],
"11384": [],
"11400": [],
"11408": [],
"11413": [],
"11465": [],
"11475": [],
"11491": [
"CVE-2009-2817"
],
"11561": [],
"11573": [],
"11581": [
"CVE-2010-0688"
],
"11647": [],
"11651": [],
"11656": [],
"11663": [],
"14092": [],
"11682": [],
"11713": [],
"11764": [],
"11779": [],
"11786": [
"CVE-2010-1225"
],
"11787": [
"CVE-2010-0188",
"CVE-2006-3459"
],
"11789": [],
"11791": [],
"11794": [],
"11797": [],
"11828": [],
"11834": [],
"11872": [],
"11900": [],
"11909": [],
"11911": [],
"11944": [],
"11953": [],
"11957": [
"CVE-2009-1642"
],
"11958": [
"CVE-2009-1642"
],
"11976": [
"CVE-2011-5165"
],
"11981": [],
"11987": [
"CVE-2010-1240",
"CVE-2010-1239"
],
"12008": [
"CVE-2008-4779"
],
"12012": [
"CVE-2011-5165"
],
"12024": [],
"12035": [],
"12051": [],
"12053": [
"CVE-2006-2439"
],
"12059": [
"CVE-2009-1028"
],
"12090": [],
"12091": [],
"12103": [],
"12130": [
"CVE-2010-1146"
],
"12189": [],
"12213": [],
"20109": [],
"12255": [],
"12261": [],
"12293": [
"CVE-2010-1458"
],
"12326": [
"CVE-2010-1597"
],
"43381": [
"CVE-2017-17405"
],
"12342": [],
"12368": [
"CVE-2010-1685"
],
"12379": [],
"12388": [],
"12403": [],
"12404": [],
"12406": [
"CVE-2010-0705",
"CVE-2009-3523",
"CVE-2008-1625"
],
"12469": [
"CVE-2010-1686"
],
"12497": [
"CVE-2007-2192"
],
"12501": [],
"12516": [],
"12528": [],
"12540": [],
"12621": [],
"12662": [
"CVE-2010-1688"
],
"30093": [
"CVE-2007-2683"
],
"12677": [],
"12710": [
"CVE-2010-2031"
],
"12803": [],
"12821": [],
"40335": [],
"15499": [],
"13756": [],
"13760": [
"CVE-2010-2343"
],
"13761": [
"CVE-2010-2343"
],
"13763": [
"CVE-2010-2343"
],
"13767": [],
"13768": [],
"13806": [],
"13820": [
"CVE-2010-2311"
],
"13895": [
"CVE-2010-2329"
],
"13905": [
"CVE-2006-6199"
],
"13907": [],
"13909": [
"CVE-2010-2348"
],
"13940": [
"CVE-2010-0688"
],
"13942": [
"CVE-2010-2439"
],
"13998": [],
"14002": [
"CVE-2010-2020"
],
"14029": [],
"14044": [],
"14046": [],
"14068": [],
"14077": [],
"14081": [],
"14098": [],
"14150": [],
"14153": [],
"14191": [],
"14215": [],
"14256": [
"CVE-2010-1964"
],
"14258": [],
"14339": [
"CVE-2010-0832"
],
"14352": [],
"14361": [
"CVE-2010-0822"
],
"14373": [
"CVE-2010-5081"
],
"14397": [
"CVE-2010-2439"
],
"14403": [
"CVE-2015-0096",
"CVE-2010-2568"
],
"14406": [
"CVE-2010-1869"
],
"14428": [],
"14431": [],
"14433": [
"CVE-2006-2439"
],
"14464": [],
"14482": [],
"14491": [],
"14497": [],
"14503": [],
"14527": [],
"14532": [],
"14538": [
"CVE-2010-2973",
"CVE-2010-2972",
"CVE-2010-1797"
],
"14550": [
"CVE-2009-1330"
],
"14566": [
"CVE-2010-2739"
],
"14576": [],
"14581": [],
"14591": [
"CVE-2009-4962"
],
"14610": [
"CVE-2010-2554"
],
"14612": [],
"14630": [],
"14633": [],
"14676": [],
"14651": [],
"14663": [],
"14664": [],
"14673": [],
"14681": [],
"14688": [
"CVE-2010-2693"
],
"14693": [
"CVE-2009-0565"
],
"14706": [
"CVE-2009-3129"
],
"14720": [
"CVE-2010-5299"
],
"14721": [
"CVE-2010-3133"
],
"14723": [
"CVE-2010-3142",
"CVE-2010-3141"
],
"14727": [
"CVE-2010-1797"
],
"14726": [
"CVE-2010-3129"
],
"14728": [],
"14730": [
"CVE-2010-3131"
],
"14731": [
"CVE-2010-3967"
],
"14732": [
"CVE-2010-5227"
],
"14733": [
"CVE-2010-3147",
"CVE-2010-3143"
],
"14734": [
"CVE-2010-3128"
],
"14735": [
"CVE-2010-3132"
],
"14744": [
"CVE-2010-3148"
],
"14745": [
"CVE-2010-3147",
"CVE-2010-3143"
],
"14746": [
"CVE-2011-0108",
"CVE-2010-3146"
],
"14747": [
"CVE-2010-3125"
],
"14739": [],
"14740": [
"CVE-2010-3132"
],
"14741": [
"CVE-2010-3127"
],
"14743": [
"CVE-2010-3126"
],
"14748": [
"CVE-2010-3129"
],
"14750": [
"CVE-2010-3124"
],
"14751": [
"CVE-2010-3145"
],
"14752": [],
"14756": [],
"14753": [],
"14754": [
"CVE-2010-3144"
],
"14755": [
"CVE-2010-3149"
],
"14762": [],
"14758": [
"CVE-2010-3139"
],
"14764": [
"CVE-2010-3130"
],
"14765": [
"CVE-2010-3138"
],
"14766": [
"CVE-2010-3136"
],
"14768": [
"CVE-2010-5236"
],
"14769": [],
"14771": [
"CVE-2010-3150"
],
"14772": [
"CVE-2010-3151"
],
"14773": [
"CVE-2010-3152"
],
"14774": [
"CVE-2010-3135"
],
"14775": [
"CVE-2010-3153"
],
"14778": [
"CVE-2010-3147",
"CVE-2010-3143"
],
"14780": [
"CVE-2010-3140"
],
"14781": [
"CVE-2010-5195"
],
"14782": [
"CVE-2010-3142",
"CVE-2010-3141"
],
"14783": [
"CVE-2010-3131"
],
"14784": [
"CVE-2010-3154"
],
"14785": [
"CVE-2010-3155"
],
"14786": [
"CVE-2014-8393",
"CVE-2010-5240"
],
"14787": [
"CVE-2014-8393",
"CVE-2010-5240"
],
"14788": [
"CVE-2010-3138"
],
"14789": [
"CVE-2010-3137"
],
"14790": [
"CVE-2010-3134"
],
"14791": [
"CVE-2010-5239"
],
"14793": [
"CVE-2010-5241"
],
"14814": [
"CVE-2010-2959"
],
"14830": [
"CVE-2009-2629"
],
"14831": [],
"14944": [
"CVE-2010-1681"
],
"14966": [
"CVE-2010-1247",
"CVE-2010-1246"
],
"14959": [],
"14961": [],
"14982": [
"CVE-2010-2201"
],
"15013": [
"CVE-2009-0476"
],
"15022": [],
"15023": [
"CVE-2010-3301"
],
"15024": [
"CVE-2010-3081"
],
"15026": [
"CVE-2010-4740"
],
"15031": [],
"15033": [],
"15047": [],
"15099": [],
"15069": [],
"15074": [
"CVE-2010-2961"
],
"15081": [],
"15094": [
"CVE-2010-0822"
],
"15133": [],
"15134": [],
"15150": [
"CVE-2010-3437"
],
"15155": [
"CVE-2010-2943"
],
"15156": [],
"15184": [],
"15201": [],
"15206": [
"CVE-2010-4210"
],
"15285": [
"CVE-2010-3904"
],
"15599": [],
"15609": [
"CVE-2010-4398"
],
"15274": [
"CVE-2011-0536",
"CVE-2010-3847"
],
"15279": [
"CVE-2009-4962"
],
"15287": [
"CVE-2010-4371"
],
"15304": [
"CVE-2010-3856",
"CVE-2010-3847"
],
"15312": [
"CVE-2010-4371"
],
"15344": [
"CVE-2010-2963"
],
"15376": [],
"15403": [],
"15406": [],
"15417": [],
"15461": [],
"15475": [
"CVE-2010-4236",
"CVE-2010-3895"
],
"15480": [],
"15481": [],
"15483": [],
"15489": [
"CVE-2009-2364"
],
"15532": [],
"15539": [],
"15540": [],
"15541": [],
"15542": [],
"15566": [],
"15569": [
"CVE-2009-2364"
],
"15575": [],
"15584": [],
"15589": [
"CVE-2010-3888",
"CVE-2010-3338"
],
"15620": [
"CVE-2010-4170"
],
"15624": [
"CVE-2010-4502"
],
"15626": [],
"15630": [],
"15663": [],
"15692": [],
"15693": [],
"15696": [],
"15704": [
"CVE-2010-4258",
"CVE-2010-3850",
"CVE-2010-3849"
],
"15706": [],
"15745": [
"CVE-2010-4604"
],
"15727": [],
"15729": [],
"15730": [],
"15747": [],
"15751": [],
"15761": [],
"15762": [],
"15763": [],
"15764": [],
"15774": [
"CVE-2011-1021",
"CVE-2010-4347"
],
"15782": [],
"15785": [],
"15855": [],
"15895": [
"CVE-2008-3408"
],
"15888": [],
"15901": [
"CVE-2011-0501"
],
"15916": [],
"15919": [],
"15934": [],
"15936": [
"CVE-2011-0500",
"CVE-2011-0499"
],
"15941": [],
"15944": [],
"15962": [
"CVE-2008-5689"
],
"15972": [
"CVE-2011-0513"
],
"16264": [],
"15975": [
"CVE-2011-0498"
],
"15985": [
"CVE-2010-2743"
],
"15994": [],
"16009": [],
"17210": [
"CVE-2009-1028"
],
"16024": [],
"16070": [],
"16071": [
"CVE-2011-0096"
],
"16072": [],
"16073": [],
"16083": [],
"16085": [],
"16086": [
"CVE-2011-0018"
],
"16092": [],
"16098": [],
"16099": [],
"16107": [],
"16119": [],
"16132": [],
"16133": [],
"16138": [],
"16141": [],
"16153": [],
"16162": [],
"16169": [],
"16173": [],
"16253": [],
"16307": [
"CVE-2009-2261"
],
"41804": [
"CVE-2017-2490"
],
"40435": [
"CVE-2016-4997"
],
"16503": [
"CVE-2009-4324"
],
"16504": [
"CVE-2008-2992"
],
"16531": [
"CVE-2006-0476"
],
"16546": [
"CVE-2009-3459"
],
"16556": [
"CVE-2006-6063"
],
"16562": [
"CVE-2005-0043"
],
"16589": [
"CVE-2010-1818"
],
"16593": [
"CVE-2009-0658"
],
"41786": [
"CVE-2016-9091"
],
"16606": [
"CVE-2009-0927"
],
"16614": [
"CVE-2010-1297"
],
"16615": [
"CVE-2008-0015"
],
"16617": [
"CVE-2006-6251"
],
"16618": [
"CVE-2006-6199"
],
"16619": [
"CVE-2010-2883"
],
"16621": [],
"16622": [
"CVE-2009-3953"
],
"16623": [
"CVE-2009-4324"
],
"16624": [
"CVE-2008-2992"
],
"16625": [
"CVE-2009-3129"
],
"16626": [
"CVE-2009-0476"
],
"16627": [
"CVE-2007-2888"
],
"16628": [],
"16629": [
"CVE-2008-4654"
],
"16631": [
"CVE-2009-0133"
],
"16632": [
"CVE-2007-2193"
],
"16633": [],
"16634": [
"CVE-2009-0184"
],
"16636": [],
"16637": [
"CVE-2011-0531"
],
"16640": [
"CVE-2009-0546"
],
"16642": [],
"16643": [
"CVE-2009-3861"
],
"16644": [],
"16645": [
"CVE-2005-0308"
],
"16646": [
"CVE-2009-2485"
],
"16648": [
"CVE-2006-0564"
],
"16651": [],
"16652": [
"CVE-2009-3459"
],
"16653": [],
"16654": [
"CVE-2010-0688"
],
"16655": [
"CVE-2009-3214"
],
"16656": [
"CVE-2007-3314"
],
"16658": [],
"16659": [
"CVE-2008-5405"
],
"16660": [
"CVE-2010-3970"
],
"16662": [],
"16663": [],
"16664": [],
"16665": [
"CVE-2010-0033"
],
"16666": [
"CVE-2009-1260"
],
"16667": [
"CVE-2010-3654"
],
"16668": [],
"16669": [
"CVE-2009-4195"
],
"16670": [
"CVE-2010-0188"
],
"16671": [
"CVE-2010-1240"
],
"16672": [
"CVE-2009-0658"
],
"16673": [],
"16674": [
"CVE-2007-5659"
],
"16675": [
"CVE-2006-6665"
],
"16677": [
"CVE-2007-2864"
],
"16678": [
"CVE-2009-2484"
],
"16679": [],
"16680": [
"CVE-2007-4776"
],
"16681": [
"CVE-2009-0927"
],
"16682": [
"CVE-2010-1240"
],
"16683": [
"CVE-2006-0564"
],
"16684": [
"CVE-2009-3429"
],
"16686": [
"CVE-2010-3333"
],
"16687": [
"CVE-2010-1297"
],
"16688": [
"CVE-2004-0964"
],
"16940": [],
"16942": [],
"16951": [
"CVE-2008-5736"
],
"16965": [],
"16971": [],
"16976": [],
"16977": [],
"16978": [],
"16991": [],
"16999": [],
"17001": [],
"17012": [],
"17013": [],
"17064": [],
"17083": [],
"17086": [],
"17124": [],
"17196": [],
"17144": [],
"17147": [
"CVE-2011-1496"
],
"17150": [],
"17153": [
"CVE-2011-0500",
"CVE-2011-0499"
],
"17157": [],
"17158": [],
"17166": [],
"17169": [],
"17171": [],
"17177": [
"CVE-2009-0565"
],
"17185": [
"CVE-2011-1591"
],
"17186": [
"CVE-2011-1591"
],
"17217": [],
"17223": [],
"17225": [],
"17229": [],
"17230": [],
"17317": [
"CVE-2011-2386"
],
"17318": [
"CVE-2011-1938"
],
"17270": [],
"17277": [],
"17275": [],
"17294": [],
"17302": [],
"17306": [],
"17313": [],
"17329": [],
"17362": [],
"17364": [],
"17383": [],
"17391": [],
"17441": [],
"17449": [],
"17451": [
"CVE-2010-1681"
],
"17459": [],
"17473": [
"CVE-2011-0611"
],
"17474": [
"CVE-2010-3333"
],
"17486": [
"CVE-2011-1938"
],
"17488": [
"CVE-2004-0194"
],
"17489": [],
"17492": [],
"17499": [],
"17502": [
"CVE-2010-5299"
],
"17511": [],
"40085": [
"CVE-2016-0051"
],
"17561": [],
"17563": [],
"17565": [],
"17600": [
"CVE-2004-0964"
],
"17604": [],
"17605": [],
"17607": [],
"17611": [],
"17634": [],
"17647": [],
"17654": [],
"17665": [],
"17715": [],
"17727": [
"CVE-2011-5165"
],
"17732": [],
"17735": [],
"17744": [],
"17745": [],
"17754": [],
"17770": [
"CVE-2007-3068"
],
"17787": [
"CVE-2010-4073",
"CVE-2010-3850",
"CVE-2010-3848"
],
"17777": [
"CVE-2011-0257"
],
"17780": [],
"17783": [],
"17788": [
"CVE-2007-3068"
],
"17803": [
"CVE-2007-3068"
],
"17817": [
"CVE-2011-4535"
],
"17820": [],
"17821": [],
"17833": [
"CVE-2011-4535"
],
"17847": [
"CVE-2009-1325"
],
"17854": [],
"17877": [],
"17880": [
"CVE-2011-3494"
],
"17892": [],
"17893": [],
"17902": [],
"17932": [
"CVE-2011-1485"
],
"17939": [
"CVE-2009-0450"
],
"17942": [
"CVE-2011-1485"
],
"17966": [
"CVE-2011-2595"
],
"17967": [
"CVE-2008-4779"
],
"17985": [],
"18040": [
"CVE-2011-4613",
"CVE-2011-4029"
],
"18027": [],
"18038": [],
"18064": [],
"18067": [],
"18071": [],
"18072": [],
"18080": [],
"18082": [
"CVE-2009-5109"
],
"18086": [],
"18087": [
"CVE-2011-0105"
],
"18096": [],
"18105": [
"CVE-2010-3856"
],
"18109": [],
"18113": [
"CVE-2010-5081"
],
"18137": [
"CVE-2011-5006"
],
"18142": [
"CVE-2011-5165"
],
"18143": [
"CVE-2010-0822"
],
"18147": [
"CVE-2011-4089"
],
"18174": [
"CVE-2011-5162",
"CVE-2007-0707"
],
"18176": [
"CVE-2011-2005"
],
"18178": [
"CVE-2011-5170"
],
"18184": [
"CVE-2011-5002"
],
"18186": [
"CVE-2011-5172"
],
"18195": [
"CVE-2011-5170"
],
"18201": [
"CVE-2011-5044"
],
"18228": [
"CVE-2011-2777"
],
"18258": [
"CVE-2011-4620"
],
"18334": [
"CVE-2010-3333"
],
"18349": [],
"18372": [
"CVE-2012-0013"
],
"18375": [],
"18366": [
"CVE-2011-2462"
],
"18411": [
"CVE-2012-0056"
],
"18471": [
"CVE-2012-1189"
],
"18500": [],
"18501": [
"CVE-2009-4656"
],
"18515": [
"CVE-2008-1602"
],
"18547": [
"CVE-2009-4656"
],
"18533": [],
"18548": [
"CVE-2008-5036"
],
"18611": [],
"18656": [],
"18657": [],
"18681": [],
"18693": [],
"18710": [
"CVE-2012-0270"
],
"18726": [
"CVE-2014-9448"
],
"18733": [
"CVE-2012-2095"
],
"18749": [],
"18747": [
"CVE-2011-5171"
],
"18748": [],
"18760": [],
"18781": [
"CVE-2009-1642"
],
"18783": [
"CVE-2012-1586"
],
"18785": [],
"18792": [
"CVE-2012-4054"
],
"18808": [
"CVE-2012-4250"
],
"18823": [
"CVE-2011-3479"
],
"18826": [],
"18861": [
"CVE-2012-2376"
],
"18862": [
"CVE-2012-2052"
],
"18869": [],
"18892": [
"CVE-2012-2271"
],
"18905": [
"CVE-2009-0837"
],
"18914": [
"CVE-2007-5762"
],
"18917": [
"CVE-2012-2760"
],
"18923": [
"CVE-2008-0320"
],
"18981": [],
"18947": [],
"18954": [
"CVE-2011-3625"
],
"18959": [],
"19006": [
"CVE-2012-2915"
],
"19037": [
"CVE-2012-0013"
],
"19041": [
"CVE-1999-1194"
],
"19042": [
"CVE-1999-1123"
],
"19043": [
"CVE-1999-1123"
],
"19045": [],
"19066": [
"CVE-1999-0051"
],
"19067": [
"CVE-1999-0051"
],
"19068": [],
"19070": [],
"19071": [],
"19072": [
"CVE-1999-1499"
],
"19073": [],
"19074": [
"CVE-1999-1498"
],
"19077": [
"CVE-1999-0137"
],
"19078": [
"CVE-1999-0137"
],
"19080": [
"CVE-1999-1390"
],
"19095": [
"CVE-1999-0491"
],
"19106": [
"CVE-1999-0023"
],
"19108": [
"CVE-1999-0014"
],
"19122": [
"CVE-1999-1434"
],
"19125": [
"CVE-1999-0711"
],
"19126": [
"CVE-1999-1432"
],
"19128": [
"CVE-1999-0369"
],
"19138": [
"CVE-2012-1661"
],
"19139": [
"CVE-2012-0780"
],
"19142": [],
"19143": [],
"19144": [
"CVE-1999-1431"
],
"19145": [],
"19146": [
"CVE-1999-0388"
],
"19158": [
"CVE-1999-1158"
],
"19159": [
"CVE-1999-0109"
],
"19160": [
"CVE-1999-1191"
],
"19163": [
"CVE-1999-0314"
],
"19167": [
"CVE-1999-1171",
"CVE-1999-1170"
],
"19168": [
"CVE-1999-0301"
],
"19172": [
"CVE-1999-0306",
"CVE-1999-0038",
"CVE-1999-0030"
],
"19173": [
"CVE-1999-0306",
"CVE-1999-0038",
"CVE-1999-0030"
],
"19175": [
"CVE-2012-2915"
],
"19176": [],
"19192": [
"CVE-1999-0372"
],
"19196": [
"CVE-1999-0755"
],
"19198": [
"CVE-1999-0376"
],
"19199": [
"CVE-1999-0210"
],
"19200": [
"CVE-1999-0040"
],
"19201": [
"CVE-1999-0040"
],
"19202": [
"CVE-1999-0040"
],
"19203": [
"CVE-1999-0046"
],
"19205": [
"CVE-1999-0806"
],
"19206": [
"CVE-1999-0773"
],
"19209": [
"CVE-1999-0716"
],
"19210": [
"CVE-1999-0765"
],
"19211": [
"CVE-1999-0715"
],
"19213": [
"CVE-1999-0767"
],
"19214": [
"CVE-1999-0767"
],
"19215": [
"CVE-1999-0767"
],
"19216": [
"CVE-1999-0767"
],
"19217": [
"CVE-1999-0767"
],
"19220": [
"CVE-1999-0757"
],
"19227": [
"CVE-1999-1414"
],
"19229": [
"CVE-1999-0803"
],
"19232": [
"CVE-1999-0859"
],
"19233": [
"CVE-1999-1026"
],
"19234": [
"CVE-1999-0410"
],
"19235": [
"CVE-1999-0860"
],
"19240": [
"CVE-1999-0735"
],
"19243": [
"CVE-1999-0730"
],
"19244": [
"CVE-1999-1412"
],
"19249": [
"CVE-1999-1553"
],
"19401": [],
"19254": [
"CVE-1999-0409"
],
"19255": [
"CVE-2000-0118"
],
"19256": [
"CVE-1999-0914"
],
"19257": [
"CVE-1999-0433"
],
"19258": [
"CVE-1999-0442"
],
"19259": [
"CVE-1999-0363"
],
"19260": [
"CVE-1999-1410",
"CVE-1999-1286"
],
"19261": [
"CVE-1999-1409"
],
"19262": [
"CVE-1999-0960"
],
"19267": [
"CVE-1999-0108"
],
"19268": [],
"19269": [
"CVE-1999-1494"
],
"19270": [
"CVE-1999-0381"
],
"19273": [],
"19274": [
"CVE-1999-0025"
],
"19275": [],
"19276": [
"CVE-1999-0027"
],
"19277": [
"CVE-1999-0027"
],
"19279": [
"CVE-1999-1491"
],
"19280": [
"CVE-1999-0044"
],
"19281": [
"CVE-1999-1490"
],
"19283": [
"CVE-1999-1489"
],
"19284": [],
"19285": [],
"19286": [],
"19287": [
"CVE-1999-0118"
],
"19293": [],
"19602": [],
"19300": [
"CVE-1999-1405"
],
"19302": [],
"19304": [
"CVE-1999-1461"
],
"19305": [],
"19306": [
"CVE-1999-0092"
],
"19307": [
"CVE-1999-1208"
],
"19309": [
"CVE-1999-0122"
],
"19310": [
"CVE-1999-0036"
],
"19311": [
"CVE-1999-0125"
],
"19312": [
"CVE-1999-0125"
],
"19313": [
"CVE-1999-1120"
],
"19314": [],
"19315": [],
"19317": [
"CVE-1999-0029"
],
"19318": [
"CVE-1999-0328"
],
"19319": [],
"19411": [
"CVE-1999-1394"
],
"19412": [],
"19323": [],
"19341": [
"CVE-1999-0321"
],
"19342": [
"CVE-1999-0321"
],
"19343": [],
"19344": [],
"19345": [
"CVE-1999-1117"
],
"19346": [
"CVE-1999-1402"
],
"19347": [
"CVE-1999-0026"
],
"19349": [],
"19350": [
"CVE-1999-0051"
],
"19351": [
"CVE-1999-1022"
],
"19353": [
"CVE-1999-1114"
],
"19354": [
"CVE-1999-1219"
],
"19355": [
"CVE-1999-0959"
],
"19356": [
"CVE-1999-1384"
],
"19358": [
"CVE-1999-1398"
],
"19359": [
"CVE-1999-0382"
],
"19360": [],
"19362": [],
"19384": [],
"19370": [
"CVE-1999-0778"
],
"19371": [
"CVE-1999-0733"
],
"19373": [
"CVE-1999-0405"
],
"19374": [
"CVE-1999-0405"
],
"19376": [
"CVE-1999-0412"
],
"19417": [
"CVE-1999-1543"
],
"19418": [],
"19419": [
"CVE-1999-1166"
],
"19422": [
"CVE-1999-1460"
],
"19425": [
"CVE-1999-1011"
],
"19427": [],
"19428": [
"CVE-1999-0811"
],
"19429": [
"CVE-1999-0350"
],
"19430": [],
"19433": [
"CVE-2012-0663"
],
"19434": [],
"19437": [],
"19438": [],
"19439": [],
"19440": [
"CVE-1999-0700"
],
"19447": [
"CVE-1999-0674"
],
"19460": [
"CVE-1999-0888"
],
"19461": [
"CVE-1999-0888"
],
"19462": [
"CVE-1999-0749"
],
"19464": [
"CVE-1999-0192"
],
"19465": [
"CVE-1999-0192"
],
"19467": [
"CVE-1999-0720"
],
"19469": [
"CVE-1999-0768"
],
"19470": [
"CVE-1999-0768"
],
"19472": [
"CVE-1999-0718"
],
"19473": [
"CVE-1999-1235"
],
"19474": [
"CVE-1999-0769"
],
"19480": [
"CVE-1999-0705"
],
"19485": [
"CVE-1999-0774"
],
"19497": [
"CVE-1999-0691"
],
"19498": [
"CVE-1999-0689"
],
"19499": [],
"19500": [],
"19501": [
"CVE-1999-0693"
],
"19502": [
"CVE-1999-0886"
],
"19504": [
"CVE-1999-0708"
],
"19506": [],
"19508": [
"CVE-1999-0906"
],
"19509": [
"CVE-1999-0786"
],
"19510": [
"CVE-1999-0787"
],
"19511": [
"CVE-1999-1534"
],
"19512": [
"CVE-1999-1477"
],
"19516": [
"CVE-1999-1484"
],
"19517": [],
"19519": [
"CVE-2012-0897"
],
"19523": [],
"19528": [
"CVE-1999-1578",
"CVE-1999-1575"
],
"19529": [
"CVE-1999-1014"
],
"19533": [
"CVE-1999-0069"
],
"19534": [
"CVE-1999-0069"
],
"19535": [
"CVE-1999-0050"
],
"19542": [
"CVE-1999-0893"
],
"19543": [],
"19544": [
"CVE-1999-0335",
"CVE-1999-0032"
],
"19545": [
"CVE-1999-0335",
"CVE-1999-0032"
],
"19546": [
"CVE-1999-0034"
],
"19547": [
"CVE-1999-0034"
],
"19551": [
"CVE-1999-0041"
],
"19552": [
"CVE-1999-0041"
],
"19556": [
"CVE-1999-0130"
],
"19565": [
"CVE-2000-0362"
],
"19673": [
"CVE-1999-0975"
],
"19674": [
"CVE-1999-0979"
],
"19676": [
"CVE-1999-1008"
],
"19677": [
"CVE-1999-1008"
],
"19582": [
"CVE-1999-0948"
],
"19583": [
"CVE-1999-0949"
],
"19585": [
"CVE-1999-0946"
],
"19590": [
"CVE-1999-1340"
],
"19594": [
"CVE-1999-0899"
],
"19609": [
"CVE-1999-0820"
],
"19610": [
"CVE-1999-1112"
],
"19633": [
"CVE-2000-0073"
],
"19641": [
"CVE-1999-0830"
],
"19642": [],
"19643": [
"CVE-1999-0845"
],
"19647": [
"CVE-1999-0818"
],
"19648": [
"CVE-1999-0841"
],
"19649": [
"CVE-1999-0855"
],
"19650": [
"CVE-1999-0857"
],
"19651": [
"CVE-1999-0821"
],
"19652": [
"CVE-1999-0823"
],
"19653": [
"CVE-1999-0826"
],
"40430": [
"CVE-2016-3373"
],
"19654": [
"CVE-1999-0836"
],
"19655": [
"CVE-1999-0834"
],
"19656": [
"CVE-1999-0866"
],
"19657": [
"CVE-1999-0825"
],
"19658": [
"CVE-1999-0828"
],
"19659": [
"CVE-1999-0864"
],
"19660": [
"CVE-1999-0828"
],
"19661": [
"CVE-1999-0988",
"CVE-1999-0828"
],
"19665": [
"CVE-1999-0989"
],
"19678": [
"CVE-1999-1007"
],
"19683": [
"CVE-1999-1497"
],
"19684": [],
"19685": [
"CVE-2000-0018"
],
"19692": [],
"19693": [],
"19697": [
"CVE-2000-0027"
],
"19698": [
"CVE-2000-0035"
],
"19699": [
"CVE-2000-0037"
],
"19700": [
"CVE-2000-0037"
],
"19704": [
"CVE-2000-0009"
],
"19706": [
"CVE-2000-0013"
],
"19707": [
"CVE-2000-0015"
],
"19709": [
"CVE-2000-0052"
],
"19710": [
"CVE-2000-0052"
],
"19721": [
"CVE-2000-0045"
],
"19723": [
"CVE-2000-0048"
],
"19726": [
"CVE-2000-0094"
],
"19727": [
"CVE-2000-0091"
],
"19728": [
"CVE-2000-0100"
],
"19733": [
"CVE-2000-0119"
],
"19735": [
"CVE-2000-0107"
],
"19739": [
"CVE-2000-0121"
],
"19752": [
"CVE-2000-0224",
"CVE-2000-0154"
],
"19754": [
"CVE-2000-0155"
],
"19756": [
"CVE-2000-0163"
],
"19757": [
"CVE-2000-0210"
],
"19762": [
"CVE-2000-0214"
],
"19763": [
"CVE-2000-0219"
],
"19764": [
"CVE-2000-0194"
],
"19765": [
"CVE-2000-0195"
],
"19776": [],
"19778": [
"CVE-2000-0170"
],
"19779": [
"CVE-2000-0170"
],
"19787": [
"CVE-2000-0193"
],
"19789": [
"CVE-2000-0200"
],
"19794": [
"CVE-2000-0206"
],
"19796": [
"CVE-2000-0172"
],
"19798": [
"CVE-1999-1084"
],
"19802": [
"CVE-2000-0223"
],
"19803": [
"CVE-2000-0223"
],
"19804": [
"CVE-2000-0171"
],
"19811": [
"CVE-2000-0230"
],
"19812": [
"CVE-2000-0230"
],
"19813": [
"CVE-2000-0231"
],
"19816": [
"CVE-2000-0229"
],
"19821": [
"CVE-2000-0244"
],
"19823": [
"CVE-2000-0109"
],
"19836": [
"CVE-2000-0300"
],
"19837": [
"CVE-2000-0274"
],
"19838": [
"CVE-2000-0275"
],
"19839": [
"CVE-2000-0275"
],
"19840": [
"CVE-2000-0276"
],
"19841": [
"CVE-2000-0279"
],
"19851": [
"CVE-2000-0250"
],
"19855": [
"CVE-2000-0264"
],
"19904": [
"CVE-2000-0384"
],
"19867": [
"CVE-2000-0293"
],
"19872": [
"CVE-2000-0317"
],
"19873": [
"CVE-2000-0317"
],
"19874": [
"CVE-2000-0317"
],
"19875": [
"CVE-2000-1199"
],
"19876": [
"CVE-2000-0337"
],
"19878": [
"CVE-2000-0316"
],
"19883": [
"CVE-2000-0340"
],
"19894": [
"CVE-2000-0427"
],
"19900": [
"CVE-2000-0378"
],
"19910": [
"CVE-2000-0407"
],
"19911": [
"CVE-2000-0407"
],
"19912": [
"CVE-2000-0409"
],
"19915": [
"CVE-2000-0393"
],
"19925": [
"CVE-2000-0389"
],
"19930": [
"CVE-2010-3888",
"CVE-2010-3338"
],
"19933": [
"CVE-2009-2692"
],
"19946": [
"CVE-2000-0336"
],
"19952": [
"CVE-2000-0438"
],
"19953": [
"CVE-2000-0438"
],
"19954": [
"CVE-2000-0438"
],
"19955": [
"CVE-2000-0442"
],
"19967": [
"CVE-2000-0449"
],
"19968": [],
"19969": [
"CVE-2000-0454"
],
"19970": [
"CVE-2000-0460"
],
"19971": [],
"19972": [],
"19979": [
"CVE-2000-0530"
],
"19980": [
"CVE-2000-0530"
],
"19981": [
"CVE-2000-0530"
],
"19989": [
"CVE-2000-0492"
],
"19990": [
"CVE-2000-0468"
],
"19991": [
"CVE-2000-0545"
],
"19992": [
"CVE-2000-0545"
],
"19993": [
"CVE-2000-0552"
],
"19999": [
"CVE-2000-0537"
],
"20000": [
"CVE-2000-0506"
],
"20001": [
"CVE-2000-0506"
],
"20002": [
"CVE-2000-0515"
],
"20003": [
"CVE-2000-0516"
],
"20004": [
"CVE-2000-0520"
],
"20012": [
"CVE-2000-0559"
],
"20013": [
"CVE-2000-0467"
],
"20014": [
"CVE-2000-0471"
],
"20018": [
"CVE-2000-0494"
],
"20021": [],
"20022": [],
"20024": [
"CVE-2000-0607"
],
"20036": [],
"20042": [
"CVE-2000-0589"
],
"20045": [],
"20053": [],
"20056": [
"CVE-2000-0572"
],
"20058": [
"CVE-2000-0572"
],
"20073": [
"CVE-2000-0670"
],
"20081": [
"CVE-2000-0684",
"CVE-2000-0625"
],
"20092": [
"CVE-2000-0639"
],
"20093": [
"CVE-2000-0617"
],
"20107": [
"CVE-2000-0679"
],
"20108": [
"CVE-2000-0680"
],
"20116": [
"CVE-2009-1328"
],
"20126": [
"CVE-2000-0797"
],
"20127": [
"CVE-2000-0794"
],
"20128": [
"CVE-2000-0796"
],
"20129": [
"CVE-2000-0795"
],
"20130": [
"CVE-2000-0799"
],
"20133": [
"CVE-2000-0737"
],
"20137": [
"CVE-2000-0798"
],
"20138": [],
"20141": [
"CVE-2000-0703"
],
"20142": [
"CVE-2000-0703"
],
"20147": [
"CVE-2000-0695",
"CVE-2000-0693"
],
"20153": [
"CVE-2000-0763"
],
"20154": [
"CVE-2000-0763"
],
"20155": [
"CVE-2000-0721"
],
"20160": [
"CVE-2000-0698"
],
"20162": [
"CVE-2000-0702"
],
"20179": [
"CVE-2000-0691"
],
"20185": [
"CVE-2000-0844"
],
"20186": [
"CVE-2000-0844"
],
"20187": [
"CVE-2000-0844"
],
"20188": [
"CVE-2000-0844"
],
"20189": [
"CVE-2000-0844"
],
"20190": [
"CVE-2000-0844"
],
"20191": [
"CVE-2000-0901"
],
"20193": [
"CVE-2000-0881"
],
"20201": [
"CVE-2012-0946"
],
"20209": [
"CVE-2000-0851"
],
"20212": [
"CVE-2000-0864"
],
"20213": [
"CVE-2000-0873"
],
"20542": [],
"20230": [
"CVE-2000-0865"
],
"20232": [
"CVE-2000-0854"
],
"20241": [
"CVE-2000-1008"
],
"20250": [
"CVE-2000-0949"
],
"20251": [
"CVE-2000-0949"
],
"20252": [
"CVE-2000-0949"
],
"20256": [
"CVE-2000-0994"
],
"20257": [],
"20543": [],
"20262": [],
"20263": [
"CVE-1999-1243"
],
"20265": [],
"20274": [
"CVE-1999-0944"
],
"20275": [
"CVE-2000-1072"
],
"20276": [
"CVE-2000-1074"
],
"20285": [
"CVE-2000-0816"
],
"20290": [
"CVE-1999-0115"
],
"20291": [],
"20294": [
"CVE-2000-0976"
],
"20296": [],
"40428": [],
"20312": [
"CVE-2000-0987"
],
"20316": [],
"20317": [],
"20326": [],
"20329": [
"CVE-2000-0972"
],
"20333": [
"CVE-1999-0971"
],
"20338": [
"CVE-2000-0935"
],
"20339": [
"CVE-2000-0935"
],
"20341": [
"CVE-2000-0936"
],
"20377": [
"CVE-2000-0998"
],
"20378": [
"CVE-2000-0998"
],
"20380": [
"CVE-2000-1140"
],
"20381": [
"CVE-2000-1144"
],
"20382": [],
"20383": [
"CVE-2000-1147"
],
"20385": [
"CVE-2000-1125"
],
"20386": [
"CVE-2000-1127"
],
"20396": [
"CVE-2000-0077"
],
"40427": [],
"20401": [
"CVE-2000-1244"
],
"20402": [
"CVE-2000-1095"
],
"20407": [],
"20409": [],
"20410": [
"CVE-2000-1175"
],
"20411": [
"CVE-2000-1180"
],
"41031": [],
"20417": [
"CVE-2012-3483"
],
"20418": [
"CVE-2010-1183"
],
"20436": [
"CVE-2000-1134"
],
"20443": [
"CVE-2012-3485",
"CVE-2012-3483"
],
"20451": [
"CVE-2000-1081"
],
"20452": [
"CVE-2000-1119"
],
"20453": [
"CVE-2000-1120"
],
"20454": [
"CVE-2000-1121"
],
"20455": [
"CVE-2000-1124"
],
"20456": [
"CVE-2000-1083"
],
"20457": [
"CVE-2000-1085"
],
"20458": [],
"20485": [
"CVE-2012-4284"
],
"20493": [
"CVE-2001-0736"
],
"20505": [],
"20514": [
"CVE-2001-0059"
],
"20517": [
"CVE-2001-0087"
],
"20520": [
"CVE-2001-0095"
],
"20521": [
"CVE-2001-0095"
],
"20526": [
"CVE-2001-0084"
],
"20554": [
"CVE-2001-0109"
],
"20555": [
"CVE-2001-0109"
],
"20556": [
"CVE-2001-0111"
],
"20560": [
"CVE-2001-0259"
],
"20581": [
"CVE-2001-1274"
],
"20585": [
"CVE-2001-0189"
],
"20603": [
"CVE-2001-0165"
],
"20604": [
"CVE-2001-0193"
],
"20621": [
"CVE-2001-0208"
],
"20626": [
"CVE-2001-0316"
],
"20645": [],
"20651": [
"CVE-2001-0293"
],
"20658": [
"CVE-2001-0289"
],
"20678": [
"CVE-2001-0459"
],
"20679": [
"CVE-2001-0459"
],
"40426": [],
"20684": [
"CVE-2001-0401"
],
"20691": [
"CVE-2001-0468"
],
"20697": [
"CVE-2001-0369"
],
"20715": [
"CVE-2001-0403"
],
"20718": [
"CVE-2001-0407"
],
"20720": [
"CVE-2001-0317"
],
"20721": [
"CVE-2001-0317"
],
"40425": [],
"20724": [],
"20740": [
"CVE-2001-0594"
],
"20741": [
"CVE-2001-0594"
],
"20743": [
"CVE-2001-0422"
],
"20746": [
"CVE-2001-0597"
],
"20751": [
"CVE-2001-0423"
],
"20766": [
"CVE-2001-0426"
],
"20767": [
"CVE-2001-0595"
],
"20768": [
"CVE-2001-0595"
],
"20769": [
"CVE-2001-0384"
],
"20772": [
"CVE-2001-0565"
],
"20773": [
"CVE-2001-0565"
],
"20776": [
"CVE-2001-0406"
],
"20777": [
"CVE-2001-1442"
],
"20778": [
"CVE-2001-1442"
],
"20781": [
"CVE-2001-0610"
],
"20795": [
"CVE-2001-0623"
],
"20798": [
"CVE-2001-0623"
],
"20804": [
"CVE-2001-0485"
],
"40422": [],
"20822": [
"CVE-2001-0559"
],
"20823": [
"CVE-2001-0559"
],
"20843": [
"CVE-2001-0641"
],
"20851": [
"CVE-2004-0390"
],
"20861": [
"CVE-2012-0217"
],
"20867": [
"CVE-2001-1346"
],
"20868": [
"CVE-2001-1346"
],
"20880": [
"CVE-2001-1347"
],
"20885": [
"CVE-2001-0526 "
],
"20897": [],
"20898": [],
"20900": [
"CVE-2001-0690"
],
"20901": [
"CVE-2001-0279"
],
"20905": [
"CVE-2001-0685"
],
"20906": [
"CVE-2001-0762"
],
"20915": [],
"20923": [
"CVE-2001-0787"
],
"20926": [],
"20927": [
"CVE-2001-0759"
],
"20928": [
"CVE-2001-1077"
],
"20937": [
"CVE-2001-0823"
],
"20945": [
"CVE-2001-0701"
],
"20960": [
"CVE-2001-0764"
],
"20961": [
"CVE-2001-0782"
],
"20962": [
"CVE-2001-0735"
],
"20963": [
"CVE-2001-0735"
],
"20964": [
"CVE-2001-0735"
],
"20965": [
"CVE-2001-1080"
],
"20967": [
"CVE-2001-0409"
],
"20969": [
"CVE-2001-1582"
],
"20970": [
"CVE-2001-1582"
],
"20974": [
"CVE-2001-1076"
],
"20979": [],
"20985": [
"CVE-2001-1246"
],
"20986": [
"CVE-2001-1561"
],
"20988": [],
"20990": [
"CVE-2001-0906"
],
"20992": [
"CVE-2001-1085"
],
"20999": [
"CVE-2001-1177"
],
"21000": [
"CVE-2001-1177"
],
"21001": [
"CVE-2001-1177"
],
"21010": [
"CVE-2001-1178"
],
"21014": [],
"21020": [
"CVE-2001-1354"
],
"21024": [
"CVE-2001-0548"
],
"21043": [
"CVE-2001-1036"
],
"21044": [
"CVE-2001-0941"
],
"21045": [
"CVE-2001-0833"
],
"21058": [
"CVE-2001-0652"
],
"21059": [
"CVE-2001-0652"
],
"21060": [
"CVE-2001-0653"
],
"21061": [
"CVE-2001-0653"
],
"21062": [
"CVE-2001-0653"
],
"21063": [
"CVE-2001-0653"
],
"21069": [
"CVE-2001-1519"
],
"21070": [],
"21071": [
"CVE-2001-0506"
],
"21072": [
"CVE-2001-0507"
],
"21073": [],
"21076": [
"CVE-2001-1165"
],
"21078": [
"CVE-2001-1003"
],
"21256": [
"CVE-2009-1831"
],
"21090": [],
"21091": [
"CVE-2001-0983"
],
"21094": [],
"21096": [],
"21098": [
"CVE-2001-0979"
],
"21101": [
"CVE-2001-1000"
],
"21105": [
"CVE-2001-1093"
],
"21106": [
"CVE-2001-0873"
],
"21107": [
"CVE-2001-1092"
],
"21108": [
"CVE-2001-0956"
],
"21114": [
"CVE-2001-1029"
],
"21117": [
"CVE-2001-1127"
],
"21120": [
"CVE-2001-1015"
],
"21124": [
"CVE-2001-1384"
],
"21130": [],
"21139": [],
"40418": [],
"21150": [
"CVE-2001-0855"
],
"21158": [
"CVE-2001-0915"
],
"21159": [
"CVE-2001-0916"
],
"21173": [
"CVE-2001-1546"
],
"21176": [
"CVE-2001-1185"
],
"40417": [],
"21216": [
"CVE-2002-0137"
],
"21217": [
"CVE-2002-0137"
],
"21218": [
"CVE-2002-0137"
],
"21219": [
"CVE-2002-0137"
],
"21226": [
"CVE-2002-0143"
],
"21227": [
"CVE-2002-0043"
],
"21229": [
"CVE-2002-0004"
],
"21231": [
"CVE-2002-0132"
],
"21239": [
"CVE-2002-0311"
],
"21244": [
"CVE-2002-0211"
],
"21247": [
"CVE-2002-0210"
],
"21248": [
"CVE-2002-2016"
],
"21258": [],
"21259": [
"CVE-2002-2072"
],
"21280": [
"CVE-2002-0239"
],
"21281": [
"CVE-2002-0239"
],
"21282": [
"CVE-2002-0244"
],
"21283": [
"CVE-2002-1731"
],
"21284": [
"CVE-2002-0246"
],
"21288": [
"CVE-2002-0265"
],
"21290": [
"CVE-2002-0296"
],
"21302": [
"CVE-2002-0327"
],
"21318": [],
"21320": [],
"21323": [
"CVE-2012-3524",
"CVE-2012-4425"
],
"21331": [],
"21341": [
"CVE-2002-0468"
],
"21342": [
"CVE-2002-0468"
],
"21344": [
"CVE-2002-0367"
],
"21347": [
"CVE-2002-0484"
],
"21348": [
"CVE-2002-1673"
],
"21351": [
"CVE-2002-0486"
],
"21353": [
"CVE-2002-0499"
],
"21356": [
"CVE-2002-0162"
],
"21359": [
"CVE-2001-1127"
],
"21360": [
"CVE-2002-0158"
],
"21362": [
"CVE-2002-1767"
],
"21373": [
"CVE-2002-0542"
],
"21375": [
"CVE-2002-0525"
],
"21398": [],
"21407": [
"CVE-2002-0572"
],
"21408": [
"CVE-2002-0740"
],
"21414": [
"CVE-2002-1602"
],
"21420": [
"CVE-2002-0184"
],
"21458": [
"CVE-2002-1826"
],
"21462": [],
"21489": [
"CVE-2002-0887"
],
"21496": [
"CVE-2002-0905"
],
"21497": [
"CVE-2002-0905"
],
"21499": [
"CVE-2002-0793"
],
"21500": [
"CVE-2002-0793"
],
"21501": [
"CVE-2002-0793"
],
"21502": [
"CVE-2002-2039"
],
"21503": [
"CVE-2002-2040"
],
"21504": [
"CVE-2002-2040"
],
"21505": [
"CVE-2002-2041"
],
"21506": [
"CVE-2002-2041"
],
"21507": [
"CVE-2002-2042"
],
"21516": [],
"21538": [
"CVE-2002-0767"
],
"21547": [],
"21549": [
"CVE-2002-0624"
],
"21550": [
"CVE-2002-0942"
],
"21551": [
"CVE-2002-0942"
],
"21565": [
"CVE-2003-0281",
"CVE-2002-2087"
],
"21566": [
"CVE-2003-0281",
"CVE-2002-2087"
],
"21568": [
"CVE-2002-1447"
],
"40348": [],
"21577": [
"CVE-2002-0991"
],
"21583": [
"CVE-2002-1814"
],
"21584": [
"CVE-2002-1814"
],
"21585": [
"CVE-2002-1814"
],
"21592": [
"CVE-2002-0994"
],
"40440": [],
"21623": [],
"21624": [],
"21629": [
"CVE-2002-1016"
],
"21666": [],
"21667": [
"CVE-2002-0658"
],
"21669": [
"CVE-2002-0824"
],
"40362": [],
"40365": [],
"40429": [
"CVE-2016-3371"
],
"21674": [
"CVE-2002-0817"
],
"21683": [
"CVE-2002-1414"
],
"21684": [
"CVE-2002-1230"
],
"21685": [
"CVE-2002-1230"
],
"21686": [
"CVE-2002-1230"
],
"21687": [
"CVE-2002-1230"
],
"21688": [
"CVE-2002-1230"
],
"21689": [
"CVE-2002-1230"
],
"21690": [
"CVE-2002-1230"
],
"21691": [
"CVE-2002-1230"
],
"21700": [
"CVE-2002-0851"
],
"21701": [
"CVE-2002-0851"
],
"21713": [],
"21720": [
"CVE-2002-0875"
],
"21721": [
"CVE-2002-0976"
],
"21732": [
"CVE-2002-1469"
],
"21733": [],
"21758": [
"CVE-2002-0987"
],
"21760": [
"CVE-2002-1812"
],
"21761": [
"CVE-2002-1506"
],
"21762": [
"CVE-2002-1506"
],
"21763": [
"CVE-2002-1506"
],
"21771": [
"CVE-2002-1503"
],
"21772": [],
"21773": [],
"21774": [
"CVE-2002-1605"
],
"21781": [
"CVE-2002-2162"
],
"21790": [],
"21793": [
"CVE-2002-1512"
],
"21796": [
"CVE-2002-1125"
],
"21797": [
"CVE-2002-1125"
],
"21798": [
"CVE-2002-1125"
],
"21799": [
"CVE-2002-1125"
],
"21805": [
"CVE-2002-1492"
],
"21806": [
"CVE-2002-1492"
],
"21807": [
"CVE-2002-1129"
],
"21814": [
"CVE-2002-1896"
],
"21815": [
"CVE-2002-1898"
],
"21884": [
"CVE-2002-1165"
],
"21881": [
"CVE-2002-1192"
],
"21831": [
"CVE-2012-4552"
],
"21843": [],
"21844": [
"CVE-2011-2005"
],
"21845": [],
"21848": [
"CVE-2009-1185"
],
"21856": [
"CVE-2002-1513"
],
"21865": [
"CVE-2002-1514"
],
"21871": [
"CVE-2002-0838"
],
"21872": [
"CVE-2002-0838"
],
"21887": [],
"21892": [],
"21904": [
"CVE-2002-1468"
],
"21922": [
"CVE-2002-1230"
],
"21923": [
"CVE-2002-1230"
],
"21980": [
"CVE-2002-1250"
],
"21988": [
"CVE-2012-6568"
],
"21994": [],
"22002": [
"CVE-2002-1239"
],
"22014": [
"CVE-2002-1364"
],
"22055": [],
"22066": [
"CVE-2002-1381"
],
"22067": [
"CVE-2002-1576"
],
"22069": [
"CVE-2012-3137"
],
"22120": [
"CVE-2003-1071"
],
"22128": [
"CVE-2003-1247"
],
"22189": [
"CVE-2003-0034"
],
"22190": [],
"22193": [],
"22203": [
"CVE-2003-1073"
],
"22210": [
"CVE-2003-1366"
],
"22212": [],
"22225": [
"CVE-2003-0004"
],
"22231": [
"CVE-2003-1375"
],
"22233": [
"CVE-2003-0358"
],
"22234": [
"CVE-2003-0358"
],
"22235": [
"CVE-2003-0358"
],
"22246": [
"CVE-2003-1359"
],
"22247": [
"CVE-2003-1359"
],
"22248": [
"CVE-2003-1358"
],
"22265": [],
"22272": [],
"22332": [
"CVE-2003-0144"
],
"22331": [
"CVE-2003-0144"
],
"22320": [],
"22321": [],
"22322": [],
"22323": [],
"22324": [
"CVE-2003-0102"
],
"22325": [
"CVE-2003-0102"
],
"22326": [
"CVE-2003-1092"
],
"22329": [],
"22335": [],
"22340": [
"CVE-2003-0150"
],
"22344": [
"CVE-2003-0124"
],
"22354": [],
"22362": [
"CVE-2003-0127"
],
"22363": [
"CVE-2003-0127"
],
"22376": [
"CVE-2003-0165"
],
"22442": [
"CVE-2003-0161"
],
"22452": [],
"22456": [],
"22458": [
"CVE-2001-1287"
],
"22465": [],
"22528": [],
"22531": [
"CVE-2003-0265"
],
"22538": [
"CVE-2003-0390"
],
"22540": [
"CVE-2003-0396"
],
"22564": [],
"22565": [
"CVE-2003-1480"
],
"22566": [
"CVE-2003-0269"
],
"22567": [
"CVE-2003-0262"
],
"22573": [
"CVE-2003-0274"
],
"22574": [
"CVE-2003-1473"
],
"22580": [
"CVE-2002-2087"
],
"22594": [
"CVE-2003-0289"
],
"22613": [
"CVE-2003-0325"
],
"22614": [
"CVE-2003-0325"
],
"22615": [
"CVE-2003-0325"
],
"22616": [],
"22617": [],
"22628": [],
"22633": [],
"22640": [
"CVE-2003-0019"
],
"22643": [],
"22644": [],
"22645": [],
"22652": [],
"22661": [
"CVE-2003-0408"
],
"22683": [],
"22695": [],
"22703": [],
"22719": [
"CVE-2002-1155"
],
"22720": [
"CVE-2002-1155"
],
"22727": [],
"22729": [],
"22732": [
"CVE-2003-1123"
],
"22745": [],
"22748": [
"CVE-2003-0385"
],
"40410": [],
"22756": [
"CVE-2002-0747"
],
"22768": [],
"22773": [
"CVE-2003-0449"
],
"22775": [],
"22779": [],
"22781": [
"CVE-2003-0388"
],
"22806": [],
"22811": [],
"22813": [
"CVE-2003-0501"
],
"22815": [],
"40409": [
"CVE-2016-3237"
],
"22835": [],
"22836": [
"CVE-1999-1184"
],
"22840": [
"CVE-2003-0462"
],
"22847": [
"CVE-2003-0497"
],
"22851": [],
"22860": [],
"22861": [],
"22862": [],
"22863": [],
"22870": [],
"23037": [],
"22882": [
"CVE-2003-0496"
],
"22883": [
"CVE-2003-0496"
],
"22884": [],
"22911": [
"CVE-2003-0863"
],
"22912": [
"CVE-2003-0579"
],
"22943": [],
"22946": [],
"22965": [],
"22923": [
"CVE-2003-0584"
],
"22924": [
"CVE-2003-0584"
],
"22928": [
"CVE-2012-4409"
],
"22931": [],
"22932": [],
"23007": [],
"22939": [],
"22971": [
"CVE-2003-0620"
],
"22979": [
"CVE-2003-0655"
],
"22980": [
"CVE-2003-1310"
],
"22984": [],
"22985": [],
"22988": [
"CVE-2003-0898"
],
"22989": [
"CVE-2003-1052"
],
"22993": [],
"22996": [
"CVE-2003-0649"
],
"23022": [],
"23023": [],
"23041": [],
"23045": [],
"23046": [],
"23047": [],
"23052": [],
"23062": [],
"23063": [],
"23077": [
"CVE-2012-5613"
],
"23096": [
"CVE-2003-0666"
],
"23119": [],
"23126": [],
"23141": [],
"23143": [],
"23168": [],
"23189": [
"CVE-2003-0830"
],
"23197": [],
"23204": [],
"23210": [],
"23223": [
"CVE-2003-0847"
],
"23228": [
"CVE-2003-0848"
],
"23251": [],
"23255": [
"CVE-2003-0659"
],
"23258": [],
"23297": [
"CVE-2003-1139"
],
"23299": [
"CVE-2003-0947"
],
"23300": [
"CVE-2003-0947"
],
"23301": [
"CVE-2003-0947"
],
"23303": [
"CVE-2003-1140"
],
"23308": [
"CVE-2003-1167"
],
"23327": [
"CVE-2003-1169"
],
"23341": [
"CVE-2003-0090"
],
"23342": [
"CVE-2003-0090"
],
"23343": [
"CVE-2003-0089"
],
"23344": [
"CVE-2003-1051"
],
"23345": [
"CVE-2003-1051"
],
"23346": [
"CVE-2003-1051"
],
"23350": [],
"23351": [],
"23352": [],
"23364": [],
"23414": [
"CVE-2003-1308"
],
"23479": [],
"23481": [
"CVE-2003-1307"
],
"23482": [
"CVE-2003-1307"
],
"23510": [
"CVE-2004-0074"
],
"23511": [],
"23581": [],
"23609": [
"CVE-2004-2131"
],
"23610": [
"CVE-2004-2131"
],
"23611": [
"CVE-2004-2134"
],
"23634": [
"CVE-2004-0238"
],
"23655": [
"CVE-2004-0114"
],
"23658": [
"CVE-2004-2073"
],
"23674": [
"CVE-2004-0186"
],
"23682": [
"CVE-2004-0083"
],
"23738": [
"CVE-2004-0158"
],
"23739": [
"CVE-2004-2359"
],
"23743": [
"CVE-2004-0318"
],
"23759": [
"CVE-2004-2303"
],
"23783": [
"CVE-2006-6199"
],
"23838": [
"CVE-2004-2312"
],
"23840": [
"CVE-2004-0544"
],
"23841": [
"CVE-2004-0544"
],
"23849": [],
"23874": [
"CVE-2004-2686"
],
"23882": [
"CVE-2004-1861"
],
"23883": [
"CVE-2004-2697"
],
"23892": [],
"23910": [],
"23921": [],
"40400": [],
"23989": [
"CVE-2003-0910"
],
"23996": [],
"24014": [],
"24015": [],
"24027": [
"CVE-2004-0233"
],
"24043": [
"CVE-2004-0228"
],
"24062": [],
"24063": [],
"24064": [],
"24113": [
"CVE-2004-2012"
],
"24123": [
"CVE-2004-2014"
],
"24141": [
"CVE-2004-0490"
],
"24171": [
"CVE-2004-2555"
],
"24173": [],
"24182": [
"CVE-2004-1471"
],
"24200": [],
"24207": [],
"24210": [],
"24258": [],
"24277": [
"CVE-2004-0210"
],
"24278": [
"CVE-2004-2502"
],
"24293": [
"CVE-2004-0511"
],
"24335": [
"CVE-2004-1707"
],
"24366": [],
"24374": [],
"24398": [
"CVE-2004-2698"
],
"24406": [
"CVE-2004-1170"
],
"24421": [],
"24458": [],
"24459": [
"CVE-2013-0160"
],
"24505": [],
"24555": [
"CVE-2013-1763"
],
"24570": [],
"24578": [
"CVE-2012-3485"
],
"24579": [
"CVE-2012-4284"
],
"24606": [],
"24608": [],
"24609": [],
"24678": [
"CVE-2005-4868"
],
"24682": [
"CVE-2004-2176"
],
"24694": [
"CVE-2004-0940"
],
"24746": [
"CVE-2013-1763"
],
"24749": [
"CVE-2004-0996"
],
"24750": [
"CVE-2004-0996"
],
"24753": [],
"24754": [
"CVE-2005-1590"
],
"24757": [],
"24758": [],
"24863": [],
"24872": [],
"24884": [],
"24885": [],
"24899": [],
"24910": [],
"24919": [],
"24923": [],
"24929": [],
"24933": [],
"25039": [
"CVE-2004-1329"
],
"25040": [],
"25055": [],
"25106": [
"CVE-2005-0105"
],
"25130": [
"CVE-2013-5656"
],
"25131": [
"CVE-2013-5660"
],
"25134": [
"CVE-2012-0809"
],
"25141": [],
"25202": [
"CVE-2005-0736"
],
"25204": [],
"25256": [
"CVE-2005-0713"
],
"25288": [
"CVE-2005-0750"
],
"25289": [
"CVE-2005-0750"
],
"25296": [],
"25333": [
"CVE-2005-0993"
],
"25361": [
"CVE-2005-0464"
],
"25362": [
"CVE-2005-0465"
],
"25406": [],
"25411": [],
"25419": [],
"25444": [
"CVE-2013-2094"
],
"25448": [
"CVE-2013-0726"
],
"25450": [
"CVE-2013-1959"
],
"25554": [],
"40394": [],
"25607": [],
"25636": [
"CVE-2005-1606"
],
"40393": [],
"25688": [
"CVE-2005-1686"
],
"25703": [],
"25707": [
"CVE-2004-2135"
],
"25709": [
"CVE-2005-1707"
],
"25718": [],
"25725": [
"CVE-2013-2730"
],
"40392": [],
"25789": [
"CVE-2005-1858"
],
"40389": [],
"25883": [],
"25896": [
"CVE-2005-2071"
],
"25912": [
"CVE-2013-3661",
"CVE-2013-3660",
"CVE-2013-3130"
],
"25947": [],
"25961": [],
"25993": [],
"26100": [],
"26131": [
"CVE-2013-2094"
],
"26185": [
"CVE-2005-2508"
],
"26195": [
"CVE-2005-2725"
],
"26218": [
"CVE-2005-2807"
],
"26222": [],
"26242": [],
"26245": [
"CVE-2006-0720"
],
"26321": [
"CVE-2005-0023"
],
"26323": [
"CVE-2005-4696"
],
"26352": [],
"26353": [
"CVE-2005-3257"
],
"26367": [],
"26368": [
"CVE-2013-2171"
],
"26402": [],
"26403": [],
"26404": [],
"26409": [],
"26411": [],
"26418": [
"CVE-2008-3158"
],
"26448": [],
"26451": [],
"26452": [
"CVE-2013-3956"
],
"26454": [
"CVE-2013-2171"
],
"26479": [
"CVE-2005-3560"
],
"26492": [
"CVE-2003-1232"
],
"26497": [
"CVE-2005-2629"
],
"26498": [
"CVE-2005-4158"
],
"26520": [
"CVE-2013-4743"
],
"26523": [],
"26525": [],
"26554": [
"CVE-2013-3661",
"CVE-2013-3660",
"CVE-2013-3130"
],
"28085": [
"CVE-2013-6128"
],
"26579": [],
"26703": [
"CVE-2013-2729"
],
"26708": [
"CVE-2013-3482"
],
"26709": [
"CVE-2010-1183"
],
"26752": [
"CVE-2005-4176"
],
"26753": [
"CVE-2005-4176"
],
"26805": [
"CVE-2013-3248",
"CVE-2013-0742"
],
"26889": [
"CVE-2006-6199"
],
"40385": [
"CVE-2016-6253"
],
"26950": [
"CVE-2013-4679"
],
"26970": [
"CVE-2005-4505"
],
"26996": [
"CVE-2006-0133"
],
"26997": [
"CVE-2006-0133"
],
"27041": [],
"27056": [
"CVE-2005-4158"
],
"27057": [
"CVE-2005-4158"
],
"27065": [
"CVE-2006-0177"
],
"27066": [
"CVE-2006-0177"
],
"27168": [
"CVE-2005-1528"
],
"27191": [
"CVE-2013-3956"
],
"27231": [
"CVE-2006-0455"
],
"27282": [],
"27285": [
"CVE-2013-4868",
"CVE-2013-4867"
],
"27296": [
"CVE-2013-0008"
],
"27297": [
"CVE-2013-0268"
],
"27316": [
"CVE-2013-6079"
],
"27334": [
"CVE-2006-1015"
],
"27335": [
"CVE-2006-1014"
],
"40764": [
"CVE-2016-7225"
],
"40763": [
"CVE-2016-7226"
],
"27461": [
"CVE-2006-1342"
],
"27609": [
"CVE-2013-3928"
],
"27766": [
"CVE-2006-1864"
],
"27769": [
"CVE-2006-1863"
],
"27874": [
"CVE-2013-4694"
],
"27938": [
"CVE-2013-1662"
],
"27944": [
"CVE-2013-1775"
],
"27965": [
"CVE-2013-1775"
],
"28084": [
"CVE-2013-6127"
],
"28130": [
"CVE-2012-5383",
"CVE-2012-5382",
"CVE-2012-5381",
"CVE-2012-5380",
"CVE-2012-5379",
"CVE-2012-5378",
"CVE-2012-5377"
],
"28287": [
"CVE-2006-3815"
],
"28288": [
"CVE-2006-3931"
],
"28332": [
"CVE-2013-4984"
],
"28335": [],
"28405": [],
"28425": [],
"28427": [
"CVE-2006-4310"
],
"28504": [
"CVE-2006-4625"
],
"28507": [
"CVE-2013-4011"
],
"28576": [],
"40376": [],
"28655": [
"CVE-2013-4660"
],
"28657": [
"CVE-2013-4788"
],
"40375": [],
"28680": [
"CVE-2013-4987"
],
"28718": [
"CVE-2012-0217"
],
"28763": [
"CVE-2006-4927"
],
"28764": [
"CVE-2006-4927"
],
"28788": [
"CVE-2006-4842"
],
"28789": [
"CVE-2006-4842"
],
"29213": [],
"28806": [
"CVE-2013-4362"
],
"28817": [
"CVE-2006-7129"
],
"28955": [],
"28969": [],
"28984": [
"CVE-2006-7235"
],
"40768": [
"CVE-2016-1247"
],
"29069": [
"CVE-2006-6952"
],
"29070": [
"CVE-2006-6952"
],
"29102": [],
"29125": [],
"34371": [],
"29190": [
"CVE-2006-6129"
],
"29194": [
"CVE-2006-6130"
],
"29201": [
"CVE-2006-6173"
],
"29234": [],
"29239": [
"CVE-2006-6383"
],
"29327": [
"CVE-2013-6935"
],
"29263": [
"CVE-2006-6199"
],
"29309": [],
"29374": [
"CVE-2007-0081"
],
"29403": [
"CVE-2007-0161"
],
"29446": [
"CVE-2007-0257"
],
"29465": [
"CVE-2007-0333"
],
"29467": [],
"30032": [
"CVE-2013-7186"
],
"30039": [],
"30017": [
"CVE-2007-2553"
],
"30021": [
"CVE-2007-2617"
],
"30014": [
"CVE-2013-5065"
],
"29547": [],
"29528": [
"CVE-2007-0448"
],
"29548": [],
"29549": [
"CVE-2013-7409"
],
"29594": [
"CVE-2013-6937"
],
"29603": [],
"29630": [
"CVE-2007-0843"
],
"30192": [
"CVE-2006-3074"
],
"29695": [
"CVE-2007-1330"
],
"29712": [
"CVE-2007-1369"
],
"29714": [],
"29798": [
"CVE-2013-7409"
],
"29746": [
"CVE-2007-1474"
],
"29777": [
"CVE-2013-6874"
],
"30783": [],
"30154": [
"CVE-2013-6356"
],
"30183": [],
"29799": [],
"29801": [
"CVE-2007-1835"
],
"29804": [],
"29822": [
"CVE-2006-4250"
],
"29881": [
"CVE-2013-0640"
],
"29922": [
"CVE-2013-3934"
],
"29950": [
"CVE-2007-2580"
],
"29954": [
"CVE-2007-2027"
],
"30007": [],
"30096": [
"CVE-2007-0753"
],
"30237": [
"CVE-2013-7030"
],
"30244": [],
"30280": [
"CVE-2007-2839"
],
"30295": [
"CVE-2007-3855"
],
"30393": [
"CVE-2013-0109"
],
"30392": [
"CVE-2013-5065"
],
"30336": [],
"30802": [],
"30374": [
"CVE-2013-6767"
],
"30399": [
"CVE-2007-3333"
],
"40520": [],
"40522": [],
"30464": [
"CVE-2007-4302"
],
"30468": [
"CVE-2013-7260",
"CVE-2013-6877"
],
"30474": [
"CVE-2012-3993",
"CVE-2013-1710"
],
"30477": [
"CVE-2014-8359",
"CVE-2014-8358"
],
"30484": [
"CVE-2007-4305"
],
"30503": [
"CVE-2007-4390"
],
"30546": [
"CVE-2007-4649"
],
"30970": [
"CVE-2008-0100"
],
"30604": [
"CVE-2007-4573"
],
"30605": [
"CVE-2007-4571"
],
"30620": [
"CVE-2007-4993"
],
"30666": [],
"30680": [
"CVE-2007-5587"
],
"30681": [
"CVE-2007-5633"
],
"30780": [
"CVE-2007-6182"
],
"30788": [
"CVE-2013-4988"
],
"30789": [
"CVE-2013-5447"
],
"30839": [
"CVE-2007-6210"
],
"30999": [
"CVE-2008-7211"
],
"31036": [
"CVE-2008-0365"
],
"31090": [
"CVE-2014-2013"
],
"31151": [],
"31182": [
"CVE-2013-5582",
"CVE-2013-5581"
],
"31346": [
"CVE-2014-0038"
],
"31347": [
"CVE-2014-0038"
],
"31386": [],
"31460": [],
"31524": [
"CVE-2014-0980"
],
"31574": [
"CVE-2013-6282"
],
"31576": [
"CVE-2013-3881"
],
"31643": [
"CVE-2010-2343"
],
"31667": [
"CVE-2008-1436"
],
"31688": [
"CVE-2014-2030",
"CVE-2014-1947"
],
"31766": [],
"31895": [],
"40350": [],
"31911": [
"CVE-2008-2712"
],
"31930": [],
"31937": [
"CVE-2008-2666"
],
"31940": [
"CVE-2008-2830"
],
"31959": [
"CVE-2008-2827"
],
"40349": [],
"31972": [],
"31988": [],
"31991": [
"CVE-2007-2568"
],
"32041": [
"CVE-2013-7409"
],
"32050": [],
"32055": [],
"32074": [
"CVE-2013-7409"
],
"32152": [],
"32153": [
"CVE-2014-2533"
],
"32154": [],
"32155": [],
"32156": [
"CVE-2014-2534"
],
"32158": [],
"32205": [
"CVE-2014-3222"
],
"32261": [
"CVE-2010-5299"
],
"32343": [
"CVE-2008-7002"
],
"32358": [
"CVE-2006-2465"
],
"32370": [],
"32446": [
"CVE-2008-4405"
],
"32501": [],
"46639": [],
"32572": [
"CVE-2008-5048"
],
"32585": [],
"32590": [
"CVE-2008-5229"
],
"32693": [],
"32700": [
"CVE-2013-4011"
],
"32737": [],
"32751": [
"CVE-2009-0343"
],
"32752": [],
"32771": [
"CVE-2009-0449"
],
"32778": [],
"32793": [
"CVE-2014-1761"
],
"32805": [
"CVE-2009-0676"
],
"32820": [
"CVE-2009-0368"
],
"32813": [],
"32829": [
"CVE-2009-0835"
],
"32845": [
"CVE-2009-0880"
],
"32847": [],
"32848": [
"CVE-2009-0876"
],
"32850": [
"CVE-2009-0824"
],
"32884": [
"CVE-2014-0514"
],
"32891": [
"CVE-2009-0078"
],
"32892": [
"CVE-2009-0079"
],
"32893": [
"CVE-2009-0080"
],
"32901": [],
"32946": [
"CVE-2009-1436"
],
"32947": [
"CVE-2009-1526"
],
"33012": [
"CVE-2009-1808"
],
"33028": [],
"33069": [
"CVE-2014-2299"
],
"33145": [],
"33161": [],
"33213": [
"CVE-2013-1300"
],
"33229": [
"CVE-2009-2793"
],
"33255": [
"CVE-2009-3525"
],
"33321": [
"CVE-2009-3547"
],
"33322": [
"CVE-2009-3547"
],
"33593": [
"CVE-2010-0233"
],
"33336": [
"CVE-2013-1763"
],
"33360": [
"CVE-2009-4049"
],
"33387": [],
"33395": [
"CVE-2009-4131"
],
"40823": [
"CVE-2016-7255"
],
"33508": [
"CVE-2010-0002"
],
"33516": [
"CVE-2014-0196"
],
"33572": [
"CVE-2010-0462"
],
"33576": [],
"33589": [
"CVE-2013-2094"
],
"33523": [
"CVE-2009-4141"
],
"33604": [
"CVE-2010-0411"
],
"33614": [
"CVE-2013-0292"
],
"33623": [
"CVE-2009-4648"
],
"33725": [
"CVE-2014-3977",
"CVE-2012-2179"
],
"40342": [],
"33791": [
"CVE-2014-0514"
],
"33799": [
"CVE-2010-1183"
],
"33808": [],
"33824": [
"CVE-2014-4014"
],
"33892": [
"CVE-2014-0257"
],
"33893": [
"CVE-2013-5045"
],
"33899": [
"CVE-2014-0476"
],
"33904": [
"CVE-2014-4703"
],
"33961": [
"CVE-2014-5453"
],
"33963": [
"CVE-2010-1457"
],
"34112": [
"CVE-2014-4971"
],
"34001": [
"CVE-2010-1636"
],
"34037": [
"CVE-2014-5455"
],
"40936": [
"CVE-2009-2477"
],
"34131": [
"CVE-2014-4971"
],
"34134": [
"CVE-2014-4699"
],
"34167": [
"CVE-2014-4971"
],
"34267": [],
"40917": [],
"34272": [
"CVE-2014-3434"
],
"34311": [
"CVE-2010-2382"
],
"34313": [
"CVE-2010-2383"
],
"34314": [
"CVE-2010-2384"
],
"34333": [
"CVE-2014-2477"
],
"34331": [],
"34421": [
"CVE-2014-5119"
],
"34489": [],
"34512": [],
"34537": [
"CVE-2010-3073"
],
"34648": [],
"34822": [],
"34923": [
"CVE-2014-5207"
],
"34921": [
"CVE-2009-1324"
],
"34954": [
"CVE-2010-3039"
],
"34966": [],
"34967": [],
"34982": [
"CVE-2014-4971"
],
"34987": [
"CVE-2010-4158"
],
"35010": [
"CVE-2010-3830"
],
"35019": [
"CVE-2014-6352",
"CVE-2014-4114"
],
"35020": [
"CVE-2014-6352",
"CVE-2014-4114"
],
"35021": [
"CVE-2011-1485"
],
"35040": [
"CVE-2014-5507"
],
"35074": [],
"35077": [
"CVE-2014-8347"
],
"35101": [
"CVE-2014-4113"
],
"35112": [
"CVE-2013-5467"
],
"35161": [
"CVE-2012-0056"
],
"35177": [],
"35189": [],
"35216": [
"CVE-2014-6352",
"CVE-2014-4114"
],
"35234": [
"CVE-2014-5284"
],
"35235": [
"CVE-2014-6352",
"CVE-2014-4114"
],
"35236": [
"CVE-2014-6352",
"CVE-2014-4114"
],
"35322": [],
"35370": [
"CVE-2014-3153"
],
"35377": [
"CVE-2014-9448"
],
"35395": [
"CVE-2014-9113"
],
"35423": [
"CVE-2014-9141"
],
"35440": [
"CVE-2014-4404"
],
"35449": [
"CVE-2014-2973"
],
"35450": [],
"35472": [],
"35488": [
"CVE-2011-0180"
],
"35503": [
"CVE-2014-8386"
],
"35590": [],
"35595": [
"CVE-2014-7208"
],
"35661": [
"CVE-2015-0002"
],
"35671": [],
"35681": [
"CVE-2011-1760"
],
"35714": [],
"35712": [
"CVE-2014-2973"
],
"35711": [
"CVE-2014-4322"
],
"35732": [],
"35741": [],
"35742": [
"CVE-2014-8835"
],
"35746": [],
"35748": [],
"35749": [],
"35811": [
"CVE-2015-0004"
],
"35812": [],
"35813": [],
"35821": [
"CVE-2015-1171"
],
"35993": [
"CVE-2014-9632"
],
"35994": [
"CVE-2014-9642"
],
"35847": [
"CVE-2014-4492"
],
"35848": [],
"35850": [],
"35992": [
"CVE-2014-9643"
],
"35901": [
"CVE-2014-9597"
],
"35902": [
"CVE-2014-9598"
],
"35905": [
"CVE-2014-9633"
],
"35983": [
"CVE-2015-0016"
],
"35934": [
"CVE-2014-8826"
],
"35936": [
"CVE-2014-4076"
],
"35953": [
"CVE-2015-1305"
],
"35962": [
"CVE-2014-9641"
],
"35964": [
"CVE-2014-7286"
],
"36052": [
"CVE-2015-1515"
],
"36053": [],
"36062": [],
"36104": [
"CVE-2014-0980"
],
"36143": [],
"36188": [],
"36189": [],
"36207": [],
"36229": [],
"36257": [],
"36294": [],
"36296": [
"CVE-2011-4122"
],
"36310": [
"CVE-2015-0565"
],
"36311": [
"CVE-2015-3693",
"CVE-2015-0565"
],
"36327": [],
"36390": [
"CVE-2015-2789"
],
"36417": [],
"36424": [],
"36430": [
"CVE-2011-4834"
],
"36437": [
"CVE-2014-0980"
],
"36465": [
"CVE-2011-5165"
],
"36476": [],
"36501": [],
"36502": [
"CVE-2009-1646"
],
"36533": [],
"36747": [
"CVE-2015-3315",
"CVE-2015-1862"
],
"36564": [
"CVE-2015-1815"
],
"36571": [
"CVE-2012-0055"
],
"36739": [],
"36692": [
"CVE-2015-1130"
],
"36746": [
"CVE-2015-1862",
"CVE-2015-1318"
],
"36745": [
"CVE-2015-1130"
],
"36782": [
"CVE-2015-1318"
],
"36813": [
"CVE-2014-7951"
],
"36819": [],
"36820": [
"CVE-2015-3643"
],
"36822": [],
"36826": [
"CVE-2011-5165"
],
"36827": [
"CVE-2011-5165"
],
"36837": [],
"37065": [
"CVE-2014-7872"
],
"36855": [],
"36859": [
"CVE-2015-3632"
],
"36887": [
"CVE-2012-1096"
],
"36909": [],
"36920": [],
"36966": [
"CVE-2012-0943"
],
"36928": [],
"36980": [],
"36981": [],
"36982": [],
"37049": [
"CVE-2015-1701",
"CVE-2015-1680",
"CVE-2015-1679",
"CVE-2015-1678",
"CVE-2015-1677",
"CVE-2015-1676"
],
"37052": [
"CVE-2015-1674"
],
"37056": [
"CVE-2008-5753"
],
"37064": [
"CVE-2014-4113"
],
"37088": [
"CVE-2015-1325"
],
"37089": [
"CVE-2015-3202"
],
"37098": [
"CVE-2015-0060",
"CVE-2015-0059",
"CVE-2015-0058",
"CVE-2015-0057",
"CVE-2015-0010",
"CVE-2015-0003"
],
"37197": [],
"37167": [],
"37168": [],
"37183": [],
"37211": [],
"37212": [],
"37265": [
"CVE-2015-3222"
],
"37292": [
"CVE-2015-1328"
],
"37293": [
"CVE-2015-1328"
],
"37344": [],
"37367": [
"CVE-2015-1701"
],
"37535": [],
"40709": [
"CVE-2016-3053"
],
"37543": [
"CVE-2012-3430"
],
"37631": [
"CVE-2012-3480"
],
"37657": [
"CVE-2015-0097"
],
"37670": [],
"37699": [],
"37737": [],
"37825": [],
"37710": [
"CVE-2015-5602"
],
"37716": [],
"37722": [
"CVE-2015-3290"
],
"37724": [],
"37730": [],
"37732": [
"CVE-2013-5065"
],
"38106": [],
"38107": [],
"37755": [
"CVE-2014-4076"
],
"37760": [],
"37768": [
"CVE-2015-2370"
],
"37771": [],
"37772": [
"CVE-2015-4495"
],
"37780": [
"CVE-2012-1666"
],
"37799": [],
"37813": [],
"37937": [
"CVE-2012-0957"
],
"37890": [],
"37898": [],
"37925": [
"CVE-2015-4481"
],
"37964": [],
"37975": [],
"37987": [],
"37988": [],
"38035": [
"CVE-2015-7243"
],
"38036": [
"CVE-2015-3673"
],
"38087": [],
"38089": [],
"38136": [
"CVE-2015-5754"
],
"38137": [
"CVE-2015-5784"
],
"38095": [],
"38138": [
"CVE-2015-3704"
],
"38147": [],
"40975": [
"CVE-2013-6282"
],
"38185": [],
"38198": [
"CVE-2015-2508"
],
"38199": [
"CVE-2015-2527"
],
"38200": [
"CVE-2015-2525"
],
"38201": [
"CVE-2015-2528"
],
"38202": [
"CVE-2015-2524"
],
"38218": [],
"38219": [],
"38220": [],
"38222": [
"CVE-2015-2433",
"CVE-2015-2426"
],
"38232": [
"CVE-2013-0221"
],
"38243": [],
"38244": [],
"38287": [],
"38289": [
"CVE-2015-6305"
],
"38298": [],
"38299": [
"CVE-2012-6533"
],
"38303": [
"CVE-2015-6306"
],
"38447": [
"CVE-2015-7805"
],
"38319": [],
"38347": [],
"38349": [],
"38353": [
"CVE-2015-1338"
],
"38357": [],
"38360": [],
"38362": [],
"38371": [
"CVE-2015-5889"
],
"38381": [],
"38382": [],
"38390": [],
"38403": [
"CVE-2015-7358"
],
"38423": [],
"38456": [],
"38452": [],
"38467": [],
"38472": [],
"38473": [],
"38474": [
"CVE-2015-2553"
],
"38486": [],
"38504": [],
"38532": [],
"38533": [],
"38540": [
"CVE-2015-5889"
],
"38559": [
"CVE-2013-2852"
],
"38576": [
"CVE-2014-8904"
],
"38600": [],
"38601": [],
"38603": [],
"38609": [],
"38631": [],
"38668": [],
"38672": [
"CVE-2013-4147"
],
"38700": [],
"38704": [],
"38751": [
"CVE-2015-7422",
"CVE-2015-2023"
],
"38752": [
"CVE-2013-5701"
],
"38775": [
"CVE-2014-0476"
],
"38792": [
"CVE-2015-7865"
],
"38817": [
"CVE-2013-4474"
],
"38832": [
"CVE-2015-5287"
],
"38835": [
"CVE-2015-5287",
"CVE-2015-5273"
],
"38847": [
"CVE-2015-4027"
],
"38871": [],
"38903": [],
"38904": [],
"38937": [
"CVE-2013-6480"
],
"39010": [
"CVE-2015-8556"
],
"39035": [
"CVE-2015-0057"
],
"39061": [
"CVE-2014-1664"
],
"39112": [],
"39120": [],
"39121": [],
"39122": [],
"39132": [],
"39134": [
"CVE-2015-7556"
],
"39147": [
"CVE-2014-1322"
],
"39159": [],
"39166": [
"CVE-2015-8660"
],
"39207": [
"CVE-2014-3865"
],
"39214": [
"CVE-2014-1739"
],
"39217": [],
"39230": [
"CVE-2015-8660"
],
"39244": [],
"39260": [],
"39277": [
"CVE-2016-0728"
],
"40003": [
"CVE-2016-0728"
],
"39284": [],
"39285": [],
"40337": [],
"39310": [
"CVE-2016-0007"
],
"39311": [
"CVE-2016-0007",
"CVE-2016-0006"
],
"40360": [
"CVE-2016-6662"
],
"40774": [
"CVE-2016-8641"
],
"39340": [],
"39417": [],
"39432": [
"CVE-2016-0051"
],
"39433": [],
"39438": [],
"39442": [
"CVE-2016-0049"
],
"39443": [],
"39446": [
"CVE-2014-1767"
],
"39480": [],
"39508": [],
"39510": [],
"39520": [],
"39523": [],
"39525": [
"CVE-2014-1767"
],
"39531": [
"CVE-2016-3984",
"CVE-2016-4534"
],
"39535": [
"CVE-2016-1531"
],
"39549": [
"CVE-2016-1531"
],
"39574": [
"CVE-2016-0099"
],
"39579": [],
"39594": [],
"39595": [
"CVE-2016-1757"
],
"39628": [],
"39630": [
"CVE-2016-2288"
],
"39656": [
"CVE-2016-2087"
],
"39666": [
"CVE-2014-4113"
],
"39670": [
"CVE-2015-7378"
],
"39671": [
"CVE-2016-3943"
],
"39673": [],
"39674": [],
"39675": [
"CVE-2016-1743"
],
"39680": [],
"39692": [],
"39694": [
"CVE-2016-0122"
],
"39702": [
"CVE-2016-1531"
],
"39967": [
"CVE-2016-3643"
],
"39719": [
"CVE-2016-0099"
],
"39727": [],
"39734": [],
"39741": [
"CVE-2016-1757"
],
"39757": [
"CVE-2015-6639"
],
"39764": [],
"39769": [
"CVE-2016-4338"
],
"39771": [],
"39772": [
"CVE-2016-4557"
],
"39786": [],
"39788": [
"CVE-2016-0051"
],
"39791": [
"CVE-2016-3714"
],
"39803": [],
"39804": [],
"39809": [
"CVE-2016-0099"
],
"39810": [],
"39811": [],
"39814": [],
"39820": [],
"39843": [],
"42551": [],
"39845": [],
"39888": [
"CVE-2016-5237"
],
"39902": [],
"39903": [],
"39908": [],
"39916": [],
"39933": [
"CVE-2009-1330"
],
"39938": [],
"39954": [],
"40054": [],
"39980": [],
"39984": [],
"39992": [
"CVE-2016-1583"
],
"40017": [],
"40018": [],
"40020": [],
"40023": [],
"40025": [],
"40039": [
"CVE-2016-0400"
],
"40040": [],
"40049": [],
"40066": [],
"40069": [],
"40071": [],
"40072": [],
"40107": [
"CVE-2016-0099"
],
"40145": [],
"40118": [
"CVE-2016-0189"
],
"40132": [],
"40141": [
"CVE-2016-6253"
],
"40148": [],
"40151": [],
"40164": [
"CVE-2013-1406"
],
"42550": [],
"40169": [
"CVE-2013-1662"
],
"40172": [],
"40173": [],
"40203": [],
"40219": [
"CVE-2016-3223"
],
"40224": [
"CVE-2016-3313"
],
"40226": [],
"40268": [],
"40270": [
"CVE-2016-7089"
],
"40271": [
"CVE-2016-6367"
],
"40322": [],
"40323": [],
"40330": [],
"40438": [],
"40442": [],
"40443": [],
"40450": [
"CVE-2016-1240"
],
"40451": [],
"40460": [],
"40461": [],
"40471": [],
"40473": [],
"40539": [],
"40477": [],
"40478": [],
"40482": [],
"40483": [],
"40484": [],
"40485": [],
"40488": [
"CVE-2016-5425"
],
"40489": [
"CVE-2016-4997"
],
"40490": [],
"40494": [],
"40497": [],
"40564": [
"CVE-2011-1249"
],
"40503": [
"CVE-2014-0038"
],
"40504": [],
"40523": [],
"40525": [],
"40528": [],
"40533": [],
"40535": [],
"43799": [],
"43816": [
"CVE-2004-1569"
],
"43817": [
"CVE-2004-1417"
],
"43857": [
"CVE-2017-14355"
],
"43875": [
"CVE-2017-7310"
],
"43878": [
"CVE-2018-2698"
],
"43879": [],
"43887": [
"CVE-2014-8147",
"CVE-2014-8146"
],
"40538": [],
"40540": [],
"40541": [],
"40550": [],
"40562": [
"CVE-2016-7188"
],
"40567": [],
"40572": [
"CVE-2016-7185"
],
"40573": [
"CVE-2016-0075"
],
"40574": [
"CVE-2016-0073"
],
"40577": [],
"40578": [],
"40579": [],
"40580": [],
"40581": [],
"40582": [],
"40585": [],
"40583": [],
"40586": [],
"40587": [],
"40588": [],
"40606": [
"CVE-2016-3388"
],
"40607": [
"CVE-2016-3387"
],
"40608": [
"CVE-2016-0079"
],
"40611": [
"CVE-2016-5195"
],
"40616": [
"CVE-2016-5195"
],
"40627": [
"CVE-2011-1974"
],
"40630": [],
"40634": [],
"40636": [],
"40653": [
"CVE-2016-4625"
],
"40655": [
"CVE-2016-7384"
],
"40660": [
"CVE-2016-8812"
],
"40669": [
"CVE-2016-4625"
],
"40678": [
"CVE-2016-6663",
"CVE-2016-5616"
],
"40686": [
"CVE-2016-9111"
],
"40688": [
"CVE-2015-1328",
"CVE-2015-8660"
],
"40679": [
"CVE-2016-6664",
"CVE-2016-5617"
],
"40710": [
"CVE-2016-6079"
],
"40838": [
"CVE-2016-5195"
],
"40759": [
"CVE-2016-4557"
],
"40741": [],
"40765": [
"CVE-2016-7224"
],
"40788": [
"CVE-2016-9151"
],
"40789": [
"CVE-2016-9151"
],
"40807": [
"CVE-2016-8769"
],
"40810": [
"CVE-2010-0415"
],
"40811": [],
"40812": [
"CVE-2009-3547"
],
"40839": [
"CVE-2016-5195"
],
"40847": [
"CVE-2016-5195"
],
"40848": [],
"40859": [],
"40860": [],
"40861": [],
"40863": [],
"40864": [],
"40865": [
"CVE-2016-8742"
],
"40871": [
"CVE-2016-8655"
],
"40873": [],
"40902": [],
"40903": [],
"40921": [
"CVE-2016-9566"
],
"40931": [
"CVE-2016-7661",
"CVE-2016-7644",
"CVE-2016-7637"
],
"40937": [
"CVE-2016-9951",
"CVE-2016-9950",
"CVE-2016-9949"
],
"40938": [
"CVE-2014-6271"
],
"40943": [],
"40950": [
"CVE-2016-8972"
],
"40953": [],
"40956": [
"CVE-2016-7621"
],
"40957": [
"CVE-2016-7637"
],
"40962": [
"CVE-2016-10010"
],
"40967": [
"CVE-2016-10031"
],
"40995": [],
"41015": [
"CVE-2016-7255"
],
"41020": [],
"41021": [],
"41022": [],
"41076": [],
"41090": [],
"41130": [],
"41144": [],
"41149": [],
"41152": [],
"41154": [],
"41158": [
"CVE-2015-1336"
],
"41171": [
"CVE-2016-10156"
],
"41173": [
"CVE-2015-6565"
],
"41176": [
"CVE-2017-5329"
],
"41196": [
"CVE-2017-3316"
],
"41207": [],
"41217": [],
"41221": [],
"41240": [
"CVE-2017-0358"
],
"41265": [],
"41320": [],
"41321": [],
"41349": [],
"41356": [
"CVE-2017-0358"
],
"41435": [
"CVE-2016-10081"
],
"41458": [
"CVE-2017-6074"
],
"41476": [
"CVE-2017-3813"
],
"41538": [],
"41542": [
"CVE-2017-6178"
],
"41597": [],
"41605": [],
"41607": [
"CVE-2017-0100"
],
"41619": [
"CVE-2017-0045"
],
"43359": [
"CVE-2017-5180"
],
"43366": [],
"43390": [
"CVE-2016-6914"
],
"43397": [],
"43418": [
"CVE-2017-10001"
],
"43421": [],
"43427": [
"CVE-2017-5753",
"CVE-2017-5715"
],
"43449": [],
"43465": [],
"43494": [
"CVE-2018-5189"
],
"43499": [
"CVE-2017-18016"
],
"43500": [
"CVE-2016-0772"
],
"43775": [
"CVE-2018-10000"
],
"43925": [
"CVE-2017-16928"
],
"43926": [
"CVE-2017-16945"
],
"43929": [
"CVE-2018-5701"
],
"43935": [
"CVE-2017-18078"
],
"43962": [
"CVE-2018-0743"
],
"43971": [
"CVE-2015-1318"
],
"43973": [
"CVE-2018-6593"
],
"43979": [],
"43987": [
"CVE-2018-6606"
],
"44006": [],
"44023": [
"CVE-2017-9232"
],
"44024": [
"CVE-2010-3847"
],
"44025": [
"CVE-2010-3856",
"CVE-2010-3847"
],
"44042": [
"CVE-2018-6460"
],
"44217": [],
"44049": [
"CVE-2017-16939"
],
"44063": [
"CVE-2017-7950",
"CVE-2017-2796"
],
"44064": [
"CVE-2017-10803"
],
"44066": [
"CVE-2017-11657"
],
"44097": [
"CVE-2015-3315"
],
"41675": [
"CVE-2012-6636",
"CVE-2013-4710"
],
"41683": [
"CVE-2013-0758",
"CVE-2013-0757"
],
"41700": [
"CVE-2010-1423",
"CVE-2010-0886"
],
"41701": [
"CVE-2014-4936"
],
"41702": [
"CVE-2013-0074",
"CVE-2013-3896"
],
"41704": [
"CVE-2011-0647"
],
"41706": [
"CVE-2016-3235",
"CVE-2016-0100",
"CVE-2016-0041",
"CVE-2015-6133",
"CVE-2015-6132",
"CVE-2015-6128"
],
"41707": [
"CVE-2011-3011"
],
"41708": [
"CVE-2015-2219"
],
"41709": [
"CVE-2013-2492"
],
"41710": [
"CVE-2012-3274"
],
"41711": [
"CVE-2016-5330"
],
"41712": [
"CVE-2012-4705"
],
"42555": [
"CVE-2017-6999",
"CVE-2017-6998",
"CVE-2017-6997",
"CVE-2017-6996",
"CVE-2017-6995",
"CVE-2017-6994",
"CVE-2017-6989",
"CVE-2017-6979"
],
"41887": [],
"42305": [
"CVE-2017-6970"
],
"41886": [
"CVE-2017-7874"
],
"41721": [
"CVE-2015-5736"
],
"41722": [
"CVE-2015-5736"
],
"41745": [
"CVE-2017-5227"
],
"41754": [
"CVE-2017-5671"
],
"41760": [
"CVE-2016-2856"
],
"41761": [
"CVE-2016-2854",
"CVE-2016-2853"
],
"41762": [
"CVE-2016-1575"
],
"41763": [
"CVE-2016-1576"
],
"41764": [
"CVE-2016-0727"
],
"41765": [
"CVE-2015-2285"
],
"41766": [],
"41770": [
"CVE-2011-1020"
],
"41771": [],
"41772": [],
"41773": [
"CVE-2017-7310"
],
"42087": [],
"41853": [],
"41854": [
"CVE-2017-7643"
],
"41870": [
"CVE-2017-7228"
],
"41871": [],
"41873": [],
"41875": [],
"41878": [
"CVE-2017-3006"
],
"42548": [],
"41901": [
"CVE-2017-0165"
],
"41902": [
"CVE-2017-0211"
],
"41904": [
"CVE-2017-3558"
],
"41907": [
"CVE-2017-3576"
],
"41908": [
"CVE-2017-3563"
],
"41917": [],
"41923": [
"CVE-2017-7358",
"CVE-2017-7358&"
],
"41933": [
"CVE-2017-7293"
],
"41951": [],
"41952": [],
"41955": [
"CVE-2017-8291"
],
"41959": [],
"41972": [
"CVE-2017-6953"
],
"41971": [
"CVE-2017-8869"
],
"41973": [],
"41994": [
"CVE-2017-7308"
],
"41995": [
"CVE-2016-9793"
],
"41999": [
"CVE-2016-2384"
],
"42000": [
"CVE-2017-8918"
],
"42020": [
"CVE-2017-0213"
],
"42045": [
"CVE-2017-4915"
],
"42053": [
"CVE-2017-8849",
"CVE-2017-8422"
],
"42059": [],
"42076": [],
"42077": [],
"42116": [],
"42119": [
"CVE-2017-9355"
],
"42121": [
"CVE-2017-3141"
],
"42141": [
"CVE-2017-7180"
],
"42142": [],
"42145": [
"CVE-2017-7004"
],
"42146": [
"CVE-2017-2533"
],
"42157": [],
"42160": [],
"42161": [],
"42163": [],
"42174": [],
"42181": [],
"42183": [
"CVE-2017-10003"
],
"42255": [],
"42265": [],
"42267": [],
"42270": [
"CVE-2017-3631",
"CVE-2017-3630",
"CVE-2017-3629"
],
"42271": [
"CVE-2017-10003"
],
"42273": [
"CVE-2017-10003"
],
"42274": [
"CVE-2017-10003"
],
"42275": [
"CVE-2017-10003"
],
"42276": [
"CVE-2017-10003"
],
"42542": [
"CVE-2017-9644"
],
"42310": [],
"42319": [
"CVE-2017-11197"
],
"42325": [],
"42334": [
"CVE-2017-7642"
],
"42356": [],
"42357": [],
"42368": [
"CVE-2017-9769"
],
"42382": [
"CVE-2017-8464"
],
"42549": [],
"42385": [
"CVE-2017-8870"
],
"42407": [
"CVE-2017-7047"
],
"42418": [
"CVE-2017-7442"
],
"42424": [
"CVE-2017-9430"
],
"42425": [
"CVE-2017-10204"
],
"42426": [
"CVE-2017-10129"
],
"42429": [
"CVE-2017-8464"
],
"42432": [],
"42435": [],
"42454": [
"CVE-2017-8665"
],
"42455": [],
"42456": [],
"42460": [
"CVE-2017-12763"
],
"42521": [],
"42536": [],
"42537": [
"CVE-2017-13056"
],
"42538": [],
"42539": [],
"42540": [],
"42565": [],
"42567": [],
"42568": [],
"42586": [],
"42601": [
"CVE-2016-10277"
],
"42605": [
"CVE-2015-0179"
],
"42611": [
"CVE-2017-0901"
],
"42612": [],
"42624": [
"CVE-2017-14153"
],
"42625": [
"CVE-2017-14075"
],
"42626": [],
"42665": [
"CVE-2017-14344"
],
"42718": [],
"42735": [
"CVE-2017-14311"
],
"42777": [
"CVE-2017-14627"
],
"42887": [
"CVE-2017-10002"
],
"42890": [],
"42918": [],
"42921": [],
"42930": [],
"42936": [
"CVE-2017-11322"
],
"42937": [
"CVE-2017-11321"
],
"42948": [],
"42951": [],
"42960": [
"CVE-2016-3309"
],
"42963": [
"CVE-2017-15083"
],
"42974": [
"CVE-2017-15221"
],
"43006": [],
"43007": [],
"43017": [],
"43029": [
"CVE-2017-5123"
],
"43033": [],
"43057": [
"CVE-2017-6008"
],
"43104": [],
"43109": [
"CVE-2017-16237"
],
"43127": [
"CVE-2017-5123"
],
"43134": [
"CVE-2017-6331"
],
"43139": [
"CVE-2017-14961"
],
"43156": [],
"43162": [
"CVE-2017-11830"
],
"43179": [],
"43187": [
"CVE-2017-9095"
],
"43192": [],
"43201": [
"CVE-2017-13872"
],
"43216": [
"CVE-2017-16895"
],
"43217": [],
"43218": [
"CVE-2017-15357"
],
"43219": [
"CVE-2017-16777"
],
"43220": [
"CVE-2017-16001"
],
"43221": [
"CVE-2017-15918"
],
"43222": [
"CVE-2017-15884"
],
"43223": [
"CVE-2017-12579"
],
"43224": [
"CVE-2017-11741"
],
"43225": [
"CVE-2017-7690"
],
"43247": [],
"43248": [
"CVE-2017-13872"
],
"43331": [
"CVE-2017-10004"
],
"43345": [
"CVE-2017-10661"
],
"44147": [
"CVE-2018-0822"
],
"44148": [
"CVE-2018-0823"
],
"44149": [
"CVE-2018-0821"
],
"44150": [
"CVE-2017-6516"
],
"44152": [
"CVE-2018-0826"
],
"44167": [
"CVE-2018-6947"
],
"44168": [
"CVE-2018-6947"
],
"44169": [
"CVE-2018-7289"
],
"45568": [
"CVE-2018-17775"
],
"44177": [],
"44218": [],
"44198": [],
"44199": [],
"44200": [
"CVE-cve 2014-1"
],
"44204": [
"CVE-2014-1303"
],
"44205": [
"CVE-2014-9322"
],
"44206": [],
"44224": [],
"38457": [],
"44234": [
"CVE-2017-13868"
],
"44237": [
"CVE-2016-7617",
"CVE-2016-1825"
],
"44239": [
"CVE-2016-1828"
],
"44243": [],
"44244": [],
"44246": [],
"44263": [
"CVE-2017-8570"
],
"44266": [
"CVE-2017-5415"
],
"44267": [],
"44269": [],
"44270": [
"CVE-2018-7581"
],
"44279": [],
"44282": [],
"44298": [
"CVE-2017-16995"
],
"44299": [
"CVE-2013-1763"
],
"44300": [],
"44302": [
"CVE-2017-7533"
],
"44303": [
"CVE-2017-16994"
],
"44306": [
"CVE-2015-8088"
],
"44307": [
"CVE-2018-6084"
],
"44313": [
"CVE-2018-0877"
],
"44314": [
"CVE-2018-0880"
],
"44315": [
"CVE-2018-0882"
],
"44325": [
"CVE-2018-7273"
],
"44330": [],
"44331": [],
"44337": [],
"44341": [],
"44342": [],
"44363": [],
"44364": [],
"44365": [],
"44382": [],
"44389": [],
"44410": [
"CVE-2018-4863"
],
"44411": [
"CVE-2018-9233"
],
"44422": [],
"44423": [],
"44426": [],
"44438": [
"CVE-2018-9128"
],
"44452": [
"CVE-2018-0492"
],
"44455": [],
"44470": [
"CVE-2018-7886"
],
"44472": [
"CVE-2013-5019"
],
"44474": [
"CVE-2017-18256"
],
"44475": [
"CVE-2016-10718"
],
"44476": [
"CVE-2018-6546"
],
"44477": [
"CVE-2018-9131"
],
"44478": [
"CVE-2017-0263"
],
"44479": [
"CVE-2017-0101"
],
"44480": [
"CVE-2016-0165"
],
"44499": [],
"44516": [],
"44518": [],
"44523": [],
"44549": [],
"44564": [
"CVE-2018-10583"
],
"44565": [],
"44573": [],
"44581": [
"CVE-2018-1038"
],
"44586": [
"CVE-2016-0040"
],
"44590": [
"CVE-2018-10655"
],
"44601": [
"CVE-2018-0494"
],
"44603": [],
"44614": [
"CVE-2018-1185"
],
"45565": [],
"44630": [
"CVE-2018-8134"
],
"44633": [
"CVE-2015-3246",
"CVE-2015-3245"
],
"44644": [],
"44649": [],
"44652": [
"CVE-2018-1111"
],
"44654": [
"CVE-2017-7308"
],
"45159": [],
"44658": [],
"44677": [
"CVE-2010-3904"
],
"44680": [],
"44688": [],
"44690": [
"CVE-2018-11242"
],
"44696": [
"CVE-2016-8655"
],
"44697": [
"CVE-2018-8897"
],
"46070": [
"CVE-2017-15222"
],
"44713": [],
"44741": [
"CVE-2018-8174"
],
"44742": [
"CVE-2015-5112"
],
"44743": [
"CVE-2015-2419"
],
"44744": [
"CVE-2018-4878"
],
"44745": [
"CVE-2018-4878"
],
"44776": [
"CVE-2018-11505"
],
"44787": [],
"44797": [],
"44798": [],
"44806": [
"CVE-2018-1124",
"CVE-2018-1123",
"CVE-2018-1122",
"CVE-2018-1121",
"CVE-2018-1120"
],
"44818": [],
"44819": [],
"44820": [],
"44828": [
"CVE-2018-16302"
],
"44830": [],
"44834": [],
"44838": [],
"44840": [],
"44841": [],
"44842": [
"CVE-2018-11646"
],
"44899": [
"CVE-2018-11652"
],
"41705": [],
"44852": [],
"44858": [
"CVE-2018-10507"
],
"44888": [
"CVE-2018-0982"
],
"44889": [
"CVE-2018-10000"
],
"44892": [
"CVE-2018-10619"
],
"44896": [],
"44900": [
"CVE-2018-12292"
],
"44903": [],
"44904": [
"CVE-2018-12326"
],
"44906": [
"CVE-2018-0824"
],
"44920": [
"CVE-2018-1235"
],
"44961": [],
"44971": [
"CVE-2015-7243"
],
"44979": [],
"44983": [
"CVE-2018-13108"
],
"44984": [
"CVE-2018-13110"
],
"44989": [],
"45009": [],
"45010": [
"CVE-2017-16995"
],
"45024": [
"CVE-2018-8897"
],
"45026": [],
"45041": [],
"45048": [
"CVE-2018-4192"
],
"45058": [
"CVE-2017-16995"
],
"45071": [],
"45072": [],
"45126": [
"CVE-2018-2892"
],
"45085": [],
"45086": [],
"45089": [
"CVE-2018-14533"
],
"45339": [
"CVE-2018-0438",
"CVE-2018-0437"
],
"45101": [],
"45120": [],
"45107": [
"CVE-2017-15358"
],
"45137": [],
"45130": [],
"45132": [],
"45142": [],
"45147": [
"CVE-2017-10001"
],
"45149": [
"CVE-2015-5736",
"CVE-2015-4077"
],
"45151": [],
"45163": [],
"45165": [],
"45166": [],
"45171": [],
"45175": [
"CVE-2017-18344"
],
"45176": [],
"45181": [],
"45184": [
"CVE-2017-14798"
],
"45192": [
"CVE-2018-9445"
],
"45194": [],
"45205": [
"CVE-2018-12293"
],
"45235": [],
"45243": [],
"45244": [
"CVE-2018-0952"
],
"45250": [],
"45259": [],
"45269": [
"CVE-2018-9958",
"CVE-2018-9948"
],
"45280": [],
"45288": [],
"45289": [],
"45312": [],
"45313": [
"CVE-2018-10900"
],
"45325": [],
"45346": [],
"45349": [],
"45350": [],
"45352": [],
"45353": [],
"45354": [],
"45355": [],
"45356": [],
"45369": [
"CVE-2018-16509"
],
"45372": [],
"45378": [],
"45379": [
"CVE-2018-9488"
],
"45395": [],
"45401": [],
"45402": [],
"45403": [
"CVE-2019-9766"
],
"45406": [],
"45407": [],
"45412": [
"CVE-2019-9767"
],
"45433": [
"CVE-2006-4842"
],
"45442": [],
"45467": [],
"45479": [
"CVE-2017-3622"
],
"45492": [],
"45497": [
"CVE-2018-17182"
],
"45501": [
"CVE-2018-14327"
],
"45503": [
"CVE-2018-17776"
],
"45504": [],
"45505": [
"CVE-2018-17408"
],
"45516": [
"CVE-2018-14634"
],
"45528": [
"CVE-2018-17793"
],
"45531": [],
"45548": [
"CVE-2018-17456"
],
"45553": [
"CVE-2017-11176"
],
"45560": [
"CVE-2018-17408"
],
"45562": [
"CVE-2016-3225"
],
"45573": [
"CVE-2018-17961"
],
"45575": [
"CVE-2014-2533"
],
"45583": [
"CVE-2018-8533"
],
"45585": [
"CVE-2018-8527"
],
"45587": [
"CVE-2018-8532"
],
"45598": [],
"45625": [
"CVE-2017-3630",
"CVE-2017-3629",
"CVE-2017-10003",
"CVE-2017-3631"
],
"45626": [
"CVE-2018-11529"
],
"45627": [],
"45631": [
"CVE-2018-17456"
],
"45496": [],
"45653": [
"CVE-2018-8120"
],
"45660": [],
"45675": [],
"45687": [
"CVE-2018-19459"
],
"45696": [
"CVE-2018-15442"
],
"45697": [
"CVE-2018-14665"
],
"45709": [],
"45710": [],
"45715": [
"CVE-2018-15687"
],
"45738": [],
"45742": [
"CVE-2018-14665"
],
"45744": [],
"45765": [],
"45778": [],
"45782": [
"CVE-2018-18859",
"CVE-2018-18858",
"CVE-2018-18857",
"CVE-2018-18856"
],
"45785": [
"CVE-2018-5407"
],
"45796": [],
"45798": [
"CVE-2018-18957"
],
"45804": [
"CVE-2016-7567"
],
"45805": [],
"45828": [],
"45832": [
"CVE-2018-14665"
],
"45846": [
"CVE-2018-7182"
],
"45854": [
"CVE-2018-18860"
],
"45865": [],
"45866": [
"CVE-2017-7089"
],
"45867": [
"CVE-2017-5124"
],
"45886": [
"CVE-2018-18955"
],
"45888": [],
"45890": [
"CVE-2018-16323"
],
"45893": [
"CVE-2018-8550"
],
"45907": [],
"45908": [
"CVE-2018-14665"
],
"45913": [
"CVE-2018-6329"
],
"45915": [
"CVE-2018-18955"
],
"45916": [
"CVE-2018-4237"
],
"45921": [],
"45922": [
"CVE-2018-14665",
"CVE-2006-0745"
],
"45938": [
"CVE-2018-14665"
],
"45953": [],
"45960": [
"CVE-2018-4435"
],
"45961": [
"CVE-2018-6757",
"CVE-2018-6756",
"CVE-2018-6755"
],
"45985": [
"CVE-2017-14627"
],
"45988": [],
"46005": [],
"46006": [
"CVE-2016-4486"
],
"46008": [],
"46009": [],
"46016": [],
"46018": [],
"46020": [],
"46021": [],
"46025": [],
"46028": [],
"46040": [],
"46044": [
"CVE-2018-18629"
],
"46051": [
"CVE-2018-15982"
],
"46056": [],
"46058": [],
"46059": [],
"46093": [
"CVE-2018-18435"
],
"46098": [],
"46104": [
"CVE-2018-8584"
],
"46107": [],
"46120": [],
"46142": [
"CVE-2018-14665"
],
"46155": [
"CVE-2018-5410"
],
"46156": [
"CVE-2019-0543"
],
"46157": [
"CVE-2019-0572"
],
"46158": [
"CVE-2019-0573"
],
"46159": [
"CVE-2019-0571"
],
"46160": [
"CVE-2019-0574"
],
"46161": [
"CVE-2019-0566"
],
"46162": [
"CVE-2019-0552"
],
"46167": [],
"46185": [
"CVE-2019-0555"
],
"46186": [
"CVE-2015-8612"
],
"46188": [],
"46189": [],
"46222": [],
"46241": [],
"46249": [],
"46255": [],
"46265": [],
"46267": [],
"46269": [],
"46279": [],
"46283": [],
"46288": [],
"46290": [],
"46301": [],
"46331": [],
"46334": [],
"46335": [],
"46341": [
"CVE-2017-10000"
],
"46345": [],
"46346": [],
"46359": [
"CVE-2019-5736"
],
"46361": [
"CVE-2019-7304"
],
"46362": [
"CVE-2019-7304"
],
"46370": [],
"46441": [],
"46369": [
"CVE-2019-5736"
],
"46416": [],
"46428": [
"CVE-2018-4193"
],
"46479": [
"CVE-2019-1674"
],
"46437": [],
"46507": [],
"46508": [
"CVE-2012-0217"
],
"46522": [
"CVE-2018-4441"
],
"46530": [],
"46536": [
"CVE-2019-0541"
],
"46552": [
"CVE-2018-20250"
],
"46561": [],
"46578": [],
"46584": [
"CVE-2018-9128"
],
"46596": [],
"46600": [
"CVE-2018-5511"
],
"46601": [
"CVE-2019-5512"
],
"46625": [],
"46636": [],
"46657": [
"CVE-2019-10843"
],
"46660": [],
"46665": [],
"46668": [],
"46670": [],
"46673": [],
"46676": [
"CVE-2019-0211"
],
"46683": [
"CVE-2019-0841"
],
"46685": [],
"46686": [],
"46688": [
"CVE-2018-14894"
],
"46690": [],
"46692": [],
"46724": [
"CVE-2019-10038"
],
"46707": [
"CVE-2018-19374"
],
"46712": [
"CVE-2019-0735"
],
"46713": [
"CVE-2019-0730"
],
"46714": [
"CVE-2019-0731"
],
"46715": [
"CVE-2019-0796"
],
"46716": [
"CVE-2019-0732"
],
"46717": [
"CVE-2019-0805"
],
"46718": [
"CVE-2019-0836"
],
"46727": [
"CVE-2018-16858"
],
"46730": [
"CVE-2010-4170"
],
"46737": [],
"46742": [],
"46747": [
"CVE-2019-2721"
],
"46755": [],
"46756": [
"CVE-2018-20250"
],
"46779": [
"CVE-2019-11563"
],
"1": [
"CVE-2003-0109"
],
"2": [
"CVE-2003-0109"
],
"5": [
"CVE-2003-0003"
],
"7": [
"CVE-2003-0201"
],
"8": [
"CVE-2003-1118"
],
"10": [
"CVE-2003-0201"
],
"16": [
"CVE-2003-0213"
],
"18": [
"CVE-2003-0209"
],
"19": [
"CVE-2003-0213"
],
"20": [
"CVE-2008-4037"
],
"23": [
"CVE-2002-1643"
],
"24": [
"CVE-2003-0161"
],
"25": [
"CVE-2003-0190"
],
"26": [
"CVE-2003-0190"
],
"27": [
"CVE-2003-1481"
],
"28": [
"CVE-2003-0220"
],
"30": [
"CVE-2004-2720"
],
"33": [
"CVE-2003-0339"
],
"34": [],
"36": [
"CVE-2003-0109"
],
"37": [
"CVE-2003-0344"
],
"39": [
"CVE-2003-0380"
],
"41": [
"CVE-2003-0437"
],
"42": [
"CVE-2003-0391"
],
"43": [
"CVE-2003-0500"
],
"45": [
"CVE-2002-0031"
],
"46": [
"CVE-2003-0487"
],
"48": [
"CVE-2003-0349"
],
"49": [
"CVE-2001-1078"
],
"50": [],
"51": [
"CVE-2003-0109"
],
"54": [
"CVE-2003-0558"
],
"55": [
"CVE-2003-0201"
],
"56": [
"CVE-2003-0227"
],
"57": [
"CVE-2001-0797"
],
"58": [],
"63": [],
"64": [
"CVE-2003-0605"
],
"66": [
"CVE-2003-0605"
],
"67": [
"CVE-2003-0651"
],
"69": [
"CVE-2003-0605"
],
"70": [
"CVE-2003-0605"
],
"74": [
"CVE-2003-0466"
],
"76": [
"CVE-2003-0605"
],
"77": [
"CVE-2003-0647"
],
"78": [
"CVE-2003-0466"
],
"80": [
"CVE-2003-0727"
],
"81": [],
"83": [
"CVE-2003-0701"
],
"84": [],
"86": [
"CVE-2003-0725"
],
"88": [
"CVE-2003-0755"
],
"89": [
"CVE-2003-0686"
],
"90": [],
"92": [
"CVE-2003-0666"
],
"95": [
"CVE-2003-0767"
],
"96": [],
"97": [
"CVE-2003-0605"
],
"98": [
"CVE-2003-0780"
],
"99": [
"CVE-2003-0720"
],
"100": [
"CVE-2003-0352"
],
"101": [
"CVE-2003-0722"
],
"102": [
"CVE-2005-0491"
],
"103": [
"CVE-2003-0605"
],
"105": [
"CVE-2003-0849"
],
"107": [
"CVE-2003-0831"
],
"109": [
"CVE-2003-0605"
],
"110": [
"CVE-2003-0831"
],
"112": [
"CVE-2003-1336"
],
"116": [
"CVE-2003-1142"
],
"117": [
"CVE-2003-0605"
],
"119": [
"CVE-2003-0812"
],
"121": [
"CVE-2003-0822"
],
"123": [
"CVE-2003-0812"
],
"124": [
"CVE-2003-1192"
],
"126": [
"CVE-2003-0842"
],
"127": [],
"130": [
"CVE-2003-0812"
],
"132": [],
"133": [
"CVE-2003-1339"
],
"135": [
"CVE-2003-0717"
],
"136": [
"CVE-2003-1339"
],
"139": [],
"143": [
"CVE-2003-0963"
],
"149": [
"CVE-2004-2111"
],
"151": [
"CVE-2003-1026"
],
"155": [
"CVE-2004-0326"
],
"156": [
"CVE-2004-0313"
],
"157": [
"CVE-2004-0297"
],
"158": [
"CVE-2004-0330"
],
"159": [
"CVE-2004-0340"
],
"163": [
"CVE-2004-1521"
],
"164": [
"CVE-2004-2719"
],
"165": [
"CVE-2004-1883"
],
"166": [
"CVE-2004-1868"
],
"167": [
"CVE-2004-0176"
],
"168": [
"CVE-2004-0362"
],
"169": [],
"171": [
"CVE-2004-0184"
],
"173": [
"CVE-2003-1083"
],
"174": [
"CVE-2004-1897"
],
"175": [
"CVE-2004-1892"
],
"181": [],
"189": [
"CVE-2000-0884"
],
"190": [
"CVE-2000-0884"
],
"191": [
"CVE-2000-0884"
],
"192": [
"CVE-2000-0884"
],
"201": [
"CVE-2000-0573"
],
"204": [],
"208": [],
"211": [
"CVE-2000-1186"
],
"213": [
"CVE-1999-0977"
],
"220": [
"CVE-2000-0967"
],
"225": [],
"226": [
"CVE-2000-0917"
],
"227": [
"CVE-2000-0917"
],
"228": [
"CVE-2001-0029"
],
"230": [
"CVE-2000-0917"
],
"232": [],
"234": [
"CVE-2001-0053"
],
"237": [],
"239": [
"CVE-2000-0573"
],
"253": [
"CVE-2000-0284"
],
"254": [],
"263": [
"CVE-1999-0744"
],
"266": [
"CVE-2001-0241"
],
"268": [
"CVE-2001-0241"
],
"269": [
"CVE-2000-0573"
],
"275": [
"CVE-2003-0719"
],
"277": [
"CVE-2001-0010"
],
"279": [
"CVE-2001-0010"
],
"280": [
"CVE-2001-0010"
],
"282": [
"CVE-2001-0010"
],
"284": [
"CVE-2000-0284"
],
"293": [
"CVE-2003-0533"
],
"294": [],
"295": [
"CVE-2003-0533"
],
"296": [
"CVE-2004-0409"
],
"297": [],
"300": [
"CVE-2004-0396"
],
"301": [
"CVE-2004-0396"
],
"303": [
"CVE-2004-2043"
],
"304": [
"CVE-2004-0397"
],
"307": [
"CVE-2004-0393"
],
"308": [
"CVE-2004-0659"
],
"310": [
"CVE-2004-2291"
],
"311": [
"CVE-2004-0627"
],
"313": [],
"315": [],
"316": [
"CVE-2004-0549"
],
"340": [
"CVE-1999-0042"
],
"346": [
"CVE-2001-0797"
],
"347": [
"CVE-2002-0163"
],
"348": [
"CVE-2001-0550"
],
"349": [
"CVE-2001-0144"
],
"359": [],
"361": [
"CVE-2004-1783"
],
"364": [
"CVE-2004-0600"
],
"372": [
"CVE-2004-2523"
],
"373": [
"CVE-2004-2523"
],
"378": [
"CVE-2004-1439"
],
"379": [
"CVE-2004-1456"
],
"380": [
"CVE-2004-1437"
],
"382": [
"CVE-2002-1351"
],
"386": [
"CVE-2004-1475"
],
"387": [],
"389": [
"CVE-2004-0597"
],
"390": [
"CVE-2004-1717"
],
"391": [
"CVE-2004-0430"
],
"392": [
"CVE-2004-0416"
],
"397": [
"CVE-2000-0284"
],
"398": [
"CVE-2002-0048"
],
"399": [
"CVE-2002-0048"
],
"400": [
"CVE-2004-1717"
],
"404": [
"CVE-2004-2263"
],
"408": [
"CVE-2004-0691"
],
"409": [
"CVE-2001-0093"
],
"413": [
"CVE-2004-1741"
],
"416": [],
"418": [
"CVE-2004-0820"
],
"421": [
"CVE-2004-1752"
],
"424": [
"CVE-2004-1705"
],
"425": [
"CVE-2004-1650"
],
"426": [
"CVE-2004-1641"
],
"431": [
"CVE-2004-0636"
],
"432": [
"CVE-2004-0777"
],
"435": [
"CVE-2004-1666"
],
"437": [
"CVE-2004-1705"
],
"439": [
"CVE-2004-1439"
],
"472": [
"CVE-2004-0200"
],
"473": [
"CVE-2004-1546"
],
"475": [
"CVE-2004-0200"
],
"478": [
"CVE-2004-0200"
],
"480": [
"CVE-2004-0200"
],
"556": [
"CVE-2004-0200"
],
"566": [
"CVE-2004-0798"
],
"568": [
"CVE-2004-1561"
],
"572": [],
"573": [
"CVE-2004-1561"
],
"577": [
"CVE-2004-1558"
],
"580": [
"CVE-2004-1898"
],
"581": [
"CVE-2004-1602"
],
"582": [
"CVE-2004-1558"
],
"583": [
"CVE-2004-1612"
],
"584": [
"CVE-2004-0209"
],
"588": [
"CVE-2004-1626"
],
"589": [
"CVE-2004-1381",
"CVE-2004-1380"
],
"590": [
"CVE-2004-1595"
],
"592": [
"CVE-2004-1627"
],
"598": [
"CVE-2004-1638"
],
"608": [
"CVE-2004-1636"
],
"609": [
"CVE-2004-1095"
],
"612": [
"CVE-2004-1050"
],
"616": [
"CVE-2004-2271"
],
"618": [
"CVE-2004-1626"
],
"619": [
"CVE-2004-2416"
],
"620": [
"CVE-2004-2677"
],
"621": [
"CVE-2004-2685"
],
"623": [
"CVE-2004-2418"
],
"627": [
"CVE-2004-1520"
],
"636": [
"CVE-2004-2271"
],
"637": [
"CVE-2004-1638"
],
"638": [
"CVE-2003-0264"
],
"640": [
"CVE-2004-0575"
],
"641": [
"CVE-2001-0875"
],
"644": [
"CVE-2004-1533"
],
"650": [
"CVE-2004-1118"
],
"652": [
"CVE-2004-1120"
],
"654": [
"CVE-2004-1119"
],
"658": [
"CVE-2004-2501"
],
"660": [
"CVE-2004-0594"
],
"663": [
"CVE-2004-2513",
"CVE-2004-1211"
],
"668": [
"CVE-2004-2513",
"CVE-2004-1211"
],
"670": [
"CVE-2004-2513",
"CVE-2004-1211"
],
"675": [
"CVE-2004-1217"
],
"681": [
"CVE-2004-1192"
],
"689": [],
"693": [],
"705": [],
"711": [
"CVE-2004-1327"
],
"712": [
"CVE-2004-1373"
],
"716": [
"CVE-2001-0797"
],
"719": [
"CVE-2004-1043"
],
"726": [
"CVE-2004-1317"
],
"729": [
"CVE-2003-0172"
],
"730": [],
"733": [
"CVE-2004-0567"
],
"734": [
"CVE-2004-0206"
],
"745": [],
"746": [],
"750": [
"CVE-2004-1172"
],
"753": [],
"759": [],
"761": [
"CVE-2005-0185"
],
"764": [
"CVE-2002-0082"
],
"765": [
"CVE-2005-0416"
],
"767": [
"CVE-2005-0566"
],
"771": [
"CVE-2005-0416"
],
"775": [
"CVE-2004-1388"
],
"781": [
"CVE-2005-0338"
],
"784": [
"CVE-2005-0226"
],
"785": [
"CVE-2005-0101"
],
"787": [
"CVE-2005-0338"
],
"794": [
"CVE-2005-0419"
],
"802": [],
"804": [],
"805": [
"CVE-2005-0439"
],
"806": [
"CVE-2005-0523"
],
"812": [],
"819": [
"CVE-2005-0338"
],
"822": [
"CVE-2004-2111"
],
"823": [
"CVE-2004-2074"
],
"825": [
"CVE-2005-0277"
],
"826": [
"CVE-2004-0735"
],
"827": [
"CVE-2005-0277"
],
"828": [
"CVE-2005-0491"
],
"829": [
"CVE-2005-0494"
],
"830": [
"CVE-2004-1373"
],
"831": [],
"845": [
"CVE-2005-0595"
],
"847": [],
"854": [
"CVE-2005-0635"
],
"859": [
"CVE-2005-0582",
"CVE-2005-0581"
],
"868": [],
"875": [
"CVE-2005-0353"
],
"878": [],
"879": [
"CVE-2005-0788"
],
"883": [],
"900": [
"CVE-2005-0892"
],
"902": [
"CVE-2005-0958"
],
"903": [],
"906": [
"CVE-2005-1009"
],
"909": [
"CVE-2004-1080"
],
"915": [],
"930": [],
"934": [
"CVE-2005-1100"
],
"940": [
"CVE-2005-1110"
],
"943": [],
"944": [],
"945": [
"CVE-2005-1173"
],
"947": [
"CVE-2005-0560"
],
"949": [
"CVE-2005-1173"
],
"952": [
"CVE-2005-1348"
],
"953": [
"CVE-2005-1163"
],
"955": [
"CVE-2005-1323"
],
"960": [],
"967": [
"CVE-2005-0634"
],
"968": [
"CVE-2005-0634"
],
"969": [
"CVE-2005-0634"
],
"970": [
"CVE-2005-1246"
],
"975": [
"CVE-2005-1415"
],
"976": [],
"977": [],
"979": [
"CVE-2005-1654"
],
"981": [],
"986": [
"CVE-2005-1476",
"CVE-2005-1477"
],
"987": [
"CVE-2005-1654"
],
"990": [
"CVE-2005-1547",
"CVE-2005-1009"
],
"1007": [],
"1021": [
"CVE-2005-1461"
],
"1026": [
"CVE-2005-1903"
],
"1028": [
"CVE-2005-1873"
],
"1035": [
"CVE-2005-1255"
],
"1038": [],
"1047": [
"CVE-2005-2041"
],
"1055": [
"CVE-2005-1806"
],
"1066": [
"CVE-2005-1213"
],
"1075": [
"CVE-2005-0059"
],
"1079": [
"CVE-2005-2087"
],
"1081": [
"CVE-2005-2250"
],
"1089": [],
"1096": [
"CVE-2005-2219"
],
"1099": [],
"1102": [
"CVE-2005-2262"
],
"1108": [],
"1114": [
"CVE-2001-0311"
],
"1115": [],
"1118": [],
"1123": [
"CVE-2005-1523"
],
"1124": [
"CVE-2005-1255"
],
"1130": [
"CVE-2005-1272"
],
"1131": [],
"1132": [
"CVE-2006-6379"
],
"1138": [
"CVE-2005-2409"
],
"1139": [
"CVE-2005-2367"
],
"1144": [
"CVE-2005-1990",
"CVE-2005-1989",
"CVE-2005-1988"
],
"1146": [
"CVE-2005-1983"
],
"1147": [
"CVE-2005-2611"
],
"1149": [
"CVE-2005-1983"
],
"1150": [
"CVE-2005-1543"
],
"1151": [
"CVE-2004-1520"
],
"1152": [
"CVE-2005-2551"
],
"1167": [
"CVE-2001-1583"
],
"1171": [
"CVE-2005-2665"
],
"1178": [],
"1179": [
"CVE-2005-1983"
],
"1180": [],
"1183": [
"CVE-2004-1220"
],
"1184": [
"CVE-2002-1120"
],
"1188": [
"CVE-2005-2773"
],
"1190": [
"CVE-2005-2842"
],
"1193": [
"CVE-2005-2857"
],
"1201": [],
"1209": [
"CVE-2005-2878"
],
"1210": [
"CVE-2003-0471"
],
"1223": [
"CVE-2007-1373",
"CVE-2006-5961"
],
"1224": [
"CVE-2005-2871"
],
"1231": [
"CVE-2005-3081"
],
"1232": [
"CVE-2005-2710"
],
"1234": [
"CVE-2005-2878"
],
"1238": [
"CVE-2005-2961"
],
"1242": [
"CVE-2005-2967"
],
"1243": [
"CVE-2005-3190"
],
"1247": [],
"1258": [],
"1259": [],
"1260": [],
"1261": [
"CVE-2005-3277"
],
"1262": [],
"1263": [
"CVE-2005-2715"
],
"1264": [
"CVE-2005-2715"
],
"1265": [
"CVE-2005-2715"
],
"1272": [
"CVE-2005-3252"
],
"1277": [],
"1279": [],
"1288": [],
"1290": [
"CVE-2005-3523"
],
"1291": [
"CVE-2005-3523"
],
"1292": [
"CVE-2005-3081"
],
"1295": [
"CVE-2005-3524"
],
"1313": [
"CVE-2005-3252"
],
"1314": [
"CVE-2005-3252"
],
"1330": [
"CVE-2005-3684",
"CVE-2005-3683"
],
"1332": [
"CVE-2005-3155"
],
"1333": [
"CVE-2005-3757"
],
"1352": [
"CVE-2005-2119",
"CVE-2005-1980",
"CVE-2005-1979",
"CVE-2005-1978"
],
"1355": [
"CVE-2005-3995"
],
"1357": [
"CVE-2005-4417"
],
"1365": [
"CVE-2003-0727"
],
"1366": [
"CVE-2005-4143"
],
"1369": [],
"1374": [
"CVE-2005-4270"
],
"1375": [
"CVE-2005-4411"
],
"1378": [
"CVE-2005-4456",
"CVE-2005-4402"
],
"1380": [
"CVE-2006-0637",
"CVE-2005-4267"
],
"1381": [
"CVE-2005-4553"
],
"1391": [],
"1408": [
"CVE-2005-4085"
],
"1413": [
"CVE-2006-0189"
],
"1414": [
"CVE-2006-0189"
],
"1417": [
"CVE-2006-0319"
],
"1420": [],
"1421": [
"CVE-2005-3116"
],
"1448": [
"CVE-2006-0441"
],
"1452": [
"CVE-2006-0441"
],
"1456": [],
"1458": [
"CVE-2006-0476"
],
"1460": [
"CVE-2006-0476"
],
"1462": [
"CVE-2006-0441"
],
"1463": [
"CVE-2005-2287"
],
"1466": [
"CVE-2006-0537"
],
"1474": [
"CVE-2006-0295"
],
"1480": [
"CVE-2006-0295"
],
"1486": [
"CVE-2006-0681"
],
"1487": [
"CVE-2005-4714"
],
"1502": [
"CVE-2006-0006"
],
"1504": [
"CVE-2006-0005"
],
"1505": [
"CVE-2006-0005"
],
"1506": [
"CVE-2005-1219"
],
"1519": [],
"1520": [
"CVE-2006-0005"
],
"1536": [],
"1537": [
"CVE-2003-0220"
],
"1565": [
"CVE-2006-1124"
],
"1574": [],
"1578": [],
"1582": [
"CVE-2006-1236"
],
"1583": [
"CVE-2006-0396"
],
"1592": [
"CVE-2006-1255"
],
"1602": [
"CVE-2006-0460"
],
"1606": [
"CVE-2006-1359"
],
"1607": [],
"1620": [
"CVE-2006-1359"
],
"1626": [],
"1628": [
"CVE-2006-1359"
],
"1664": [],
"1679": [],
"1681": [],
"1703": [
"CVE-2006-0230"
],
"1717": [
"CVE-2006-2022"
],
"1739": [],
"1741": [
"CVE-2006-1518"
],
"1742": [
"CVE-2006-1516"
],
"1750": [
"CVE-2006-2236"
],
"1776": [],
"1787": [
"CVE-2006-2407"
],
"1788": [
"CVE-2002-1359"
],
"1791": [
"CVE-2006-2369"
],
"1794": [
"CVE-2006-2369"
],
"1799": [],
"1813": [
"CVE-2006-2502"
],
"1862": [
"CVE-2006-2814"
],
"1885": [
"CVE-2006-2926"
],
"1889": [
"CVE-2006-2901"
],
"1906": [
"CVE-2006-2961"
],
"1915": [],
"1940": [
"CVE-2006-2370"
],
"1965": [
"CVE-2006-2370"
],
"1997": [
"CVE-2006-3392"
],
"2014": [
"CVE-2006-3670"
],
"2017": [
"CVE-2006-3392"
],
"2034": [
"CVE-2006-3561"
],
"2047": [],
"2048": [
"CVE-2006-3734"
],
"2052": [
"CVE-2006-0003"
],
"2053": [],
"2054": [
"CVE-2006-2372"
],
"2061": [],
"2070": [],
"2074": [
"CVE-2006-3838"
],
"2075": [
"CVE-2006-3838"
],
"2076": [],
"2079": [],
"2080": [
"CVE-2006-3838"
],
"2082": [
"CVE-2006-3677"
],
"2136": [
"CVE-2006-4081"
],
"2140": [
"CVE-2006-3838"
],
"2145": [
"CVE-2006-4081"
],
"2162": [
"CVE-2006-3439"
],
"2164": [
"CVE-2006-0003"
],
"2185": [
"CVE-2006-2502"
],
"2223": [
"CVE-2006-3439"
],
"2233": [
"CVE-2006-4318"
],
"2234": [
"CVE-2006-3952"
],
"2237": [
"CVE-2006-3747"
],
"2258": [
"CVE-2006-4364"
],
"2265": [
"CVE-2006-3439"
],
"2274": [
"CVE-2006-3124"
],
"2276": [],
"2277": [
"CVE-2006-3124"
],
"2283": [],
"2320": [
"CVE-2006-4681"
],
"2328": [
"CVE-2006-4723"
],
"2345": [
"CVE-2006-1255"
],
"2355": [
"CVE-2006-3439"
],
"2358": [
"CVE-2006-4777"
],
"2401": [
"CVE-2006-4974"
],
"2403": [],
"2408": [],
"2425": [
"CVE-2006-4868",
"CVE-2006-3866"
],
"2426": [
"CVE-2006-4868",
"CVE-2006-3866"
],
"2440": [
"CVE-2006-3730"
],
"2445": [
"CVE-2006-5112"
],
"2448": [
"CVE-2006-3730"
],
"2458": [
"CVE-2006-3730"
],
"2460": [
"CVE-2006-3730"
],
"2467": [
"CVE-2006-5156"
],
"2482": [
"CVE-2006-5216"
],
"2530": [],
"2601": [
"CVE-2006-4379"
],
"2637": [
"CVE-2006-5725",
"CVE-2006-5596"
],
"2638": [],
"2649": [
"CVE-2006-5551"
],
"2651": [
"CVE-2006-5597"
],
"2657": [],
"2671": [],
"2680": [
"CVE-2006-3252"
],
"2689": [],
"2690": [
"CVE-2006-5714"
],
"2699": [
"CVE-2006-5715"
],
"2729": [
"CVE-2006-5780"
],
"2743": [
"CVE-2006-5745"
],
"2749": [
"CVE-2006-5745"
],
"2753": [
"CVE-2006-5745"
],
"2770": [
"CVE-2006-5882"
],
"2771": [
"CVE-2006-6055"
],
"2784": [
"CVE-2006-5925"
],
"2785": [
"CVE-2006-6884"
],
"2789": [
"CVE-2006-4691"
],
"2800": [
"CVE-2006-4691"
],
"2809": [
"CVE-2006-4691"
],
"2837": [],
"2856": [
"CVE-2006-5815"
],
"2858": [
"CVE-2006-5864"
],
"2865": [
"CVE-2006-6183"
],
"2866": [
"CVE-2006-6121"
],
"2870": [
"CVE-2006-6251"
],
"2887": [
"CVE-2006-6184"
],
"2933": [
"CVE-2006-6493"
],
"2936": [],
"2951": [
"CVE-2004-1364"
],
"2959": [
"CVE-2006-7141"
],
"2974": [
"CVE-2006-6758"
],
"3021": [],
"3022": [
"CVE-2003-0818"
],
"3037": [
"CVE-2006-6853"
],
"3055": [
"CVE-2006-6884"
],
"3058": [
"CVE-2006-6838"
],
"3063": [
"CVE-2007-0055"
],
"3064": [
"CVE-2007-0015"
],
"3067": [
"CVE-2006-5551"
],
"3072": [
"CVE-2007-0015"
],
"3077": [
"CVE-2007-0059"
],
"3084": [
"CVE-2007-0046"
],
"3086": [
"CVE-2006-6917"
],
"3092": [
"CVE-2006-5112"
],
"3099": [
"CVE-2004-1388"
],
"3107": [
"CVE-2006-3726"
],
"40404": [],
"3132": [
"CVE-2006-4948"
],
"3133": [
"CVE-2006-1255"
],
"3137": [
"CVE-2007-0024"
],
"3140": [
"CVE-2006-0441"
],
"3148": [
"CVE-2007-0024"
],
"3158": [],
"3168": [
"CVE-2007-0243"
],
"3170": [
"CVE-2006-6183"
],
"3189": [
"CVE-2007-0528"
],
"3211": [
"CVE-2007-0449"
],
"3218": [
"CVE-2007-0449"
],
"3244": [
"CVE-2007-0449"
],
"3264": [
"CVE-2006-4379"
],
"3265": [
"CVE-2006-4379"
],
"3269": [
"CVE-2006-2505",
"CVE-2006-2081"
],
"3274": [],
"3279": [
"CVE-2007-0827"
],
"3291": [
"CVE-2006-5784"
],
"3293": [
"CVE-2007-0882"
],
"3294": [
"CVE-2007-0883"
],
"3296": [
"CVE-2007-0927"
],
"3302": [
"CVE-2007-0977",
"CVE-2005-2428"
],
"3303": [
"CVE-2006-5229",
"CVE-2003-0190"
],
"3319": [
"CVE-2006-6423"
],
"3320": [
"CVE-2006-6423"
],
"3329": [],
"3335": [
"CVE-2006-4847"
],
"3340": [
"CVE-2007-0981"
],
"3358": [
"CVE-2006-3698"
],
"3359": [
"CVE-2006-0586"
],
"3363": [
"CVE-2006-0549"
],
"3364": [
"CVE-2005-4832"
],
"3375": [
"CVE-2006-3698"
],
"3376": [
"CVE-2006-0586"
],
"3377": [
"CVE-2006-0549"
],
"3378": [
"CVE-2005-4832"
],
"3380": [
"CVE-2007-0888"
],
"3381": [
"CVE-2007-1225",
"CVE-2007-1224"
],
"3388": [
"CVE-2006-6183"
],
"3389": [
"CVE-2006-6332"
],
"3391": [
"CVE-2006-5276"
],
"3395": [
"CVE-2007-1260"
],
"3397": [
"CVE-2007-1301"
],
"3405": [
"CVE-2007-1287"
],
"3420": [
"CVE-2006-3890"
],
"3422": [
"CVE-2006-0476"
],
"3425": [
"CVE-2007-1359"
],
"3452": [
"CVE-2007-1452"
],
"3462": [
"CVE-2007-1568"
],
"3463": [
"CVE-2007-1568"
],
"3474": [
"CVE-2007-1567"
],
"3482": [
"CVE-2007-1567"
],
"3491": [],
"3495": [
"CVE-2006-5143"
],
"3531": [
"CVE-2006-6026"
],
"3537": [
"CVE-2007-1579"
],
"3540": [
"CVE-2006-1255"
],
"3541": [
"CVE-2007-1645"
],
"3544": [
"CVE-2007-1644"
],
"3554": [
"CVE-2007-1465"
],
"3555": [
"CVE-2003-0001"
],
"3561": [
"CVE-2004-1211"
],
"3570": [
"CVE-2007-1567"
],
"3575": [
"CVE-2007-1511"
],
"3577": [
"CVE-2006-7206"
],
"3579": [
"CVE-2006-3952"
],
"3584": [],
"3585": [],
"3589": [
"CVE-2007-1733"
],
"3604": [
"CVE-2007-1785"
],
"3609": [
"CVE-2006-5276"
],
"3610": [
"CVE-2007-0976"
],
"3615": [
"CVE-2007-1866"
],
"3616": [
"CVE-2007-1675"
],
"3627": [
"CVE-2005-1255"
],
"3634": [
"CVE-2007-1765",
"CVE-2007-0038"
],
"3635": [
"CVE-2007-1765",
"CVE-2007-0038"
],
"3636": [
"CVE-2007-1765",
"CVE-2007-0038"
],
"3650": [
"CVE-2007-1511"
],
"3651": [
"CVE-2007-0038",
"CVE-2007-1765"
],
"3654": [
"CVE-2007-1882"
],
"3661": [
"CVE-2007-1819"
],
"3662": [
"CVE-2006-5820"
],
"3675": [],
"3680": [
"CVE-2006-3747"
],
"3698": [],
"3708": [
"CVE-2007-0919"
],
"3724": [
"CVE-2007-2057"
],
"3728": [
"CVE-2007-0018"
],
"3737": [
"CVE-2007-1748"
],
"3738": [
"CVE-2007-2080",
"CVE-2007-2079"
],
"3740": [
"CVE-2007-1748"
],
"3746": [
"CVE-2007-1748"
],
"3787": [
"CVE-2005-2878"
],
"3804": [
"CVE-2007-1215",
"CVE-2007-1213",
"CVE-2007-1212",
"CVE-2007-1211",
"CVE-2007-0038",
"CVE-2006-5758",
"CVE-2006-5586"
],
"3808": [
"CVE-2007-0018"
],
"3810": [
"CVE-2007-1687"
],
"3815": [
"CVE-2006-2022"
],
"3821": [
"CVE-2007-2031"
],
"3822": [
"CVE-2007-2031"
],
"3829": [
"CVE-2007-2031"
],
"3844": [
"CVE-2007-0976"
],
"3872": [
"CVE-2007-2566"
],
"3877": [
"CVE-2007-1683"
],
"3880": [],
"3881": [],
"3882": [
"CVE-2007-2585"
],
"3892": [
"CVE-2007-2221"
],
"3893": [
"CVE-2007-2584"
],
"3899": [
"CVE-2007-2644"
],
"3913": [
"CVE-2007-2668"
],
"3916": [
"CVE-2007-2667"
],
"3922": [
"CVE-2007-2668"
],
"3925": [
"CVE-2007-2711"
],
"3927": [
"CVE-2007-2725"
],
"3934": [
"CVE-2007-2770"
],
"3938": [
"CVE-2007-2755"
],
"3950": [
"CVE-2007-2771"
],
"3951": [
"CVE-2007-2787"
],
"3952": [
"CVE-2007-2787"
],
"3954": [
"CVE-2007-2783"
],
"3961": [
"CVE-2007-2851"
],
"3966": [
"CVE-2007-2814"
],
"3967": [
"CVE-2007-2853"
],
"3968": [
"CVE-2007-2820"
],
"3982": [
"CVE-2007-2856"
],
"3984": [
"CVE-2007-2856"
],
"3993": [
"CVE-2007-2938"
],
"3996": [
"CVE-2006-3747"
],
"4008": [
"CVE-2007-3076"
],
"4010": [
"CVE-2007-3168"
],
"4014": [
"CVE-2007-3166"
],
"4015": [
"CVE-2007-3167"
],
"4016": [
"CVE-2007-2815"
],
"4021": [
"CVE-2007-2987"
],
"4023": [
"CVE-2007-3111"
],
"4027": [],
"4032": [
"CVE-2007-2791"
],
"4042": [
"CVE-2007-3147"
],
"4043": [
"CVE-2007-3148"
],
"4045": [
"CVE-2007-0038",
"CVE-2007-1765"
],
"4049": [],
"4050": [],
"4052": [
"CVE-2007-3148"
],
"4053": [
"CVE-2007-3147"
],
"4060": [
"CVE-2007-3233"
],
"4061": [],
"4065": [
"CVE-2007-2222"
],
"4066": [
"CVE-2007-2222"
],
"4087": [
"CVE-2007-3360"
],
"4093": [],
"4094": [
"CVE-2007-3435"
],
"4101": [
"CVE-2007-3400"
],
"4109": [
"CVE-2007-3493"
],
"4110": [
"CVE-2007-3459"
],
"4119": [
"CVE-2007-3487"
],
"4123": [
"CVE-2007-3536"
],
"4143": [
"CVE-2007-2239"
],
"4146": [
"CVE-2007-1770"
],
"4152": [
"CVE-2007-3612"
],
"4155": [
"CVE-2007-3649"
],
"4157": [
"CVE-2007-3614"
],
"4158": [
"CVE-2006-6707"
],
"4160": [
"CVE-2007-3633"
],
"4162": [
"CVE-2007-0774"
],
"4170": [
"CVE-2007-3703"
],
"4176": [
"CVE-2007-3785"
],
"4177": [],
"4188": [],
"4190": [
"CVE-2007-3883"
],
"4200": [
"CVE-2007-2563"
],
"4207": [
"CVE-2007-1675"
],
"4208": [
"CVE-2007-3983",
"CVE-2007-3982"
],
"4214": [
"CVE-2007-3984",
"CVE-2007-2987"
],
"4217": [
"CVE-2007-3955"
],
"4222": [
"CVE-2007-4006",
"CVE-2007-4005"
],
"4223": [
"CVE-2007-3925"
],
"4226": [
"CVE-2007-4067"
],
"4228": [
"CVE-2007-3927"
],
"4230": [
"CVE-2007-4031"
],
"4234": [],
"4237": [
"CVE-2007-4062",
"CVE-2007-4061",
"CVE-2007-4031"
],
"4240": [
"CVE-2007-4059"
],
"4243": [
"CVE-2007-4060"
],
"4244": [
"CVE-2007-4058"
],
"4245": [
"CVE-2007-4155"
],
"4247": [],
"4250": [
"CVE-2007-4034"
],
"4255": [
"CVE-2007-4252"
],
"4259": [
"CVE-2007-4254"
],
"4266": [
"CVE-2007-2926"
],
"4279": [
"CVE-2007-4336"
],
"4280": [
"CVE-2002-1120"
],
"4283": [
"CVE-2007-4370"
],
"4287": [
"CVE-2007-4377"
],
"4290": [
"CVE-2007-4420"
],
"4292": [
"CVE-2007-4375"
],
"4299": [
"CVE-2007-4489"
],
"4301": [
"CVE-2007-4440"
],
"4312": [],
"4315": [
"CVE-2007-4566"
],
"4316": [
"CVE-2004-2513",
"CVE-2004-1211"
],
"4321": [
"CVE-2007-4584"
],
"4322": [
"CVE-2007-4582"
],
"4323": [
"CVE-2007-4583"
],
"4324": [
"CVE-2007-4583"
],
"4328": [
"CVE-2007-4607"
],
"4334": [
"CVE-2007-2931"
],
"4348": [
"CVE-2007-4748"
],
"4351": [
"CVE-2007-4515"
],
"4357": [
"CVE-2007-4740"
],
"4360": [
"CVE-2004-2685"
],
"4362": [
"CVE-2007-4726"
],
"4366": [
"CVE-2007-4802"
],
"4367": [
"CVE-2007-1070"
],
"4372": [
"CVE-2007-4802"
],
"4388": [
"CVE-2007-4902"
],
"4389": [
"CVE-2007-4903"
],
"4391": [],
"4393": [
"CVE-2007-4891"
],
"4394": [
"CVE-2007-4890"
],
"4398": [
"CVE-2007-4814"
],
"4399": [],
"4420": [
"CVE-2007-4982"
],
"4424": [],
"4427": [
"CVE-2007-4983"
],
"4428": [
"CVE-2007-5017"
],
"4429": [
"CVE-2007-5018"
],
"4437": [],
"4438": [
"CVE-2007-5094"
],
"4445": [
"CVE-2007-5070"
],
"4450": [
"CVE-2007-5067"
],
"4452": [
"CVE-2007-5108",
"CVE-2007-5107"
],
"4453": [
"CVE-2007-5111",
"CVE-2007-5110"
],
"4455": [
"CVE-2008-1117"
],
"4468": [
"CVE-2007-4174"
],
"4478": [
"CVE-2007-5184"
],
"4484": [
"CVE-2007-5256"
],
"4487": [],
"4488": [
"CVE-2007-5320"
],
"4506": [
"CVE-2007-5322"
],
"4514": [
"CVE-2007-2807"
],
"4522": [
"CVE-2007-5450"
],
"4526": [
"CVE-2007-5446"
],
"4530": [
"CVE-2007-5461"
],
"4533": [
"CVE-2007-5467",
"CVE-2007-5466"
],
"4534": [
"CVE-2007-5467",
"CVE-2007-5466"
],
"4537": [],
"4541": [],
"4542": [
"CVE-2007-4915"
],
"4552": [
"CVE-2007-5461"
],
"4556": [
"CVE-2007-5654"
],
"4566": [
"CVE-2007-5699"
],
"4567": [
"CVE-2007-5731"
],
"4573": [
"CVE-2007-4880"
],
"4574": [],
"4579": [
"CVE-2007-5779"
],
"4594": [
"CVE-2007-5603"
],
"4598": [
"CVE-2007-5826"
],
"4616": [
"CVE-2007-2217"
],
"4651": [
"CVE-2007-6166"
],
"4657": [
"CVE-2007-6166"
],
"4663": [
"CVE-2007-6189",
"CVE-2007-5775"
],
"4664": [
"CVE-2007-6166"
],
"4673": [
"CVE-2002-0252"
],
"4699": [],
"4700": [
"CVE-2007-6405",
"CVE-2007-6404"
],
"4713": [
"CVE-2007-6317",
"CVE-2007-6316",
"CVE-2007-6315",
"CVE-2007-6314"
],
"4715": [
"CVE-2007-6379",
"CVE-2007-6378",
"CVE-2007-6377"
],
"4720": [
"CVE-2007-6333",
"CVE-2007-6332",
"CVE-2007-6331"
],
"4724": [
"CVE-2007-6204"
],
"4744": [
"CVE-2007-6702"
],
"4745": [
"CVE-2007-3039"
],
"4746": [
"CVE-2007-6516"
],
"4747": [
"CVE-2007-6453"
],
"4754": [],
"4760": [
"CVE-2007-3039"
],
"4761": [
"CVE-2007-4560"
],
"4784": [
"CVE-2007-6377"
],
"4797": [
"CVE-2007-6638"
],
"4806": [
"CVE-2007-6530"
],
"4818": [
"CVE-2007-4474"
],
"4819": [
"CVE-2007-6654"
],
"4820": [
"CVE-2007-4474"
],
"4825": [
"CVE-2007-6387"
],
"4862": [
"CVE-2007-6335",
"CVE-2007-5759"
],
"4866": [
"CVE-2007-3901"
],
"4868": [
"CVE-2007-4722"
],
"4869": [
"CVE-2008-0221",
"CVE-2008-0220"
],
"4873": [
"CVE-2008-0236"
],
"4874": [
"CVE-2008-0237"
],
"4877": [
"CVE-2008-0244"
],
"4894": [
"CVE-2008-0248"
],
"4903": [
"CVE-2008-4547"
],
"4906": [
"CVE-2008-0234"
],
"4909": [
"CVE-2008-4587"
],
"4913": [
"CVE-2008-4586"
],
"4918": [
"CVE-2008-4548"
],
"4923": [
"CVE-2008-0338",
"CVE-2008-0337"
],
"4932": [
"CVE-2008-0380"
],
"4934": [
"CVE-2007-3039"
],
"4941": [
"CVE-2008-0403"
],
"4946": [
"CVE-2008-0399"
],
"4947": [
"CVE-2008-0434"
],
"4948": [],
"4949": [
"CVE-2008-0394"
],
"4959": [
"CVE-2008-0437"
],
"4967": [
"CVE-2008-0443"
],
"4974": [
"CVE-2008-0470"
],
"4979": [
"CVE-2008-0477"
],
"4981": [
"CVE-2008-4549"
],
"4982": [
"CVE-2008-0220"
],
"4986": [
"CVE-2008-0551"
],
"4987": [
"CVE-2008-0492"
],
"4999": [
"CVE-2008-0631"
],
"5005": [
"CVE-2008-4584"
],
"5025": [
"CVE-2008-0659"
],
"5028": [
"CVE-2008-4583"
],
"5045": [
"CVE-2008-0634"
],
"5046": [
"CVE-2008-0624",
"CVE-2008-0623"
],
"5048": [
"CVE-2008-0624",
"CVE-2008-0623"
],
"5049": [
"CVE-2008-5711",
"CVE-2008-0660"
],
"5051": [
"CVE-2008-0624",
"CVE-2008-0623"
],
"5052": [
"CVE-2008-0625"
],
"5069": [
"CVE-2008-0661"
],
"5078": [
"CVE-2008-0457"
],
"5079": [
"CVE-2008-0621"
],
"5087": [],
"5100": [
"CVE-2008-0748"
],
"5102": [
"CVE-2008-5711"
],
"5106": [
"CVE-2006-6334"
],
"5111": [
"CVE-2007-4474"
],
"5113": [
"CVE-2008-4876",
"CVE-2008-4875",
"CVE-2008-4874"
],
"5150": [
"CVE-2008-0804"
],
"5153": [
"CVE-2008-0647"
],
"5188": [
"CVE-2008-1116"
],
"5190": [
"CVE-2008-1044"
],
"5193": [
"CVE-2008-4771"
],
"5205": [
"CVE-2007-6016"
],
"5212": [
"CVE-2007-0919"
],
"5213": [
"CVE-2008-1319"
],
"5215": [
"CVE-2008-1145"
],
"5224": [],
"5228": [
"CVE-2008-1411",
"CVE-2008-1410"
],
"5230": [],
"5238": [
"CVE-2008-1118",
"CVE-2008-1117"
],
"5248": [
"CVE-2008-1358"
],
"5249": [
"CVE-2008-1276"
],
"5257": [
"CVE-2008-1218"
],
"5259": [
"CVE-2008-1498"
],
"5264": [
"CVE-2008-1472"
],
"5269": [
"CVE-2008-1402",
"CVE-2008-1401",
"CVE-2008-1400"
],
"5282": [],
"5283": [
"CVE-2008-1467"
],
"5289": [
"CVE-2008-1160"
],
"5313": [
"CVE-2008-1247"
],
"5314": [
"CVE-2008-1611"
],
"5315": [
"CVE-2008-1610"
],
"5330": [],
"5332": [
"CVE-2008-1309"
],
"5338": [
"CVE-2008-1647"
],
"5342": [
"CVE-2008-1697"
],
"5366": [
"CVE-1999-0209"
],
"5386": [
"CVE-2007-6258"
],
"5395": [
"CVE-2007-3883"
],
"5397": [
"CVE-2008-1886",
"CVE-2008-1885"
],
"5398": [
"CVE-2008-1724"
],
"5416": [
"CVE-2008-1725"
],
"5430": [],
"5445": [],
"5451": [
"CVE-2008-1914"
],
"5461": [],
"5489": [
"CVE-2008-1933"
],
"5496": [
"CVE-2008-2015"
],
"5511": [
"CVE-2008-2390"
],
"5519": [
"CVE-2007-6682"
],
"5530": [
"CVE-2008-1898"
],
"5534": [],
"5536": [],
"5563": [
"CVE-2008-2161"
],
"5612": [
"CVE-2008-2283"
],
"5619": [
"CVE-2008-2281"
],
"5622": [
"CVE-2008-0166"
],
"5632": [
"CVE-2008-0166"
],
"5681": [
"CVE-2008-0955"
],
"5694": [
"CVE-2008-1491"
],
"5695": [
"CVE-2008-0871"
],
"5720": [
"CVE-2008-3280",
"CVE-2008-0166"
],
"5732": [
"CVE-2008-2551"
],
"5738": [
"CVE-2008-1661"
],
"5741": [
"CVE-2008-1770"
],
"5746": [
"CVE-2008-2693"
],
"5747": [
"CVE-2008-2693"
],
"5750": [
"CVE-2008-2684",
"CVE-2008-2683"
],
"5751": [
"CVE-2008-2573"
],
"5777": [
"CVE-2008-2745"
],
"5778": [
"CVE-2008-2745"
],
"5790": [
"CVE-2008-0960"
],
"5793": [
"CVE-2008-2910"
],
"5795": [
"CVE-2008-2841"
],
"5827": [
"CVE-2008-4193"
],
"5926": [
"CVE-2006-5202"
],
"6004": [
"CVE-2008-3156",
"CVE-2008-3155"
],
"6012": [
"CVE-2008-6922"
],
"6013": [
"CVE-2007-6166"
],
"6045": [
"CVE-2008-6825"
],
"6089": [
"CVE-2008-3257"
],
"6094": [
"CVE-2008-3234"
],
"6100": [],
"6116": [
"CVE-2008-3360"
],
"6118": [
"CVE-2008-3361"
],
"6121": [
"CVE-2008-3360"
],
"6122": [
"CVE-2008-4194",
"CVE-2008-1447"
],
"6123": [
"CVE-2008-4194",
"CVE-2008-1447"
],
"6124": [
"CVE-2008-2463"
],
"6130": [
"CVE-2008-4194",
"CVE-2008-1447"
],
"6151": [
"CVE-2008-7084"
],
"6152": [
"CVE-2008-3364"
],
"6155": [
"CVE-2007-2586"
],
"6175": [],
"6195": [
"CVE-2008-3583"
],
"6217": [
"CVE-2006-6199"
],
"6220": [
"CVE-2008-3558",
"CVE-2008-2737"
],
"6227": [
"CVE-2008-3361"
],
"6229": [
"CVE-2008-2938"
],
"6236": [],
"6238": [
"CVE-2008-3360"
],
"6248": [
"CVE-2008-4321"
],
"6256": [
"CVE-2008-4321"
],
"6278": [
"CVE-2008-3480"
],
"6302": [
"CVE-2008-2922"
],
"6305": [
"CVE-2008-7115",
"CVE-2008-1245",
"CVE-2008-1244",
"CVE-2008-1242"
],
"6317": [
"CVE-2008-3704"
],
"6318": [
"CVE-2008-3878"
],
"6323": [
"CVE-2008-4048"
],
"6324": [
"CVE-2008-4049"
],
"6328": [
"CVE-2008-0964"
],
"6334": [
"CVE-2008-4050"
],
"6355": [
"CVE-2008-6996"
],
"6366": [
"CVE-2008-6976"
],
"6367": [
"CVE-2008-6994"
],
"6387": [
"CVE-2008-2639"
],
"6407": [],
"6414": [
"CVE-2008-4699"
],
"6454": [
"CVE-2008-3008"
],
"6476": [
"CVE-2008-4128"
],
"6477": [],
"6491": [
"CVE-2008-4342"
],
"6506": [
"CVE-2008-4243"
],
"6532": [],
"6537": [
"CVE-2008-4343"
],
"6548": [],
"6570": [
"CVE-2006-6488"
],
"6600": [
"CVE-2008-7022"
],
"6630": [
"CVE-2008-4472",
"CVE-2008-4471"
],
"6638": [
"CVE-2008-4453"
],
"6656": [
"CVE-2008-1087",
"CVE-2008-1083"
],
"6661": [
"CVE-2008-4501"
],
"6666": [
"CVE-2008-4449"
],
"6686": [
"CVE-2008-4421"
],
"6690": [
"CVE-2008-5697"
],
"6699": [
"CVE-2008-4493"
],
"6750": [],
"6773": [
"CVE-2008-4728"
],
"6774": [
"CVE-2008-4728"
],
"6776": [
"CVE-2008-4728"
],
"6786": [
"CVE-2008-4556"
],
"6793": [
"CVE-2008-4652"
],
"6801": [
"CVE-2008-4725",
"CVE-2008-4696"
],
"6804": [
"CVE-2008-4726"
],
"6813": [],
"6828": [
"CVE-2008-4750",
"CVE-2008-4749"
],
"6840": [
"CVE-2008-4652"
],
"6841": [
"CVE-2008-4250"
],
"6870": [
"CVE-2008-4923"
],
"6871": [
"CVE-2008-4924"
],
"6872": [
"CVE-2008-4925"
],
"6873": [
"CVE-2008-4926"
],
"6875": [
"CVE-2008-4919"
],
"6878": [
"CVE-2008-4922"
],
"6880": [],
"6899": [
"CVE-2008-6824",
"CVE-2008-6823"
],
"6921": [
"CVE-2008-0175"
],
"6963": [
"CVE-2011-5289",
"CVE-2008-5002"
],
"7055": [
"CVE-2008-6916"
],
"7056": [],
"7104": [
"CVE-2008-4250"
],
"7125": [
"CVE-2008-4037"
],
"7132": [
"CVE-2008-4250"
],
"7142": [
"CVE-2008-6959"
],
"7145": [
"CVE-2008-6937",
"CVE-2008-6936",
"CVE-2008-6935"
],
"7151": [
"CVE-2008-5297"
],
"7167": [
"CVE-2008-6937",
"CVE-2008-6936",
"CVE-2008-6935"
],
"7181": [
"CVE-2008-7070"
],
"7183": [
"CVE-2008-5706",
"CVE-2008-5705"
],
"7196": [
"CVE-2008-4033",
"CVE-2008-4029"
],
"7355": [
"CVE-2008-6534"
],
"7384": [
"CVE-2008-6499",
"CVE-2008-6498"
],
"7389": [
"CVE-2008-6975",
"CVE-2008-6974"
],
"7402": [
"CVE-2008-6447"
],
"7403": [
"CVE-2008-4844"
],
"7410": [
"CVE-2008-4844"
],
"7442": [
"CVE-2008-6528"
],
"7452": [
"CVE-2006-4948"
],
"7477": [
"CVE-2010-1175"
],
"7496": [
"CVE-2008-1094"
],
"7505": [
"CVE-2008-5691"
],
"7521": [
"CVE-2008-5862"
],
"7566": [
"CVE-2008-5750",
"CVE-2008-5749"
],
"7583": [],
"7584": [],
"7594": [
"CVE-2008-4584",
"CVE-2008-1647"
],
"7617": [
"CVE-2008-6898"
],
"7623": [
"CVE-2008-6748"
],
"7630": [
"CVE-2008-6748"
],
"7701": [],
"7706": [],
"7712": [],
"7739": [],
"7747": [],
"7748": [],
"7749": [],
"7755": [],
"7757": [],
"7760": [],
"7762": [],
"7763": [],
"7779": [
"CVE-2009-0134"
],
"7781": [],
"7794": [],
"7804": [],
"7826": [],
"7827": [],
"7842": [
"CVE-2009-0253"
],
"7845": [],
"7858": [],
"7868": [
"CVE-2009-0301"
],
"7871": [],
"7875": [
"CVE-2009-0351"
],
"7903": [
"CVE-2009-0374"
],
"7910": [
"CVE-2009-0389"
],
"7912": [
"CVE-2009-0369"
],
"7913": [],
"7915": [
"CVE-2009-0393",
"CVE-2009-0392"
],
"7918": [],
"7919": [
"CVE-2009-0468",
"CVE-2009-0467"
],
"7920": [],
"7921": [],
"7926": [],
"7928": [
"CVE-2009-0465"
],
"7935": [],
"7966": [],
"7988": [],
"7989": [],
"8022": [],
"8023": [
"CVE-2009-0545"
],
"8037": [
"CVE-2009-0543",
"CVE-2009-0542"
],
"8041": [
"CVE-2009-5087"
],
"8059": [
"CVE-2009-0865"
],
"8079": [
"CVE-2009-0076",
"CVE-2009-0075"
],
"8080": [
"CVE-2009-0076",
"CVE-2009-0075"
],
"8082": [
"CVE-2009-0076",
"CVE-2009-0075"
],
"8096": [],
"8097": [
"CVE-2009-0753"
],
"8117": [],
"8118": [
"CVE-2009-0187"
],
"8142": [],
"8143": [
"CVE-2009-0811"
],
"8144": [
"CVE-2009-0813"
],
"8149": [],
"8152": [
"CVE-2009-0076",
"CVE-2009-0075"
],
"8154": [],
"8155": [
"CVE-2009-4809"
],
"8160": [],
"8173": [],
"8191": [
"CVE-2009-5135"
],
"8200": [],
"8203": [
"CVE-2009-1029"
],
"8206": [
"CVE-2009-1092"
],
"8208": [],
"8211": [
"CVE-2009-1031"
],
"8215": [
"CVE-2009-1087"
],
"8227": [],
"8248": [],
"8253": [
"CVE-2007-4370"
],
"8256": [
"CVE-2009-4800",
"CVE-2009-4790"
],
"8257": [
"CVE-2009-1064"
],
"8269": [],
"8273": [],
"8283": [
"CVE-2008-2032"
],
"8284": [],
"8295": [
"CVE-2008-6899"
],
"8316": [],
"8321": [
"CVE-2009-1209"
],
"8332": [
"CVE-2009-1212"
],
"8336": [
"CVE-2008-5457"
],
"8338": [],
"8339": [],
"8340": [],
"8354": [],
"8359": [],
"8363": [],
"8368": [],
"8384": [],
"8392": [],
"8398": [],
"8419": [],
"8421": [],
"8422": [],
"8428": [
"CVE-2009-1354"
],
"8458": [
"CVE-2008-5518"
],
"8463": [],
"8518": [],
"8525": [],
"8537": [],
"8554": [],
"8556": [
"CVE-2009-0065"
],
"8560": [],
"8561": [],
"8562": [
"CVE-2009-2570"
],
"8564": [],
"8569": [
"CVE-2009-1492"
],
"8570": [
"CVE-2009-1493"
],
"8579": [
"CVE-2009-1612"
],
"8613": [
"CVE-2009-1611"
],
"8614": [
"CVE-2009-1592"
],
"8621": [
"CVE-2009-1611"
],
"8623": [
"CVE-2009-1675"
],
"8651": [],
"8666": [],
"8696": [],
"8704": [
"CVE-2009-1676",
"CVE-2009-1535"
],
"8716": [],
"8732": [],
"8733": [],
"8742": [],
"8753": [
"CVE-2008-5353"
],
"8754": [],
"8757": [
"CVE-2009-1807"
],
"8758": [
"CVE-2009-1800"
],
"8765": [],
"8786": [],
"8804": [
"CVE-2009-1830"
],
"8806": [
"CVE-2009-1122",
"CVE-2009-1535"
],
"8824": [
"CVE-2009-4841"
],
"8835": [
"CVE-2009-4840"
],
"8846": [],
"8861": [
"CVE-2009-0950"
],
"8880": [],
"8897": [],
"8907": [],
"8916": [],
"8922": [
"CVE-2009-2011"
],
"8930": [],
"8934": [
"CVE-2009-0950"
],
"8938": [],
"8963": [
"CVE-2009-2258",
"CVE-2009-2257"
],
"8969": [],
"8970": [],
"8986": [
"CVE-2009-2169"
],
"9002": [
"CVE-2009-2227"
],
"9031": [
"CVE-2009-2227"
],
"9039": [
"CVE-2009-2275"
],
"9065": [],
"9066": [
"CVE-2009-2306"
],
"9093": [
"CVE-2009-2544"
],
"9096": [],
"9106": [
"CVE-2009-3760",
"CVE-2009-3759",
"CVE-2009-3758",
"CVE-2009-3757"
],
"9108": [
"CVE-2008-0015"
],
"9117": [],
"9128": [],
"9137": [
"CVE-2009-2478",
"CVE-2009-2477"
],
"9143": [],
"9181": [
"CVE-2009-2478"
],
"9209": [
"CVE-2009-2766",
"CVE-2009-2765",
"CVE-2008-6975",
"CVE-2008-6974"
],
"9214": [
"CVE-2009-2477"
],
"9224": [],
"9247": [],
"9278": [],
"9303": [],
"9318": [],
"9319": [
"CVE-2009-4988"
],
"9330": [
"CVE-2009-1209"
],
"9422": [],
"9432": [],
"9443": [
"CVE-2009-1873"
],
"9456": [],
"9468": [
"CVE-2007-1404"
],
"9473": [],
"9498": [],
"9500": [],
"9503": [],
"9508": [
"CVE-2009-3976"
],
"9541": [
"CVE-2009-3023"
],
"9559": [
"CVE-2009-3023"
],
"9586": [
"CVE-2007-4566"
],
"9592": [
"CVE-2007-4566"
],
"9596": [
"CVE-2007-4566"
],
"9613": [
"CVE-2009-3364"
],
"9615": [
"CVE-2009-2694",
"CVE-2009-1376"
],
"9638": [],
"9643": [],
"9644": [],
"9649": [
"CVE-2009-3544"
],
"9650": [],
"9651": [
"CVE-2009-3076"
],
"9652": [
"CVE-2009-1977",
"CVE-2009-1978"
],
"9658": [],
"9660": [],
"9662": [
"CVE-2007-2795"
],
"9663": [
"CVE-2008-0016"
],
"9673": [
"CVE-2009-4660",
"CVE-2008-1914"
],
"9676": [],
"9690": [
"CVE-2009-4660",
"CVE-2008-1914"
],
"9694": [
"CVE-2009-3646"
],
"9704": [],
"9705": [
"CVE-2009-4663"
],
"9718": [
"CVE-2009-3562",
"CVE-2009-3561"
],
"9800": [
"CVE-2009-4873"
],
"9802": [
"CVE-2009-3518"
],
"9803": [],
"9805": [],
"9810": [],
"9813": [],
"9816": [],
"9829": [
"CVE-2009-3898"
],
"9843": [
"CVE-2009-3850"
],
"9851": [],
"9853": [
"CVE-2009-3031"
],
"9858": [
"CVE-2009-3710"
],
"9862": [],
"9886": [],
"9893": [
"CVE-2009-1547"
],
"9896": [],
"9900": [],
"9902": [],
"9905": [
"CVE-2009-1979"
],
"9913": [
"CVE-2007-4560"
],
"9914": [
"CVE-2006-2447"
],
"9915": [
"CVE-2004-2687"
],
"9917": [
"CVE-2001-0797"
],
"9918": [
"CVE-2007-0882"
],
"9920": [
"CVE-2008-4556"
],
"9921": [
"CVE-2001-1583"
],
"9923": [
"CVE-2001-0803"
],
"9924": [
"CVE-2003-0201"
],
"9925": [],
"9927": [],
"9928": [
"CVE-2004-0695"
],
"9929": [
"CVE-2006-0395"
],
"9930": [
"CVE-2005-0491"
],
"9931": [
"CVE-2004-0430"
],
"9932": [],
"9934": [
"CVE-2009-0695"
],
"9935": [
"CVE-2004-0397"
],
"9936": [
"CVE-2003-0085"
],
"9937": [
"CVE-2002-1643"
],
"9939": [
"CVE-2007-1286"
],
"9940": [
"CVE-2001-0414"
],
"9941": [
"CVE-2004-1389"
],
"9942": [
"CVE-2001-0311"
],
"9943": [
"CVE-2007-2175"
],
"9944": [
"CVE-2008-4696"
],
"9945": [],
"9946": [
"CVE-2006-3677"
],
"9947": [
"CVE-2005-2265"
],
"9948": [
"CVE-2008-5353"
],
"9949": [],
"9950": [
"CVE-2007-2446"
],
"9951": [
"CVE-2004-0541"
],
"9952": [
"CVE-2003-0213"
],
"9953": [
"CVE-2008-0226"
],
"9954": [
"CVE-2007-5243"
],
"9957": [
"CVE-2009-3838"
],
"9966": [
"CVE-2009-4873"
],
"33433": [],
"9992": [
"CVE-2009-3658"
],
"9993": [
"CVE-2009-0796",
"CVE-2009-0795"
],
"9994": [],
"9995": [],
"9997": [],
"9998": [
"CVE-2008-5754"
],
"10000": [
"CVE-2009-3457"
],
"10001": [
"CVE-2009-2820"
],
"10007": [],
"10011": [
"CVE-2009-2684"
],
"10019": [
"CVE-2007-5244"
],
"10020": [
"CVE-2007-5243"
],
"10021": [
"CVE-2007-5243"
],
"10023": [
"CVE-2005-1099"
],
"10024": [
"CVE-2006-6332"
],
"10025": [
"CVE-2000-0284"
],
"10026": [
"CVE-2005-3252"
],
"10027": [
"CVE-2006-1148"
],
"10028": [
"CVE-2005-2799"
],
"10029": [
"CVE-2004-1388"
],
"10030": [
"CVE-2009-2765"
],
"10032": [
"CVE-2004-0608"
],
"10033": [
"CVE-2001-0800"
],
"10034": [
"CVE-2002-1473"
],
"10035": [
"CVE-2008-7232"
],
"10036": [
"CVE-2001-0797"
],
"10037": [
"CVE-2004-2221"
],
"10047": [],
"10053": [
"CVE-2009-3711"
],
"10054": [],
"10055": [
"CVE-2009-2684"
],
"10056": [],
"10070": [
"CVE-2009-3691"
],
"10071": [
"CVE-2009-3555"
],
"10079": [],
"33431": [],
"33432": [],
"10081": [],
"10083": [],
"10086": [],
"10093": [
"CVE-2009-3244"
],
"10095": [],
"10097": [],
"10098": [],
"10099": [
"CVE-2009-2685"
],
"10162": [
"CVE-2009-4053"
],
"10235": [
"CVE-2009-3837"
],
"10258": [
"CVE-2009-4194"
],
"10269": [
"CVE-2009-4219"
],
"10282": [],
"10340": [
"CVE-2009-1429"
],
"10362": [],
"10365": [],
"10375": [],
"10380": [
"CVE-2009-0689"
],
"10394": [
"CVE-2009-4179"
],
"10434": [
"CVE-2002-1120"
],
"10451": [
"CVE-2009-4462"
],
"10510": [],
"10542": [],
"10579": [
"CVE-2009-3555"
],
"10610": [],
"14257": [],
"10715": [
"CVE-2009-3844"
],
"10765": [],
"10791": [],
"10911": [],
"10973": [],
"10980": [],
"11022": [],
"11027": [
"CVE-2007-6166"
],
"11059": [],
"11138": [
"CVE-2009-0950"
],
"11151": [],
"11167": [
"CVE-2010-0249"
],
"11172": [
"CVE-2009-3958"
],
"11173": [],
"11179": [],
"11203": [
"CVE-2010-0013"
],
"11204": [],
"11210": [],
"11220": [],
"11257": [],
"11272": [],
"11293": [],
"11328": [],
"11420": [],
"11422": [
"CVE-2010-0679"
],
"11453": [],
"11457": [],
"11468": [],
"11497": [
"CVE-2008-5517"
],
"11500": [],
"11539": [],
"11615": [
"CVE-2010-0483"
],
"11618": [],
"11650": [
"CVE-2010-0425"
],
"11661": [],
"11662": [
"CVE-2010-1132"
],
"11668": [],
"11683": [
"CVE-2010-0806"
],
"11694": [],
"11720": [],
"11742": [],
"11750": [],
"11765": [],
"11817": [],
"11820": [],
"11822": [],
"11856": [],
"11857": [],
"11877": [],
"11879": [],
"11886": [
"CVE-2010-1185"
],
"11973": [],
"11974": [
"CVE-2009-4178"
],
"11986": [
"CVE-2010-1147"
],
"12033": [],
"12044": [],
"12114": [],
"12117": [
"CVE-2010-0886"
],
"12119": [],
"12122": [
"CVE-2010-0886"
],
"12152": [
"CVE-2010-1465"
],
"12156": [],
"12202": [],
"12203": [],
"12244": [
"CVE-2007-6493"
],
"12247": [],
"12248": [],
"12250": [],
"12263": [
"CVE-2010-0432"
],
"12264": [
"CVE-2010-0432"
],
"12265": [],
"12298": [],
"12304": [],
"12308": [],
"12309": [
"CVE-2009-4535"
],
"12310": [],
"12312": [],
"12320": [
"CVE-2010-0356"
],
"12331": [],
"12332": [],
"12343": [
"CVE-2010-1157"
],
"12367": [],
"12380": [],
"12417": [],
"12480": [],
"12495": [],
"12498": [],
"12511": [],
"12512": [],
"12573": [
"CVE-2010-1939"
],
"12580": [],
"12581": [],
"12582": [],
"12587": [],
"12614": [
"CVE-2010-1939"
],
"12657": [
"CVE-2010-1663"
],
"12663": [],
"12673": [],
"14321": [],
"12804": [],
"12815": [],
"12834": [],
"12865": [
"CVE-2010-2307"
],
"13588": [],
"13735": [
"CVE-2010-2309"
],
"13787": [
"CVE-2010-1297"
],
"13808": [
"CVE-2010-1885"
],
"13818": [
"CVE-2010-2266",
"CVE-2010-2263"
],
"13822": [
"CVE-2010-2263"
],
"13834": [
"CVE-2010-2305"
],
"13850": [
"CVE-2010-2333"
],
"13853": [
"CVE-2010-2075"
],
"13903": [
"CVE-2010-2331"
],
"13932": [
"CVE-2010-2620"
],
"14360": [
"CVE-2010-1870"
],
"14013": [],
"14091": [],
"30100": [
"CVE-2007-2983"
],
"14179": [
"CVE-2010-2731"
],
"14180": [
"CVE-2010-1553"
],
"14181": [
"CVE-2010-1554"
],
"14182": [
"CVE-2010-1555"
],
"14194": [
"CVE-2010-0361"
],
"14195": [
"CVE-2008-6898"
],
"14200": [],
"14222": [],
"14248": [],
"14254": [
"CVE-2010-2309"
],
"14267": [
"CVE-2010-2627"
],
"14269": [
"CVE-2010-2701"
],
"14272": [],
"14275": [],
"14287": [
"CVE-2010-0361"
],
"14309": [],
"14385": [],
"14386": [],
"14387": [],
"14388": [],
"14399": [],
"14400": [],
"14402": [],
"14407": [
"CVE-2010-1039"
],
"14409": [
"CVE-2010-3187"
],
"14412": [],
"14416": [],
"14447": [],
"14451": [],
"14456": [
"CVE-2010-3187"
],
"14496": [],
"14489": [
"CVE-2008-2938"
],
"14492": [],
"14505": [
"CVE-2010-2932"
],
"14514": [
"CVE-2010-2931"
],
"14519": [
"CVE-2010-2932"
],
"14522": [],
"14539": [
"CVE-2010-2701"
],
"14536": [
"CVE-2010-2860"
],
"14551": [],
"14552": [],
"14553": [],
"14580": [],
"14586": [],
"14599": [],
"14600": [],
"14602": [],
"14605": [],
"14604": [],
"14623": [],
"14658": [],
"14641": [
"CVE-2010-2861"
],
"14674": [
"CVE-2009-3103",
"CVE-2009-2532",
"CVE-2009-2526"
],
"14779": [],
"14853": [
"CVE-2010-1297"
],
"14856": [],
"14857": [],
"14875": [],
"14886": [
"CVE-2010-0265"
],
"14878": [],
"14885": [],
"14895": [
"CVE-2010-0480"
],
"14925": [
"CVE-2010-3306"
],
"14941": [],
"14976": [],
"15001": [],
"15042": [
"CVE-2010-1527"
],
"15005": [
"CVE-2010-3407"
],
"15016": [],
"15048": [
"CVE-2010-3486"
],
"15056": [
"CVE-2010-0838"
],
"15071": [],
"15072": [
"CVE-2010-1527"
],
"15073": [
"CVE-2010-3106"
],
"15168": [
"CVE-2010-3189"
],
"15186": [],
"15213": [
"CVE-2010-3332"
],
"15600": [],
"15601": [],
"15231": [],
"15235": [],
"15238": [],
"15241": [
"CVE-2010-3552"
],
"15244": [],
"15265": [
"CVE-2010-3332"
],
"15266": [
"CVE-2010-0231"
],
"15288": [
"CVE-2010-3573"
],
"15292": [
"CVE-2010-3332"
],
"15296": [
"CVE-2010-3653"
],
"15298": [],
"15318": [
"CVE-2010-4099"
],
"15333": [],
"15336": [],
"15337": [
"CVE-2010-4142"
],
"15347": [],
"15349": [],
"15352": [
"CVE-2010-3765"
],
"15357": [],
"15358": [],
"15368": [],
"15371": [
"CVE-2010-4181"
],
"15373": [],
"15421": [
"CVE-2010-3962"
],
"15423": [
"CVE-2010-1807"
],
"15427": [],
"15437": [],
"15438": [],
"15445": [],
"15449": [
"CVE-2010-4221"
],
"15450": [],
"15505": [
"CVE-2010-4231"
],
"15548": [
"CVE-2010-1807"
],
"15617": [],
"15631": [
"CVE-2010-4107"
],
"15648": [],
"15655": [],
"15658": [
"CVE-2010-5194"
],
"15662": [],
"15664": [],
"15668": [
"CVE-2010-5193"
],
"15689": [],
"15717": [
"CVE-2010-4297"
],
"15723": [],
"15725": [
"CVE-2010-4344"
],
"15733": [
"CVE-2010-2590"
],
"15746": [
"CVE-2010-3971"
],
"15802": [
"CVE-2010-4598"
],
"15806": [
"CVE-2010-4566"
],
"15809": [
"CVE-2010-4588",
"CVE-2010-3973"
],
"15834": [
"CVE-2010-5301"
],
"15842": [],
"15861": [],
"15862": [],
"15866": [],
"15868": [],
"15869": [
"CVE-2010-0219"
],
"15885": [],
"18245": [
"CVE-2011-4779",
"CVE-2011-4644",
"CVE-2011-4643",
"CVE-2011-4642"
],
"15991": [
"CVE-2010-3749"
],
"15957": [
"CVE-2011-0406"
],
"15937": [
"CVE-2011-0404"
],
"16123": [
"CVE-2011-0887",
"CVE-2011-0886",
"CVE-2011-0885"
],
"15963": [
"CVE-2010-2746"
],
"15984": [
"CVE-2011-0027"
],
"16014": [
"CVE-2010-4321"
],
"16036": [
"CVE-2006-6576"
],
"16041": [
"CVE-2011-0902"
],
"16052": [
"CVE-2010-3599"
],
"16053": [
"CVE-2010-3591"
],
"16055": [
"CVE-2010-3591"
],
"16056": [
"CVE-2010-3595"
],
"16075": [],
"16078": [],
"16100": [
"CVE-2011-0354"
],
"16101": [],
"16103": [
"CVE-2011-0063",
"CVE-2011-0049"
],
"16105": [],
"16137": [
"CVE-2010-4435"
],
"16145": [],
"16149": [],
"16176": [],
"16177": [],
"16226": [],
"16208": [],
"16209": [],
"16227": [],
"16228": [],
"16229": [],
"16231": [],
"16238": [],
"16239": [],
"16240": [],
"16242": [],
"16243": [],
"16244": [],
"16245": [],
"16259": [],
"16271": [],
"16275": [],
"16278": [],
"16285": [
"CVE-2001-0414"
],
"16286": [
"CVE-2002-1643"
],
"41785": [
"CVE-2016-9091"
],
"16289": [
"CVE-2010-0304"
],
"16291": [
"CVE-2001-0311"
],
"16292": [
"CVE-2010-0304"
],
"16293": [
"CVE-2008-5353"
],
"16294": [
"CVE-2009-3867"
],
"16295": [
"CVE-2007-2175"
],
"16296": [
"CVE-2009-0950"
],
"16297": [
"CVE-2010-0840"
],
"16298": [
"CVE-2009-3869"
],
"16299": [
"CVE-2009-2477"
],
"16300": [
"CVE-2006-3677"
],
"16301": [
"CVE-2006-0295"
],
"16302": [
"CVE-2008-5353"
],
"16303": [],
"16304": [
"CVE-2008-4696"
],
"16305": [
"CVE-2010-0094"
],
"16306": [
"CVE-2005-2265"
],
"16308": [],
"16309": [
"CVE-2009-2990"
],
"16310": [
"CVE-2007-1286"
],
"16311": [
"CVE-2000-0573"
],
"16312": [
"CVE-2010-0219"
],
"16314": [
"CVE-2010-0361"
],
"16315": [
"CVE-2010-0219"
],
"16316": [
"CVE-2010-0738"
],
"16317": [
"CVE-2010-4094",
"CVE-2010-0557",
"CVE-2009-4189",
"CVE-2009-4188",
"CVE-2009-3843",
"CVE-2009-3548"
],
"16318": [
"CVE-2007-1036"
],
"16319": [
"CVE-2010-0738"
],
"16320": [
"CVE-2007-2447"
],
"16321": [
"CVE-2003-0085"
],
"16322": [
"CVE-2001-1583"
],
"16323": [
"CVE-2001-0803"
],
"16324": [
"CVE-2003-0722"
],
"16325": [
"CVE-2008-4556"
],
"16326": [
"CVE-1999-0209"
],
"16327": [
"CVE-2001-0797"
],
"16328": [
"CVE-2007-0882"
],
"16329": [
"CVE-2007-2446"
],
"16330": [
"CVE-2003-0201"
],
"16331": [
"CVE-2004-1172"
],
"16332": [
"CVE-2005-0773"
],
"16333": [
"CVE-2010-0478"
],
"16334": [
"CVE-2003-0719"
],
"16335": [
"CVE-2008-5159"
],
"16336": [
"CVE-2003-1141"
],
"16337": [
"CVE-2005-1815"
],
"16338": [
"CVE-2008-0621"
],
"16339": [
"CVE-2008-1117"
],
"16340": [
"CVE-2001-0499"
],
"16341": [
"CVE-2002-0965"
],
"16342": [
"CVE-2009-1979"
],
"16343": [
"CVE-2008-5444"
],
"16344": [
"CVE-2005-1812"
],
"16345": [
"CVE-2007-1435"
],
"16346": [
"CVE-2006-4948"
],
"16347": [
"CVE-2006-6183"
],
"16348": [
"CVE-2008-1610"
],
"16349": [
"CVE-2002-2226"
],
"16350": [
"CVE-2006-6184"
],
"16351": [
"CVE-2006-3524"
],
"16352": [
"CVE-2006-3524"
],
"16353": [
"CVE-2006-3524"
],
"16354": [
"CVE-2004-1134"
],
"16355": [
"CVE-2003-0349"
],
"16356": [
"CVE-2003-0822"
],
"16357": [
"CVE-2000-1089"
],
"16358": [
"CVE-2005-4734"
],
"16359": [
"CVE-2004-1080"
],
"16360": [
"CVE-2008-4037"
],
"16361": [
"CVE-2010-2729"
],
"16362": [
"CVE-2008-4250"
],
"16363": [
"CVE-2009-3103"
],
"16364": [
"CVE-2006-2370"
],
"16366": [
"CVE-2007-1748"
],
"16367": [
"CVE-2006-3439"
],
"16368": [
"CVE-2003-0533"
],
"16369": [
"CVE-2006-4688"
],
"16370": [
"CVE-2009-1394"
],
"16371": [
"CVE-2004-0206"
],
"16372": [
"CVE-2006-4691"
],
"16373": [
"CVE-2006-4688"
],
"16374": [
"CVE-1999-0504"
],
"16375": [
"CVE-2006-2370"
],
"16376": [
"CVE-2009-1350"
],
"16377": [
"CVE-2003-0818"
],
"16378": [
"CVE-2003-0812"
],
"16379": [
"CVE-2005-1213"
],
"16380": [
"CVE-2008-2639"
],
"16381": [
"CVE-2010-4741"
],
"16382": [
"CVE-2010-4142"
],
"16383": [
"CVE-2010-4142"
],
"16384": [
"CVE-2010-4142"
],
"16385": [
"CVE-2008-4322"
],
"16388": [
"CVE-2006-5972"
],
"16389": [
"CVE-2006-5780"
],
"16390": [
"CVE-2010-0103"
],
"16391": [
"CVE-2008-2158"
],
"16392": [
"CVE-2008-5416"
],
"16393": [
"CVE-2002-0649"
],
"16394": [
"CVE-2000-1209",
"CVE-2000-0402"
],
"16395": [
"CVE-2000-1209",
"CVE-2000-0402"
],
"16396": [
"CVE-2008-5416"
],
"16397": [
"CVE-2005-4145"
],
"16398": [
"CVE-2002-1123"
],
"16399": [
"CVE-2003-0264"
],
"16400": [
"CVE-2007-0449"
],
"16401": [
"CVE-2006-5143"
],
"16402": [
"CVE-2007-5082"
],
"16403": [
"CVE-2005-1272"
],
"16404": [
"CVE-2008-4397"
],
"16405": [
"CVE-2005-1018"
],
"16406": [
"CVE-2005-0260"
],
"16407": [
"CVE-2006-6076"
],
"16408": [
"CVE-2005-2535"
],
"16409": [
"CVE-2007-3216"
],
"16410": [
"CVE-2007-4620"
],
"16411": [
"CVE-2007-5003"
],
"16412": [],
"16413": [
"CVE-2007-2139"
],
"16414": [
"CVE-2005-0581"
],
"16415": [
"CVE-2007-3216"
],
"16416": [
"CVE-2007-3216"
],
"16417": [],
"16418": [
"CVE-2007-0169"
],
"16419": [
"CVE-2005-4411"
],
"16420": [
"CVE-2007-5243"
],
"16421": [
"CVE-2009-3853"
],
"16422": [
"CVE-2008-4449"
],
"16423": [
"CVE-2009-4988"
],
"16424": [
"CVE-2007-6166"
],
"16425": [
"CVE-2008-1491"
],
"16426": [],
"16427": [
"CVE-2007-4006"
],
"16428": [
"CVE-2008-4828"
],
"16429": [
"CVE-2007-3872"
],
"16430": [
"CVE-2008-1914"
],
"16431": [
"CVE-2008-1914"
],
"16432": [
"CVE-2007-5243"
],
"16433": [
"CVE-2006-0460"
],
"16434": [
"CVE-2008-0311"
],
"16435": [
"CVE-2009-3844"
],
"16436": [
"CVE-2004-1317"
],
"16437": [
"CVE-2007-5243"
],
"16438": [
"CVE-2006-3838"
],
"16439": [],
"16440": [
"CVE-2007-5243"
],
"16441": [
"CVE-2009-1029"
],
"16442": [
"CVE-2007-3901"
],
"16443": [
"CVE-2009-3837"
],
"16444": [
"CVE-2007-2711"
],
"16445": [
"CVE-2009-2227"
],
"16446": [],
"16447": [
"CVE-2007-5243"
],
"16448": [
"CVE-2005-1009"
],
"16449": [
"CVE-2007-5243"
],
"16450": [
"CVE-2008-1661"
],
"16451": [
"CVE-2006-3838"
],
"16452": [
"CVE-2010-1318"
],
"16453": [
"CVE-2007-3566"
],
"16454": [
"CVE-2004-1595"
],
"16455": [
"CVE-2007-2280"
],
"16456": [
"CVE-2008-5664"
],
"16457": [
"CVE-2007-1674"
],
"16458": [
"CVE-2009-1029"
],
"16459": [],
"16460": [
"CVE-2002-1059"
],
"16461": [
"CVE-2006-2407"
],
"16462": [
"CVE-2006-2407"
],
"16463": [
"CVE-2002-1359"
],
"16464": [
"CVE-2004-0362"
],
"16465": [
"CVE-2003-0220"
],
"16466": [
"CVE-2005-0491"
],
"16467": [
"CVE-2001-0333"
],
"16468": [
"CVE-1999-0874"
],
"16469": [
"CVE-2001-0241"
],
"16470": [
"CVE-2003-0109"
],
"16471": [],
"16472": [
"CVE-2001-0500"
],
"16473": [
"CVE-2007-1373"
],
"16474": [
"CVE-2005-4267"
],
"16475": [
"CVE-2006-6423"
],
"16476": [
"CVE-2006-1255"
],
"16478": [
"CVE-2006-6761"
],
"16479": [
"CVE-2004-1520"
],
"16480": [
"CVE-2005-3155"
],
"16481": [
"CVE-2006-1255"
],
"16482": [
"CVE-2008-1358"
],
"16483": [
"CVE-2005-3314"
],
"16484": [
"CVE-2004-1211"
],
"16485": [
"CVE-2005-2278"
],
"16486": [],
"16487": [
"CVE-2007-3925"
],
"16488": [
"CVE-2006-6425"
],
"16489": [
"CVE-2001-0167"
],
"16490": [
"CVE-2006-1652"
],
"16491": [
"CVE-2001-0168"
],
"16492": [
"CVE-2010-3106"
],
"16493": [
"CVE-2008-4830"
],
"16494": [
"CVE-2010-2883"
],
"16495": [
"CVE-2010-3563"
],
"16496": [
"CVE-2007-5217"
],
"16497": [
"CVE-2007-5601"
],
"16498": [
"CVE-2007-3605"
],
"16499": [],
"16500": [
"CVE-2010-0679"
],
"16502": [
"CVE-2007-4474"
],
"16505": [
"CVE-2008-5711"
],
"16506": [
"CVE-2006-4777"
],
"16507": [
"CVE-2008-3704"
],
"16508": [
"CVE-2008-2908"
],
"16509": [
"CVE-2010-3765"
],
"16510": [
"CVE-2006-3961"
],
"16511": [
"CVE-2007-2918"
],
"16512": [
"CVE-2008-4388"
],
"16513": [
"CVE-2008-3878"
],
"16514": [
"CVE-2008-0935"
],
"16515": [
"CVE-2009-2011"
],
"16516": [
"CVE-2010-3973"
],
"16517": [
"CVE-2009-0215"
],
"16518": [
"CVE-2008-5002"
],
"16519": [
"CVE-2007-3147"
],
"16520": [
"CVE-2008-5492"
],
"16521": [
"CVE-2008-3008"
],
"16522": [
"CVE-2007-4515"
],
"16523": [
"CVE-2009-1568"
],
"16524": [
"CVE-2009-4588"
],
"16525": [
"CVE-2004-0636"
],
"16526": [
"CVE-2007-0038"
],
"16527": [
"CVE-2007-0015"
],
"16528": [
"CVE-2009-3033"
],
"16529": [
"CVE-2007-0348"
],
"16530": [
"CVE-2003-1336"
],
"16532": [
"CVE-2006-5745"
],
"16533": [
"CVE-2010-3971"
],
"16534": [],
"16535": [
"CVE-2007-0325"
],
"16536": [],
"16537": [
"CVE-2009-1136"
],
"16538": [
"CVE-2006-6707"
],
"16539": [
"CVE-2008-0955"
],
"16540": [
"CVE-2007-2987"
],
"16541": [
"CVE-2010-0483"
],
"16542": [
"CVE-2009-1534"
],
"16543": [
"CVE-2009-1569"
],
"16544": [],
"16545": [
"CVE-2010-1885"
],
"16547": [
"CVE-2009-3672"
],
"16548": [
"CVE-2009-0323"
],
"16549": [
"CVE-2006-1016"
],
"16550": [],
"16551": [
"CVE-2010-3962"
],
"16552": [
"CVE-2008-4385"
],
"16553": [
"CVE-2009-1612"
],
"16554": [
"CVE-2006-5650"
],
"16555": [
"CVE-2009-0075"
],
"16557": [
"CVE-2007-5107"
],
"16558": [
"CVE-2010-1799"
],
"16559": [
"CVE-2007-1559"
],
"16560": [],
"16561": [
"CVE-2006-4704",
"CVE-2006-0003"
],
"16563": [
"CVE-2008-1724"
],
"16564": [
"CVE-2006-3730"
],
"16565": [
"CVE-2007-3435"
],
"16566": [],
"16567": [
"CVE-2010-0805"
],
"16568": [
"CVE-2006-2086"
],
"16569": [
"CVE-2009-0187"
],
"16570": [
"CVE-2009-4850"
],
"16571": [
"CVE-2008-4384"
],
"16572": [
"CVE-2007-5779"
],
"16573": [
"CVE-2007-5660"
],
"16574": [
"CVE-2010-2568"
],
"16575": [
"CVE-2007-4475"
],
"16576": [
"CVE-2008-0492"
],
"16577": [
"CVE-2008-1472"
],
"16578": [
"CVE-2006-1359"
],
"16579": [
"CVE-2007-4607"
],
"16580": [
"CVE-2007-1819"
],
"16581": [
"CVE-2003-0344"
],
"16582": [
"CVE-2007-6016"
],
"16583": [
"CVE-2008-4844"
],
"16584": [
"CVE-2008-1309"
],
"16585": [
"CVE-2010-0886"
],
"16586": [
"CVE-2005-0455"
],
"16587": [
"CVE-2010-3552"
],
"16588": [
"CVE-2007-6530"
],
"16590": [
"CVE-2010-0806"
],
"16591": [],
"16592": [
"CVE-2007-1682"
],
"16594": [
"CVE-2010-3653"
],
"16595": [
"CVE-2004-0363"
],
"16597": [
"CVE-2006-4868"
],
"16598": [
"CVE-2009-3693"
],
"16599": [
"CVE-2010-0249"
],
"16600": [
"CVE-2009-3028"
],
"16601": [
"CVE-2007-2919"
],
"16602": [
"CVE-2007-5660"
],
"16603": [
"CVE-2007-0018"
],
"16604": [
"CVE-2008-3558"
],
"16605": [
"CVE-2008-2463"
],
"16607": [
"CVE-2006-5198"
],
"16608": [
"CVE-2007-2238"
],
"16609": [
"CVE-2007-4466"
],
"16610": [
"CVE-2007-1689"
],
"16611": [
"CVE-2008-0065"
],
"16612": [
"CVE-2005-4560"
],
"16613": [
"CVE-2009-3031"
],
"16616": [
"CVE-2007-5603"
],
"16630": [
"CVE-2009-4225"
],
"16635": [],
"16638": [
"CVE-2008-4922"
],
"16639": [],
"16641": [
"CVE-2008-6898"
],
"16647": [],
"16649": [
"CVE-2008-1898"
],
"41783": [
"CVE-2016-6816",
"CVE-2016-6816"
],
"16685": [
"CVE-2010-4742"
],
"16690": [
"CVE-2006-2926"
],
"16691": [
"CVE-2005-4085"
],
"16692": [
"CVE-2004-0326"
],
"16693": [
"CVE-2004-0608"
],
"16694": [
"CVE-2007-4370"
],
"16695": [
"CVE-2004-0735"
],
"16696": [
"CVE-2008-2499"
],
"16697": [
"CVE-2008-2240"
],
"16698": [
"CVE-2007-1765",
"CVE-2007-0038"
],
"16699": [
"CVE-2010-0266"
],
"16700": [
"CVE-2010-0266"
],
"16701": [
"CVE-2008-0226"
],
"16702": [
"CVE-2006-2212",
"CVE-2006-0441"
],
"16703": [
"CVE-2005-1415"
],
"16704": [],
"16705": [],
"16706": [
"CVE-1999-0256"
],
"16707": [
"CVE-2005-3683"
],
"16708": [
"CVE-2003-0558"
],
"16709": [
"CVE-2009-3976"
],
"16710": [
"CVE-2010-1465"
],
"16711": [],
"16712": [
"CVE-2004-2074"
],
"16713": [
"CVE-2006-2961"
],
"16714": [
"CVE-2003-0727"
],
"16715": [
"CVE-2004-0330"
],
"16716": [],
"16717": [
"CVE-2006-4847"
],
"16718": [
"CVE-2006-5792"
],
"16719": [
"CVE-2004-1135"
],
"16720": [],
"16721": [],
"16722": [
"CVE-2006-5792"
],
"16723": [],
"16724": [
"CVE-1999-0256"
],
"16725": [],
"16726": [],
"16727": [],
"16728": [],
"16729": [
"CVE-2005-2373"
],
"16730": [
"CVE-2005-0277"
],
"16731": [
"CVE-2003-0727"
],
"16732": [
"CVE-2009-4769"
],
"16733": [
"CVE-2006-3726"
],
"16734": [],
"16735": [
"CVE-2005-1323"
],
"16736": [],
"16737": [],
"16738": [],
"16739": [],
"16740": [
"CVE-2009-3023"
],
"16741": [
"CVE-2006-4318"
],
"16742": [
"CVE-2006-3952"
],
"16743": [],
"16744": [
"CVE-2005-0581"
],
"16745": [
"CVE-2005-0581"
],
"16746": [
"CVE-2005-0353"
],
"16747": [
"CVE-2005-0059"
],
"16748": [
"CVE-2007-1748"
],
"16749": [
"CVE-2003-0352"
],
"16750": [
"CVE-2007-3039"
],
"16751": [
"CVE-2004-1373"
],
"16752": [
"CVE-2006-3747"
],
"16753": [
"CVE-2007-5067"
],
"16754": [
"CVE-2004-2271"
],
"16755": [],
"16756": [
"CVE-2004-2086"
],
"16757": [
"CVE-2006-0992"
],
"16758": [
"CVE-2007-3614"
],
"16759": [
"CVE-2006-5216"
],
"16760": [
"CVE-2006-3252"
],
"16761": [
"CVE-2005-0595"
],
"16762": [
"CVE-2008-5457"
],
"16763": [
"CVE-2004-1561"
],
"16764": [
"CVE-2007-4880"
],
"16765": [
"CVE-2006-4305"
],
"16766": [
"CVE-2005-2297"
],
"16767": [
"CVE-2003-1192"
],
"16768": [
"CVE-2008-1365"
],
"16769": [
"CVE-2005-2551"
],
"16770": [
"CVE-2002-1120"
],
"16771": [],
"16772": [
"CVE-2004-2466"
],
"16773": [
"CVE-2006-5478"
],
"16774": [
"CVE-2008-1697"
],
"16775": [
"CVE-2009-4006"
],
"16776": [
"CVE-2003-0471"
],
"16777": [
"CVE-2009-0183"
],
"16778": [],
"16779": [
"CVE-2008-0871"
],
"16780": [
"CVE-2009-3849"
],
"16781": [
"CVE-2005-1348"
],
"16782": [
"CVE-2002-0392"
],
"16783": [
"CVE-2006-5156"
],
"16784": [
"CVE-2010-5324",
"CVE-2010-5323"
],
"16785": [
"CVE-2009-2685"
],
"16786": [
"CVE-2006-1148"
],
"16787": [
"CVE-2004-0798"
],
"16789": [
"CVE-2009-3068"
],
"16791": [
"CVE-2005-0684"
],
"16792": [
"CVE-2009-4178"
],
"16793": [],
"16794": [
"CVE-2009-4769"
],
"16795": [
"CVE-2008-0067"
],
"16796": [
"CVE-2008-4008"
],
"16797": [
"CVE-2009-4179"
],
"16798": [
"CVE-2007-0774"
],
"16799": [
"CVE-2009-3711"
],
"16800": [
"CVE-2008-0550"
],
"16801": [
"CVE-2005-3190"
],
"16802": [
"CVE-2002-2268"
],
"16803": [
"CVE-2008-4193"
],
"16804": [],
"16805": [
"CVE-2007-6204"
],
"16806": [
"CVE-2007-6377"
],
"16807": [],
"16808": [
"CVE-2006-5112"
],
"16809": [
"CVE-2003-0727"
],
"16810": [
"CVE-2007-1868"
],
"16811": [
"CVE-2005-0478"
],
"16812": [
"CVE-2003-1200"
],
"16813": [
"CVE-2006-6424"
],
"16814": [
"CVE-2008-2703"
],
"16815": [
"CVE-2005-1543"
],
"16816": [
"CVE-2000-0665"
],
"16817": [
"CVE-2005-0768"
],
"16818": [
"CVE-2004-1558"
],
"16819": [
"CVE-2005-2287"
],
"16820": [
"CVE-2003-0714"
],
"16821": [
"CVE-2007-4440"
],
"16822": [
"CVE-2004-1638"
],
"16823": [
"CVE-2001-1320"
],
"16824": [
"CVE-2004-0297"
],
"16825": [
"CVE-2005-2668"
],
"16826": [
"CVE-2009-1430"
],
"16827": [
"CVE-2007-1070"
],
"16828": [
"CVE-2007-2508"
],
"16829": [
"CVE-2007-2508"
],
"16830": [
"CVE-2006-2630"
],
"16831": [
"CVE-2009-1943"
],
"16832": [
"CVE-2005-2852"
],
"16833": [],
"16834": [
"CVE-2005-3252"
],
"16835": [
"CVE-2006-6332"
],
"16836": [
"CVE-2006-2502"
],
"16837": [
"CVE-2007-5208"
],
"16838": [
"CVE-2011-0404"
],
"16839": [
"CVE-2007-5243"
],
"16840": [
"CVE-2007-5244"
],
"16841": [
"CVE-2005-1099"
],
"16842": [
"CVE-2000-0917"
],
"16843": [
"CVE-2007-5243"
],
"16844": [
"CVE-2007-5243"
],
"16845": [
"CVE-2003-0213"
],
"16846": [
"CVE-2000-0284"
],
"16847": [
"CVE-2004-0541"
],
"16848": [
"CVE-2004-0608"
],
"16849": [
"CVE-2008-0226"
],
"16850": [
"CVE-2009-4484"
],
"16851": [
"CVE-2010-4221"
],
"16852": [
"CVE-2006-5815"
],
"16853": [
"CVE-2004-1388"
],
"16854": [
"CVE-2005-2799"
],
"16855": [
"CVE-2006-1148"
],
"16859": [
"CVE-2007-2446"
],
"16860": [
"CVE-2010-2063"
],
"16861": [
"CVE-2003-0201"
],
"16862": [
"CVE-2006-3459"
],
"16863": [
"CVE-2004-0430"
],
"16864": [
"CVE-2010-2309"
],
"16865": [
"CVE-2005-0491"
],
"16866": [
"CVE-2006-0848"
],
"16867": [
"CVE-2007-5863"
],
"16868": [
"CVE-2006-3459"
],
"16869": [
"CVE-2006-3459"
],
"16870": [
"CVE-2007-6165",
"CVE-2006-0395"
],
"16871": [
"CVE-2007-2386"
],
"16872": [
"CVE-2004-0695"
],
"16873": [
"CVE-2007-6166"
],
"16874": [
"CVE-2010-2309"
],
"16875": [
"CVE-2007-2446"
],
"16876": [
"CVE-2003-0201"
],
"16878": [
"CVE-2010-4221"
],
"16880": [
"CVE-2003-0201"
],
"16887": [
"CVE-2005-2773"
],
"16888": [
"CVE-2003-0990"
],
"16903": [
"CVE-2009-4098"
],
"16910": [],
"16915": [
"CVE-2010-3585"
],
"16916": [
"CVE-2010-4566"
],
"16918": [
"CVE-2009-4502"
],
"16920": [
"CVE-2006-2447"
],
"16921": [],
"16922": [
"CVE-2010-2075"
],
"16924": [
"CVE-2007-4560"
],
"16925": [
"CVE-2010-4345",
"CVE-2010-4344"
],
"16926": [
"CVE-2004-2221"
],
"16927": [
"CVE-2002-1473"
],
"16928": [
"CVE-2001-0797"
],
"16930": [
"CVE-2009-2727"
],
"16936": [
"CVE-2011-3142"
],
"16956": [
"CVE-2010-4321"
],
"16957": [],
"16964": [],
"16970": [
"CVE-2002-2268"
],
"16972": [],
"16974": [
"CVE-2010-1119"
],
"16984": [
"CVE-2011-0276"
],
"16985": [
"CVE-2010-2861"
],
"16990": [
"CVE-2010-4452"
],
"16993": [],
"16998": [
"CVE-2010-3747"
],
"17022": [],
"17024": [
"CVE-2011-1568",
"CVE-2011-1567",
"CVE-2011-1566",
"CVE-2011-1565"
],
"17027": [
"CVE-2011-0609"
],
"17028": [
"CVE-2011-0266"
],
"17029": [
"CVE-2010-2709"
],
"17030": [
"CVE-2010-2703"
],
"17031": [],
"17034": [
"CVE-2011-2963"
],
"17038": [
"CVE-2011-0267"
],
"17039": [
"CVE-2010-1552"
],
"17040": [
"CVE-2010-1554"
],
"17041": [
"CVE-2010-1964"
],
"17042": [
"CVE-2010-1553"
],
"17043": [
"CVE-2010-1960"
],
"17044": [
"CVE-2010-1961"
],
"17047": [
"CVE-2010-1555"
],
"17048": [
"CVE-2010-3275"
],
"17053": [],
"17058": [],
"17063": [],
"17068": [],
"17078": [],
"17104": [],
"17105": [],
"17181": [
"CVE-2007-1397"
],
"17148": [],
"17149": [],
"17151": [
"CVE-2010-3407"
],
"17152": [],
"17155": [
"CVE-2011-0364"
],
"17156": [],
"17175": [
"CVE-2011-0611"
],
"17187": [
"CVE-2010-3654"
],
"17195": [
"CVE-2011-1591"
],
"17199": [],
"17219": [
"CVE-2010-0620"
],
"17243": [],
"17240": [
"CVE-2011-2089"
],
"17244": [],
"17252": [
"CVE-2011-1574"
],
"17268": [],
"17269": [
"CVE-2011-2089"
],
"17279": [],
"17290": [],
"17300": [
"CVE-2011-1567"
],
"17304": [
"CVE-2011-0966",
"CVE-2011-0962",
"CVE-2011-0961",
"CVE-2011-0960",
"CVE-2011-0959"
],
"17328": [],
"17345": [
"CVE-2011-0922"
],
"17339": [
"CVE-2011-0923"
],
"17352": [
"CVE-2013-0657"
],
"17354": [],
"17355": [
"CVE-2006-6576"
],
"17356": [],
"17359": [],
"17361": [],
"17365": [],
"17366": [
"CVE-2011-2039"
],
"17373": [],
"17374": [
"CVE-2011-1567"
],
"17381": [],
"17456": [],
"17392": [
"CVE-2011-1220"
],
"17409": [
"CVE-2011-1260"
],
"17415": [
"CVE-2008-2683"
],
"17416": [],
"17417": [],
"17419": [
"CVE-2011-0073"
],
"17422": [
"CVE-2011-4716"
],
"17424": [
"CVE-2008-2683"
],
"17429": [],
"17430": [
"CVE-2011-0517"
],
"17434": [],
"17438": [],
"17450": [],
"17448": [
"CVE-2011-1213"
],
"17460": [],
"17462": [],
"17467": [
"CVE-2011-1865"
],
"17468": [
"CVE-2011-1865"
],
"17490": [
"CVE-2011-1865"
],
"17491": [],
"17498": [],
"17507": [],
"39661": [],
"39662": [],
"17513": [
"CVE-2011-5124"
],
"17517": [
"CVE-2011-0546"
],
"17519": [],
"17520": [
"CVE-2011-0073"
],
"17527": [],
"17535": [
"CVE-2011-3556"
],
"17537": [
"CVE-2009-0920"
],
"17539": [],
"17540": [],
"17543": [],
"17546": [],
"17548": [],
"17550": [],
"17557": [],
"17575": [
"CVE-2011-0222"
],
"17578": [],
"17581": [],
"17588": [],
"17612": [
"CVE-2011-0065"
],
"17614": [
"CVE-2011-0923"
],
"17619": [],
"17635": [
"CVE-2010-4107"
],
"17636": [
"CVE-2010-4107"
],
"17645": [],
"17648": [
"CVE-2011-0923"
],
"17649": [
"CVE-1999-1510"
],
"17650": [
"CVE-2011-0065"
],
"17656": [],
"17659": [
"CVE-2010-0480"
],
"17670": [],
"17669": [
"CVE-2011-2900"
],
"17672": [
"CVE-2011-0065"
],
"17691": [
"CVE-2010-1870"
],
"17692": [],
"17697": [
"CVE-2011-2404"
],
"17699": [
"CVE-2009-1429"
],
"17700": [],
"17719": [
"CVE-2006-2369"
],
"17721": [],
"17762": [
"CVE-2011-2882"
],
"17810": [
"CVE-1999-1510"
],
"17819": [
"CVE-2011-5166"
],
"17827": [
"CVE-2011-3322"
],
"17848": [
"CVE-2011-3496",
"CVE-2011-3490"
],
"17849": [
"CVE-2011-2950"
],
"17855": [
"CVE-2011-3492"
],
"17870": [
"CVE-2011-5166"
],
"17876": [
"CVE-2011-3976"
],
"17883": [
"CVE-2011-5127"
],
"17884": [
"CVE-2011-3493"
],
"17886": [],
"17904": [
"CVE-2011-3976"
],
"17936": [
"CVE-2011-2628"
],
"17948": [
"CVE-2011-3976"
],
"17969": [
"CVE-2011-3368"
],
"17960": [],
"17974": [
"CVE-2011-2371"
],
"17975": [
"CVE-2011-4044"
],
"17976": [
"CVE-2011-2371"
],
"17977": [],
"17986": [
"CVE-2011-3230"
],
"17993": [
"CVE-2011-1774",
"CVE-2011-1425"
],
"18015": [
"CVE-2009-3999"
],
"18016": [],
"18051": [
"CVE-2012-0241"
],
"18057": [
"CVE-2011-4040"
],
"18062": [],
"18079": [
"CVE-2011-4716"
],
"18089": [
"CVE-2011-5166"
],
"18092": [
"CVE-2011-5167"
],
"18093": [
"CVE-2007-4517"
],
"18102": [
"CVE-2011-5164"
],
"18123": [
"CVE-2010-5194",
"CVE-2010-5193"
],
"18125": [
"CVE-2011-3360"
],
"18134": [
"CVE-2010-0356"
],
"18138": [
"CVE-2011-4404",
"CVE-2009-1523"
],
"18145": [
"CVE-2011-1591"
],
"18171": [
"CVE-2011-3544"
],
"18172": [
"CVE-2011-5010"
],
"18179": [
"CVE-2011-1519",
"CVE-2011-0920"
],
"18181": [],
"18182": [
"CVE-2011-4800"
],
"18183": [
"CVE-2011-5003"
],
"18187": [
"CVE-2011-5007"
],
"18189": [
"CVE-2011-4722"
],
"18190": [
"CVE-2004-2111"
],
"18235": [
"CVE-2011-4717"
],
"18240": [
"CVE-2011-5007"
],
"18280": [
"CVE-2011-4862"
],
"18283": [
"CVE-2011-5052"
],
"18291": [
"CVE-2011-5053"
],
"18984": [
"CVE-2012-0391"
],
"18345": [
"CVE-2008-1611"
],
"18354": [],
"18376": [],
"18365": [
"CVE-2005-1790"
],
"18367": [],
"18368": [
"CVE-2011-4862"
],
"18369": [
"CVE-2011-4862"
],
"18377": [
"CVE-2011-0065"
],
"18381": [
"CVE-2011-4786"
],
"18382": [
"CVE-2012-6530"
],
"18388": [
"CVE-2011-3167"
],
"18393": [],
"18397": [],
"18401": [],
"18697": [],
"18420": [
"CVE-2012-6530"
],
"18423": [
"CVE-2011-4789"
],
"18426": [
"CVE-2012-0003"
],
"18437": [
"CVE-2011-2140"
],
"18442": [
"CVE-2012-0053"
],
"18446": [
"CVE-2010-2300",
"CVE-2010-1759"
],
"18448": [],
"18449": [
"CVE-2008-2551"
],
"18476": [],
"18478": [],
"18479": [
"CVE-2011-2140"
],
"18485": [
"CVE-2010-0842"
],
"18492": [
"CVE-2012-0209"
],
"18520": [
"CVE-2012-0500"
],
"18514": [
"CVE-2011-5001"
],
"18521": [
"CVE-2011-0923"
],
"18531": [
"CVE-2011-2371"
],
"18534": [],
"18535": [],
"18538": [
"CVE-2012-4924"
],
"18539": [
"CVE-2012-0201"
],
"18542": [
"CVE-2012-1466"
],
"18543": [
"CVE-2012-1464"
],
"18565": [],
"18555": [
"CVE-2012-4992"
],
"18557": [],
"18703": [],
"18572": [
"CVE-2012-0754"
],
"18619": [],
"18604": [
"CVE-2012-1465"
],
"18610": [
"CVE-2012-5335"
],
"18704": [],
"18621": [],
"18622": [
"CVE-2012-1195"
],
"18623": [
"CVE-2012-1196"
],
"18624": [],
"18625": [
"CVE-2012-1065"
],
"18634": [],
"18640": [],
"18642": [
"CVE-2010-0248"
],
"18695": [],
"18658": [
"CVE-2012-5002"
],
"18666": [
"CVE-2008-0610"
],
"18672": [
"CVE-2012-5897"
],
"18673": [
"CVE-2012-5306"
],
"18674": [
"CVE-2012-5896"
],
"18675": [
"CVE-2012-4876"
],
"18679": [
"CVE-2012-0507"
],
"18683": [],
"18709": [
"CVE-2012-4876"
],
"18714": [
"CVE-2012-1196",
"CVE-2012-1195"
],
"18718": [],
"18723": [
"CVE-2006-5276"
],
"18727": [
"CVE-2012-0198"
],
"18735": [
"CVE-2012-5896"
],
"18738": [
"CVE-2011-4828"
],
"18759": [
"CVE-2008-1611"
],
"18761": [
"CVE-2008-5499"
],
"18763": [],
"18780": [
"CVE-2012-0158"
],
"18779": [
"CVE-2012-2441",
"CVE-2012-1803"
],
"18833": [],
"18805": [
"CVE-2012-4598"
],
"18812": [
"CVE-2012-4598"
],
"18818": [
"CVE-2012-2576"
],
"18825": [
"CVE-2012-1775"
],
"18834": [
"CVE-2012-2336",
"CVE-2012-2311",
"CVE-2012-1823"
],
"18836": [
"CVE-2012-2336",
"CVE-2012-2311",
"CVE-2012-1823"
],
"18847": [
"CVE-2011-3658"
],
"18866": [],
"18870": [
"CVE-2011-3659"
],
"18896": [],
"18893": [
"CVE-2012-4362",
"CVE-2012-4361",
"CVE-2012-2986"
],
"18898": [
"CVE-2012-6554"
],
"18897": [
"CVE-2008-3257"
],
"18901": [
"CVE-2012-4362",
"CVE-2012-4361",
"CVE-2012-2986"
],
"18915": [],
"18929": [],
"18933": [],
"18942": [
"CVE-2012-0297"
],
"19025": [
"CVE-2012-3815"
],
"18967": [],
"18968": [],
"18969": [],
"18973": [
"CVE-2012-2763"
],
"18986": [],
"19027": [
"CVE-2012-4333"
],
"19026": [
"CVE-2002-1142"
],
"19002": [
"CVE-2011-3400"
],
"19030": [
"CVE-2011-2217"
],
"19028": [
"CVE-1999-0095"
],
"19033": [],
"19039": [],
"19040": [
"CVE-1999-0209"
],
"19044": [],
"19047": [
"CVE-1999-1504"
],
"19048": [],
"19069": [
"CVE-1999-1113"
],
"19079": [],
"19081": [],
"19083": [
"CVE-1999-1555"
],
"19084": [
"CVE-1999-0268"
],
"19086": [
"CVE-1999-0368"
],
"19087": [
"CVE-1999-0368"
],
"19091": [
"CVE-2012-1493"
],
"19092": [
"CVE-2012-2122"
],
"19093": [
"CVE-1999-0477",
"CVE-1999-0455"
],
"19094": [
"CVE-1999-0487"
],
"19096": [
"CVE-1999-0002"
],
"19099": [
"CVE-2012-1493"
],
"19101": [
"CVE-1999-0003"
],
"19102": [
"CVE-1999-0003"
],
"40434": [],
"19104": [
"CVE-1999-0018"
],
"19105": [
"CVE-1999-0021"
],
"19107": [
"CVE-1999-0005"
],
"19109": [
"CVE-1999-0006"
],
"19110": [
"CVE-1999-0006"
],
"19111": [
"CVE-1999-0009"
],
"19112": [
"CVE-1999-0009"
],
"19113": [],
"19118": [
"CVE-1999-0278"
],
"19119": [],
"19120": [
"CVE-1999-1437"
],
"19121": [
"CVE-1999-1436"
],
"19123": [],
"19124": [
"CVE-1999-1433"
],
"19127": [],
"19129": [
"CVE-1999-0736"
],
"19131": [
"CVE-2007-1195"
],
"19141": [
"CVE-2012-1875"
],
"19147": [
"CVE-1999-1538"
],
"19149": [
"CVE-1999-0448"
],
"19152": [
"CVE-1999-0450"
],
"19387": [
"CVE-2012-0677"
],
"19156": [
"CVE-1999-0347"
],
"19402": [],
"19164": [
"CVE-1999-1453"
],
"19177": [],
"19186": [
"CVE-2012-1889"
],
"19193": [
"CVE-1999-0800"
],
"19194": [
"CVE-1999-1375"
],
"19197": [],
"19208": [
"CVE-1999-1520"
],
"19218": [
"CVE-1999-0219"
],
"19219": [
"CVE-1999-1510"
],
"19221": [
"CVE-1999-0928"
],
"19222": [
"CVE-1999-0927"
],
"19223": [
"CVE-1999-0887"
],
"19224": [],
"19226": [
"CVE-1999-0920"
],
"19231": [
"CVE-2012-2329"
],
"19236": [
"CVE-1999-1413"
],
"19237": [],
"19239": [],
"19242": [
"CVE-1999-1063"
],
"19245": [
"CVE-1999-0874"
],
"19246": [
"CVE-1999-0874"
],
"19247": [
"CVE-1999-0874"
],
"19248": [
"CVE-1999-0874"
],
"19251": [
"CVE-1999-1024"
],
"19253": [
"CVE-1999-0678"
],
"19266": [],
"19288": [
"CVE-2011-0922"
],
"19291": [],
"19295": [
"CVE-2011-2110",
"CVE-2008-4192"
],
"19601": [
"CVE-1999-1509"
],
"19297": [
"CVE-1999-1488"
],
"19298": [
"CVE-1999-0149"
],
"19299": [
"CVE-1999-0039"
],
"19303": [
"CVE-1999-0148"
],
"19316": [
"CVE-1999-1485"
],
"19322": [],
"19327": [
"CVE-1999-0493"
],
"19348": [
"CVE-1999-0113"
],
"19407": [
"CVE-2011-3478"
],
"19361": [
"CVE-1999-0725"
],
"19363": [
"CVE-1999-0239"
],
"19364": [
"CVE-1999-0470"
],
"19365": [
"CVE-1999-1020"
],
"19369": [
"CVE-2012-0779"
],
"19383": [],
"19420": [
"CVE-1999-0696"
],
"19421": [
"CVE-1999-0696"
],
"19424": [
"CVE-1999-1011"
],
"19426": [],
"19435": [
"CVE-2000-0325"
],
"19442": [],
"19443": [
"CVE-1999-1130"
],
"19444": [
"CVE-1999-0913"
],
"19448": [
"CVE-1999-0671"
],
"19449": [
"CVE-1999-0672"
],
"19450": [
"CVE-1999-0673"
],
"19451": [
"CVE-1999-0875"
],
"19458": [
"CVE-1999-0426",
"CVE-1999-0414"
],
"19459": [
"CVE-1999-0679"
],
"19466": [
"CVE-1999-0753"
],
"19468": [
"CVE-1999-0668"
],
"19475": [
"CVE-1999-0911"
],
"19476": [
"CVE-1999-0911"
],
"19478": [
"CVE-1999-0704"
],
"19479": [
"CVE-1999-0704"
],
"19484": [
"CVE-2012-0124"
],
"19486": [
"CVE-1999-0685"
],
"19487": [
"CVE-1999-0669"
],
"19490": [
"CVE-1999-0702"
],
"19491": [],
"19492": [
"CVE-1999-0750"
],
"19493": [
"CVE-1999-0751"
],
"19494": [],
"19495": [
"CVE-1999-1521"
],
"19496": [
"CVE-1999-0759"
],
"19503": [
"CVE-2000-0824"
],
"19514": [
"CVE-1999-1576"
],
"19515": [
"CVE-1999-1575"
],
"19520": [],
"19521": [
"CVE-1999-1577",
"CVE-1999-1575"
],
"19522": [
"CVE-2004-0641",
"CVE-2002-1463",
"CVE-2001-1104",
"CVE-2001-0751",
"CVE-2001-0328",
"CVE-2001-0288",
"CVE-2001-0163",
"CVE-2001-0162",
"CVE-2000-0916",
"CVE-1999-0077"
],
"19530": [
"CVE-1999-0891"
],
"19532": [
"CVE-1999-0789"
],
"19537": [
"CVE-1999-0933"
],
"19538": [
"CVE-1999-0791"
],
"19539": [
"CVE-1999-0877"
],
"19540": [
"CVE-1999-1083",
"CVE-1999-1082"
],
"19553": [
"CVE-1999-0068"
],
"19554": [
"CVE-1999-0060"
],
"19555": [
"CVE-1999-0060"
],
"19557": [
"CVE-1999-0066"
],
"19558": [
"CVE-1999-0943"
],
"19559": [
"CVE-1999-0793"
],
"19560": [
"CVE-1999-0879"
],
"19561": [
"CVE-2000-0016"
],
"19566": [
"CVE-1999-0951"
],
"19567": [
"CVE-1999-1481"
],
"19568": [
"CVE-1999-0915"
],
"19570": [
"CVE-1999-0950"
],
"19576": [
"CVE-2012-0708"
],
"19580": [],
"19581": [],
"19584": [
"CVE-1999-0873"
],
"19586": [],
"19587": [
"CVE-1999-0947"
],
"19588": [
"CVE-1999-1531"
],
"19589": [],
"19591": [
"CVE-1999-0981"
],
"19592": [
"CVE-1999-0896"
],
"19593": [
"CVE-1999-0896"
],
"19595": [
"CVE-1999-0885"
],
"19603": [
"CVE-2000-0329"
],
"20122": [
"CVE-2010-3964"
],
"20120": [],
"19903": [
"CVE-2000-0381"
],
"19607": [
"CVE-2000-0330"
],
"19608": [
"CVE-2000-0330"
],
"19611": [
"CVE-2000-1116"
],
"19612": [
"CVE-2001-0679",
"CVE-1999-1529"
],
"19613": [],
"19614": [
"CVE-2001-0679",
"CVE-1999-1529"
],
"19617": [],
"19618": [
"CVE-1999-1110"
],
"19620": [
"CVE-1999-1050"
],
"19621": [
"CVE-1999-1190"
],
"19622": [],
"19623": [],
"19625": [],
"19632": [
"CVE-1999-1508"
],
"19634": [
"CVE-2000-0165"
],
"19637": [],
"19644": [
"CVE-1999-0842"
],
"19645": [
"CVE-1999-0822"
],
"19646": [
"CVE-1999-0822"
],
"19662": [
"CVE-1999-0869"
],
"19663": [
"CVE-1999-0973"
],
"19667": [
"CVE-1999-0972"
],
"19668": [
"CVE-1999-0977"
],
"19669": [
"CVE-1999-0977"
],
"19670": [
"CVE-1999-0977"
],
"19672": [
"CVE-1999-0977"
],
"19679": [
"CVE-1999-0996"
],
"19680": [
"CVE-2000-0026"
],
"19682": [
"CVE-1999-1005"
],
"19686": [
"CVE-2000-0028"
],
"19688": [
"CVE-2000-0002"
],
"19689": [
"CVE-2000-0002"
],
"19690": [
"CVE-2000-0038"
],
"19691": [
"CVE-2000-0010"
],
"19694": [
"CVE-2000-0039"
],
"19696": [
"CVE-2000-0012"
],
"19705": [
"CVE-1999-0744"
],
"19708": [
"CVE-2000-0059"
],
"19712": [
"CVE-2000-0057"
],
"19713": [
"CVE-2000-0054"
],
"40086": [
"CVE-2016-2098"
],
"19717": [
"CVE-2012-1723"
],
"19718": [
"CVE-2011-2657"
],
"19719": [
"CVE-2000-0156",
"CVE-2000-0061"
],
"19722": [
"CVE-2000-1221"
],
"19724": [
"CVE-2000-0046"
],
"19729": [
"CVE-2000-0096"
],
"19730": [
"CVE-2000-0065"
],
"19731": [
"CVE-2000-0097"
],
"19732": [
"CVE-2000-0116"
],
"19734": [
"CVE-2000-0132"
],
"19889": [
"CVE-2000-0347"
],
"19737": [
"CVE-2000-0133"
],
"19738": [
"CVE-2000-0653",
"CVE-2000-0105"
],
"19741": [
"CVE-2000-0125"
],
"19742": [
"CVE-2000-0126"
],
"19743": [
"CVE-2000-0129"
],
"19745": [
"CVE-2000-0128"
],
"19747": [
"CVE-2000-0149"
],
"19749": [],
"19751": [],
"19753": [
"CVE-1999-0386"
],
"19761": [
"CVE-2000-0213"
],
"19781": [
"CVE-2000-0187"
],
"19784": [
"CVE-2000-0191"
],
"19785": [
"CVE-2000-0208"
],
"19786": [
"CVE-2000-0177"
],
"19788": [
"CVE-2000-0207"
],
"19830": [
"CVE-2000-0302"
],
"19795": [
"CVE-2000-0192"
],
"19797": [
"CVE-2000-0174"
],
"19800": [],
"19801": [
"CVE-2000-0183"
],
"19805": [
"CVE-2000-0185"
],
"19808": [
"CVE-2000-0180"
],
"19809": [
"CVE-2000-0169"
],
"19814": [
"CVE-2000-0236"
],
"19815": [
"CVE-2000-0240"
],
"19819": [
"CVE-2000-0242"
],
"19822": [
"CVE-2000-0245"
],
"19824": [
"CVE-2000-0246"
],
"19828": [
"CVE-2000-0234"
],
"19831": [],
"19832": [],
"19833": [],
"19842": [
"CVE-2000-0282"
],
"19844": [
"CVE-2000-0287"
],
"19845": [
"CVE-2000-0260"
],
"19846": [
"CVE-2000-0260"
],
"19847": [
"CVE-2000-0284"
],
"19848": [
"CVE-2000-0284"
],
"19849": [
"CVE-2000-0284"
],
"19852": [
"CVE-2000-0254"
],
"19857": [],
"19905": [
"CVE-2000-0412"
],
"19868": [
"CVE-2000-0295"
],
"19871": [
"CVE-2000-0339"
],
"19877": [],
"19879": [
"CVE-2000-0248"
],
"19881": [
"CVE-2000-0429"
],
"19882": [
"CVE-2000-0380"
],
"19886": [
"CVE-2000-0343"
],
"19887": [
"CVE-2000-0343"
],
"19888": [
"CVE-2000-0343"
],
"19890": [
"CVE-2000-0332"
],
"19891": [
"CVE-2000-0333"
],
"19892": [
"CVE-2000-0333"
],
"19893": [
"CVE-2000-0425"
],
"19895": [
"CVE-2000-0423"
],
"19897": [
"CVE-2000-0413"
],
"19901": [
"CVE-2000-0379"
],
"19906": [
"CVE-2000-0411"
],
"19908": [
"CVE-2000-0457"
],
"19909": [
"CVE-2001-0329"
],
"19913": [
"CVE-2000-0424"
],
"19914": [
"CVE-2000-0397"
],
"19916": [
"CVE-2000-0405"
],
"19917": [
"CVE-2000-0405"
],
"19918": [
"CVE-2000-0405"
],
"19921": [
"CVE-2000-0432"
],
"19922": [
"CVE-2000-0350"
],
"19924": [
"CVE-2000-0389"
],
"19926": [
"CVE-2000-0389"
],
"19928": [
"CVE-2000-0400"
],
"19966": [
"CVE-2000-0446"
],
"19931": [],
"19932": [],
"19937": [],
"19939": [
"CVE-2000-0465"
],
"19942": [],
"19943": [
"CVE-2000-0451"
],
"19944": [
"CVE-2000-1046",
"CVE-2000-0452"
],
"19945": [
"CVE-2000-0436"
],
"19947": [
"CVE-2000-0491"
],
"19948": [
"CVE-2000-0491"
],
"19949": [
"CVE-2000-0437 "
],
"19951": [
"CVE-2000-0136"
],
"19956": [
"CVE-2000-0443"
],
"19957": [
"CVE-2000-0396"
],
"19958": [
"CVE-2011-3176",
"CVE-2011-3175"
],
"19959": [
"CVE-2011-3176",
"CVE-2011-3175"
],
"19973": [],
"19975": [
"CVE-2000-0505"
],
"19976": [
"CVE-2000-0507"
],
"19978": [
"CVE-2000-0493"
],
"19983": [
"CVE-2000-0490"
],
"19995": [
"CVE-2000-0521"
],
"19997": [
"CVE-2000-0523"
],
"19998": [
"CVE-2000-0472"
],
"20007": [
"CVE-2000-0527"
],
"20008": [
"CVE-2000-0526"
],
"20009": [
"CVE-2012-2593"
],
"20019": [
"CVE-2000-0430"
],
"20027": [
"CVE-2000-0500"
],
"20028": [],
"20030": [
"CVE-2000-0573"
],
"20031": [
"CVE-2000-0573"
],
"20032": [
"CVE-2000-0573"
],
"20040": [
"CVE-2000-0592"
],
"20041": [
"CVE-2000-0588"
],
"20043": [
"CVE-2000-0586"
],
"20046": [
"CVE-2000-0577"
],
"20048": [
"CVE-2000-0580"
],
"20059": [
"CVE-2000-0590"
],
"20060": [
"CVE-2000-0594"
],
"20061": [
"CVE-2000-0584"
],
"20065": [
"CVE-2000-0640"
],
"20066": [
"CVE-2000-0641"
],
"20067": [
"CVE-2000-0613"
],
"20068": [
"CVE-2000-0638"
],
"20070": [
"CVE-2000-0660 "
],
"20074": [
"CVE-2000-0675"
],
"20075": [
"CVE-2000-0666"
],
"20076": [
"CVE-2000-0666"
],
"20077": [
"CVE-2000-0666"
],
"20078": [
"CVE-2000-0567"
],
"20079": [
"CVE-2000-0567"
],
"20082": [],
"20085": [
"CVE-2000-0626"
],
"20086": [
"CVE-2000-0622"
],
"20088": [
"CVE-2012-2953"
],
"20089": [
"CVE-2000-0630"
],
"20091": [
"CVE-2000-0634"
],
"20095": [],
"20096": [
"CVE-2000-0649"
],
"20097": [
"CVE-2000-0652"
],
"20103": [
"CVE-2000-0664"
],
"20104": [
"CVE-2000-0671"
],
"20105": [
"CVE-2000-0668"
],
"20106": [
"CVE-2000-0673"
],
"20112": [],
"20113": [
"CVE-2012-2953"
],
"20301": [
"CVE-2000-0884"
],
"20145": [
"CVE-2000-0757"
],
"20125": [
"CVE-2000-0685"
],
"20131": [
"CVE-2000-0759"
],
"20132": [
"CVE-2000-0760"
],
"20134": [
"CVE-2000-0740"
],
"20135": [
"CVE-2000-0739"
],
"20136": [
"CVE-2000-0741"
],
"20139": [
"CVE-2000-0711"
],
"20140": [
"CVE-2000-0676"
],
"20143": [
"CVE-2000-0705"
],
"20144": [
"CVE-2000-0696"
],
"20146": [
"CVE-2000-0697"
],
"20148": [
"CVE-2000-0776"
],
"20149": [
"CVE-2000-0733"
],
"20150": [
"CVE-2000-0706"
],
"20151": [
"CVE-2000-0778"
],
"20152": [
"CVE-2000-0778"
],
"20156": [
"CVE-2000-0782"
],
"20157": [
"CVE-2000-0743"
],
"20159": [
"CVE-2000-0846"
],
"20161": [
"CVE-2000-0787"
],
"20163": [
"CVE-2000-0704"
],
"20164": [
"CVE-2000-0689"
],
"20165": [
"CVE-2000-0689"
],
"20168": [],
"20174": [
"CVE-2012-1876"
],
"20176": [
"CVE-2000-0688"
],
"20177": [
"CVE-2000-0688"
],
"20180": [
"CVE-2000-0775"
],
"20181": [],
"20182": [
"CVE-2000-0780"
],
"20183": [
"CVE-2000-0720"
],
"20184": [
"CVE-2000-0734"
],
"20194": [
"CVE-2000-0690"
],
"20299": [
"CVE-2000-0884"
],
"20300": [
"CVE-2000-0884"
],
"20202": [
"CVE-2012-0284"
],
"20204": [
"CVE-2012-2962"
],
"20205": [],
"20206": [
"CVE-2000-0903"
],
"20207": [
"CVE-2000-0904"
],
"20210": [
"CVE-2000-0869"
],
"20211": [
"CVE-2000-0828"
],
"20214": [],
"20215": [
"CVE-2000-1037"
],
"20216": [
"CVE-2000-1037"
],
"20218": [
"CVE-2000-0853"
],
"20220": [
"CVE-2000-0883"
],
"20222": [
"CVE-2000-0834"
],
"20223": [
"CVE-2000-0835"
],
"20224": [
"CVE-2000-0836"
],
"20231": [
"CVE-2000-1022"
],
"20234": [
"CVE-2000-1036"
],
"20235": [
"CVE-2000-1054"
],
"20236": [
"CVE-2000-1016"
],
"20237": [
"CVE-2000-0909"
],
"20238": [
"CVE-2000-1023"
],
"20240": [
"CVE-2000-0929"
],
"20242": [
"CVE-2000-1014"
],
"20243": [
"CVE-2001-0149"
],
"20244": [],
"20245": [],
"20246": [],
"20247": [
"CVE-2000-0926"
],
"20248": [
"CVE-2000-0925"
],
"20249": [
"CVE-2000-0930"
],
"20253": [
"CVE-2000-0992"
],
"20258": [
"CVE-1999-0208"
],
"20259": [
"CVE-1999-0208"
],
"20500": [],
"20266": [
"CVE-2000-1061"
],
"20298": [
"CVE-2000-0884"
],
"20269": [
"CVE-2000-0951"
],
"20273": [
"CVE-2000-0906"
],
"20277": [
"CVE-2000-0924"
],
"20279": [
"CVE-2000-1005"
],
"20280": [
"CVE-2000-0922"
],
"20281": [
"CVE-2000-0921"
],
"20283": [
"CVE-2000-0979"
],
"20284": [
"CVE-2000-0979"
],
"20286": [
"CVE-2000-0967"
],
"20287": [
"CVE-2000-0985"
],
"20288": [],
"20292": [
"CVE-2000-0973"
],
"20293": [
"CVE-2000-0973"
],
"20297": [
"CVE-2012-0549"
],
"20302": [
"CVE-2000-0884"
],
"20303": [
"CVE-2000-0977"
],
"20305": [
"CVE-1999-0360"
],
"20306": [],
"20308": [
"CVE-1999-0182"
],
"20309": [
"CVE-1999-0191"
],
"20313": [
"CVE-2000-1050"
],
"20314": [
"CVE-2000-1053"
],
"20315": [],
"20318": [],
"20319": [],
"20321": [
"CVE-2012-4177"
],
"20322": [
"CVE-2000-0958"
],
"20324": [
"CVE-2000-1075"
],
"20325": [
"CVE-2000-1075"
],
"20327": [
"CVE-1999-0492"
],
"20330": [
"CVE-2000-0945"
],
"20334": [
"CVE-2000-1033"
],
"20335": [
"CVE-2000-0942"
],
"20337": [
"CVE-2000-1026"
],
"20340": [
"CVE-2000-0937"
],
"20354": [],
"20355": [
"CVE-2012-3951"
],
"20369": [
"CVE-2000-1027"
],
"20370": [
"CVE-2000-0941"
],
"20371": [],
"20372": [
"CVE-2000-0955"
],
"20374": [
"CVE-2000-1029"
],
"20375": [
"CVE-1999-0283"
],
"20384": [
"CVE-2000-0886"
],
"20387": [
"CVE-2000-1176"
],
"20392": [
"CVE-2009-1730"
],
"20394": [
"CVE-1999-0968"
],
"20395": [
"CVE-1999-0968"
],
"20397": [],
"20399": [
"CVE-2000-1105"
],
"20404": [
"CVE-2000-1154"
],
"20405": [
"CVE-2000-1132"
],
"20406": [
"CVE-2000-1181"
],
"20408": [
"CVE-2000-1171"
],
"20412": [
"CVE-2000-1114"
],
"20413": [
"CVE-2000-1177"
],
"20414": [
"CVE-2000-1174"
],
"20424": [
"CVE-2000-1112"
],
"20423": [
"CVE-1999-0146"
],
"20425": [
"CVE-2000-1173"
],
"20426": [],
"20427": [
"CVE-2000-1113"
],
"20429": [
"CVE-2000-1224"
],
"20430": [
"CVE-1999-0266"
],
"20433": [
"CVE-1999-0985"
],
"20434": [
"CVE-1999-0264"
],
"20435": [
"CVE-1999-0070"
],
"20441": [
"CVE-2000-1110"
],
"20442": [
"CVE-1999-0935"
],
"20444": [
"CVE-1999-0934"
],
"20445": [
"CVE-1999-0233"
],
"20446": [
"CVE-1999-0467",
"CVE-1999-0287"
],
"20447": [
"CVE-1999-0467",
"CVE-1999-0287"
],
"20448": [
"CVE-1999-0175"
],
"20449": [
"CVE-1999-0147"
],
"20450": [
"CVE-2000-1100"
],
"20459": [
"CVE-2001-0089"
],
"20460": [
"CVE-2000-1089"
],
"20461": [
"CVE-2001-0054"
],
"20462": [
"CVE-1999-0262"
],
"20463": [
"CVE-1999-0176"
],
"20465": [
"CVE-1999-0710"
],
"20466": [
"CVE-2001-0042"
],
"20467": [],
"20468": [],
"20469": [
"CVE-2001-0021"
],
"20472": [
"CVE-2001-0051"
],
"20481": [
"CVE-1999-0154"
],
"20482": [
"CVE-1999-1081"
],
"20483": [
"CVE-1999-0196"
],
"20486": [
"CVE-1999-0173"
],
"20488": [
"CVE-2001-0038"
],
"20489": [
"CVE-2001-0037"
],
"20490": [
"CVE-2001-0050"
],
"20491": [
"CVE-2001-0034"
],
"20492": [
"CVE-2001-0032"
],
"20495": [
"CVE-2001-0028"
],
"20496": [
"CVE-2001-0028"
],
"20497": [
"CVE-2001-0023"
],
"20501": [],
"20502": [
"CVE-2011-2653"
],
"20503": [
"CVE-2001-0024"
],
"20504": [
"CVE-2001-0025"
],
"20506": [
"CVE-2001-0022"
],
"20507": [
"CVE-2000-1092"
],
"20510": [
"CVE-2000-1093"
],
"20511": [
"CVE-2000-1094"
],
"20512": [
"CVE-2001-0053"
],
"20513": [
"CVE-1999-1069"
],
"20516": [
"CVE-2001-0098"
],
"20519": [
"CVE-2001-0082"
],
"20522": [
"CVE-2001-0074"
],
"20523": [
"CVE-2001-0075"
],
"20524": [
"CVE-2001-0099"
],
"20525": [
"CVE-2001-0100"
],
"20527": [],
"20528": [
"CVE-2001-0148"
],
"20529": [
"CVE-2001-0009"
],
"20530": [
"CVE-2001-0009"
],
"20533": [
"CVE-2001-0123"
],
"20537": [
"CVE-2001-0008"
],
"20547": [
"CVE-2011-1255"
],
"20551": [],
"20553": [
"CVE-2001-0137"
],
"20557": [
"CVE-2001-0114",
"CVE-2001-0113"
],
"20559": [
"CVE-2001-0129"
],
"20563": [
"CVE-1999-0997"
],
"20565": [],
"20567": [
"CVE-1999-0238"
],
"20568": [
"CVE-1999-0174"
],
"20569": [
"CVE-2001-0233"
],
"20570": [],
"20571": [],
"20612": [
"CVE-2001-0202"
],
"20582": [
"CVE-2001-0197"
],
"20583": [
"CVE-1999-1479"
],
"20584": [
"CVE-2001-0255"
],
"20590": [],
"20591": [
"CVE-2001-0250"
],
"20592": [],
"20593": [
"CVE-2001-0183"
],
"20594": [
"CVE-2001-0187"
],
"20595": [
"CVE-1999-0236"
],
"20597": [
"CVE-1999-0207"
],
"20599": [
"CVE-1999-0204"
],
"20600": [
"CVE-1999-0404"
],
"20601": [
"CVE-2001-0253"
],
"20602": [
"CVE-1999-1588"
],
"20605": [
"CVE-2001-0198"
],
"20606": [
"CVE-2001-0173"
],
"20607": [
"CVE-2001-0228"
],
"20608": [
"CVE-2001-0199"
],
"20609": [
"CVE-2001-0200"
],
"20611": [
"CVE-2000-0975"
],
"20614": [
"CVE-2001-0205"
],
"20615": [
"CVE-2001-0471"
],
"20616": [
"CVE-2001-0206"
],
"20617": [
"CVE-2001-0144"
],
"20618": [
"CVE-2001-0319"
],
"20619": [
"CVE-2000-0017"
],
"20620": [
"CVE-2000-0306"
],
"20622": [
"CVE-2001-0192"
],
"20623": [
"CVE-2001-0210"
],
"20624": [
"CVE-2012-1535"
],
"20625": [
"CVE-2001-0211"
],
"20628": [
"CVE-2001-0212"
],
"20629": [
"CVE-2001-0214"
],
"20630": [
"CVE-2001-0215"
],
"20631": [
"CVE-2001-0217"
],
"20632": [
"CVE-2001-0216"
],
"20633": [
"CVE-2001-0224"
],
"20635": [
"CVE-2001-0304"
],
"20636": [
"CVE-2001-0305"
],
"20637": [
"CVE-2001-0306"
],
"20638": [
"CVE-2001-0308"
],
"20639": [
"CVE-2001-0307"
],
"20640": [
"CVE-2001-0276"
],
"20642": [
"CVE-2001-0425"
],
"20646": [
"CVE-2001-0440"
],
"20647": [
"CVE-2001-0280"
],
"20648": [
"CVE-2001-0236"
],
"20649": [
"CVE-2001-0236"
],
"20652": [
"CVE-2001-0711"
],
"20653": [
"CVE-2001-0283"
],
"20657": [
"CVE-2001-0286"
],
"20660": [
"CVE-2001-0274"
],
"20661": [
"CVE-2001-0295"
],
"20663": [
"CVE-2001-0454"
],
"20680": [
"CVE-2001-0150"
],
"20683": [
"CVE-2001-0360"
],
"20685": [],
"20686": [
"CVE-2001-0461"
],
"20687": [
"CVE-2001-0626"
],
"20688": [
"CVE-2001-0365"
],
"20689": [
"CVE-2001-0476"
],
"20690": [
"CVE-2001-1501"
],
"20692": [
"CVE-2001-0925"
],
"20693": [
"CVE-2001-0925"
],
"20694": [
"CVE-2001-0925"
],
"20695": [
"CVE-2001-0925"
],
"20702": [],
"20714": [
"CVE-2001-0593"
],
"20716": [
"CVE-2001-0590"
],
"20717": [
"CVE-2001-0571"
],
"20719": [],
"20722": [
"CVE-2001-0399"
],
"20723": [
"CVE-2001-0264"
],
"20725": [
"CVE-2001-0466"
],
"20726": [
"CVE-2001-0263"
],
"20727": [
"CVE-2001-0414"
],
"20730": [
"CVE-2001-0402"
],
"20731": [
"CVE-2001-0247"
],
"20732": [
"CVE-2001-0247"
],
"20733": [
"CVE-2001-0247"
],
"20738": [
"CVE-2001-0265"
],
"20744": [
"CVE-2001-0400"
],
"20745": [],
"20748": [
"CVE-2001-0609"
],
"20749": [
"CVE-2001-0609"
],
"20752": [
"CVE-2001-0418"
],
"20944": [],
"20758": [],
"20764": [
"CVE-2001-0421"
],
"20765": [
"CVE-2001-0405"
],
"20774": [
"CVE-2001-0643"
],
"20775": [
"CVE-2001-0262"
],
"20780": [
"CVE-2001-0464"
],
"20782": [
"CVE-2001-1325"
],
"20791": [
"CVE-2001-0596"
],
"20793": [
"CVE-2001-0467"
],
"20794": [
"CVE-2001-0296"
],
"20796": [
"CVE-2009-4498"
],
"20797": [
"CVE-2001-0462"
],
"20799": [
"CVE-2000-0074"
],
"20800": [
"CVE-2000-0074"
],
"20801": [
"CVE-2000-0074"
],
"20803": [
"CVE-2001-0491"
],
"20805": [
"CVE-1999-0215"
],
"20806": [
"CVE-2001-0484"
],
"20807": [
"CVE-2001-0495"
],
"20808": [
"CVE-2001-0463"
],
"20809": [],
"20815": [
"CVE-2001-0241"
],
"20816": [
"CVE-2001-0241"
],
"20817": [
"CVE-2001-0241"
],
"20818": [
"CVE-2001-0241"
],
"20819": [
"CVE-2001-0452"
],
"20820": [
"CVE-2001-0490"
],
"20825": [],
"20826": [
"CVE-2001-0574"
],
"20829": [
"CVE-2001-0557"
],
"20831": [
"CVE-2001-0561"
],
"20832": [
"CVE-2001-0561"
],
"20833": [
"CVE-2001-0561"
],
"20835": [
"CVE-2001-0333"
],
"20836": [
"CVE-2001-0333"
],
"20837": [
"CVE-2001-0333"
],
"20838": [
"CVE-2001-0333"
],
"20839": [
"CVE-2001-0333"
],
"20840": [
"CVE-2001-0333"
],
"20841": [
"CVE-2001-0333"
],
"20842": [
"CVE-2001-0333"
],
"20849": [
"CVE-2001-0527"
],
"20850": [
"CVE-2001-0614"
],
"20865": [
"CVE-2012-4681",
"CVE-2012-3539",
"CVE-2012-0547"
],
"20869": [
"CVE-2001-0520"
],
"20876": [],
"20878": [
"CVE-2001-0630"
],
"20879": [
"CVE-2001-0779"
],
"20881": [
"CVE-2001-1339"
],
"20882": [
"CVE-2001-0615"
],
"20884": [
"CVE-2001-1335"
],
"20886": [
"CVE-2001-0778"
],
"20887": [
"CVE-2001-0780"
],
"20888": [
"CVE-2001-1326"
],
"20889": [
"CVE-2001-0522"
],
"20890": [
"CVE-2001-0519"
],
"20891": [
"CVE-2001-0521"
],
"20892": [
"CVE-2001-0380"
],
"20893": [
"CVE-2001-0791"
],
"20894": [
"CVE-2001-0748"
],
"20895": [
"CVE-2001-0693"
],
"20896": [
"CVE-2001-0743"
],
"20899": [
"CVE-2001-1088"
],
"20902": [],
"20903": [],
"20908": [
"CVE-2001-0763"
],
"20909": [
"CVE-2001-0552"
],
"20910": [
"CVE-2001-0688"
],
"20911": [
"CVE-2001-0766"
],
"20912": [],
"20914": [
"CVE-2001-1344"
],
"20916": [
"CVE-2001-1343"
],
"20924": [
"CVE-2001-0818"
],
"20929": [
"CVE-2002-1904",
"CVE-2001-0820"
],
"20931": [
"CVE-2001-0500"
],
"20932": [
"CVE-2001-0500"
],
"20933": [
"CVE-2001-0500"
],
"20934": [
"CVE-2001-0788"
],
"20935": [
"CVE-2001-1160"
],
"20936": [
"CVE-2001-1163"
],
"20938": [
"CVE-2001-0821"
],
"20939": [
"CVE-2001-0821"
],
"20940": [
"CVE-2001-0805"
],
"20941": [
"CVE-2001-0700"
],
"20947": [
"CVE-2001-0705"
],
"20948": [
"CVE-2001-0704"
],
"20950": [
"CVE-2001-0341"
],
"20951": [
"CVE-2001-0341"
],
"20953": [
"CVE-2001-1078"
],
"20954": [
"CVE-2001-1078"
],
"21017": [],
"21018": [
"CVE-2001-0554"
],
"20966": [
"CVE-2000-1196"
],
"20968": [
"CVE-2001-1162"
],
"20972": [
"CVE-2001-0784"
],
"20975": [
"CVE-2001-0537"
],
"20976": [
"CVE-2001-0537"
],
"20977": [
"CVE-2001-0537"
],
"20978": [
"CVE-2001-0537"
],
"20980": [
"CVE-2001-0499"
],
"20982": [
"CVE-2001-1290"
],
"20984": [
"CVE-2001-1412"
],
"20993": [
"CVE-2001-1086"
],
"20994": [
"CVE-2001-1075"
],
"20998": [
"CVE-2001-0775"
],
"21002": [
"CVE-2001-0731"
],
"21003": [
"CVE-2001-0538"
],
"21004": [
"CVE-2001-0538"
],
"21008": [
"CVE-2001-0804"
],
"21009": [
"CVE-2001-1142"
],
"21011": [
"CVE-2001-1291"
],
"21015": [
"CVE-2001-1303"
],
"21019": [],
"21021": [
"CVE-2001-0553"
],
"21023": [
"CVE-2001-0987"
],
"21025": [
"CVE-2001-0991"
],
"21026": [
"CVE-2001-1010"
],
"21027": [
"CVE-2001-1106"
],
"21029": [],
"21030": [
"CVE-2001-1108"
],
"21034": [
"CVE-2012-2611"
],
"21035": [
"CVE-2001-1107"
],
"21036": [
"CVE-2001-1021"
],
"21037": [
"CVE-2001-1022"
],
"21039": [
"CVE-2001-1586"
],
"21049": [
"CVE-1999-0267",
"CVE-1999-0235"
],
"21050": [
"CVE-1999-0267",
"CVE-1999-0235"
],
"21057": [],
"21064": [
"CVE-2001-1009"
],
"21066": [
"CVE-2001-1009"
],
"21067": [],
"21068": [
"CVE-2001-1115"
],
"21075": [
"CVE-2001-1130"
],
"21080": [
"CVE-2007-1036"
],
"21088": [
"CVE-2001-1067"
],
"21089": [
"CVE-2001-1067"
],
"21093": [
"CVE-1999-0745"
],
"21095": [
"CVE-2001-1002"
],
"21097": [
"CVE-2001-1583"
],
"21100": [
"CVE-2001-0669"
],
"21102": [
"CVE-2001-1138"
],
"21104": [
"CVE-2001-0985"
],
"21109": [
"CVE-2001-1112"
],
"21110": [
"CVE-2001-1109"
],
"21112": [
"CVE-2001-1013"
],
"21113": [
"CVE-2001-0986"
],
"21115": [
"CVE-2001-1170"
],
"21116": [
"CVE-2001-1528"
],
"21118": [
"CVE-2001-0664"
],
"21121": [
"CVE-2001-0836"
],
"21125": [
"CVE-2001-1502"
],
"21127": [
"CVE-2001-1410"
],
"21128": [
"CVE-2001-0838"
],
"21129": [
"CVE-2001-0839"
],
"21136": [
"CVE-2012-3579"
],
"21137": [],
"21138": [],
"21142": [],
"21144": [
"CVE-2001-0722"
],
"21145": [],
"21151": [
"CVE-2001-0857"
],
"21152": [
"CVE-2001-0815"
],
"21153": [
"CVE-2001-0815"
],
"21154": [
"CVE-2001-0815"
],
"21155": [
"CVE-2001-0899"
],
"21156": [
"CVE-2001-0898"
],
"21160": [
"CVE-2001-0924"
],
"21161": [
"CVE-2001-0550"
],
"21164": [
"CVE-2001-0875"
],
"21169": [
"CVE-2001-1549"
],
"21178": [
"CVE-2001-1188"
],
"21179": [
"CVE-2001-0797"
],
"21182": [
"CVE-2001-1195"
],
"21183": [
"CVE-2001-1196"
],
"21185": [
"CVE-2001-1487"
],
"21186": [
"CVE-2001-1194"
],
"21188": [
"CVE-2001-0876"
],
"21189": [
"CVE-2001-0876"
],
"21190": [],
"21191": [],
"21192": [
"CVE-2002-0002"
],
"21193": [
"CVE-2001-1202"
],
"21194": [
"CVE-2001-1209"
],
"21195": [
"CVE-2002-0023"
],
"21196": [
"CVE-2002-0005"
],
"21197": [
"CVE-2002-0095"
],
"21198": [
"CVE-2002-2031"
],
"21199": [
"CVE-2002-2031"
],
"21200": [
"CVE-2002-1570"
],
"21201": [
"CVE-2002-2026"
],
"21203": [
"CVE-2002-0236"
],
"21204": [
"CVE-2002-2029"
],
"21205": [
"CVE-2002-0098"
],
"21207": [
"CVE-2002-0207"
],
"21210": [
"CVE-2002-0006"
],
"21211": [
"CVE-2002-0112"
],
"21212": [
"CVE-2002-0107"
],
"21214": [],
"21215": [],
"21225": [
"CVE-2002-0142"
],
"21235": [
"CVE-2002-0502"
],
"21238": [
"CVE-2002-0153"
],
"21242": [
"CVE-2002-0048"
],
"21243": [
"CVE-2002-0209"
],
"21249": [
"CVE-2002-0215"
],
"21260": [
"CVE-2002-2073"
],
"21263": [
"CVE-2002-0230"
],
"21264": [
"CVE-2004-0327",
"CVE-2002-0229"
],
"21265": [
"CVE-2004-0327",
"CVE-2002-0229"
],
"21266": [
"CVE-2004-0327",
"CVE-2002-0229"
],
"21268": [],
"21274": [
"CVE-2002-0231"
],
"21276": [
"CVE-2002-0266"
],
"21285": [
"CVE-2002-0250"
],
"21286": [
"CVE-2002-0252"
],
"21287": [
"CVE-2002-0263"
],
"21289": [
"CVE-2002-0276"
],
"21291": [
"CVE-2002-0288"
],
"21292": [
"CVE-2002-0288"
],
"21294": [
"CVE-2002-0289"
],
"21295": [
"CVE-2002-0300"
],
"21297": [
"CVE-2002-0068"
],
"21298": [
"CVE-2006-5850",
"CVE-2002-0313"
],
"21303": [
"CVE-2002-0325"
],
"21309": [
"CVE-2002-0332"
],
"21310": [
"CVE-2002-0333"
],
"21311": [
"CVE-2002-0331"
],
"21313": [
"CVE-2002-0419"
],
"21314": [
"CVE-2002-0083"
],
"21334": [
"CVE-2002-0430"
],
"21335": [
"CVE-2002-0430"
],
"21339": [
"CVE-2002-0440"
],
"21340": [
"CVE-2002-0436"
],
"21350": [
"CVE-2002-0061"
],
"21354": [
"CVE-2002-0495"
],
"21355": [
"CVE-2002-0504"
],
"21361": [
"CVE-2002-0191"
],
"21363": [
"CVE-2002-0177"
],
"21364": [],
"21365": [
"CVE-2002-0536"
],
"21367": [
"CVE-2002-0544",
"CVE-2002-0543"
],
"21368": [
"CVE-2002-0079"
],
"21369": [
"CVE-2002-0079"
],
"21370": [
"CVE-2002-0079"
],
"21371": [
"CVE-2002-0079"
],
"21372": [
"CVE-2002-0148"
],
"21376": [
"CVE-2002-1688"
],
"21378": [
"CVE-2002-0540"
],
"21384": [
"CVE-2002-0539"
],
"21385": [
"CVE-2002-1744"
],
"21386": [
"CVE-2002-0591"
],
"21390": [
"CVE-2002-0737"
],
"21402": [
"CVE-2002-0575"
],
"21410": [
"CVE-2002-0608"
],
"21412": [
"CVE-2002-2006"
],
"21415": [
"CVE-2002-0749"
],
"21422": [
"CVE-2002-0733"
],
"21437": [
"CVE-2002-0033"
],
"21438": [
"CVE-2002-1741"
],
"21439": [
"CVE-2002-1740"
],
"21440": [
"CVE-2002-0702"
],
"21441": [
"CVE-2002-0769"
],
"21442": [
"CVE-2002-0379"
],
"21443": [
"CVE-2002-0379"
],
"21444": [
"CVE-2002-0787"
],
"21445": [
"CVE-2002-0786"
],
"21446": [
"CVE-2002-0375"
],
"21450": [
"CVE-2002-0770"
],
"21451": [
"CVE-2002-0783"
],
"21452": [
"CVE-2002-0193",
"CVE-2002-0192"
],
"21453": [
"CVE-2002-2341"
],
"21456": [
"CVE-2002-0908"
],
"21466": [
"CVE-2002-0799"
],
"21467": [
"CVE-2002-0799"
],
"21468": [
"CVE-2002-0895"
],
"21469": [
"CVE-2002-0892"
],
"21470": [
"CVE-2002-0893"
],
"21475": [
"CVE-2002-0897"
],
"21483": [
"CVE-2002-0898"
],
"21484": [
"CVE-2002-0031"
],
"21485": [
"CVE-2002-0823"
],
"21488": [
"CVE-2002-1634"
],
"21490": [
"CVE-2002-2007"
],
"21491": [
"CVE-2002-2007"
],
"21492": [
"CVE-2002-2007"
],
"21650": [
"CVE-2002-0644"
],
"21510": [
"CVE-2002-0371"
],
"21511": [
"CVE-2002-0907"
],
"21513": [
"CVE-2002-0949"
],
"21515": [
"CVE-2002-2062"
],
"21520": [],
"21530": [
"CVE-2002-0946"
],
"21541": [
"CVE-2002-0187"
],
"21542": [
"CVE-2002-0968"
],
"21548": [
"CVE-2002-1700"
],
"40415": [],
"21554": [
"CVE-2002-1965"
],
"21555": [
"CVE-2002-0938"
],
"21559": [
"CVE-2002-0392"
],
"21560": [
"CVE-2002-0392"
],
"21571": [
"CVE-2002-0652"
],
"21574": [
"CVE-2002-0928"
],
"21576": [
"CVE-2002-1685"
],
"21578": [
"CVE-2002-0640"
],
"21579": [
"CVE-2002-0640"
],
"21581": [
"CVE-2002-1008"
],
"21582": [
"CVE-2002-0665"
],
"21586": [
"CVE-2002-2376"
],
"21589": [
"CVE-2002-1001"
],
"21591": [
"CVE-2002-1004"
],
"21595": [
"CVE-2002-2195"
],
"21596": [
"CVE-2002-0676"
],
"21597": [
"CVE-2002-1031"
],
"21599": [
"CVE-2002-1683"
],
"21601": [
"CVE-2002-1973"
],
"21602": [
"CVE-2002-1982"
],
"21603": [
"CVE-2002-1042"
],
"21604": [
"CVE-2002-0682"
],
"21605": [],
"21606": [
"CVE-2002-0723"
],
"21607": [
"CVE-2002-0680"
],
"21608": [
"CVE-2002-0681"
],
"21611": [
"CVE-2002-1009"
],
"21613": [
"CVE-2002-1790"
],
"21614": [],
"21615": [
"CVE-2002-1014"
],
"21616": [
"CVE-2002-1021"
],
"21618": [],
"21619": [
"CVE-2002-2169"
],
"21625": [
"CVE-2002-0637"
],
"21626": [
"CVE-2002-1073"
],
"22072": [
"CVE-2002-1361"
],
"21627": [
"CVE-2002-1089"
],
"21630": [
"CVE-2002-2170"
],
"21631": [],
"21633": [
"CVE-2002-1057"
],
"21635": [
"CVE-2002-1059"
],
"21636": [
"CVE-2002-2312"
],
"21638": [
"CVE-2002-2314"
],
"21639": [
"CVE-2002-0814"
],
"21641": [
"CVE-2002-0855"
],
"21642": [
"CVE-2002-0855"
],
"21643": [
"CVE-2002-0280"
],
"21648": [
"CVE-2002-1075"
],
"21649": [
"CVE-2002-1060"
],
"21651": [
"CVE-2002-0982"
],
"21652": [
"CVE-2002-0649"
],
"21654": [
"CVE-2002-1076"
],
"21662": [],
"21663": [
"CVE-2002-1792"
],
"21670": [
"CVE-2002-1847"
],
"21671": [
"CVE-2002-0082"
],
"40347": [
"CVE-2002-0656"
],
"21675": [],
"21677": [
"CVE-2002-2425"
],
"21678": [],
"21680": [
"CVE-2002-0833"
],
"21681": [
"CVE-2002-2358"
],
"21682": [
"CVE-2002-2359"
],
"21692": [
"CVE-2002-1183",
"CVE-2002-0862",
"CVE-2002-0828"
],
"21693": [
"CVE-2002-1123"
],
"21695": [
"CVE-2002-2351"
],
"21696": [
"CVE-2002-2351"
],
"21697": [
"CVE-2002-0661"
],
"21698": [
"CVE-2002-2318"
],
"21699": [
"CVE-2002-0812"
],
"21704": [
"CVE-2002-1445"
],
"21705": [],
"21706": [
"CVE-2002-0874"
],
"21707": [
"CVE-2002-1951"
],
"21709": [
"CVE-2002-1452"
],
"21710": [
"CVE-2002-1453"
],
"21711": [
"CVE-2002-0980"
],
"21717": [
"CVE-2002-0974"
],
"21718": [
"CVE-2002-0721"
],
"21719": [
"CVE-2002-0654"
],
"21722": [
"CVE-2002-1405"
],
"21725": [
"CVE-2002-1809"
],
"21726": [],
"21731": [
"CVE-2002-1436"
],
"21734": [
"CVE-2002-1567"
],
"21735": [
"CVE-2002-1079"
],
"21748": [
"CVE-2002-0647"
],
"21749": [
"CVE-2002-0648"
],
"21750": [
"CVE-2002-0189"
],
"21751": [
"CVE-2002-1451"
],
"21752": [
"CVE-2002-1451"
],
"21753": [
"CVE-2002-1455"
],
"21754": [
"CVE-2002-1455"
],
"21757": [],
"21759": [
"CVE-2002-1456"
],
"21764": [
"CVE-2002-1143"
],
"21765": [
"CVE-2002-2360"
],
"21767": [
"CVE-2002-1497"
],
"21777": [
"CVE-2002-1187"
],
"21784": [
"CVE-2002-1566"
],
"21794": [
"CVE-2002-2145"
],
"21800": [
"CVE-2002-1483"
],
"21801": [
"CVE-2002-1484"
],
"21803": [],
"21804": [
"CVE-2002-1486"
],
"21808": [
"CVE-2002-0866"
],
"21810": [
"CVE-2002-1486"
],
"21812": [
"CVE-2002-1143"
],
"21818": [
"CVE-2002-1496"
],
"21882": [],
"21883": [],
"21885": [
"CVE-2002-0840"
],
"21827": [
"CVE-2002-2422"
],
"21837": [
"CVE-2011-4051"
],
"21838": [],
"21839": [
"CVE-2012-0267"
],
"21840": [
"CVE-2012-4969"
],
"21841": [
"CVE-2012-0266"
],
"21842": [],
"21846": [],
"21847": [
"CVE-2012-3811"
],
"21849": [],
"21850": [
"CVE-2012-1182"
],
"21851": [
"CVE-2012-2982"
],
"21852": [],
"21853": [
"CVE-2002-1148"
],
"21857": [
"CVE-2002-2154"
],
"21858": [
"CVE-2002-2171"
],
"21868": [
"CVE-2010-0188",
"CVE-2006-3459"
],
"21869": [
"CVE-2010-0188",
"CVE-2006-3459"
],
"21870": [],
"21876": [
"CVE-2002-1943"
],
"21880": [
"CVE-2002-1852"
],
"21888": [
"CVE-2012-2516"
],
"21897": [
"CVE-2002-0708"
],
"21898": [
"CVE-2002-0709"
],
"21902": [
"CVE-2002-0693"
],
"21910": [],
"21913": [],
"21919": [
"CVE-1999-0661"
],
"21927": [],
"21932": [
"CVE-2002-1179"
],
"21934": [
"CVE-2002-1224"
],
"21936": [
"CVE-2002-1816"
],
"21937": [
"CVE-2001-0820"
],
"21940": [
"CVE-2002-1217"
],
"21942": [
"CVE-2002-1910"
],
"21944": [
"CVE-2002-1222"
],
"21945": [],
"21947": [
"CVE-2002-1167"
],
"21948": [
"CVE-2002-1168"
],
"21955": [
"CVE-2002-1930"
],
"21958": [
"CVE-2002-1813"
],
"21959": [
"CVE-2002-1254"
],
"21964": [
"CVE-2002-1209"
],
"21974": [
"CVE-2002-1275"
],
"21983": [],
"21993": [],
"21996": [
"CVE-2002-2191"
],
"21997": [
"CVE-2002-2192"
],
"21998": [
"CVE-2002-1652"
],
"21999": [
"CVE-2002-2192"
],
"22000": [
"CVE-2002-1785"
],
"22001": [
"CVE-2002-1238"
],
"22007": [
"CVE-2012-3810",
"CVE-2012-3809",
"CVE-2012-3808",
"CVE-2012-3807"
],
"22012": [
"CVE-2002-1549"
],
"22013": [
"CVE-2002-1549"
],
"22016": [
"CVE-2002-2400"
],
"22018": [
"CVE-2002-2403"
],
"22020": [
"CVE-2002-1986"
],
"22021": [
"CVE-2002-1823"
],
"22022": [],
"22023": [
"CVE-2002-2357"
],
"22024": [
"CVE-2002-2353"
],
"22025": [
"CVE-2002-2226"
],
"22026": [
"CVE-2002-1307"
],
"22027": [
"CVE-2003-0111"
],
"22028": [
"CVE-2002-2281"
],
"22029": [],
"22032": [
"CVE-2002-2417"
],
"22034": [],
"22035": [],
"22036": [
"CVE-2002-1317"
],
"22046": [],
"22049": [
"CVE-2002-2251"
],
"22054": [],
"22057": [],
"22058": [],
"22063": [
"CVE-2002-2416"
],
"22064": [
"CVE-2002-2416"
],
"22078": [],
"22082": [
"CVE-2002-1349"
],
"22084": [
"CVE-2002-1374"
],
"22085": [
"CVE-2002-1375"
],
"22091": [],
"22093": [],
"22094": [],
"22101": [],
"22106": [
"CVE-2002-1368"
],
"22112": [],
"22113": [],
"22129": [
"CVE-2003-1247"
],
"22130": [
"CVE-2003-1271"
],
"22131": [
"CVE-2003-0001"
],
"22135": [
"CVE-2003-1236"
],
"22136": [],
"22138": [],
"22139": [],
"22140": [],
"22141": [],
"22142": [],
"22143": [],
"22144": [],
"22145": [],
"22147": [],
"22161": [],
"22171": [
"CVE-2003-1341"
],
"22173": [
"CVE-2003-1344"
],
"22174": [
"CVE-2003-1343"
],
"22178": [],
"22179": [],
"22184": [
"CVE-2003-1260"
],
"22185": [],
"22187": [
"CVE-2003-0015"
],
"22194": [
"CVE-2003-0003"
],
"22200": [],
"22201": [
"CVE-2003-1350"
],
"22205": [
"CVE-2003-0042"
],
"22213": [],
"22217": [],
"22218": [],
"22219": [],
"22224": [
"CVE-2003-1430"
],
"22226": [
"CVE-2003-1328"
],
"22229": [
"CVE-2003-1090"
],
"22236": [
"CVE-2003-1427"
],
"22244": [
"CVE-2003-1442"
],
"22251": [
"CVE-1999-0101"
],
"22264": [
"CVE-2003-0078"
],
"22269": [
"CVE-2003-1242"
],
"22270": [
"CVE-2003-1243"
],
"22271": [
"CVE-2003-0100"
],
"22274": [
"CVE-2003-0107"
],
"22275": [
"CVE-2003-0101"
],
"22278": [
"CVE-2003-0203"
],
"22280": [
"CVE-2003-1378"
],
"22288": [],
"22289": [
"CVE-2003-0009"
],
"22291": [
"CVE-2003-1381"
],
"22292": [],
"22296": [
"CVE-2003-1386"
],
"22301": [],
"22304": [],
"22305": [
"CVE-2012-2020"
],
"22306": [
"CVE-2012-2019"
],
"22311": [],
"22312": [
"CVE-2003-1414"
],
"22313": [
"CVE-2002-1337"
],
"22314": [
"CVE-2002-1337"
],
"22319": [
"CVE-2002-1048"
],
"22327": [],
"22338": [
"CVE-2003-0121"
],
"22341": [],
"22342": [
"CVE-2003-0143"
],
"22346": [],
"22350": [],
"22351": [
"CVE-2012-5106"
],
"22353": [],
"22355": [],
"22356": [
"CVE-2003-0085"
],
"22361": [],
"22365": [
"CVE-2003-0109"
],
"22366": [
"CVE-2003-0109"
],
"22367": [
"CVE-2003-0109"
],
"22368": [
"CVE-2003-0109"
],
"22369": [
"CVE-2003-0129"
],
"22371": [
"CVE-2003-0130"
],
"22375": [],
"22379": [],
"22381": [
"CVE-2003-1553"
],
"22388": [
"CVE-2003-1540"
],
"22394": [],
"22409": [],
"22410": [],
"22416": [],
"22418": [
"CVE-2003-0220"
],
"22432": [],
"22434": [],
"22448": [],
"22449": [],
"22450": [],
"22453": [],
"22454": [],
"22455": [],
"22462": [],
"22466": [],
"22468": [
"CVE-2003-0201"
],
"22469": [
"CVE-2003-0201"
],
"22470": [
"CVE-2003-0201"
],
"22471": [
"CVE-2003-0201"
],
"22472": [
"CVE-2003-0400"
],
"22475": [],
"22476": [],
"22479": [
"CVE-2003-0213"
],
"22480": [],
"22485": [],
"22488": [],
"22496": [],
"22497": [],
"22504": [],
"22506": [],
"22509": [],
"22511": [],
"22515": [],
"22522": [],
"22570": [
"CVE-2003-0228"
],
"22525": [
"CVE-2012-2288"
],
"22526": [],
"22530": [
"CVE-2003-0113"
],
"22532": [],
"22533": [],
"22541": [
"CVE-2003-1463"
],
"22542": [
"CVE-2003-1463"
],
"22546": [],
"22556": [],
"22562": [],
"22563": [],
"22575": [
"CVE-2003-0309"
],
"22584": [
"CVE-2003-0282"
],
"22593": [
"CVE-2003-1129"
],
"22601": [],
"22604": [],
"22609": [
"CVE-2003-0312"
],
"22611": [
"CVE-1999-0269"
],
"22620": [
"CVE-2003-0332"
],
"22622": [],
"22623": [
"CVE-2003-0338"
],
"22626": [
"CVE-2003-0240"
],
"22627": [
"CVE-2000-0342"
],
"22630": [
"CVE-2003-1091"
],
"22631": [
"CVE-2003-0317"
],
"22635": [],
"22636": [],
"22646": [
"CVE-2003-0400"
],
"22648": [
"CVE-2003-0404"
],
"22649": [],
"22657": [
"CVE-2012-5076",
"CVE-2012-5067"
],
"22658": [
"CVE-2003-0407"
],
"22659": [
"CVE-2003-0407"
],
"22662": [],
"22664": [
"CVE-2003-0411"
],
"22665": [
"CVE-2003-0413"
],
"22674": [],
"22676": [],
"22677": [],
"22678": [],
"22686": [
"CVE-2012-5692"
],
"22691": [],
"22696": [
"CVE-2003-0442"
],
"22699": [],
"22714": [
"CVE-2010-3600"
],
"22721": [],
"22722": [],
"22723": [],
"22726": [
"CVE-2003-0344"
],
"22728": [],
"22733": [],
"22734": [],
"22737": [
"CVE-2012-5931",
"CVE-2012-5930"
],
"22738": [],
"22751": [],
"22753": [
"CVE-2003-0436"
],
"22754": [
"CVE-2003-0436"
],
"22755": [],
"22758": [],
"22769": [],
"22771": [
"CVE-2003-0434"
],
"22782": [],
"22783": [
"CVE-2003-0446"
],
"22784": [
"CVE-2003-0447"
],
"22785": [],
"22786": [],
"22787": [
"CVE-2012-4959"
],
"22795": [],
"22807": [],
"22824": [
"CVE-2003-0469"
],
"22827": [],
"22830": [],
"22832": [
"CVE-2003-0723"
],
"22833": [
"CVE-2003-0471"
],
"22834": [
"CVE-2003-0471"
],
"22837": [
"CVE-2003-0349"
],
"22838": [],
"22848": [
"CVE-2003-0510"
],
"22854": [],
"22856": [],
"22858": [],
"22867": [],
"22869": [],
"22871": [
"CVE-2003-0561"
],
"22872": [
"CVE-2003-0561"
],
"22873": [],
"23034": [],
"22890": [],
"22891": [
"CVE-2003-0561"
],
"22892": [],
"22893": [
"CVE-2003-0805"
],
"22894": [
"CVE-2003-0805"
],
"22898": [],
"22903": [
"CVE-2012-5932"
],
"22905": [
"CVE-2012-3752"
],
"22908": [],
"22909": [],
"22944": [],
"22951": [],
"22959": [],
"22964": [],
"22966": [],
"22967": [],
"22968": [],
"22917": [
"CVE-2003-0352"
],
"22919": [
"CVE-2003-0526"
],
"23006": [],
"22969": [],
"22973": [
"CVE-2012-3753"
],
"22974": [
"CVE-2003-0466"
],
"22975": [
"CVE-2003-0466"
],
"22976": [
"CVE-2003-0466"
],
"22994": [],
"23002": [],
"23019": [],
"23024": [],
"23038": [],
"23040": [],
"23043": [
"CVE-2003-0726"
],
"23044": [],
"23049": [],
"23054": [],
"23066": [
"CVE-2003-0729"
],
"23068": [],
"23069": [
"CVE-2003-0747"
],
"23070": [
"CVE-2003-0748"
],
"23071": [
"CVE-2003-0749"
],
"23073": [
"CVE-2012-5615"
],
"23074": [
"CVE-2009-0880"
],
"23079": [
"CVE-2012-6066"
],
"23080": [
"CVE-2012-6066"
],
"23081": [
"CVE-2012-5615"
],
"23082": [
"CVE-2012-5975"
],
"23083": [],
"23091": [],
"23092": [],
"23093": [],
"23094": [
"CVE-2003-0347"
],
"23095": [
"CVE-2003-0665"
],
"23100": [
"CVE-2003-0772"
],
"23113": [
"CVE-1999-0284"
],
"23114": [
"CVE-2003-0838"
],
"23115": [
"CVE-2003-0705"
],
"23121": [],
"23122": [
"CVE-2003-0809"
],
"23123": [],
"23131": [
"CVE-2003-0816"
],
"23224": [],
"23135": [],
"23136": [],
"23137": [],
"23144": [],
"23147": [
"CVE-2003-0802"
],
"23148": [
"CVE-2003-0803"
],
"23149": [
"CVE-2003-0801"
],
"23151": [],
"23152": [],
"23154": [
"CVE-2003-0681"
],
"23155": [
"CVE-2012-5357"
],
"23156": [
"CVE-2012-5975"
],
"23157": [],
"23161": [
"CVE-2003-0826"
],
"23162": [
"CVE-2003-0826"
],
"23171": [
"CVE-2003-0865"
],
"23173": [],
"23174": [],
"23176": [],
"23178": [],
"23179": [
"CVE-2012-5613"
],
"23182": [
"CVE-2003-0849"
],
"23183": [
"CVE-2003-0849"
],
"23185": [],
"23186": [
"CVE-2003-0835"
],
"23187": [],
"23188": [],
"23196": [
"CVE-2003-0833"
],
"23198": [],
"23199": [
"CVE-2002-0659"
],
"23203": [
"CVE-2009-0880"
],
"23209": [],
"23211": [],
"23212": [
"CVE-2003-1096"
],
"23221": [
"CVE-2003-0845"
],
"23222": [],
"23225": [],
"23226": [],
"23227": [],
"23229": [],
"23230": [],
"23243": [],
"23247": [
"CVE-2003-0717"
],
"23404": [
"CVE-2003-0974"
],
"23257": [
"CVE-2003-1511"
],
"23265": [
"CVE-2003-1516"
],
"23270": [
"CVE-2003-1521"
],
"23271": [
"CVE-2003-1522"
],
"23272": [],
"23387": [],
"23282": [
"CVE-2003-1172"
],
"23283": [],
"23290": [
"CVE-2010-3007"
],
"23291": [],
"23295": [
"CVE-2003-1137"
],
"23296": [
"CVE-2003-1138"
],
"23298": [
"CVE-2003-1017"
],
"23304": [
"CVE-2003-1149"
],
"23306": [
"CVE-2003-0899"
],
"23307": [
"CVE-2003-1151"
],
"23309": [
"CVE-2003-1173"
],
"23312": [
"CVE-2003-0621"
],
"23316": [
"CVE-2003-1157"
],
"23317": [
"CVE-2003-1160"
],
"23318": [],
"23320": [
"CVE-2003-1164"
],
"23321": [],
"23323": [
"CVE-2012-4959",
"CVE-2012-4958",
"CVE-2012-4957"
],
"23328": [
"CVE-2003-1174"
],
"23329": [
"CVE-2003-1174"
],
"23334": [
"CVE-2003-1192"
],
"23340": [],
"23385": [],
"23365": [],
"23366": [
"CVE-2003-0328"
],
"23368": [],
"23369": [],
"23371": [
"CVE-2003-0886"
],
"23373": [],
"23376": [],
"23377": [],
"23378": [],
"23379": [],
"23380": [],
"23396": [],
"23397": [
"CVE-2003-1083"
],
"23398": [
"CVE-2000-0342"
],
"23399": [
"CVE-2000-0342"
],
"23400": [
"CVE-2004-0380"
],
"23401": [
"CVE-2004-0380"
],
"23405": [
"CVE-2003-0974"
],
"23411": [],
"23413": [],
"23417": [],
"23419": [],
"23422": [
"CVE-2003-1025"
],
"23423": [
"CVE-2003-1025"
],
"23449": [],
"23450": [],
"23451": [],
"23433": [],
"23435": [
"CVE-2003-1030"
],
"23436": [
"CVE-2003-1030"
],
"23437": [
"CVE-2003-1030"
],
"23439": [],
"23441": [],
"23446": [
"CVE-2002-1603"
],
"23461": [],
"23464": [],
"23465": [
"CVE-2003-1025"
],
"23472": [
"CVE-2010-2590"
],
"23489": [],
"23490": [
"CVE-2003-1566"
],
"23491": [],
"23492": [],
"23493": [],
"23695": [
"CVE-2004-0380"
],
"23500": [
"CVE-2011-0340"
],
"23502": [
"CVE-2003-1200"
],
"23503": [],
"23509": [
"CVE-2004-1793"
],
"23514": [
"CVE-2004-1784"
],
"23522": [],
"23527": [
"CVE-2004-1789"
],
"23528": [
"CVE-2004-1790"
],
"23529": [
"CVE-2004-0046"
],
"23531": [
"CVE-2004-0069"
],
"23532": [],
"23533": [
"CVE-2004-0072"
],
"23541": [],
"23542": [],
"23544": [],
"23545": [],
"23552": [],
"23555": [],
"23557": [],
"23559": [
"CVE-2004-2748"
],
"23560": [
"CVE-2004-2745"
],
"23562": [
"CVE-2004-2749"
],
"23563": [
"CVE-2004-2094"
],
"23564": [
"CVE-2004-2096"
],
"23878": [
"CVE-2004-1856"
],
"23877": [
"CVE-2004-2487"
],
"23579": [
"CVE-2012-6329"
],
"23580": [
"CVE-2012-6330",
"CVE-2012-6329"
],
"23582": [
"CVE-2004-2102"
],
"23583": [],
"23585": [
"CVE-2004-2107"
],
"23586": [
"CVE-2004-2104"
],
"23587": [
"CVE-2004-2104"
],
"23588": [
"CVE-2004-2104"
],
"23589": [],
"23591": [
"CVE-2004-2111"
],
"23592": [
"CVE-2004-2111"
],
"23593": [
"CVE-2004-2115"
],
"23594": [
"CVE-2004-2116"
],
"23596": [
"CVE-2004-2119"
],
"23597": [
"CVE-2004-2121"
],
"23598": [
"CVE-2004-1442"
],
"23600": [
"CVE-2004-2113"
],
"23694": [
"CVE-2012-5691"
],
"23601": [],
"23603": [
"CVE-2004-2112"
],
"23604": [],
"23605": [
"CVE-2004-2171"
],
"23608": [
"CVE-2004-2114"
],
"23612": [
"CVE-2004-2128"
],
"23632": [
"CVE-2004-2309"
],
"23643": [],
"23649": [],
"23650": [
"CVE-2012-2174"
],
"23651": [],
"23652": [],
"23668": [
"CVE-2004-2090"
],
"23671": [
"CVE-2004-0281"
],
"23675": [
"CVE-2004-0474"
],
"23678": [],
"23679": [],
"23707": [
"CVE-2004-0290"
],
"23714": [
"CVE-2004-0292"
],
"23717": [],
"23721": [
"CVE-2004-0312"
],
"23728": [
"CVE-2004-0104"
],
"23730": [
"CVE-2004-2373"
],
"23732": [
"CVE-2004-0313"
],
"23733": [
"CVE-2004-0313"
],
"23734": [
"CVE-2004-0313"
],
"23735": [],
"23736": [
"CVE-2012-2175"
],
"23737": [
"CVE-2012-2176"
],
"23740": [
"CVE-2004-0159"
],
"23741": [
"CVE-2004-0326"
],
"23751": [
"CVE-2004-0173"
],
"23754": [
"CVE-2012-4792"
],
"23756": [],
"23758": [
"CVE-2004-0349"
],
"23763": [
"CVE-2004-0330"
],
"23764": [
"CVE-2004-0192"
],
"23766": [
"CVE-2004-2383"
],
"23768": [],
"23771": [
"CVE-2004-0354"
],
"23772": [
"CVE-2004-0353"
],
"23776": [
"CVE-2004-0337"
],
"23777": [
"CVE-2004-0189"
],
"23785": [
"CVE-2012-4792"
],
"23790": [
"CVE-2003-0816"
],
"23794": [
"CVE-2004-1801"
],
"23796": [
"CVE-2004-0121"
],
"23800": [
"CVE-2003-0514"
],
"23801": [
"CVE-2003-1199"
],
"23802": [
"CVE-2004-2617"
],
"23803": [
"CVE-2004-2618"
],
"23804": [
"CVE-2004-1769"
],
"23808": [
"CVE-2004-2326"
],
"23811": [
"CVE-2003-1228"
],
"23836": [
"CVE-2004-2311"
],
"23837": [
"CVE-2004-2310"
],
"23847": [],
"23848": [],
"23855": [],
"23856": [],
"23864": [
"CVE-2004-1838"
],
"23871": [],
"23873": [
"CVE-2004-1855"
],
"23879": [
"CVE-2004-1857"
],
"23880": [
"CVE-2004-1857"
],
"23881": [],
"23887": [
"CVE-2011-5227"
],
"23969": [
"CVE-2012-0202"
],
"23893": [
"CVE-2004-1872"
],
"23903": [],
"23905": [
"CVE-2004-1887"
],
"23906": [
"CVE-2004-1887"
],
"23909": [
"CVE-2004-2464"
],
"23926": [
"CVE-2004-1908"
],
"23936": [
"CVE-2004-1915"
],
"33402": [
"CVE-2008-7248"
],
"23987": [
"CVE-2004-2253"
],
"24012": [],
"24017": [
"CVE-2012-1876"
],
"24018": [],
"24019": [
"CVE-2013-0156"
],
"24020": [
"CVE-2011-1996"
],
"24021": [],
"24024": [
"CVE-2004-1947"
],
"24025": [
"CVE-2004-1947"
],
"24028": [
"CVE-2004-1945"
],
"24030": [
"CVE-2004-0230"
],
"24031": [
"CVE-2004-0230"
],
"24032": [
"CVE-2004-0230"
],
"24033": [
"CVE-2004-0230"
],
"24038": [
"CVE-2004-1951"
],
"24040": [],
"24041": [
"CVE-2004-1958"
],
"24045": [
"CVE-2013-0422"
],
"24065": [
"CVE-2004-2626"
],
"24067": [
"CVE-2005-0643"
],
"24069": [
"CVE-2004-0763"
],
"24076": [
"CVE-2003-1286"
],
"24077": [
"CVE-2004-0204"
],
"24079": [
"CVE-2004-2026"
],
"24084": [
"CVE-2012-6096"
],
"24093": [
"CVE-2004-0399"
],
"24097": [
"CVE-2004-2614"
],
"24098": [
"CVE-2004-2649"
],
"24101": [
"CVE-2004-0502"
],
"24102": [
"CVE-2004-0526"
],
"24105": [
"CVE-2004-2480"
],
"24106": [],
"24114": [
"CVE-2004-0501"
],
"24115": [
"CVE-2004-0580"
],
"24116": [],
"24117": [],
"24118": [],
"24120": [
"CVE-2004-0771"
],
"24121": [
"CVE-2004-0486"
],
"24125": [
"CVE-2004-2289"
],
"24129": [
"CVE-2004-2299"
],
"24133": [
"CVE-2012-6066"
],
"24136": [
"CVE-2004-0527"
],
"24137": [
"CVE-2004-0528"
],
"24140": [
"CVE-2004-2032"
],
"24148": [],
"24149": [],
"24187": [],
"24189": [],
"24159": [
"CVE-2012-6096"
],
"24160": [
"CVE-2004-0520"
],
"24161": [
"CVE-2004-2564"
],
"24162": [
"CVE-2004-2564"
],
"24163": [
"CVE-2004-2565"
],
"24165": [
"CVE-2004-2043"
],
"24174": [],
"24179": [
"CVE-2004-1444"
],
"24196": [],
"24205": [
"CVE-2012-0432"
],
"24230": [
"CVE-2004-0616"
],
"24206": [],
"24213": [],
"24218": [
"CVE-2004-1754"
],
"24219": [],
"24220": [],
"24221": [],
"24223": [
"CVE-2004-0393"
],
"24224": [],
"24226": [
"CVE-2004-0615"
],
"24246": [
"CVE-2004-0673"
],
"24249": [],
"24250": [],
"24253": [
"CVE-2004-0678"
],
"24259": [
"CVE-2004-0633"
],
"24262": [],
"24263": [
"CVE-2004-0648"
],
"24264": [],
"24265": [
"CVE-2004-0727"
],
"24266": [
"CVE-2004-0841"
],
"24268": [
"CVE-2004-2494"
],
"24272": [],
"24273": [],
"24276": [
"CVE-2004-0760"
],
"24280": [
"CVE-2004-0595"
],
"24297": [
"CVE-2004-2563"
],
"24304": [],
"24308": [
"CVE-2012-5088"
],
"24309": [
"CVE-2012-5076"
],
"24310": [
"CVE-2013-0332",
"CVE-2013-0232"
],
"24312": [
"CVE-2004-0763"
],
"24321": [
"CVE-2013-0209",
"CVE-2012-6315"
],
"24322": [
"CVE-2013-1359"
],
"24323": [
"CVE-2012-0432"
],
"24325": [
"CVE-2004-2491"
],
"24326": [
"CVE-2004-2061"
],
"24327": [
"CVE-2004-2061"
],
"24328": [
"CVE-2004-0842"
],
"24336": [],
"24337": [],
"24338": [],
"24339": [],
"24342": [
"CVE-2004-2528"
],
"24345": [
"CVE-2004-2526"
],
"24350": [
"CVE-2004-2628"
],
"24353": [
"CVE-2004-1364"
],
"24354": [],
"24361": [
"CVE-2004-1701"
],
"24363": [],
"24376": [],
"24387": [],
"24404": [
"CVE-2004-2530"
],
"24407": [],
"24409": [],
"24413": [],
"24414": [],
"24417": [
"CVE-2004-1645"
],
"24418": [
"CVE-2004-1645"
],
"24419": [
"CVE-2004-1646"
],
"24460": [
"CVE-2012-3569"
],
"24434": [
"CVE-2013-0333"
],
"24444": [
"CVE-2013-7387",
"CVE-2013-1412"
],
"24455": [
"CVE-2012-5965",
"CVE-2012-5964",
"CVE-2012-5963",
"CVE-2012-5962",
"CVE-2012-5961",
"CVE-2012-5960",
"CVE-2012-5959",
"CVE-2012-5958",
"CVE-2012-5858"
],
"24461": [
"CVE-2012-3569"
],
"24467": [],
"24479": [],
"24490": [
"CVE-2012-0439"
],
"24494": [],
"24495": [
"CVE-2013-0025"
],
"24502": [],
"24526": [
"CVE-2010-3333"
],
"24527": [
"CVE-2012-6275"
],
"24528": [
"CVE-2012-6274"
],
"24529": [
"CVE-2011-4275",
"CVE-2009-4140"
],
"24538": [
"CVE-2013-0025"
],
"24539": [
"CVE-2013-0431"
],
"24547": [],
"24548": [],
"24549": [
"CVE-2013-0803"
],
"24557": [],
"24567": [
"CVE-2004-0637"
],
"24568": [],
"24571": [],
"24572": [],
"24720": [],
"24581": [],
"24584": [],
"24598": [
"CVE-2004-1470"
],
"24600": [
"CVE-2004-2516"
],
"24607": [
"CVE-2004-2475"
],
"24622": [
"CVE-2004-2167"
],
"24623": [
"CVE-2004-0552"
],
"24624": [
"CVE-2004-1546"
],
"24653": [],
"24654": [],
"24656": [
"CVE-2004-0958"
],
"24669": [
"CVE-2004-0835"
],
"24681": [
"CVE-2004-1596"
],
"24686": [],
"24687": [],
"24688": [
"CVE-2004-1612"
],
"24693": [
"CVE-2005-0053"
],
"24977": [
"CVE-2004-1267"
],
"24978": [
"CVE-2004-1300"
],
"24701": [],
"24704": [
"CVE-2004-0989"
],
"24707": [],
"24890": [],
"24711": [
"CVE-2004-1392"
],
"24712": [],
"24713": [],
"24714": [
"CVE-2004-1104"
],
"24716": [
"CVE-2004-1121"
],
"24724": [
"CVE-2004-1500"
],
"24725": [
"CVE-2004-1003"
],
"24727": [],
"24728": [],
"24730": [],
"24745": [
"CVE-2013-0108"
],
"24760": [
"CVE-2004-1540"
],
"24767": [],
"24774": [
"CVE-2004-1127"
],
"24784": [
"CVE-2004-1304"
],
"24813": [
"CVE-2004-1488"
],
"24794": [],
"24795": [
"CVE-2004-1161"
],
"24800": [
"CVE-2004-1166"
],
"24801": [
"CVE-2004-1165"
],
"24802": [],
"24808": [],
"24811": [
"CVE-2004-1223"
],
"24852": [
"CVE-2004-1284"
],
"24853": [],
"24848": [
"CVE-2004-1264"
],
"24856": [
"CVE-2004-1286"
],
"24857": [
"CVE-2004-1286"
],
"24874": [
"CVE-2011-3923"
],
"24875": [],
"24876": [
"CVE-2012-4914"
],
"24886": [
"CVE-2013-3075"
],
"24887": [
"CVE-2012-4711"
],
"24888": [
"CVE-2012-3001"
],
"24891": [
"CVE-2012-5201"
],
"24892": [],
"24897": [
"CVE-2005-0575"
],
"24943": [],
"24955": [
"CVE-2013-1362"
],
"24902": [],
"24903": [],
"24904": [
"CVE-2013-1493"
],
"24905": [],
"24907": [
"CVE-2012-5879"
],
"24931": [],
"24935": [
"CVE-2013-1892"
],
"24936": [],
"24937": [],
"24938": [
"CVE-2013-1080"
],
"24950": [
"CVE-2005-0575"
],
"643": [
"CVE-2003-0264"
],
"646": [
"CVE-2003-0264"
],
"24944": [],
"24945": [],
"24946": [
"CVE-2013-0632",
"CVE-2013-0629",
"CVE-2013-0625"
],
"24947": [
"CVE-2013-1892"
],
"24956": [],
"24958": [],
"24961": [],
"24963": [],
"25091": [],
"24974": [],
"24976": [
"CVE-2013-2423"
],
"24979": [
"CVE-2004-1301"
],
"24980": [
"CVE-2004-1303"
],
"24981": [],
"24982": [],
"24983": [
"CVE-2004-1299"
],
"24984": [],
"24985": [
"CVE-2004-1020"
],
"24995": [],
"24996": [],
"25187": [],
"25188": [],
"25190": [
"CVE-2005-0671"
],
"25191": [],
"25194": [],
"29277": [],
"24999": [
"CVE-2002-1549"
],
"25294": [
"CVE-2013-1347"
],
"25001": [
"CVE-2013-3502"
],
"25005": [
"CVE-2004-1287"
],
"25006": [
"CVE-2004-1293"
],
"25008": [
"CVE-2004-1282"
],
"25009": [
"CVE-2004-1410"
],
"25010": [
"CVE-2004-1288"
],
"25011": [],
"25013": [],
"25015": [
"CVE-2004-1292"
],
"25016": [
"CVE-2004-1261"
],
"25018": [],
"25019": [
"CVE-2004-1256"
],
"25020": [
"CVE-2004-1298"
],
"25021": [
"CVE-2004-1259"
],
"25022": [],
"25023": [],
"25025": [],
"25026": [],
"25027": [
"CVE-2004-1260"
],
"25028": [],
"25029": [
"CVE-2004-1260"
],
"25030": [],
"25031": [
"CVE-2004-1324"
],
"25032": [
"CVE-2004-1325"
],
"25033": [],
"25034": [],
"25035": [
"CVE-2004-1289"
],
"25036": [
"CVE-2004-1289"
],
"25049": [
"CVE-2004-1306"
],
"25050": [],
"25054": [
"CVE-2005-0129"
],
"25057": [],
"25066": [
"CVE-2005-0316"
],
"25072": [
"CVE-2005-0229"
],
"25079": [],
"25080": [
"CVE-2005-0153"
],
"25092": [
"CVE-2005-0344"
],
"25094": [
"CVE-2004-0597"
],
"25095": [],
"25122": [],
"25129": [],
"25132": [],
"25133": [],
"25136": [
"CVE-2013-3238"
],
"25137": [
"CVE-2013-2010"
],
"25144": [],
"25146": [],
"25150": [
"CVE-2005-0161"
],
"25157": [],
"25163": [],
"25166": [],
"25167": [],
"25181": [],
"25195": [
"CVE-2005-0701"
],
"25196": [
"CVE-2005-0737"
],
"25205": [],
"25207": [
"CVE-2005-0731"
],
"25209": [
"CVE-2005-0709"
],
"25210": [
"CVE-2005-0710"
],
"25211": [
"CVE-2005-0711"
],
"25221": [
"CVE-2005-4809"
],
"25238": [
"CVE-2005-0838"
],
"25274": [
"CVE-2005-0905"
],
"25275": [
"CVE-2005-0892"
],
"25291": [
"CVE-2005-0906"
],
"25775": [
"CVE-2013-2028"
],
"25297": [],
"25319": [
"CVE-2005-0950"
],
"25321": [
"CVE-2005-0959"
],
"25325": [
"CVE-2005-0978"
],
"25335": [],
"25336": [
"CVE-2005-1002"
],
"25359": [
"CVE-2005-1059"
],
"25365": [
"CVE-2005-1087"
],
"25375": [
"CVE-2005-0404"
],
"25384": [
"CVE-2005-0048"
],
"25385": [
"CVE-2005-0555"
],
"25386": [
"CVE-2005-0553"
],
"25391": [
"CVE-2005-1077"
],
"25392": [
"CVE-2005-1099"
],
"25395": [
"CVE-2005-1105"
],
"25396": [],
"25397": [
"CVE-2004-1774"
],
"25420": [
"CVE-2005-1112"
],
"25421": [
"CVE-2005-1118"
],
"25445": [],
"25446": [],
"25452": [
"CVE-2005-4832"
],
"25453": [
"CVE-2005-4832"
],
"25454": [
"CVE-2005-1191"
],
"25486": [
"CVE-2005-1480"
],
"25487": [],
"25517": [
"CVE-2013-0136"
],
"25526": [],
"25546": [
"CVE-2005-1380"
],
"25547": [
"CVE-2005-1349"
],
"25557": [
"CVE-2005-1370"
],
"25559": [
"CVE-2005-1383"
],
"25561": [
"CVE-2005-1382"
],
"25562": [
"CVE-2005-1381"
],
"25563": [
"CVE-2005-1381"
],
"25571": [],
"25572": [],
"25573": [],
"25574": [
"CVE-2005-1401"
],
"25597": [],
"25598": [
"CVE-2005-1333"
],
"25600": [
"CVE-2005-1493"
],
"25608": [],
"25609": [],
"25820": [],
"25822": [
"CVE-2005-1306"
],
"25613": [],
"25621": [
"CVE-2005-1423"
],
"25624": [
"CVE-2005-1344"
],
"25625": [
"CVE-2005-1344"
],
"25626": [
"CVE-2005-1507"
],
"25627": [
"CVE-2005-1604"
],
"25643": [
"CVE-2005-1552"
],
"25646": [],
"25648": [],
"25652": [],
"25669": [
"CVE-2005-1365"
],
"25670": [
"CVE-2005-1532"
],
"25684": [
"CVE-2005-1827"
],
"25687": [
"CVE-2005-1679"
],
"25691": [
"CVE-2005-1702"
],
"25694": [],
"25695": [],
"25696": [],
"25697": [
"CVE-2005-1708"
],
"25698": [
"CVE-2005-1709"
],
"25706": [
"CVE-2005-1520"
],
"25708": [],
"25710": [],
"25713": [],
"25755": [],
"33414": [
"CVE-2009-4142"
],
"33415": [
"CVE-2009-4142"
],
"33423": [],
"25784": [],
"25802": [],
"25814": [
"CVE-2012-5946"
],
"25835": [],
"25836": [],
"25841": [],
"25842": [
"CVE-2005-2006"
],
"25851": [
"CVE-2013-3563"
],
"26288": [
"CVE-2005-2968"
],
"25948": [
"CVE-2005-2176"
],
"25949": [],
"25933": [
"CVE-2001-0454"
],
"25944": [
"CVE-2005-2175"
],
"25966": [
"CVE-2005-2277"
],
"25970": [],
"25975": [
"CVE-2013-0230"
],
"25979": [
"CVE-2013-1559"
],
"25980": [
"CVE-2013-2115",
"CVE-2013-1966"
],
"25986": [
"CVE-2013-4878"
],
"25987": [
"CVE-2013-2571"
],
"25988": [],
"25989": [
"CVE-2005-2310"
],
"25999": [
"CVE-2013-1311"
],
"26002": [],
"26003": [],
"26004": [],
"26006": [],
"26013": [],
"26022": [],
"26024": [],
"26032": [],
"26035": [],
"26044": [],
"26071": [
"CVE-2005-2453"
],
"26332": [
"CVE-2005-3204"
],
"26075": [],
"26299": [],
"26101": [
"CVE-2005-2357"
],
"40874": [
"CVE-2016-6707"
],
"26123": [
"CVE-2012-1533"
],
"26134": [],
"26135": [
"CVE-2013-1488"
],
"26151": [
"CVE-2005-2644"
],
"26152": [
"CVE-2005-2523"
],
"26167": [
"CVE-2005-2127"
],
"26168": [
"CVE-2005-2640"
],
"26175": [
"CVE-2013-2551",
"CVE-2013-1298"
],
"26196": [],
"26198": [
"CVE-2005-2729"
],
"26210": [
"CVE-2005-2791"
],
"26221": [],
"26230": [],
"26306": [],
"26330": [
"CVE-2005-3202"
],
"26318": [],
"26329": [
"CVE-2005-3202"
],
"26374": [
"CVE-2005-3293"
],
"26375": [
"CVE-2005-3293"
],
"26376": [
"CVE-2005-4774"
],
"26412": [],
"26419": [],
"26420": [
"CVE-2013-3576"
],
"26421": [],
"26422": [
"CVE-2012-6495",
"CVE-2012-6081"
],
"26424": [
"CVE-2005-3330"
],
"26443": [
"CVE-2005-3390"
],
"26460": [
"CVE-2005-3489"
],
"26464": [
"CVE-2005-1939"
],
"26471": [
"CVE-2013-4730"
],
"26491": [],
"26493": [],
"26494": [],
"26495": [
"CVE-2013-4730"
],
"26529": [
"CVE-2013-2460"
],
"26531": [],
"26536": [
"CVE-2005-3189"
],
"26540": [
"CVE-2005-3737"
],
"26542": [
"CVE-2005-3745"
],
"26622": [],
"40386": [],
"26737": [
"CVE-2013-2028"
],
"26739": [
"CVE-2013-5019"
],
"26741": [
"CVE-2005-4080"
],
"26768": [],
"26773": [
"CVE-2005-4202"
],
"26774": [
"CVE-2005-4202"
],
"26775": [
"CVE-2005-4202"
],
"26913": [
"CVE-2005-4667"
],
"26966": [
"CVE-2005-4502"
],
"27007": [
"CVE-2013-4730"
],
"27012": [
"CVE-2013-1017"
],
"27013": [
"CVE-2011-4166"
],
"27024": [
"CVE-2005-4622"
],
"27032": [
"CVE-2005-3539"
],
"27044": [],
"27045": [
"CVE-2013-2121"
],
"27046": [
"CVE-2013-3520"
],
"27072": [
"CVE-2006-0187"
],
"27073": [
"CVE-2006-0187"
],
"27095": [
"CVE-2006-0254"
],
"27096": [
"CVE-2006-0254"
],
"27133": [
"CVE-2013-4659"
],
"27135": [
"CVE-2013-2251"
],
"27150": [
"CVE-2006-0496"
],
"27181": [
"CVE-2006-0663"
],
"27182": [
"CVE-2006-0663"
],
"27203": [
"CVE-2005-3058"
],
"27233": [
"CVE-2006-0731"
],
"27234": [
"CVE-2006-0731"
],
"27235": [
"CVE-2006-0731"
],
"27244": [
"CVE-2006-0787"
],
"27271": [
"CVE-2011-0922"
],
"27277": [
"CVE-2013-4730"
],
"27528": [],
"27293": [],
"27294": [],
"27295": [],
"27319": [
"CVE-2006-0947"
],
"27325": [
"CVE-2006-0971"
],
"27326": [
"CVE-2006-0903"
],
"27378": [
"CVE-2006-1161"
],
"27397": [],
"27400": [
"CVE-2011-0923"
],
"27401": [
"CVE-2010-2620"
],
"27428": [],
"27429": [
"CVE-2013-1690"
],
"27452": [
"CVE-2006-1357"
],
"27508": [
"CVE-2006-1490"
],
"27523": [],
"27526": [],
"27527": [
"CVE-2013-0156"
],
"27529": [
"CVE-2013-4211"
],
"27530": [
"CVE-2013-5036"
],
"27554": [],
"27555": [
"CVE-2013-2343",
"CVE-2012-3282"
],
"27556": [
"CVE-2010-2620"
],
"27564": [
"CVE-2006-0996"
],
"27565": [
"CVE-2006-1654"
],
"27568": [
"CVE-2006-1652"
],
"27569": [
"CVE-2006-1652"
],
"27577": [
"CVE-2006-1626"
],
"27595": [
"CVE-2006-1494"
],
"27596": [
"CVE-2006-1608"
],
"27806": [
"CVE-2006-2233"
],
"27606": [],
"27607": [],
"27608": [
"CVE-2013-5019"
],
"27610": [
"CVE-2013-5576"
],
"27611": [],
"27627": [
"CVE-2006-1771"
],
"27630": [
"CVE-2006-1711"
],
"27636": [
"CVE-2006-1786"
],
"27637": [
"CVE-2006-1786"
],
"28056": [],
"27703": [
"CVE-2013-4730"
],
"27704": [],
"27705": [
"CVE-2013-2465"
],
"27706": [
"CVE-2013-0526"
],
"27716": [
"CVE-2006-2020"
],
"27744": [
"CVE-2006-2094"
],
"27746": [
"CVE-2006-2101"
],
"27747": [],
"27752": [
"CVE-2013-5093"
],
"27754": [],
"27758": [
"CVE-2006-2099"
],
"27759": [
"CVE-2006-2100"
],
"27760": [
"CVE-2006-2102"
],
"27801": [
"CVE-2006-2223"
],
"27802": [
"CVE-2006-2224"
],
"27805": [],
"27820": [
"CVE-2006-1172"
],
"27830": [
"CVE-2006-0515"
],
"33405": [
"CVE-2009-1798"
],
"27851": [
"CVE-2006-2334"
],
"27852": [
"CVE-2006-2341"
],
"27861": [
"CVE-2006-2351"
],
"27862": [
"CVE-2006-2351"
],
"27873": [],
"27877": [
"CVE-2013-3763"
],
"27887": [
"CVE-2006-1039"
],
"27891": [
"CVE-2006-2531"
],
"27892": [
"CVE-2006-2490"
],
"27893": [
"CVE-2006-2490"
],
"40382": [],
"27894": [
"CVE-2006-2490"
],
"27902": [
"CVE-2006-2548"
],
"27923": [
"CVE-2006-2653"
],
"27931": [
"CVE-2006-2769"
],
"27939": [
"CVE-2013-2370"
],
"27940": [
"CVE-2013-0753"
],
"27941": [],
"27943": [],
"27992": [
"CVE-2006-0747"
],
"27984": [
"CVE-2006-2383"
],
"27986": [
"CVE-2006-2894"
],
"27987": [
"CVE-2006-2894"
],
"28005": [
"CVE-2006-1193"
],
"28007": [
"CVE-2006-3015"
],
"28030": [
"CVE-2006-3101"
],
"28081": [
"CVE-2012-3748"
],
"28082": [
"CVE-2013-3184"
],
"28083": [
"CVE-2013-4798"
],
"28118": [
"CVE-2006-3280"
],
"28170": [],
"28181": [
"CVE-2006-3581"
],
"28183": [],
"28186": [
"CVE-2006-3491"
],
"28187": [
"CVE-2013-4015",
"CVE-2013-3846",
"CVE-2013-3166",
"CVE-2013-3164",
"CVE-2013-3163",
"CVE-2013-3162",
"CVE-2013-3161",
"CVE-2013-3153",
"CVE-2013-3152",
"CVE-2013-3151",
"CVE-2013-3150",
"CVE-2013-3149",
"CVE-2013-3148",
"CVE-2013-3147",
"CVE-2013-3146",
"CVE-2013-3145",
"CVE-2013-3144",
"CVE-2013-3143",
"CVE-2013-3115"
],
"28188": [
"CVE-2013-2367"
],
"28189": [
"CVE-2006-3431"
],
"28198": [
"CVE-2006-2389"
],
"28209": [
"CVE-2006-3624"
],
"28210": [
"CVE-2006-3624"
],
"28224": [
"CVE-2006-3655"
],
"28225": [
"CVE-2006-3660"
],
"28226": [
"CVE-2006-3656"
],
"28235": [
"CVE-2006-3845"
],
"28245": [
"CVE-2006-3733"
],
"28254": [
"CVE-2006-3835"
],
"28284": [
"CVE-2013-2817"
],
"28298": [],
"28312": [
"CVE-2006-2481"
],
"28314": [
"CVE-2006-4006"
],
"28328": [
"CVE-2013-4730"
],
"28331": [
"CVE-2013-2472"
],
"28333": [],
"28334": [
"CVE-2013-4983"
],
"28336": [
"CVE-2013-4811"
],
"28337": [
"CVE-2013-4812"
],
"28344": [
"CVE-2006-4125"
],
"28357": [
"CVE-2006-3281"
],
"28360": [],
"28365": [
"CVE-2006-4110"
],
"28368": [
"CVE-2006-4131"
],
"28373": [
"CVE-2006-4295"
],
"28374": [
"CVE-2006-4140"
],
"28376": [],
"28397": [
"CVE-2005-4807"
],
"28398": [
"CVE-2006-4227"
],
"28400": [
"CVE-2006-4219"
],
"28407": [],
"28408": [],
"28424": [
"CVE-2006-3918"
],
"28438": [
"CVE-2006-4446"
],
"28450": [],
"28481": [
"CVE-2013-3205"
],
"28482": [
"CVE-2013-0810"
],
"28483": [
"CVE-2013-5696"
],
"28484": [
"CVE-2013-3568"
],
"28489": [
"CVE-2006-4654"
],
"28500": [
"CVE-2006-0032"
],
"28501": [
"CVE-2006-6919"
],
"28508": [],
"28512": [
"CVE-2006-5034"
],
"28595": [],
"28602": [],
"28639": [
"CVE-2006-4965"
],
"28640": [
"CVE-2006-4899"
],
"28641": [
"CVE-2006-4900"
],
"28642": [
"CVE-2006-4901"
],
"28643": [
"CVE-2006-3507"
],
"28725": [
"CVE-2006-5114"
],
"28681": [],
"28682": [
"CVE-2013-3893"
],
"28710": [
"CVE-2006-5084"
],
"28713": [
"CVE-2013-4810"
],
"28724": [],
"28760": [
"CVE-2006-4812"
],
"28765": [
"CVE-2006-5143"
],
"28766": [
"CVE-2006-5143"
],
"28809": [
"CVE-2013-4800"
],
"28810": [],
"28835": [
"CVE-2006-5478"
],
"28836": [
"CVE-2006-5478"
],
"28837": [
"CVE-2006-5478"
],
"28847": [
"CVE-2006-5536"
],
"28848": [
"CVE-2006-5512"
],
"28849": [],
"28850": [
"CVE-2006-5571"
],
"28853": [],
"28876": [],
"28877": [],
"28884": [],
"28887": [
"CVE-2006-5653"
],
"28888": [
"CVE-2006-5711"
],
"28916": [
"CVE-2006-5650"
],
"28962": [
"CVE-2013-6366"
],
"28968": [],
"28973": [
"CVE-2013-2333"
],
"28974": [
"CVE-2013-3897"
],
"28981": [
"CVE-2006-2431"
],
"28987": [],
"29032": [],
"29033": [
"CVE-2006-5925"
],
"29035": [],
"29045": [
"CVE-2006-6124"
],
"29083": [],
"29096": [
"CVE-2006-6059"
],
"29127": [],
"29129": [
"CVE-2011-1566"
],
"29130": [
"CVE-2013-4822"
],
"29132": [],
"29160": [
"CVE-2006-6097"
],
"29146": [
"CVE-2006-5854"
],
"29167": [
"CVE-2006-6125"
],
"29171": [
"CVE-2006-6133"
],
"29210": [
"CVE-2011-4275",
"CVE-2009-4140"
],
"29273": [
"CVE-2013-6021"
],
"29281": [
"CVE-2006-6597"
],
"29290": [
"CVE-2012-2336",
"CVE-2012-2311",
"CVE-2012-1823"
],
"29302": [
"CVE-2006-6104"
],
"29316": [
"CVE-2012-2336",
"CVE-2012-2311",
"CVE-2012-1823"
],
"29319": [
"CVE-2013-3591"
],
"29320": [
"CVE-2013-3631"
],
"29321": [
"CVE-2013-3628"
],
"29322": [
"CVE-2013-3629"
],
"29323": [
"CVE-2013-3632"
],
"29324": [
"CVE-2013-3630"
],
"29325": [],
"30186": [
"CVE-2007-3181"
],
"29371": [],
"29383": [
"CVE-2007-0044"
],
"29475": [
"CVE-2007-0297"
],
"29400": [
"CVE-2007-0110"
],
"29439": [
"CVE-2007-0183"
],
"29448": [],
"29449": [],
"29513": [
"CVE-2013-7382",
"CVE-2013-4467",
"CVE-2013-4468"
],
"29471": [
"CVE-2006-6899"
],
"29490": [
"CVE-2007-0357"
],
"29496": [
"CVE-2007-0389"
],
"30037": [
"CVE-2007-2441"
],
"30038": [
"CVE-2007-2440"
],
"30043": [
"CVE-2007-2788"
],
"30045": [],
"30049": [
"CVE-2007-2763"
],
"30052": [
"CVE-2007-1355"
],
"30016": [
"CVE-2007-1280"
],
"30018": [
"CVE-2007-2052"
],
"30019": [
"CVE-2007-2523"
],
"30025": [],
"30026": [
"CVE-2007-2639"
],
"29524": [
"CVE-2007-0515"
],
"29527": [],
"29538": [
"CVE-2007-0641"
],
"29685": [
"CVE-2007-1229"
],
"29686": [
"CVE-2007-1199"
],
"29687": [
"CVE-2007-1192"
],
"29812": [
"CVE-2014-5007",
"CVE-2013-7390"
],
"29552": [
"CVE-2008-2286"
],
"29573": [
"CVE-2007-0896"
],
"29575": [
"CVE-2007-0872"
],
"29595": [],
"29614": [],
"29619": [
"CVE-2007-3406"
],
"29666": [
"CVE-2013-3623"
],
"29688": [
"CVE-2007-1190"
],
"29689": [
"CVE-2007-1263"
],
"29690": [
"CVE-2007-1264"
],
"29691": [
"CVE-2007-1266"
],
"29699": [],
"29706": [
"CVE-2013-6796"
],
"29725": [
"CVE-2007-1365"
],
"29732": [
"CVE-2007-1453"
],
"29734": [
"CVE-2013-6831",
"CVE-2013-6830",
"CVE-2013-6829"
],
"29735": [
"CVE-2007-1435"
],
"29739": [
"CVE-2007-0450"
],
"29741": [
"CVE-2007-1499"
],
"29749": [
"CVE-2007-1506"
],
"29752": [
"CVE-2007-1583"
],
"29753": [
"CVE-2007-1536"
],
"29768": [
"CVE-2007-1562"
],
"29769": [
"CVE-2007-1563"
],
"29770": [
"CVE-2007-1564"
],
"29771": [
"CVE-2007-1658"
],
"29784": [
"CVE-2007-1718",
"CVE-2007-1717"
],
"29785": [
"CVE-2007-1773"
],
"29788": [
"CVE-2007-1777"
],
"30117": [
"CVE-2007-2872"
],
"30130": [
"CVE-2007-3799"
],
"30142": [],
"30144": [
"CVE-2007-3071"
],
"30164": [
"CVE-2006-3974"
],
"30169": [
"CVE-2007-3201"
],
"30176": [
"CVE-2007-3186"
],
"30394": [
"CVE-2013-3346"
],
"29807": [
"CVE-2007-1825"
],
"29808": [
"CVE-2007-1890"
],
"29814": [],
"29815": [
"CVE-2013-2751"
],
"29820": [
"CVE-2007-1947"
],
"29952": [],
"29840": [
"CVE-2007-1559"
],
"29843": [
"CVE-2007-2048"
],
"29853": [
"CVE-2007-1674"
],
"29857": [
"CVE-2013-3918"
],
"29858": [
"CVE-2013-0074",
"CVE-2012-0016"
],
"29859": [
"CVE-2013-4212"
],
"29873": [
"CVE-2007-2191"
],
"29884": [
"CVE-2007-2175"
],
"29897": [],
"29930": [
"CVE-2007-2353"
],
"29931": [
"CVE-2007-2429"
],
"29932": [],
"29945": [],
"29951": [
"CVE-2007-2581"
],
"29964": [
"CVE-2007-2508"
],
"30373": [
"CVE-2013-6162"
],
"30008": [
"CVE-2013-5486"
],
"30009": [],
"30010": [],
"30011": [
"CVE-2013-3906"
],
"30067": [
"CVE-2007-2747"
],
"30069": [],
"30074": [
"CVE-2007-2519"
],
"30078": [
"CVE-2007-2843"
],
"30089": [
"CVE-2007-3227"
],
"30209": [
"CVE-2013-4837"
],
"30210": [
"CVE-2013-0632"
],
"30211": [
"CVE-2012-0874"
],
"30212": [
"CVE-2013-3522"
],
"30218": [
"CVE-2007-3327"
],
"30219": [
"CVE-2007-3365"
],
"30222": [
"CVE-2007-3364"
],
"30228": [
"CVE-2007-2401"
],
"30229": [
"CVE-2007-3407"
],
"30231": [
"CVE-2007-3396"
],
"30284": [
"CVE-2007-3655"
],
"30254": [
"CVE-2007-3574"
],
"30256": [
"CVE-2007-3553"
],
"30257": [
"CVE-2007-3554"
],
"30264": [
"CVE-2007-3011"
],
"30265": [
"CVE-2007-3624"
],
"30278": [
"CVE-2007-3614"
],
"30279": [
"CVE-2007-3613"
],
"30281": [
"CVE-2007-0042"
],
"30285": [
"CVE-2007-3670"
],
"30287": [
"CVE-2007-3701"
],
"30288": [
"CVE-2007-3456"
],
"30291": [
"CVE-2007-3725"
],
"30292": [
"CVE-2007-2394"
],
"30315": [
"CVE-2007-3832"
],
"30319": [
"CVE-2007-3798"
],
"30322": [
"CVE-2007-3947"
],
"30381": [
"CVE-2007-3845"
],
"30469": [
"CVE-2013-2068"
],
"31465": [
"CVE-2008-6540"
],
"30431": [
"CVE-2007-4105"
],
"30432": [],
"30439": [
"CVE-2007-3844"
],
"30441": [
"CVE-2007-4145"
],
"30447": [
"CVE-2007-4174"
],
"30454": [
"CVE-2007-4226"
],
"30809": [
"CVE-2007-6483"
],
"30470": [
"CVE-2013-6955"
],
"30471": [
"CVE-2013-1349"
],
"30473": [
"CVE-2013-4835"
],
"30485": [
"CVE-2007-4318"
],
"30490": [
"CVE-2007-2216"
],
"30491": [
"CVE-2007-4385"
],
"30493": [
"CVE-2007-2223"
],
"30495": [
"CVE-2007-3386"
],
"30496": [
"CVE-2007-3382"
],
"30499": [],
"30502": [
"CVE-2007-4381"
],
"30507": [
"CVE-2007-4444"
],
"30508": [
"CVE-2007-4446"
],
"30521": [
"CVE-2007-4545"
],
"30523": [
"CVE-2007-4537"
],
"30532": [
"CVE-2007-4220"
],
"30535": [
"CVE-2007-2930"
],
"30536": [
"CVE-2007-2930"
],
"30537": [
"CVE-2007-2931"
],
"30543": [
"CVE-2007-4642"
],
"30971": [
"CVE-2008-0096"
],
"30972": [
"CVE-2008-6061"
],
"30973": [
"CVE-2008-6060"
],
"31024": [
"CVE-2008-0265"
],
"30882": [
"CVE-2007-6003"
],
"30883": [],
"30562": [
"CVE-2007-4722"
],
"30565": [
"CVE-2007-4725"
],
"30567": [
"CVE-2007-3040"
],
"30569": [
"CVE-2007-4843"
],
"32417": [],
"32416": [],
"32512": [
"CVE-2014-1903"
],
"32399": [
"CVE-2008-4247"
],
"32393": [
"CVE-2008-4131"
],
"32391": [],
"33141": [],
"32390": [],
"32277": [
"CVE-2013-2028"
],
"30582": [
"CVE-2007-4909"
],
"30589": [
"CVE-2007-4962"
],
"30600": [
"CVE-2007-5064"
],
"30622": [
"CVE-2007-5158"
],
"30627": [
"CVE-2007-5256"
],
"30630": [
"CVE-2007-5248"
],
"30631": [
"CVE-2007-5255"
],
"30635": [
"CVE-2007-3898"
],
"30636": [
"CVE-2007-3898"
],
"30643": [
"CVE-2007-5264"
],
"30645": [
"CVE-2007-3896"
],
"30650": [
"CVE-2007-5411"
],
"30652": [
"CVE-2007-5381"
],
"30673": [
"CVE-2007-5562"
],
"30677": [
"CVE-2007-5488"
],
"30678": [
"CVE-2007-5636"
],
"30692": [
"CVE-2007-5601"
],
"30711": [
"CVE-2007-5685"
],
"30720": [
"CVE-2007-5722"
],
"30728": [
"CVE-2007-5837"
],
"30729": [
"CVE-2007-5796"
],
"30730": [
"CVE-2007-5815"
],
"30736": [
"CVE-2007-5795"
],
"30740": [],
"30742": [
"CVE-2007-5926"
],
"30755": [
"CVE-2007-5979"
],
"30768": [
"CVE-2007-5944"
],
"30771": [
"CVE-2007-6054"
],
"30772": [
"CVE-2007-6028"
],
"30781": [
"CVE-2007-6165"
],
"31026": [
"CVE-2008-7161"
],
"30787": [
"CVE-2013-3214"
],
"30816": [
"CVE-2007-6593"
],
"30819": [],
"30833": [
"CVE-2007-6704"
],
"30834": [
"CVE-2007-6704"
],
"30835": [
"CVE-2007-6203"
],
"30838": [],
"30850": [],
"30897": [
"CVE-2007-6493"
],
"30901": [
"CVE-2007-6514"
],
"30905": [
"CVE-2007-6244"
],
"30907": [
"CVE-2007-6244"
],
"30908": [
"CVE-2014-1202"
],
"30915": [
"CVE-2014-0659"
],
"30920": [
"CVE-2007-6513"
],
"30928": [
"CVE-2007-6561"
],
"30933": [
"CVE-2007-6533"
],
"30935": [],
"30939": [],
"30944": [
"CVE-2007-6630"
],
"30998": [
"CVE-2008-1136"
],
"31010": [
"CVE-2008-0339"
],
"31013": [
"CVE-2007-4389"
],
"31023": [
"CVE-2008-4664"
],
"31031": [
"CVE-2008-0372"
],
"31032": [
"CVE-2008-0364"
],
"31033": [
"CVE-2013-6343"
],
"31039": [
"CVE-2008-0396"
],
"31040": [],
"31046": [],
"31047": [
"CVE-2008-0438"
],
"31050": [
"CVE-2008-0387"
],
"31051": [
"CVE-2008-0418"
],
"31052": [
"CVE-2008-0455"
],
"31053": [
"CVE-2007-4850"
],
"31056": [
"CVE-2008-0406"
],
"40358": [],
"31072": [
"CVE-2008-0457"
],
"31076": [
"CVE-2008-0485"
],
"31078": [],
"31095": [
"CVE-2006-4220"
],
"31106": [
"CVE-2008-5159"
],
"31113": [],
"31118": [
"CVE-2008-0108"
],
"31119": [
"CVE-2008-0671"
],
"31127": [],
"31130": [
"CVE-2007-5333"
],
"31132": [
"CVE-2008-0767"
],
"31133": [
"CVE-2008-7032"
],
"31149": [
"CVE-2008-0760"
],
"31163": [
"CVE-2008-0790"
],
"40760": [],
"31683": [],
"31179": [
"CVE-2013-7246"
],
"31181": [
"CVE-2013-6194"
],
"31204": [
"CVE-2008-0838"
],
"31231": [
"CVE-2008-1169"
],
"31253": [
"CVE-2012-3153",
"CVE-2012-3152"
],
"31254": [
"CVE-2013-4730"
],
"31255": [
"CVE-2013-4730"
],
"31462": [
"CVE-2008-1482"
],
"31260": [],
"31264": [],
"31279": [],
"31298": [
"CVE-2008-1037"
],
"31309": [
"CVE-2008-0411"
],
"31311": [
"CVE-2008-1180"
],
"31340": [
"CVE-2008-1208"
],
"31342": [
"CVE-2008-1262"
],
"31345": [
"CVE-2008-1221"
],
"31359": [],
"31362": [
"CVE-2008-1283"
],
"31364": [],
"31395": [
"CVE-2008-0533"
],
"31396": [
"CVE-2008-1270"
],
"31698": [
"CVE-2008-2030"
],
"31699": [],
"31405": [
"CVE-2008-1461"
],
"31407": [],
"31409": [
"CVE-2008-1403"
],
"31412": [
"CVE-2008-1000"
],
"31432": [
"CVE-2014-1683"
],
"31433": [
"CVE-2009-3548"
],
"31434": [
"CVE-2012-0394"
],
"31473": [],
"31474": [],
"31479": [
"CVE-2008-6543"
],
"40354": [
"CVE-2016-3861"
],
"31518": [],
"31519": [
"CVE-2013-4710"
],
"31533": [
"CVE-2008-0926"
],
"31534": [
"CVE-2008-1605"
],
"31536": [
"CVE-2008-1564"
],
"31540": [
"CVE-2008-1488"
],
"31551": [
"CVE-2005-4703"
],
"31562": [
"CVE-2008-1620"
],
"31575": [
"CVE-2013-2827"
],
"31577": [],
"31583": [],
"31591": [
"CVE-2008-6195"
],
"31613": [
"CVE-2008-2006"
],
"31624": [],
"31630": [
"CVE-2007-6019"
],
"31632": [
"CVE-2008-1888"
],
"31634": [
"CVE-2008-1721"
],
"31638": [
"CVE-2008-0068"
],
"31639": [
"CVE-2008-6563"
],
"31917": [
"CVE-2013-5014",
"CVE-2013-5015"
],
"31689": [
"CVE-2013-2347"
],
"31694": [
"CVE-2014-10031"
],
"31695": [],
"31706": [
"CVE-2008-1965"
],
"31736": [
"CVE-2013-5019"
],
"31737": [
"CVE-2012-3152"
],
"31756": [
"CVE-2008-2162"
],
"31757": [
"CVE-2008-2167"
],
"31758": [],
"31759": [
"CVE-2008-2168"
],
"31767": [
"CVE-2014-1610"
],
"31769": [],
"31770": [
"CVE-2008-2138"
],
"31788": [],
"31789": [
"CVE-2013-4730"
],
"31814": [
"CVE-2013-5019"
],
"31820": [
"CVE-2008-2499"
],
"31828": [
"CVE-2008-2333"
],
"31831": [
"CVE-2014-10001"
],
"31853": [
"CVE-2013-5015",
"CVE-2013-5014"
],
"31862": [
"CVE-2008-5225"
],
"31863": [
"CVE-2008-5225"
],
"31864": [
"CVE-2008-5225"
],
"31873": [
"CVE-2007-5604"
],
"31875": [
"CVE-2014-1912"
],
"31885": [
"CVE-2008-2637"
],
"31886": [
"CVE-2008-2637"
],
"31887": [
"CVE-2008-2702"
],
"31890": [
"CVE-2008-7184"
],
"31901": [
"CVE-2008-5266"
],
"31903": [
"CVE-2008-2719"
],
"31909": [],
"31912": [
"CVE-2008-7170"
],
"31918": [
"CVE-2008-6737"
],
"31920": [
"CVE-2008-2821"
],
"31921": [
"CVE-2008-2822"
],
"31922": [
"CVE-2008-2751"
],
"31923": [
"CVE-2008-2751"
],
"31924": [
"CVE-2008-2751"
],
"31925": [
"CVE-2008-2751"
],
"31926": [
"CVE-2008-2751"
],
"31927": [
"CVE-2008-2751"
],
"31928": [
"CVE-2008-2751"
],
"31936": [
"CVE-2008-2795"
],
"31941": [
"CVE-2008-2889"
],
"31942": [
"CVE-2008-2894"
],
"32048": [
"CVE-2008-2303"
],
"32133": [
"CVE-2008-2935"
],
"31980": [
"CVE-2008-7168"
],
"31987": [
"CVE-2014-0750"
],
"31996": [
"CVE-2008-2949",
"CVE-2008-2948"
],
"31997": [
"CVE-2008-5175"
],
"32012": [
"CVE-2008-3076"
],
"32132": [
"CVE-2014-2206"
],
"32049": [],
"32052": [
"CVE-2008-6442"
],
"32084": [
"CVE-2008-3285"
],
"32110": [],
"32124": [
"CVE-2008-3430"
],
"32129": [],
"32137": [
"CVE-2008-2370"
],
"32138": [
"CVE-2008-1232"
],
"32163": [
"CVE-2014-10001"
],
"32164": [
"CVE-2013-2347"
],
"32165": [
"CVE-2008-3569"
],
"32166": [
"CVE-2008-3569"
],
"32167": [
"CVE-2008-3494"
],
"32189": [],
"32197": [
"CVE-2008-3667"
],
"32209": [
"CVE-2014-0783"
],
"32210": [
"CVE-2014-0784"
],
"32223": [
"CVE-2008-3657",
"CVE-2008-3655"
],
"32224": [
"CVE-2008-3655"
],
"32225": [
"CVE-2008-3432"
],
"32228": [
"CVE-2008-4437"
],
"32286": [
"CVE-2008-3776"
],
"32289": [
"CVE-2008-4101"
],
"32301": [
"CVE-2008-7110"
],
"32303": [
"CVE-2008-3906"
],
"32336": [
"CVE-2008-4133"
],
"32339": [
"CVE-2008-3956"
],
"32344": [
"CVE-2008-3957"
],
"32345": [
"CVE-2008-3957"
],
"32367": [],
"32359": [
"CVE-2008-5191"
],
"32363": [],
"32371": [],
"32372": [],
"32382": [
"CVE-2008-7012"
],
"32426": [],
"32429": [
"CVE-2008-5073"
],
"32438": [
"CVE-2014-0307"
],
"32439": [
"CVE-2014-1691"
],
"32440": [],
"32442": [],
"32445": [
"CVE-2008-4456"
],
"32456": [],
"32457": [],
"32458": [],
"32460": [],
"32465": [
"CVE-2008-4508"
],
"32466": [
"CVE-2008-4582"
],
"32469": [
"CVE-2008-5869"
],
"32470": [
"CVE-2008-3641"
],
"32475": [
"CVE-2008-6065"
],
"32564": [
"CVE-2008-6504"
],
"32489": [
"CVE-2008-1547"
],
"32491": [],
"32493": [],
"32515": [
"CVE-2013-2143"
],
"32529": [
"CVE-2008-4910"
],
"32530": [
"CVE-2006-7234"
],
"32548": [
"CVE-2008-4795"
],
"32552": [
"CVE-2008-4918"
],
"32555": [],
"32565": [
"CVE-2008-6505"
],
"32568": [
"CVE-2014-1216"
],
"32578": [
"CVE-2008-5177"
],
"32582": [],
"32586": [
"CVE-2008-5112"
],
"32621": [
"CVE-2008-5191"
],
"32591": [],
"32599": [
"CVE-2008-6280"
],
"32618": [],
"32643": [
"CVE-2014-2560"
],
"32654": [
"CVE-2008-5551"
],
"32673": [
"CVE-2008-5659"
],
"32674": [
"CVE-2008-5659"
],
"32681": [],
"32684": [
"CVE-2008-5745"
],
"32686": [],
"32690": [
"CVE-2006-7236"
],
"32691": [
"CVE-2008-5824"
],
"32699": [],
"32711": [
"CVE-2009-0043"
],
"32723": [
"CVE-2008-3821"
],
"32725": [
"CVE-2014-2314"
],
"32738": [],
"32743": [],
"32745": [
"CVE-2014-0346",
"CVE-2014-0160"
],
"32753": [],
"32762": [
"CVE-2009-0348"
],
"32764": [
"CVE-2014-0346",
"CVE-2014-0160"
],
"32776": [
"CVE-2009-0470"
],
"32780": [
"CVE-2009-0544"
],
"32781": [],
"32789": [
"CVE-2014-2850",
"CVE-2014-2849"
],
"32791": [
"CVE-2014-0346",
"CVE-2014-0160"
],
"32794": [
"CVE-2014-2268"
],
"32795": [
"CVE-2009-0611"
],
"32796": [
"CVE-2009-0640"
],
"32798": [
"CVE-2009-0542"
],
"32799": [],
"32801": [],
"32811": [
"CVE-2009-0520"
],
"32904": [
"CVE-2014-0322"
],
"32825": [
"CVE-2009-0858"
],
"32826": [],
"32832": [
"CVE-2009-0849"
],
"32834": [
"CVE-2009-0037"
],
"32837": [
"CVE-2009-0367"
],
"32839": [
"CVE-2009-0855"
],
"32851": [
"CVE-2014-0322"
],
"32876": [],
"32877": [
"CVE-2009-4795"
],
"32878": [
"CVE-2009-1220"
],
"32879": [
"CVE-2007-4475"
],
"32885": [
"CVE-2014-3139",
"CVE-2014-3008"
],
"32998": [
"CVE-2014-0346",
"CVE-2014-0160"
],
"32997": [
"CVE-2014-2994"
],
"32919": [
"CVE-2014-0984"
],
"32920": [
"CVE-2009-0038"
],
"32921": [
"CVE-2009-0038"
],
"32922": [
"CVE-2009-0039"
],
"32923": [],
"32925": [
"CVE-2014-2913"
],
"32929": [
"CVE-2009-1349"
],
"32931": [
"CVE-2009-1561"
],
"32938": [],
"32942": [
"CVE-2009-1312"
],
"32944": [],
"32945": [],
"32954": [
"CVE-2009-1558"
],
"32955": [
"CVE-2009-1557"
],
"32957": [],
"32959": [
"CVE-2013-0634",
"CVE-2013-0633"
],
"32962": [],
"32965": [
"CVE-2009-1416"
],
"32967": [
"CVE-2009-1595"
],
"32971": [
"CVE-2009-1553"
],
"33577": [],
"33352": [
"CVE-2014-3791"
],
"32978": [
"CVE-2009-1553"
],
"32974": [
"CVE-2009-1553"
],
"32975": [
"CVE-2009-1553"
],
"32977": [
"CVE-2009-1553"
],
"32979": [
"CVE-2009-1553"
],
"32980": [
"CVE-2009-1553"
],
"32981": [
"CVE-2009-1553"
],
"32987": [
"CVE-2009-1554"
],
"32994": [
"CVE-2009-0162"
],
"32996": [],
"33007": [
"CVE-2009-1634"
],
"33010": [],
"33016": [],
"33023": [
"CVE-2009-0580"
],
"33024": [
"CVE-2009-1140"
],
"33025": [],
"33027": [
"CVE-2014-4158"
],
"33032": [
"CVE-2009-1391"
],
"33033": [
"CVE-2009-1684"
],
"33034": [
"CVE-2009-1699"
],
"33035": [],
"33039": [
"CVE-2009-1834"
],
"33044": [
"CVE-2009-0961"
],
"33045": [
"CVE-2009-0961"
],
"33046": [
"CVE-2009-0961"
],
"33047": [
"CVE-2009-1724"
],
"33050": [],
"33051": [
"CVE-2009-2288"
],
"33053": [
"CVE-2009-1886"
],
"33054": [
"CVE-2009-1203"
],
"33055": [
"CVE-2009-1201"
],
"33063": [
"CVE-2009-2350"
],
"33064": [
"CVE-2009-2352"
],
"33066": [
"CVE-2009-2377"
],
"33067": [
"CVE-2009-2386"
],
"33071": [
"CVE-2013-0140"
],
"33078": [
"CVE-2009-1422"
],
"33079": [
"CVE-2009-1975"
],
"33081": [
"CVE-2009-1019"
],
"33082": [
"CVE-2009-1968"
],
"33084": [
"CVE-2009-1020"
],
"33089": [
"CVE-2009-3860"
],
"33351": [
"CVE-2009-4653"
],
"33580": [
"CVE-2010-0470"
],
"33095": [
"CVE-2013-5331"
],
"33103": [
"CVE-2009-2654"
],
"33118": [],
"33123": [],
"33124": [],
"33142": [
"CVE-2014-0113",
"CVE-2014-0112",
"CVE-2014-0094"
],
"33143": [
"CVE-2014-3220",
"CVE-2014-2937"
],
"33162": [
"CVE-2009-2626"
],
"33163": [
"CVE-2009-2626"
],
"33164": [
"CVE-2009-2195"
],
"33165": [],
"33172": [],
"33177": [],
"33192": [],
"33203": [
"CVE-2008-6992"
],
"33207": [],
"33210": [
"CVE-2009-3099"
],
"33211": [
"CVE-2009-4188"
],
"33212": [
"CVE-2014-0497"
],
"33215": [],
"33234": [],
"33257": [
"CVE-2009-3485"
],
"33258": [
"CVE-2009-3486"
],
"33259": [
"CVE-2009-3486"
],
"33260": [
"CVE-2009-3487"
],
"33261": [
"CVE-2009-3487"
],
"33263": [
"CVE-2009-3573"
],
"33265": [],
"33270": [
"CVE-2009-1547"
],
"33272": [
"CVE-2009-3577"
],
"33264": [
"CVE-2009-2511"
],
"33273": [
"CVE-2009-3576"
],
"33645": [],
"33310": [
"CVE-2009-3733"
],
"33311": [],
"33313": [
"CVE-2009-3373"
],
"33315": [
"CVE-2009-3867"
],
"33316": [
"CVE-2009-3867"
],
"33594": [
"CVE-2010-0239"
],
"33326": [
"CVE-2004-2466"
],
"33331": [
"CVE-2014-0782"
],
"33333": [
"CVE-2014-0515"
],
"33363": [
"CVE-2009-0689"
],
"33364": [
"CVE-2009-0689"
],
"33379": [],
"33388": [
"CVE-2009-4227"
],
"33399": [],
"41805": [
"CVE-2017-0561"
],
"33453": [],
"33454": [],
"33471": [
"CVE-2010-0936"
],
"40344": [],
"33489": [
"CVE-2009-4492"
],
"33490": [
"CVE-2009-4487"
],
"33497": [
"CVE-2009-4494"
],
"33498": [
"CVE-2009-4488"
],
"33499": [
"CVE-2009-4491"
],
"33500": [
"CVE-2009-4490"
],
"33501": [
"CVE-2009-4489"
],
"33502": [
"CVE-2009-4495"
],
"33503": [
"CVE-2009-4493"
],
"33504": [
"CVE-2009-4496"
],
"33521": [
"CVE-2014-1649"
],
"33611": [],
"33525": [],
"33535": [
"CVE-2009-4273"
],
"33536": [
"CVE-2010-0713"
],
"33538": [
"CVE-2006-3952"
],
"33540": [],
"33552": [
"CVE-2010-0027"
],
"33553": [
"CVE-2010-0387"
],
"33554": [
"CVE-2014-0749"
],
"33562": [
"CVE-2010-0315"
],
"33563": [
"CVE-2010-0314"
],
"33567": [
"CVE-2010-0440"
],
"33568": [],
"33569": [],
"33570": [],
"33588": [
"CVE-2014-3120"
],
"33598": [
"CVE-2010-0926"
],
"33599": [
"CVE-2010-0926"
],
"33600": [],
"33601": [],
"33610": [],
"33615": [],
"33616": [],
"33620": [
"CVE-2010-0416"
],
"33622": [
"CVE-2009-4645"
],
"33642": [
"CVE-2010-0108"
],
"33648": [],
"33653": [
"CVE-2010-0703"
],
"33662": [
"CVE-2010-0700"
],
"33663": [],
"33664": [
"CVE-2010-0655"
],
"33682": [],
"33686": [],
"33689": [],
"33705": [],
"33712": [],
"33739": [
"CVE-2013-5755"
],
"33741": [
"CVE-2013-5759",
"CVE-2013-5758"
],
"33742": [
"CVE-2013-5759",
"CVE-2013-5758"
],
"33750": [],
"33752": [
"CVE-2010-0049"
],
"33767": [
"CVE-2009-4655"
],
"33774": [],
"33780": [],
"33783": [],
"33786": [],
"33789": [
"CVE-2015-3292"
],
"33790": [],
"33798": [
"CVE-2010-0168"
],
"33802": [],
"33805": [
"CVE-2014-3805"
],
"33807": [
"CVE-2014-3914"
],
"33810": [
"CVE-2010-1180"
],
"33811": [
"CVE-2010-1177"
],
"33816": [],
"33817": [
"CVE-2014-3913"
],
"33852": [],
"33826": [],
"33829": [],
"33839": [],
"33841": [],
"33880": [
"CVE-2014-3789"
],
"33847": [],
"33848": [],
"33868": [
"CVE-2010-1587"
],
"33855": [
"CVE-2010-1320"
],
"34143": [
"CVE-2010-1932"
],
"33862": [],
"33863": [],
"33865": [
"CVE-2014-3804"
],
"33869": [],
"33871": [],
"33873": [
"CVE-2010-1586"
],
"33877": [],
"33878": [],
"33890": [],
"33891": [
"CVE-2013-6221"
],
"33900": [],
"33901": [],
"33905": [],
"33907": [],
"33962": [],
"33964": [],
"33971": [],
"33920": [
"CVE-2010-1866"
],
"33988": [
"CVE-2010-2094"
],
"33989": [
"CVE-2014-2424"
],
"33929": [
"CVE-2014-5023",
"CVE-2014-4511",
"CVE-2013-7392"
],
"33935": [],
"33938": [
"CVE-2010-0607"
],
"33940": [
"CVE-2010-1143"
],
"33941": [],
"33944": [
"CVE-2012-1876"
],
"33949": [],
"33974": [],
"33980": [],
"33981": [],
"33990": [
"CVE-2014-4511",
"CVE-2013-7392"
],
"33991": [
"CVE-2014-4725"
],
"34002": [],
"34009": [
"CVE-2014-3888"
],
"34013": [],
"34018": [],
"34026": [
"CVE-2013-6765"
],
"34033": [
"CVE-2010-2025"
],
"34047": [],
"34048": [],
"34050": [],
"34059": [
"CVE-2014-4158"
],
"34063": [],
"34064": [
"CVE-2014-3936"
],
"34065": [],
"34066": [
"CVE-2014-2623"
],
"34088": [
"CVE-2014-4968"
],
"34156": [],
"34115": [],
"34126": [
"CVE-2010-2265"
],
"34132": [
"CVE-2014-3085",
"CVE-2014-3081",
"CVE-2014-3080"
],
"34152": [
"CVE-2010-1748"
],
"34160": [],
"34363": [
"CVE-2013-1670"
],
"34174": [],
"34178": [],
"34182": [],
"34184": [],
"34186": [],
"34191": [],
"34192": [
"CVE-2010-1199"
],
"34200": [
"CVE-2008-7257"
],
"34201": [
"CVE-2010-2246"
],
"34208": [],
"34230": [],
"34362": [
"CVE-2013-4490"
],
"34271": [],
"34297": [],
"34301": [],
"34310": [
"CVE-2010-2370"
],
"34312": [
"CVE-2010-2375"
],
"34316": [],
"34335": [
"CVE-2014-5073"
],
"34334": [
"CVE-2015-4523",
"CVE-2014-0983"
],
"34594": [
"CVE-2014-5005",
"CVE-2014-5006"
],
"34358": [
"CVE-2010-1214"
],
"34369": [],
"34372": [],
"34465": [
"CVE-2014-2927"
],
"34385": [
"CVE-2010-2785"
],
"34390": [],
"34399": [],
"34426": [
"CVE-2010-2809"
],
"34431": [],
"34437": [],
"34439": [],
"34448": [
"CVE-2014-1511",
"CVE-2014-1510"
],
"34461": [
"CVE-2014-2913"
],
"34462": [],
"34478": [
"CVE-2010-3324"
],
"40339": [
"CVE-2015-7547"
],
"34500": [
"CVE-2010-3202"
],
"34507": [],
"34517": [
"CVE-2015-4107"
],
"34523": [],
"34532": [],
"34542": [],
"34595": [],
"34621": [
"CVE-2010-3171"
],
"34622": [
"CVE-2010-3460"
],
"34647": [],
"34654": [],
"34668": [
"CVE-2014-6287"
],
"34669": [
"CVE-2014-5468"
],
"34670": [
"CVE-2014-6037"
],
"34671": [],
"34685": [],
"34686": [],
"34691": [],
"34695": [],
"34696": [],
"34697": [],
"34821": [],
"34823": [],
"34756": [
"CVE-2013-0928"
],
"34757": [
"CVE-2014-2364"
],
"34765": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"34766": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"34768": [],
"34777": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"34796": [
"CVE-2009-5026"
],
"34802": [],
"34815": [
"CVE-2012-1876"
],
"34829": [],
"34830": [],
"34831": [],
"34832": [],
"34835": [],
"34836": [],
"34838": [],
"34844": [],
"34846": [
"CVE-2009-4531"
],
"34848": [],
"34853": [],
"34856": [
"CVE-2014-5289"
],
"34860": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7187",
"CVE-2014-7186",
"CVE-2014-7169",
"CVE-2014-6278",
"CVE-2014-62771",
"CVE-2014-6277",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"34862": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"34866": [
"CVE-2014-2624"
],
"34867": [
"CVE-2014-6034"
],
"34868": [],
"34869": [],
"34870": [],
"34879": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"34881": [
"CVE-2010-3179"
],
"34896": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"34900": [
"CVE-2014-6278",
"CVE-2014-6271"
],
"34925": [
"CVE-2014-6446"
],
"34926": [
"CVE-2014-6287"
],
"34927": [
"CVE-2014-2928"
],
"34931": [],
"34932": [
"CVE-2010-4099"
],
"34943": [],
"34945": [],
"34949": [],
"34950": [
"CVE-2010-3870"
],
"34952": [
"CVE-2010-3863"
],
"34978": [],
"34979": [
"CVE-2010-4156"
],
"34985": [
"CVE-2010-4246"
],
"34986": [],
"34997": [],
"34998": [
"CVE-2010-4647"
],
"34999": [
"CVE-2010-4647"
],
"35001": [],
"35002": [],
"35003": [
"CVE-2010-3893"
],
"35005": [
"CVE-2010-3804"
],
"35006": [
"CVE-2010-3804"
],
"35007": [],
"35011": [
"CVE-2010-4172"
],
"35014": [],
"35018": [
"CVE-2014-8322"
],
"35032": [
"CVE-2014-4872"
],
"35033": [
"CVE-2014-7228"
],
"35034": [],
"35051": [],
"35055": [
"CVE-2014-6352",
"CVE-2014-4114"
],
"35062": [],
"35068": [
"CVE-2010-4412"
],
"35069": [
"CVE-2010-4412"
],
"35070": [
"CVE-2010-4412"
],
"35071": [
"CVE-2010-4412"
],
"35078": [
"CVE-2014-3828"
],
"35092": [],
"35095": [
"CVE-2010-3770"
],
"35103": [
"CVE-2014-7279"
],
"35115": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"35119": [],
"35130": [],
"35132": [],
"35144": [],
"35148": [],
"35151": [],
"35166": [],
"35170": [],
"35171": [],
"35180": [
"CVE-2014-7140"
],
"35183": [
"CVE-2014-8998"
],
"35184": [
"CVE-2014-1635"
],
"35188": [],
"35190": [],
"35211": [
"CVE-2014-8516"
],
"35225": [],
"35226": [],
"35229": [
"CVE-2014-6332"
],
"35230": [
"CVE-2014-6332"
],
"35232": [
"CVE-2011-0020"
],
"35241": [],
"35242": [
"CVE-2008-7271"
],
"35243": [
"CVE-2008-7271"
],
"35252": [],
"35273": [
"CVE-2012-1876"
],
"35284": [],
"35280": [
"CVE-2014-1806"
],
"35282": [],
"35283": [
"CVE-2014-7146"
],
"35308": [
"CVE-2014-6332"
],
"35314": [
"CVE-2011-0538"
],
"35316": [],
"35317": [],
"35318": [],
"35380": [],
"40431": [],
"35352": [
"CVE-2011-3187"
],
"35356": [
"CVE-2014-4880"
],
"35364": [
"CVE-2011-1038"
],
"35366": [],
"35386": [
"CVE-2011-1018"
],
"35398": [],
"35399": [],
"35420": [],
"35421": [],
"35422": [],
"35427": [
"CVE-2014-8517"
],
"35433": [],
"35434": [
"CVE-2011-0167"
],
"35441": [
"CVE-2013-1428"
],
"35446": [],
"35474": [
"CVE-2014-6324"
],
"35464": [],
"35466": [
"CVE-2011-0751"
],
"35468": [],
"35495": [
"CVE-2011-4041"
],
"35501": [],
"35509": [],
"35513": [],
"35560": [],
"35563": [],
"35549": [
"CVE-2014-5470"
],
"35545": [
"CVE-2014-8791"
],
"35554": [
"CVE-2011-1487"
],
"35570": [
"CVE-2009-5065"
],
"35573": [
"CVE-2011-0104"
],
"35581": [
"CVE-2009-2936"
],
"35597": [],
"35606": [
"CVE-2011-0285"
],
"35612": [],
"35614": [
"CVE-2011-5155"
],
"35620": [],
"35638": [
"CVE-2011-0836"
],
"35639": [
"CVE-2011-0836"
],
"35640": [
"CVE-2011-0836"
],
"35641": [
"CVE-2011-0836"
],
"35642": [
"CVE-2011-0836"
],
"35644": [],
"35652": [],
"35660": [
"CVE-2014-9567"
],
"35685": [],
"35686": [],
"35688": [
"CVE-2014-9583"
],
"35694": [
"CVE-2012-2271"
],
"35703": [],
"35729": [],
"35731": [
"CVE-2010-4279"
],
"35735": [
"CVE-2011-1772"
],
"35740": [
"CVE-2011-1271"
],
"35744": [],
"35762": [
"CVE-2011-0959"
],
"35763": [
"CVE-2011-0959"
],
"35764": [
"CVE-2011-0959"
],
"35765": [
"CVE-2011-0959"
],
"35766": [
"CVE-2011-0959"
],
"35776": [
"CVE-2014-8741"
],
"35777": [
"CVE-2012-5613"
],
"35778": [
"CVE-2014-10021"
],
"35779": [
"CVE-2011-0961"
],
"35780": [
"CVE-2011-0962"
],
"35784": [
"CVE-2011-1939"
],
"35785": [
"CVE-2011-1930"
],
"35790": [],
"35792": [],
"35799": [],
"35800": [],
"35801": [],
"35805": [],
"35806": [],
"35809": [],
"35810": [
"CVE-2011-1944"
],
"35817": [],
"35818": [
"CVE-2011-2179"
],
"35822": [
"CVE-2014-9265"
],
"35836": [
"CVE-2011-2201"
],
"35995": [],
"35997": [],
"35845": [
"CVE-2014-5301"
],
"35855": [
"CVE-2011-2202"
],
"35864": [
"CVE-2011-2960"
],
"35880": [],
"35881": [],
"35885": [],
"35886": [],
"35887": [],
"35892": [],
"35897": [],
"35898": [],
"35917": [],
"35918": [],
"35919": [
"CVE-2011-1656"
],
"35921": [],
"35924": [],
"35925": [],
"35928": [],
"35932": [],
"35948": [],
"35949": [
"CVE-2014-7288"
],
"35961": [
"CVE-2014-2623"
],
"35970": [],
"36004": [],
"36006": [
"CVE-2011-2357"
],
"36013": [],
"36014": [],
"36016": [],
"36020": [
"CVE-2011-1976"
],
"36045": [],
"36049": [],
"36056": [],
"36075": [],
"36078": [
"CVE-2013-4730"
],
"36100": [],
"36101": [
"CVE-2015-2342"
],
"36111": [],
"36115": [],
"36124": [],
"36130": [
"CVE-2011-2732"
],
"36145": [
"CVE-2011-3575"
],
"36169": [
"CVE-2015-1497"
],
"36174": [],
"36199": [
"CVE-2011-3597"
],
"36205": [],
"36206": [
"CVE-2015-1497"
],
"36209": [
"CVE-2011-1999"
],
"36263": [
"CVE-2014-7285"
],
"36217": [
"CVE-2011-4273"
],
"36218": [
"CVE-2011-4273"
],
"36219": [
"CVE-2011-4273"
],
"36235": [],
"36238": [
"CVE-2012-1239"
],
"36239": [],
"36246": [],
"36250": [],
"36256": [
"CVE-2011-3315"
],
"36258": [],
"36264": [
"CVE-2014-8686",
"CVE-2014-8684",
"CVE-2014-8687"
],
"36291": [],
"36304": [
"CVE-2014-2623"
],
"36318": [
"CVE-2009-1523"
],
"36319": [],
"36337": [
"CVE-2015-1427"
],
"36352": [
"CVE-2011-4317"
],
"36360": [
"CVE-2015-0311"
],
"36370": [
"CVE-2014-7884"
],
"36376": [
"CVE-2011-4712"
],
"36412": [
"CVE-2015-0925"
],
"36415": [
"CVE-2015-1427"
],
"36420": [
"CVE-2015-0318"
],
"36421": [
"CVE-2015-0235"
],
"36480": [
"CVE-2014-8636"
],
"36426": [
"CVE-2011-5057"
],
"36428": [
"CVE-2011-5261"
],
"36429": [
"CVE-2011-4836"
],
"36438": [
"CVE-2014-7236"
],
"36455": [],
"36475": [],
"36477": [],
"36491": [
"CVE-2015-0313"
],
"36500": [
"CVE-2012-5100"
],
"36503": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"36504": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"36505": [
"CVE-2015-2097"
],
"36507": [
"CVE-2012-0007"
],
"36511": [],
"36513": [
"CVE-2012-5344"
],
"36514": [
"CVE-2012-5345"
],
"36516": [
"CVE-2014-6332"
],
"36517": [
"CVE-2015-2094"
],
"36518": [
"CVE-2015-2099"
],
"36519": [
"CVE-2015-2098"
],
"36537": [],
"36542": [],
"36546": [
"CVE-2012-6041"
],
"36562": [],
"36577": [
"CVE-2015-2797"
],
"36579": [
"CVE-2015-0313"
],
"36587": [],
"36602": [
"CVE-2015-2097"
],
"36603": [
"CVE-2015-2098"
],
"36604": [
"CVE-2015-2094"
],
"36606": [
"CVE-2015-2098"
],
"36607": [
"CVE-2015-2097"
],
"36652": [],
"36653": [
"CVE-2010-1871"
],
"36663": [
"CVE-2011-3639"
],
"36670": [],
"36679": [
"CVE-2015-2284"
],
"36680": [],
"36681": [
"CVE-2011-4367"
],
"36690": [],
"36742": [
"CVE-2015-3306"
],
"36744": [
"CVE-2014-0569"
],
"36756": [
"CVE-2015-0555"
],
"36767": [],
"36803": [
"CVE-2015-3306"
],
"36808": [
"CVE-2014-0556"
],
"36809": [
"CVE-2015-4133"
],
"36810": [],
"36811": [
"CVE-2014-8739"
],
"36812": [],
"36829": [
"CVE-2012-1221"
],
"36831": [
"CVE-2012-4923"
],
"36832": [
"CVE-2012-4923"
],
"36833": [
"CVE-2012-4923"
],
"36836": [],
"36839": [
"CVE-2013-0230"
],
"36995": [],
"37169": [
"CVE-2014-8361"
],
"36864": [
"CVE-2012-5323"
],
"36866": [
"CVE-2012-5322"
],
"36877": [
"CVE-2012-5319"
],
"36880": [
"CVE-2014-8440"
],
"36884": [
"CVE-2012-1257"
],
"36915": [],
"36931": [],
"36932": [
"CVE-2006-2369"
],
"36933": [
"CVE-2014-7187",
"CVE-2014-7186",
"CVE-2014-7169",
"CVE-2014-6278",
"CVE-2014-6277"
],
"36945": [],
"36955": [],
"36956": [
"CVE-2015-0359"
],
"36957": [
"CVE-2014-9735"
],
"36962": [
"CVE-2015-0336"
],
"36964": [
"CVE-2015-0779"
],
"36984": [],
"36996": [],
"37007": [],
"37020": [],
"37037": [
"CVE-2012-4685"
],
"37066": [
"CVE-2014-9195"
],
"37081": [],
"37097": [],
"37141": [],
"37170": [
"CVE-2015-2797"
],
"37163": [],
"37165": [],
"37171": [
"CVE-2015-2051"
],
"37184": [],
"37198": [],
"37262": [
"CVE-2015-3306"
],
"37336": [
"CVE-2015-1158"
],
"37368": [
"CVE-2015-3090"
],
"37396": [],
"37400": [
"CVE-2014-6332"
],
"37429": [
"CVE-2012-1038"
],
"37405": [],
"37426": [
"CVE-2015-5082"
],
"37428": [
"CVE-2015-5082"
],
"37564": [],
"37448": [
"CVE-2015-3105"
],
"37510": [
"CVE-2012-2764"
],
"37512": [
"CVE-2012-4739"
],
"37513": [
"CVE-2012-4739"
],
"37523": [
"CVE-2015-5119"
],
"37536": [
"CVE-2015-3113",
"CVE-2015-3043"
],
"37542": [],
"37576": [
"CVE-2012-3456"
],
"37597": [
"CVE-2015-2857"
],
"37598": [],
"37599": [
"CVE-2015-5122"
],
"37600": [
"CVE-2015-7709"
],
"37611": [],
"37628": [],
"37647": [],
"37655": [],
"37688": [
"CVE-2011-1398"
],
"37667": [
"CVE-2015-2995"
],
"37668": [
"CVE-2014-6332"
],
"37671": [
"CVE-2012-2984"
],
"37729": [],
"37731": [],
"37746": [],
"37947": [
"CVE-2012-4871"
],
"37949": [
"CVE-2012-4528"
],
"37951": [],
"37788": [
"CVE-2012-4415"
],
"37792": [
"CVE-2012-4905"
],
"37793": [
"CVE-2012-4906"
],
"37794": [
"CVE-2012-4909"
],
"37795": [
"CVE-2012-4908"
],
"37800": [
"CVE-2014-6332"
],
"37803": [
"CVE-2012-2994"
],
"37808": [],
"37812": [
"CVE-2015-1489",
"CVE-2015-1487",
"CVE-2015-1486"
],
"37814": [],
"37834": [],
"37840": [
"CVE-2015-3082"
],
"37841": [
"CVE-2015-3083"
],
"37842": [
"CVE-2015-3081"
],
"37851": [
"CVE-2015-5116"
],
"37889": [],
"37900": [],
"37952": [],
"37958": [
"CVE-2015-0816",
"CVE-2015-0802"
],
"37969": [],
"37985": [],
"37996": [
"CVE-2012-4940"
],
"38003": [],
"38005": [],
"38013": [
"CVE-2013-4730"
],
"38020": [
"CVE-2012-4960"
],
"38049": [],
"38058": [],
"38100": [],
"38096": [
"CVE-2015-5082"
],
"38109": [
"CVE-2012-5627"
],
"38124": [
"CVE-2015-1538"
],
"38203": [],
"38151": [
"CVE-2015-2509"
],
"38164": [
"CVE-2012-4366"
],
"38170": [],
"38179": [
"CVE-2012-6272"
],
"38186": [],
"38195": [
"CVE-2015-2509"
],
"38196": [
"CVE-2015-7309"
],
"38206": [
"CVE-2012-6429"
],
"38221": [
"CVE-2015-7766",
"CVE-2015-7765"
],
"38226": [
"CVE-2015-3864"
],
"38227": [],
"38230": [
"CVE-2013-0177"
],
"38233": [
"CVE-2012-2997"
],
"38242": [],
"38248": [
"CVE-2013-1391"
],
"38250": [
"CVE-2013-0804"
],
"38252": [
"CVE-2015-7767"
],
"38254": [
"CVE-2015-7768"
],
"38260": [
"CVE-2015-7603"
],
"38302": [],
"38308": [],
"38310": [
"CVE-2011-1350"
],
"38313": [],
"38325": [],
"38330": [],
"38340": [
"CVE-2015-7601"
],
"38341": [
"CVE-2015-7602"
],
"38346": [
"CVE-2015-5453",
"CVE-2015-5452"
],
"38352": [
"CVE-2015-7387"
],
"38356": [
"CVE-2013-2560"
],
"38402": [],
"38401": [
"CVE-2015-6922"
],
"38368": [
"CVE-2013-5094"
],
"38370": [],
"38384": [],
"38387": [],
"38388": [],
"38389": [],
"38394": [],
"38536": [],
"38412": [],
"38437": [],
"38454": [
"CVE-2015-3036"
],
"38453": [
"CVE-2014-9118",
"CVE-2014-8357",
"CVE-2014-8356"
],
"38464": [],
"38481": [
"CVE-2013-3095"
],
"38489": [
"CVE-2015-6967"
],
"38492": [
"CVE-2013-2645"
],
"38495": [
"CVE-2013-3083"
],
"38500": [
"CVE-2014-6332"
],
"38501": [
"CVE-2013-2679"
],
"38505": [
"CVE-2013-2097"
],
"38512": [
"CVE-2014-6332"
],
"38513": [],
"38521": [
"CVE-2013-2131"
],
"38522": [],
"38526": [],
"38535": [
"CVE-2015-7007"
],
"38644": [],
"38541": [],
"38549": [
"CVE-2013-2134"
],
"38554": [
"CVE-2015-7893"
],
"38582": [
"CVE-2013-3690"
],
"38583": [
"CVE-2013-3539"
],
"38584": [
"CVE-2013-3963"
],
"38586": [],
"38587": [
"CVE-2013-2182"
],
"38591": [],
"38597": [],
"38599": [
"CVE-2011-3478"
],
"38632": [
"CVE-2013-5620"
],
"38627": [
"CVE-2013-4787"
],
"38633": [
"CVE-2013-4786"
],
"38634": [],
"38636": [
"CVE-2013-2261"
],
"38637": [
"CVE-2013-4103"
],
"38660": [],
"38663": [],
"38666": [
"CVE-2013-2248"
],
"38667": [
"CVE-2013-2739"
],
"38669": [
"CVE-2013-3969"
],
"38671": [],
"38680": [
"CVE-2013-1436"
],
"38824": [
"CVE-2013-6826"
],
"38692": [
"CVE-2013-5092"
],
"38694": [],
"38715": [],
"38716": [],
"38717": [],
"38718": [],
"38719": [],
"38720": [],
"38721": [],
"38722": [],
"38723": [],
"38724": [],
"38725": [],
"38726": [],
"38730": [],
"38731": [],
"38732": [],
"38733": [],
"38741": [
"CVE-2013-4885"
],
"38742": [
"CVE-2013-4978"
],
"38764": [
"CVE-2015-3628"
],
"38766": [
"CVE-2013-1727"
],
"38797": [
"CVE-2015-7858",
"CVE-2015-7857",
"CVE-2015-7297"
],
"38802": [
"CVE-2013-3827"
],
"38804": [],
"38805": [
"CVE-2013-6025"
],
"38809": [],
"38810": [
"CVE-2013-6027"
],
"38812": [
"CVE-2013-6246"
],
"38813": [
"CVE-2013-4295"
],
"38818": [
"CVE-2013-3617"
],
"38821": [
"CVE-2013-6792"
],
"38825": [
"CVE-2013-4034"
],
"38826": [
"CVE-2013-4579"
],
"38827": [
"CVE-2013-6875"
],
"38829": [],
"36025": [
"CVE-2015-1578",
"CVE-2015-1577"
],
"38845": [],
"38846": [
"CVE-2013-4547"
],
"38849": [
"CVE-2014-7196",
"CVE-2014-6271"
],
"38850": [
"CVE-2013-5912"
],
"38851": [],
"38859": [
"CVE-2010-4417"
],
"38860": [],
"38900": [],
"38905": [
"CVE-2015-5603"
],
"38910": [
"CVE-2013-7420"
],
"38911": [
"CVE-2015-6131"
],
"38912": [
"CVE-2015-6127"
],
"38918": [
"CVE-2015-6128"
],
"38923": [],
"39097": [
"CVE-2013-6492"
],
"38964": [],
"38968": [
"CVE-2015-6132"
],
"38973": [],
"38974": [],
"38982": [
"CVE-2015-8249"
],
"38983": [
"CVE-2015-8103"
],
"39007": [],
"39008": [],
"39009": [],
"39018": [
"CVE-2013-5880"
],
"39074": [
"CVE-2013-7179"
],
"39105": [],
"39104": [
"CVE-2014-2072"
],
"39089": [],
"39102": [],
"39114": [
"CVE-2013-6835"
],
"39115": [],
"39119": [
"CVE-2015-7874"
],
"39138": [],
"39227": [],
"39154": [
"CVE-2014-2923"
],
"39155": [
"CVE-2014-3146"
],
"39161": [
"CVE-2014-6287"
],
"39175": [],
"39186": [],
"39194": [],
"39195": [
"CVE-2014-1849"
],
"39196": [
"CVE-2014-0242"
],
"39205": [
"CVE-2014-3004"
],
"39209": [
"CVE-2014-2946"
],
"39215": [
"CVE-2015-7768"
],
"39218": [
"CVE-2016-3987"
],
"39222": [
"CVE-2014-0007"
],
"39258": [
"CVE-2014-9301"
],
"39259": [
"CVE-2014-9302"
],
"39455": [
"CVE-2015-2080"
],
"39278": [
"CVE-2014-2595"
],
"39292": [
"CVE-2014-5380"
],
"39293": [
"CVE-2014-5381"
],
"39295": [
"CVE-2014-1564"
],
"39314": [
"CVE-2014-6437"
],
"39316": [
"CVE-2014-6436"
],
"39318": [],
"39328": [],
"39437": [],
"39439": [],
"39499": [],
"39514": [
"CVE-2016-2555"
],
"39515": [
"CVE-2016-1525"
],
"39522": [
"CVE-2016-2278"
],
"39554": [],
"39568": [
"CVE-2014-6278"
],
"39569": [
"CVE-2016-3115"
],
"39585": [],
"39596": [],
"39599": [],
"39631": [
"CVE-2016-0998"
],
"39632": [],
"39639": [],
"39640": [
"CVE-2015-3864"
],
"39643": [
"CVE-2016-0710",
"CVE-2016-0709"
],
"39645": [
"CVE-2016-4071"
],
"39693": [],
"39698": [
"CVE-2015-6086"
],
"39708": [
"CVE-2016-1593"
],
"39729": [],
"39735": [
"CVE-2016-0854"
],
"39736": [
"CVE-2016-3074"
],
"39742": [
"CVE-2016-3078"
],
"39755": [],
"39756": [
"CVE-2016-3081"
],
"39783": [],
"39792": [],
"39805": [
"CVE-2016-0185"
],
"39823": [
"CVE-2016-1287"
],
"39836": [
"CVE-2014-4977"
],
"39852": [
"CVE-2016-0492",
"CVE-2016-0491"
],
"39853": [],
"39854": [],
"39858": [
"CVE-2016-2004"
],
"39874": [
"CVE-2016-2004"
],
"39907": [],
"39917": [],
"39918": [
"CVE-2014-6271"
],
"39919": [
"CVE-2016-3087"
],
"40441": [
"CVE-2015-2866"
],
"39945": [],
"39958": [
"CVE-2015-0935"
],
"39973": [],
"39985": [],
"39999": [],
"40004": [
"CVE-2015-6567",
"CVE-2015-6568"
],
"40043": [],
"40064": [
"CVE-2016-4971"
],
"40067": [],
"40108": [],
"40113": [
"CVE-2016-6210"
],
"40119": [
"CVE-2016-3116"
],
"40120": [
"CVE-2016-3989",
"CVE-2016-3962"
],
"40846": [
"CVE-2016-6754"
],
"40125": [],
"40130": [],
"40136": [
"CVE-2016-6210"
],
"40138": [],
"40142": [],
"40144": [],
"40146": [],
"40147": [],
"40162": [],
"40167": [],
"40170": [],
"40176": [],
"40177": [],
"40178": [],
"40200": [
"CVE-2016-5680",
"CVE-2016-5679",
"CVE-2016-5678",
"CVE-2016-5677",
"CVE-2016-5676",
"CVE-2016-5675",
"CVE-2016-5674"
],
"40201": [],
"40232": [],
"40280": [
"CVE-2009-3103",
"CVE-2009-2532",
"CVE-2009-2526"
],
"40234": [],
"40279": [
"CVE-2008-4250"
],
"40235": [],
"40258": [
"CVE-2016-6366"
],
"40275": [],
"40294": [],
"40436": [
"CVE-2015-3864"
],
"40445": [],
"40452": [],
"40455": [],
"40456": [],
"40457": [],
"40458": [],
"40459": [],
"40472": [],
"40474": [],
"40491": [
"CVE-2015-1497"
],
"40507": [
"CVE-2013-2088"
],
"43899": [
"CVE-2018-10000"
],
"43588": [
"CVE-2018-5359"
],
"43589": [
"CVE-2017-15663"
],
"43609": [],
"43659": [
"CVE-2018-5347"
],
"43665": [
"CVE-2018-5702"
],
"43693": [
"CVE-2018-5726",
"CVE-2018-5725",
"CVE-2018-5724",
"CVE-2018-5723"
],
"43881": [
"CVE-2018-6000",
"CVE-2018-5999"
],
"43871": [
"CVE-2018-5997"
],
"43876": [
"CVE-2017-14143"
],
"43877": [
"CVE-2017-17562"
],
"40561": [
"CVE-2016-0752"
],
"40589": [
"CVE-2013-4863",
"CVE-2016-6255"
],
"40609": [
"CVE-2015-4624"
],
"40610": [],
"40619": [
"CVE-2014-6271"
],
"40633": [],
"40643": [],
"40651": [
"CVE-2016-5764"
],
"40670": [],
"40674": [],
"40672": [],
"40673": [],
"40675": [
"CVE-2006-0441"
],
"40677": [],
"40680": [],
"40681": [],
"40689": [
"CVE-2014-7205"
],
"40693": [],
"40694": [],
"40704": [],
"40711": [],
"40712": [],
"40713": [],
"40714": [],
"40715": [],
"40720": [],
"40721": [
"CVE-2014-6363"
],
"40758": [],
"40734": [],
"40735": [],
"40736": [],
"40737": [],
"40738": [],
"40740": [],
"40767": [],
"40778": [],
"40805": [
"CVE-2016-6563"
],
"40813": [
"CVE-2016-5639"
],
"40824": [
"CVE-2016-7098"
],
"40830": [],
"40831": [],
"40833": [],
"40832": [],
"40834": [],
"40835": [],
"40854": [],
"40857": [
"CVE-2016-3088",
"CVE-2015-1830"
],
"40858": [],
"40862": [
"CVE-2016-9796"
],
"40867": [],
"40868": [],
"40869": [],
"40881": [
"CVE-2015-1730"
],
"40911": [
"CVE-2016-8025",
"CVE-2016-8024",
"CVE-2016-8023",
"CVE-2016-8022",
"CVE-2016-8021",
"CVE-2016-8020",
"CVE-2016-8019",
"CVE-2016-8018",
"CVE-2016-8017",
"CVE-2016-8016"
],
"40916": [
"CVE-2016-1252"
],
"40920": [
"CVE-2016-9565"
],
"40930": [],
"40949": [
"CVE-2016-10176",
"CVE-2016-10175",
"CVE-2016-10174"
],
"40963": [
"CVE-2016-10009"
],
"40984": [],
"40990": [
"CVE-2016-7200",
"CVE-2016-7201"
],
"41003": [],
"41013": [
"CVE-2016-9587"
],
"41041": [
"CVE-2016-6433"
],
"41073": [],
"41079": [],
"41146": [],
"41148": [],
"41151": [
"CVE-2016-9079"
],
"41153": [
"CVE-2017-11517"
],
"41162": [],
"41233": [
"CVE-2015-1158"
],
"41236": [],
"41297": [
"CVE-2016-8523"
],
"41298": [
"CVE-2016-9244"
],
"41358": [],
"41366": [
"CVE-2017-5586"
],
"41436": [
"CVE-2017-6187"
],
"41443": [
"CVE-2017-2361"
],
"41471": [],
"41479": [],
"41480": [
"CVE-2017-6351"
],
"41511": [
"CVE-2017-6465"
],
"41545": [
"CVE-2017-6506"
],
"41592": [
"CVE-2017-6805"
],
"41598": [
"CVE-2016-6277"
],
"41613": [
"CVE-2015-7450"
],
"41614": [
"CVE-2017-5638"
],
"43353": [],
"43356": [
"CVE-2017-17560"
],
"43360": [
"CVE-2017-17562"
],
"43374": [
"CVE-2017-7411"
],
"43375": [
"CVE-2016-0792"
],
"43376": [
"CVE-2017-17692"
],
"43382": [
"CVE-2016-3087"
],
"43383": [
"CVE-2016-6415"
],
"43384": [
"CVE-2017-5135"
],
"43385": [
"CVE-2017-5689"
],
"43386": [
"CVE-2016-1909"
],
"43387": [],
"43388": [
"CVE-2017-14097",
"CVE-2017-14096",
"CVE-2017-14095",
"CVE-2017-14094",
"CVE-2017-11398"
],
"43392": [
"CVE-2017-10271"
],
"43407": [
"CVE-2017-17932"
],
"43408": [
"CVE-2017-17968"
],
"43411": [
"CVE-2010-1549"
],
"43412": [],
"43413": [
"CVE-2017-5255"
],
"44275": [
"CVE-2018-7756"
],
"43428": [
"CVE-2017-17867"
],
"43429": [
"CVE-2017-17411"
],
"43430": [
"CVE-2017-16666"
],
"43434": [],
"43435": [],
"43448": [
"CVE-2017-15222"
],
"43450": [
"CVE-2017-6736"
],
"43458": [
"CVE-2017-10271"
],
"43472": [],
"43478": [
"CVE-2018-5262"
],
"43492": [
"CVE-2017-5817"
],
"43493": [
"CVE-2017-5816"
],
"43518": [],
"43519": [
"CVE-2017-6090"
],
"43523": [
"CVE-2017-17932"
],
"41638": [],
"43902": [
"CVE-2016-1543",
"CVE-2016-1542",
"CVE-2016-5063"
],
"43905": [],
"43920": [],
"43924": [
"CVE-2017-10271"
],
"43927": [
"CVE-2017-5792"
],
"43936": [],
"43939": [
"CVE-2016-1543",
"CVE-2016-1542"
],
"43970": [
"CVE-2017-0147",
"CVE-2017-0146",
"CVE-2017-0143"
],
"43982": [],
"43983": [],
"43984": [],
"43985": [],
"45578": [
"CVE-2018-14847"
],
"43993": [
"CVE-2017-3066"
],
"43997": [],
"43999": [],
"44000": [],
"44001": [],
"44002": [],
"44004": [],
"44005": [
"CVE-2017-12542"
],
"44022": [
"CVE-2018-6871"
],
"44027": [
"CVE-2018-6892"
],
"44031": [
"CVE-2018-6911"
],
"44047": [
"CVE-2017-18001"
],
"44048": [
"CVE-2017-17761"
],
"44052": [
"CVE-2017-12243"
],
"44055": [
"CVE-2017-15643"
],
"44067": [
"CVE-2017-3897"
],
"44068": [
"CVE-2017-11467"
],
"44069": [
"CVE-2017-12653"
],
"44073": [
"CVE-2017-5815"
],
"41666": [],
"41672": [],
"41679": [
"CVE-2015-0936"
],
"41680": [
"CVE-2016-1561",
"CVE-2016-1560"
],
"41684": [
"CVE-2013-0758",
"CVE-2013-0757"
],
"41689": [
"CVE-2015-3224"
],
"41690": [
"CVE-2014-0114",
"CVE-2014-0112",
"CVE-2014-0094"
],
"41694": [
"CVE-1999-0502"
],
"41695": [
"CVE-2011-4929"
],
"41795": [],
"42261": [],
"42885": [
"CVE-2017-6020"
],
"42256": [],
"42756": [
"CVE-2016-4372"
],
"42587": [],
"42316": [
"CVE-2017-8550"
],
"42779": [
"CVE-2017-11610"
],
"41987": [
"CVE-2017-0148",
"CVE-2017-0147",
"CVE-2017-0146",
"CVE-2017-0145",
"CVE-2017-0144",
"CVE-2017-0143"
],
"42287": [],
"41718": [
"CVE-2017-7240"
],
"41719": [
"CVE-2016-10174"
],
"41720": [],
"41738": [
"CVE-2017-7269"
],
"41740": [
"CVE-2017-2619"
],
"41744": [],
"41751": [],
"41775": [],
"41808": [
"CVE-2017-0569"
],
"41825": [
"CVE-2017-7237"
],
"41850": [
"CVE-2017-7455"
],
"41852": [
"CVE-2017-7457"
],
"41861": [
"CVE-2017-6554"
],
"41872": [
"CVE-2017-3881"
],
"42122": [
"CVE-2017-3881"
],
"41892": [
"CVE-2017-8051"
],
"41894": [
"CVE-2017-0199"
],
"41895": [],
"41903": [
"CVE-2017-0160"
],
"41910": [
"CVE-2017-7692"
],
"41929": [],
"41934": [
"CVE-2017-0199"
],
"41935": [],
"41942": [],
"41964": [
"CVE-2017-2491"
],
"41975": [
"CVE-2017-0290"
],
"41978": [],
"41980": [],
"41992": [
"CVE-2017-7269"
],
"41996": [
"CVE-2016-10073",
"CVE-2016-10033"
],
"42010": [
"CVE-2017-6553"
],
"42011": [],
"42030": [
"CVE-2017-0144"
],
"42022": [],
"42023": [],
"42024": [
"CVE-2016-10033"
],
"42025": [],
"42026": [],
"42031": [
"CVE-2017-0144"
],
"42083": [],
"42084": [
"CVE-2017-7494"
],
"42041": [
"CVE-2017-9024"
],
"42057": [],
"42060": [
"CVE-2017-7494"
],
"42078": [],
"42079": [],
"42125": [
"CVE-2017-2536"
],
"42128": [],
"42134": [],
"42152": [
"CVE-2017-4914"
],
"42155": [],
"42158": [],
"42159": [],
"42165": [],
"42175": [
"CVE-2016-9651"
],
"42176": [
"CVE-2017-2741"
],
"42186": [],
"42222": [],
"42251": [
"CVE-2017-6326"
],
"42257": [
"CVE-2017-6334"
],
"42282": [
"CVE-2017-8895"
],
"42283": [
"CVE-2016-3088"
],
"42288": [],
"42289": [],
"42296": [
"CVE-2015-2845",
"CVE-2015-2843"
],
"42297": [],
"42303": [
"CVE-2017-10974"
],
"42304": [],
"42315": [
"CVE-2017-0144"
],
"42327": [
"CVE-2017-5375",
"CVE-2016-9079"
],
"42328": [],
"42331": [],
"42394": [
"CVE-2016-0792"
],
"42349": [],
"42350": [],
"42354": [
"CVE-2017-0059",
"CVE-2017-0037"
],
"42355": [],
"42369": [],
"42370": [],
"42395": [],
"42484": [
"CVE-2016-1960"
],
"42541": [
"CVE-2017-1092"
],
"42557": [],
"42558": [],
"42559": [],
"42560": [],
"42599": [
"CVE-2017-10001"
],
"42614": [
"CVE-2017-11567"
],
"42627": [
"CVE-2017-9805"
],
"42630": [],
"42650": [],
"42683": [],
"42691": [],
"42692": [],
"42693": [
"CVE-2017-5177"
],
"42694": [],
"42695": [
"CVE-2014-4153"
],
"42696": [],
"42697": [
"CVE-2014-5210"
],
"42698": [
"CVE-2015-7901"
],
"42700": [
"CVE-2016-8377"
],
"42701": [
"CVE-2013-6810"
],
"42702": [
"CVE-2013-6810"
],
"42703": [
"CVE-2005-2842"
],
"42704": [],
"42708": [
"CVE-2014-3804"
],
"42709": [
"CVE-2014-3805"
],
"42711": [
"CVE-2017-8759"
],
"42719": [
"CVE-2013-0946"
],
"42720": [],
"42721": [],
"42722": [],
"42723": [],
"42724": [
"CVE-2014-0787"
],
"42725": [],
"42726": [
"CVE-2017-6315"
],
"42753": [
"CVE-2017-12930",
"CVE-2017-12929"
],
"42778": [],
"42767": [],
"42780": [
"CVE-2003-0727"
],
"42784": [
"CVE-2017-11120"
],
"42787": [],
"42790": [],
"42793": [],
"42806": [
"CVE-2015-4852"
],
"42888": [
"CVE-2017-6622"
],
"42891": [
"CVE-2017-14084"
],
"42928": [],
"42957": [
"CVE-2017-12477"
],
"42938": [
"CVE-2014-6271"
],
"42949": [],
"42952": [
"CVE-2017-14702"
],
"42958": [
"CVE-2017-12478"
],
"42964": [],
"42965": [],
"42973": [
"CVE-2017-15220"
],
"42984": [],
"42996": [
"CVE-2017-7115"
],
"43008": [
"CVE-2017-12617"
],
"43025": [
"CVE-2017-15222"
],
"43030": [
"CVE-2017-12478"
],
"43031": [
"CVE-2017-12477"
],
"43032": [],
"43055": [],
"43059": [
"CVE-2016-2345"
],
"43061": [],
"43105": [
"CVE-2016-10401"
],
"43112": [
"CVE-2014-8517"
],
"43118": [],
"43121": [
"CVE-2017-11309"
],
"43125": [
"CVE-2017-0059",
"CVE-2017-0037"
],
"43132": [],
"43142": [
"CVE-2017-8225",
"CVE-2017-8224",
"CVE-2017-8223",
"CVE-2017-8222",
"CVE-2017-8221"
],
"43141": [
"CVE-2017-16806"
],
"43143": [],
"43145": [],
"42886": [],
"43163": [
"CVE-2017-11882"
],
"43195": [
"CVE-2017-5817"
],
"43193": [],
"43198": [
"CVE-2017-5816"
],
"43202": [],
"43209": [],
"43226": [],
"43230": [],
"43231": [
"CVE-2017-16930",
"CVE-2017-16929"
],
"43236": [],
"43338": [],
"43339": [],
"43341": [],
"43342": [
"CVE-2017-15944"
],
"44151": [],
"44155": [],
"44156": [
"CVE-2018-6481"
],
"44157": [
"CVE-2017-7310"
],
"44174": [],
"44175": [
"CVE-2018-6892"
],
"44176": [
"CVE-2018-6000",
"CVE-2018-5999"
],
"44187": [],
"44196": [],
"44226": [
"CVE-2018-7466"
],
"44227": [],
"44228": [],
"44229": [],
"44242": [],
"44245": [],
"44253": [
"CVE-2018-5767"
],
"44280": [],
"44283": [],
"44284": [],
"44290": [
"CVE-2018-7445"
],
"44292": [
"CVE-2018-2380"
],
"44293": [
"CVE-2017-5375",
"CVE-2016-2819"
],
"44294": [
"CVE-2017-5375",
"CVE-2016-1960"
],
"44297": [
"CVE-2018-6329",
"CVE-2018-6328"
],
"44345": [
"CVE-2018-7719"
],
"44349": [
"CVE-2018-7466"
],
"44356": [
"CVE-2018-5955"
],
"44357": [
"CVE-2018-10000"
],
"44376": [],
"44398": [
"CVE-2017-14459"
],
"44412": [
"CVE-2018-4878"
],
"44415": [
"CVE-2017-0781"
],
"44446": [
"CVE-2016-9244"
],
"44453": [
"CVE-2018-0886"
],
"44473": [
"CVE-2018-10110"
],
"44482": [
"CVE-2018-7600"
],
"44485": [
"CVE-2018-9059"
],
"44522": [
"CVE-2018-9059"
],
"44524": [
"CVE-2014-9583"
],
"44552": [
"CVE-2015-4852"
],
"44553": [
"CVE-2018-2628"
],
"44554": [
"CVE-2017-0781"
],
"44555": [
"CVE-2017-0785"
],
"44556": [
"CVE-2017-12611"
],
"44568": [],
"44569": [],
"44570": [],
"44571": [
"CVE-2018-6789"
],
"44574": [
"CVE-2018-5234"
],
"44576": [
"CVE-2018-10562",
"CVE-2018-10561"
],
"44577": [
"CVE-2018-9995"
],
"44582": [],
"44584": [
"CVE-2018-6065"
],
"44596": [
"CVE-2018-7573"
],
"44597": [
"CVE-2017-15944"
],
"44598": [
"CVE-2017-9101"
],
"44599": [
"CVE-2017-9080"
],
"44611": [
"CVE-2008-4687"
],
"44616": [
"CVE-2017-11885"
],
"44635": [
"CVE-2018-10123"
],
"44638": [
"CVE-2018-10000"
],
"44642": [
"CVE-2016-9299"
],
"44643": [
"CVE-2017-9791"
],
"44648": [
"CVE-2017-8982",
"CVE-2017-12500"
],
"44760": [],
"44779": [
"CVE-2018-11220"
],
"44784": [],
"44829": [
"CVE-2018-9842"
],
"44836": [
"CVE-2016-4657",
"CVE-2016-4656",
"CVE-2016-4655"
],
"44950": [
"CVE-2018-11138"
],
"44890": [
"CVE-2018-1111",
"CVE-2018-1111&"
],
"44921": [],
"44941": [
"CVE-2018-9958",
"CVE-2018-9948"
],
"44968": [
"CVE-2018-7573"
],
"44969": [
"CVE-2018-8736",
"CVE-2018-8735",
"CVE-2018-8734",
"CVE-2018-8733"
],
"44985": [
"CVE-2018-12589"
],
"44987": [
"CVE-2018-10718"
],
"44991": [],
"44992": [],
"44993": [],
"45000": [],
"45001": [],
"45005": [
"CVE-2018-1612",
"CVE-2018-1418",
"CVE-2016-9722"
],
"45018": [],
"45019": [
"CVE-2017-12636",
"CVE-2017-12635"
],
"45020": [
"CVE-2018-12613"
],
"45025": [],
"45040": [],
"45043": [
"CVE-2018-0707",
"CVE-2018-0706"
],
"45044": [
"CVE-2018-10000"
],
"45052": [],
"45079": [],
"45099": [],
"45100": [
"CVE-2018-10662",
"CVE-2018-10661",
"CVE-2018-10660"
],
"45124": [],
"45332": [],
"45180": [],
"45170": [],
"45193": [
"CVE-2018-2628"
],
"45197": [
"CVE-2018-6892"
],
"45210": [
"CVE-2018-15473"
],
"45218": [
"CVE-2013-0657"
],
"45220": [
"CVE-2013-0662"
],
"45227": [
"CVE-2018-15576"
],
"45233": [
"CVE-2018-15473"
],
"45260": [
"CVE-2018-11776"
],
"45262": [
"CVE-2018-11776"
],
"45265": [
"CVE-2017-5941"
],
"45272": [
"CVE-2018-15685"
],
"45273": [
"CVE-2017-2741"
],
"45283": [],
"45345": [],
"45367": [
"CVE-2018-11776"
],
"45425": [
"CVE-2018-15691"
],
"45427": [],
"45429": [],
"45502": [
"CVE-2018-8469",
"CVE-2018-8468",
"CVE-2018-8463"
],
"45555": [
"CVE-2018-15379"
],
"45559": [
"CVE-2018-6328",
"CVE-2017-12478"
],
"45561": [
"CVE-2018-17553",
"CVE-2018-17552"
],
"45574": [
"CVE-2018-10594"
],
"45611": [
"CVE-2018-17980"
],
"45629": [],
"45638": [
"CVE-2018-10933"
],
"45658": [],
"45671": [
"CVE-2018-6789"
],
"45695": [
"CVE-2018-15442"
],
"45712": [
"CVE-2018-7750"
],
"45748": [],
"45789": [],
"45790": [
"CVE-2018-9206"
],
"45791": [],
"45851": [],
"45905": [],
"45909": [
"CVE-2016-1555"
],
"45914": [
"CVE-2018-19518"
],
"45917": [],
"45925": [],
"45926": [
"CVE-2018-9842"
],
"45939": [
"CVE-2018-15473"
],
"45952": [
"CVE-2017-12557"
],
"45986": [
"CVE-2015-6396",
"CVE-2014-0683"
],
"45998": [
"CVE-2018-4404",
"CVE-2018-4233"
],
"45999": [
"CVE-2018-19862",
"CVE-2018-19861"
],
"46024": [],
"46034": [
"CVE-2018-1160"
],
"46052": [
"CVE-2018-10021"
],
"46053": [
"CVE-2018-10021"
],
"46073": [],
"46074": [],
"46075": [],
"46143": [],
"46201": [
"CVE-2019-9624"
],
"46193": [
"CVE-2019-6111",
"CVE-2019-6110"
],
"46215": [
"CVE-2019-6498"
],
"46218": [],
"46220": [],
"46242": [
"CVE-2019-6116"
],
"46250": [
"CVE-2018-6892"
],
"46307": [
"CVE-2018-10933"
],
"46339": [
"CVE-2016-4117"
],
"46340": [
"CVE-2018-14933"
],
"46342": [
"CVE-2019-6545",
"CVE-2019-6543"
],
"46392": [
"CVE-2019-6453"
],
"46436": [],
"46444": [
"CVE-2019-3924"
],
"46449": [
"CVE-2018-18982"
],
"46469": [
"CVE-2019-3921"
],
"46501": [],
"46506": [],
"46509": [],
"46510": [
"CVE-2019-6340"
],
"46513": [
"CVE-2018-3245",
"CVE-2018-2628"
],
"46514": [],
"46516": [
"CVE-2019-6111",
"CVE-2019-6110"
],
"46539": [
"CVE-2019-9194"
],
"46540": [
"CVE-2018-1335",
"CVE-2018-1335 "
],
"46543": [
"CVE-2019-9760"
],
"46544": [],
"46547": [],
"46556": [
"CVE-2018-20735"
],
"46572": [
"CVE-2019-10030"
],
"46627": [
"CVE-2019-9692"
],
"46628": [
"CVE-2015-4852"
],
"46641": [
"CVE-2019-10863"
],
"46645": [],
"46654": [],
"46655": [
"CVE-2019-1653",
"CVE-2019-1652"
],
"46662": [
"CVE-2019-8943",
"CVE-2019-8942"
],
"46675": [
"CVE-2018-1160"
],
"46677": [
"CVE-2019-6977"
],
"46678": [
"CVE-2019-6989"
],
"46682": [
"CVE-2019-0227"
],
"46693": [
"CVE-2019-9670",
"CVE-2019-9621"
],
"46695": [],
"46697": [],
"46698": [
"CVE-2019-11447"
],
"46699": [],
"46700": [],
"46701": [],
"46705": [
"CVE-2019-1663"
],
"46719": [],
"46725": [
"CVE-2019-11448"
],
"46731": [
"CVE-2019-3396"
],
"46740": [
"CVE-2019-11469"
],
"46748": [],
"46762": [],
"46763": [],
"46775": [
"CVE-2019-11631"
],
"46782": [
"CVE-2019-10123"
],
"46783": [
"CVE-2019-10867"
],
"6": [
"CVE-2006-2667"
],
"44": [
"CVE-2003-0486"
],
"47": [],
"53": [],
"38772": [
"CVE-2015-7259",
"CVE-2015-7258",
"CVE-2015-7257"
],
"137": [
"CVE-2003-1216"
],
"138": [],
"177": [
"CVE-2000-1069"
],
"179": [
"CVE-2000-0944"
],
"187": [],
"188": [],
"242": [],
"289": [
"CVE-2001-0272"
],
"309": [
"CVE-2004-2631"
],
"384": [
"CVE-2004-2692"
],
"406": [
"CVE-2004-2218"
],
"407": [],
"430": [],
"436": [],
"464": [],
"465": [
"CVE-2004-1932"
],
"561": [
"CVE-2004-2158"
],
"565": [
"CVE-2004-1567"
],
"570": [
"CVE-2004-1584"
],
"574": [
"CVE-2004-1592"
],
"630": [],
"631": [
"CVE-2004-1515"
],
"635": [
"CVE-2004-2456"
],
"642": [
"CVE-2004-1037"
],
"645": [],
"647": [
"CVE-2004-1315"
],
"648": [
"CVE-2004-1531"
],
"659": [
"CVE-2000-0187"
],
"673": [],
"676": [],
"697": [],
"702": [],
"703": [
"CVE-2004-2718"
],
"704": [
"CVE-2004-2262"
],
"720": [],
"725": [],
"737": [
"CVE-2005-0283"
],
"740": [],
"754": [],
"772": [
"CVE-2005-0116"
],
"773": [
"CVE-2005-0116"
],
"774": [],
"786": [],
"790": [
"CVE-2005-0343"
],
"800": [],
"801": [],
"807": [
"CVE-2005-0413"
],
"808": [
"CVE-2005-0368"
],
"809": [],
"814": [
"CVE-2005-0414"
],
"818": [
"CVE-2005-0429"
],
"820": [
"CVE-2005-0429"
],
"832": [
"CVE-2005-0511"
],
"840": [],
"853": [
"CVE-2005-0438"
],
"857": [
"CVE-2005-0678"
],
"858": [],
"860": [
"CVE-2005-0700"
],
"862": [
"CVE-2005-0689"
],
"864": [
"CVE-2005-0698"
],
"865": [
"CVE-2005-0720"
],
"866": [
"CVE-2005-0647"
],
"870": [
"CVE-2005-0680"
],
"871": [
"CVE-2005-0614"
],
"872": [
"CVE-2005-0691"
],
"873": [],
"881": [
"CVE-2005-0792"
],
"889": [
"CVE-2005-0614"
],
"892": [
"CVE-2005-0841"
],
"897": [
"CVE-2005-0614"
],
"901": [],
"907": [],
"910": [],
"921": [
"CVE-2005-0999"
],
"922": [
"CVE-2005-0689"
],
"30090": [
"CVE-2007-5728"
],
"923": [
"CVE-2005-0689"
],
"925": [
"CVE-2005-1149"
],
"928": [
"CVE-2005-1051"
],
"939": [
"CVE-2005-1134"
],
"954": [
"CVE-2005-1289"
],
"980": [
"CVE-2004-2275"
],
"982": [],
"989": [
"CVE-2005-1629"
],
"996": [],
"1003": [],
"1004": [
"CVE-2005-1628"
],
"1005": [
"CVE-2005-1628"
],
"1006": [],
"1010": [
"CVE-2005-1779"
],
"1011": [
"CVE-2005-1779"
],
"1012": [
"CVE-2005-1779"
],
"1013": [
"CVE-2005-1598"
],
"1014": [
"CVE-2005-1598"
],
"1015": [
"CVE-2005-1784"
],
"1016": [
"CVE-2005-1787"
],
"1017": [
"CVE-2005-1787"
],
"1018": [
"CVE-2005-1787"
],
"1020": [
"CVE-2005-1820"
],
"1022": [
"CVE-2005-1833"
],
"1023": [
"CVE-2005-1500"
],
"1030": [
"CVE-2005-1777"
],
"1031": [
"CVE-2005-1701"
],
"1033": [],
"1036": [],
"1039": [
"CVE-2005-1950"
],
"1040": [
"CVE-2005-1950"
],
"1041": [
"CVE-2005-1950"
],
"1048": [
"CVE-2004-0734"
],
"1049": [
"CVE-2005-2002"
],
"1050": [
"CVE-2005-2000"
],
"1051": [],
"1052": [
"CVE-2005-1375"
],
"1053": [
"CVE-2005-1375"
],
"1057": [
"CVE-2005-4891"
],
"1058": [
"CVE-2005-2028"
],
"1059": [],
"1060": [],
"1061": [],
"1062": [],
"1068": [
"CVE-2005-2075"
],
"1069": [
"CVE-2005-2058"
],
"1070": [
"CVE-2005-2067"
],
"1071": [
"CVE-2005-2066"
],
"1076": [],
"1077": [
"CVE-2005-2108"
],
"1078": [
"CVE-2005-2116",
"CVE-2005-1921"
],
"1080": [],
"1082": [
"CVE-2005-2113"
],
"1083": [
"CVE-2005-1921"
],
"1084": [
"CVE-2005-1921"
],
"1088": [
"CVE-2005-2106"
],
"1095": [],
"1097": [
"CVE-2005-2229"
],
"1103": [],
"1106": [
"CVE-2005-2327"
],
"1111": [],
"1112": [],
"1113": [
"CVE-2005-2086"
],
"1120": [
"CVE-2005-2420"
],
"1133": [],
"1134": [
"CVE-2005-2468"
],
"1135": [],
"1140": [
"CVE-2005-4208",
"CVE-2005-2540"
],
"1142": [],
"1145": [],
"1172": [
"CVE-2005-2697"
],
"1189": [],
"1191": [
"CVE-2005-2787",
"CVE-2005-2733",
"CVE-2005-2192"
],
"1194": [
"CVE-2005-2812"
],
"1200": [],
"1202": [],
"1207": [],
"1208": [
"CVE-2005-2323"
],
"1211": [
"CVE-2005-4724"
],
"1214": [
"CVE-2005-2951"
],
"1217": [
"CVE-2008-0092",
"CVE-2005-4792"
],
"1219": [],
"1221": [
"CVE-2005-3010"
],
"1225": [
"CVE-2005-3045"
],
"1226": [
"CVE-2005-3048"
],
"1227": [
"CVE-2005-3063"
],
"1236": [
"CVE-2005-2848",
"CVE-2005-2847"
],
"1237": [
"CVE-2005-3157"
],
"1240": [
"CVE-2005-3201"
],
"1241": [
"CVE-2005-3575"
],
"1244": [
"CVE-2005-3299"
],
"1245": [
"CVE-2005-3259"
],
"1250": [],
"1252": [],
"1270": [],
"1273": [
"CVE-2005-4656"
],
"1278": [
"CVE-2005-3423"
],
"1280": [],
"1289": [
"CVE-2009-4115"
],
"1296": [
"CVE-2005-3545"
],
"1298": [
"CVE-2005-4155"
],
"1312": [
"CVE-2005-3649"
],
"1315": [
"CVE-2005-3681"
],
"1317": [],
"1319": [
"CVE-2005-3686"
],
"1320": [
"CVE-2005-3696"
],
"1321": [
"CVE-2005-3575"
],
"1322": [
"CVE-2005-3682"
],
"1324": [
"CVE-2005-4226",
"CVE-2005-4218"
],
"1325": [
"CVE-2005-4218",
"CVE-2005-4226"
],
"1326": [
"CVE-2005-3792"
],
"1329": [],
"1337": [
"CVE-2005-3738"
],
"1340": [
"CVE-2005-4171"
],
"1342": [
"CVE-2005-3926"
],
"1354": [
"CVE-2005-3996"
],
"1356": [
"CVE-2005-4095"
],
"1358": [],
"1359": [
"CVE-2005-4087",
"CVE-2005-4086"
],
"1361": [
"CVE-2005-4135"
],
"1363": [
"CVE-2005-4140"
],
"1364": [
"CVE-2005-4086",
"CVE-2005-4087"
],
"1367": [
"CVE-2005-4449",
"CVE-2005-4208"
],
"1370": [
"CVE-2005-4213"
],
"1373": [
"CVE-2005-4318"
],
"1379": [
"CVE-2005-4468",
"CVE-2005-4467"
],
"1382": [],
"1383": [],
"1385": [
"CVE-2005-4517"
],
"1387": [
"CVE-2005-4554"
],
"1388": [],
"1395": [
"CVE-2005-4593"
],
"1398": [
"CVE-2006-0064"
],
"1399": [],
"1400": [],
"1401": [
"CVE-2006-0099"
],
"1405": [],
"1410": [
"CVE-2006-0157"
],
"1418": [
"CVE-2006-0199"
],
"1419": [
"CVE-2006-0199"
],
"1442": [
"CVE-2006-0214"
],
"1446": [
"CVE-2006-0478"
],
"1453": [
"CVE-2006-0444"
],
"1457": [],
"1459": [],
"1461": [
"CVE-2006-0520"
],
"1467": [
"CVE-2006-0565"
],
"1468": [
"CVE-2006-0583"
],
"1469": [],
"1471": [
"CVE-2006-0628"
],
"1472": [],
"1478": [
"CVE-2006-0644"
],
"1482": [
"CVE-2006-0626"
],
"1484": [
"CVE-2006-0658"
],
"1485": [
"CVE-2006-1793",
"CVE-2006-0659"
],
"1491": [
"CVE-2006-0687"
],
"1492": [
"CVE-2006-0750"
],
"1493": [],
"1494": [
"CVE-2006-0714"
],
"1498": [
"CVE-2006-0728"
],
"1499": [],
"1501": [
"CVE-2006-0786"
],
"1503": [],
"1508": [],
"1509": [
"CVE-2005-4633",
"CVE-2005-4619"
],
"1510": [
"CVE-2005-2564"
],
"1511": [],
"1512": [
"CVE-2006-0852"
],
"1513": [
"CVE-2006-0821"
],
"1514": [
"CVE-2006-0870"
],
"1515": [],
"1516": [
"CVE-2006-0851"
],
"1521": [],
"1522": [
"CVE-2006-0891"
],
"1523": [],
"1524": [],
"1525": [
"CVE-2006-0973"
],
"1526": [
"CVE-2006-1001"
],
"1527": [
"CVE-2006-1031"
],
"1528": [
"CVE-2006-1000"
],
"1529": [],
"1530": [
"CVE-2005-3363"
],
"1532": [
"CVE-2006-0943",
"CVE-2006-0668"
],
"1533": [
"CVE-2006-0899"
],
"1538": [
"CVE-2006-0660"
],
"1539": [
"CVE-2006-0959"
],
"1541": [
"CVE-2006-1662"
],
"1542": [
"CVE-2006-1032"
],
"1543": [
"CVE-2006-0962"
],
"1544": [
"CVE-2006-1094"
],
"1546": [],
"1547": [
"CVE-2006-1112",
"CVE-2006-1111",
"CVE-2006-1110"
],
"1548": [
"CVE-2006-0959"
],
"1549": [],
"1550": [
"CVE-2006-1109"
],
"1553": [],
"1556": [
"CVE-2006-1153"
],
"1561": [
"CVE-2006-1149"
],
"1562": [
"CVE-2006-0961"
],
"1563": [
"CVE-2006-1662"
],
"1566": [
"CVE-2006-1219"
],
"1567": [
"CVE-2006-1140"
],
"1569": [
"CVE-2006-1123"
],
"1570": [
"CVE-2006-1252",
"CVE-2006-0206"
],
"1571": [
"CVE-2006-1213"
],
"1575": [],
"1576": [
"CVE-2006-1223"
],
"1581": [
"CVE-2006-1243"
],
"1585": [
"CVE-2006-1292"
],
"1586": [
"CVE-2006-1291"
],
"1587": [],
"1588": [
"CVE-2006-1164",
"CVE-2006-1162"
],
"1589": [
"CVE-2006-1333"
],
"1590": [
"CVE-2006-0940"
],
"1594": [
"CVE-2006-1327"
],
"1595": [
"CVE-2006-1348",
"CVE-2006-1347",
"CVE-2006-1346"
],
"1597": [
"CVE-2006-1353"
],
"1600": [
"CVE-2006-1363"
],
"1605": [
"CVE-2006-1371"
],
"1608": [
"CVE-2006-1480"
],
"1609": [
"CVE-2006-1481"
],
"1610": [
"CVE-2006-1422"
],
"1611": [
"CVE-2006-1412"
],
"1612": [],
"1616": [],
"1617": [
"CVE-2006-1495"
],
"1618": [],
"1619": [],
"1621": [],
"1623": [],
"1627": [],
"1629": [
"CVE-2006-1688",
"CVE-2006-1610"
],
"1630": [],
"1631": [
"CVE-2006-1645"
],
"1632": [],
"1640": [],
"1644": [],
"1645": [
"CVE-2006-1668",
"CVE-2006-1667"
],
"1646": [],
"1647": [],
"1650": [],
"1652": [],
"1653": [
"CVE-2006-1710"
],
"1654": [],
"1655": [
"CVE-2006-1694"
],
"1656": [],
"1659": [],
"1660": [
"CVE-2006-1491"
],
"1661": [],
"1662": [
"CVE-2006-1708"
],
"1663": [
"CVE-2006-2029",
"CVE-2006-1779",
"CVE-2006-1778",
"CVE-2006-1777",
"CVE-2006-1776",
"CVE-2006-0147",
"CVE-2006-0146"
],
"1665": [
"CVE-2006-1784"
],
"1666": [
"CVE-2006-1828"
],
"1668": [],
"1669": [
"CVE-2006-1799"
],
"1670": [],
"1672": [],
"1673": [],
"1674": [],
"1677": [
"CVE-2006-1832",
"CVE-2006-1831"
],
"1678": [],
"1680": [
"CVE-2006-0522"
],
"1682": [
"CVE-2006-1838",
"CVE-2006-1837"
],
"1683": [
"CVE-2006-1917"
],
"1686": [
"CVE-2006-1978"
],
"1687": [],
"1694": [
"CVE-2006-1919"
],
"1695": [
"CVE-2006-1921"
],
"1697": [],
"1698": [],
"1699": [],
"1700": [],
"1701": [
"CVE-2006-2065"
],
"1704": [
"CVE-2006-2032"
],
"1705": [
"CVE-2006-2029"
],
"1706": [
"CVE-2006-1994"
],
"1707": [
"CVE-2006-2002"
],
"1710": [
"CVE-2006-2005"
],
"1711": [
"CVE-2006-2008"
],
"1713": [
"CVE-2006-2034"
],
"1714": [
"CVE-2005-1287"
],
"1720": [
"CVE-2006-2059"
],
"1722": [
"CVE-2006-2151"
],
"1723": [
"CVE-2006-2152"
],
"1724": [
"CVE-2006-2151"
],
"1725": [],
"1726": [],
"1727": [
"CVE-2006-2137"
],
"1728": [
"CVE-2006-2134"
],
"1729": [
"CVE-2006-2142"
],
"1730": [
"CVE-2006-7026"
],
"1731": [],
"1732": [
"CVE-2006-2149"
],
"1733": [
"CVE-2006-2097"
],
"1738": [
"CVE-2006-2156"
],
"1740": [
"CVE-2006-2175"
],
"1744": [
"CVE-2006-2182"
],
"1747": [
"CVE-2006-2245"
],
"1751": [
"CVE-2006-2363"
],
"1752": [
"CVE-2006-2253"
],
"1753": [
"CVE-2006-7055"
],
"1755": [
"CVE-2006-2237"
],
"1756": [
"CVE-2006-0759",
"CVE-2006-0757"
],
"1759": [
"CVE-2006-2263"
],
"1760": [
"CVE-2006-2331",
"CVE-2006-2330"
],
"1761": [
"CVE-2006-2270"
],
"1763": [
"CVE-2006-2261"
],
"1764": [
"CVE-2006-2256"
],
"1765": [
"CVE-2006-2285"
],
"1766": [
"CVE-2006-7048",
"CVE-2006-2284"
],
"1767": [
"CVE-2006-1959"
],
"1768": [],
"1769": [
"CVE-2006-2323",
"CVE-2006-1749"
],
"1773": [],
"1774": [
"CVE-2006-2361"
],
"1777": [
"CVE-2006-2406",
"CVE-2006-2405"
],
"1778": [
"CVE-2006-2507"
],
"1779": [
"CVE-2006-2392"
],
"1780": [],
"1785": [
"CVE-2006-2460"
],
"1789": [
"CVE-2006-2557"
],
"1790": [
"CVE-2006-2483"
],
"1793": [
"CVE-2006-2503"
],
"1795": [
"CVE-2006-2424"
],
"1796": [
"CVE-2006-2459"
],
"1797": [
"CVE-2006-4558"
],
"1798": [
"CVE-2006-2485"
],
"1800": [
"CVE-2006-2487"
],
"1804": [
"CVE-2006-2528",
"CVE-2006-2527"
],
"1805": [
"CVE-2006-2523"
],
"1807": [
"CVE-2006-2541"
],
"1808": [
"CVE-2006-2521"
],
"1809": [
"CVE-2006-2570"
],
"1810": [
"CVE-2006-2569"
],
"1811": [
"CVE-2006-2516"
],
"1812": [
"CVE-2006-3387"
],
"1814": [
"CVE-2006-2568"
],
"1816": [
"CVE-2006-2583"
],
"1817": [
"CVE-2006-2577",
"CVE-2006-2576"
],
"1818": [
"CVE-2006-2798",
"CVE-2006-2797"
],
"1821": [
"CVE-2006-2743"
],
"1823": [
"CVE-2006-2685"
],
"1824": [
"CVE-2006-2683"
],
"1825": [
"CVE-2006-2682"
],
"1826": [
"CVE-2006-2681"
],
"1827": [
"CVE-2006-2666",
"CVE-2006-2665"
],
"1828": [
"CVE-2006-2668"
],
"1829": [
"CVE-2006-2686"
],
"1832": [
"CVE-2006-2645",
"CVE-2006-0725"
],
"1833": [
"CVE-2006-2638"
],
"1834": [
"CVE-2006-2697",
"CVE-2006-2696"
],
"1835": [
"CVE-2006-2730"
],
"1836": [],
"1837": [],
"1839": [
"CVE-2006-2740",
"CVE-2006-2739"
],
"1840": [
"CVE-2006-2731"
],
"1841": [
"CVE-2006-2746",
"CVE-2006-2745",
"CVE-2006-2744"
],
"1842": [
"CVE-2006-2725"
],
"1843": [
"CVE-2006-2755",
"CVE-2006-2675"
],
"1844": [
"CVE-2006-2735"
],
"1845": [
"CVE-2006-2794",
"CVE-2006-2793"
],
"1846": [
"CVE-2006-2736"
],
"1847": [
"CVE-2006-2650"
],
"1848": [
"CVE-2006-2726"
],
"1849": [
"CVE-2006-2807"
],
"1850": [
"CVE-2006-2737"
],
"1851": [
"CVE-2006-2834"
],
"1853": [
"CVE-2006-2770"
],
"1854": [
"CVE-2006-2767"
],
"1855": [
"CVE-2006-2768"
],
"1857": [
"CVE-2006-7063"
],
"1858": [
"CVE-2006-2841"
],
"1859": [
"CVE-2006-2848",
"CVE-2006-2847"
],
"1860": [
"CVE-2006-2849"
],
"1861": [
"CVE-2006-2845",
"CVE-2006-2844",
"CVE-2006-2843"
],
"1863": [
"CVE-2006-2819"
],
"1864": [
"CVE-2003-1292"
],
"1865": [
"CVE-2006-2818"
],
"1866": [
"CVE-2006-2828"
],
"1868": [
"CVE-2006-2889"
],
"1869": [
"CVE-2006-2866"
],
"1870": [
"CVE-2006-2864"
],
"1871": [
"CVE-2006-2860"
],
"1872": [
"CVE-2006-2863"
],
"1873": [],
"1874": [
"CVE-2006-2857"
],
"1875": [
"CVE-2006-2896"
],
"1876": [
"CVE-2006-7012"
],
"1877": [
"CVE-2006-2868"
],
"1878": [
"CVE-2006-2861"
],
"1879": [
"CVE-2006-2852"
],
"1881": [
"CVE-2006-2881"
],
"1882": [
"CVE-2006-2947",
"CVE-2006-2946"
],
"1883": [
"CVE-2006-2888"
],
"1884": [
"CVE-2006-2887"
],
"1886": [
"CVE-2006-2929"
],
"1887": [],
"1888": [],
"1890": [
"CVE-2006-2928"
],
"1891": [
"CVE-2006-2982"
],
"1892": [],
"1893": [],
"1895": [
"CVE-2006-2962"
],
"1896": [
"CVE-2006-2996"
],
"1897": [],
"1898": [
"CVE-2006-2995"
],
"1899": [
"CVE-2006-2998"
],
"1900": [],
"1901": [],
"1902": [],
"1903": [
"CVE-2006-3172"
],
"1904": [
"CVE-2006-3065"
],
"1905": [],
"1907": [],
"1908": [
"CVE-2006-3028"
],
"1909": [
"CVE-2006-2908"
],
"1912": [
"CVE-2006-3177"
],
"1913": [
"CVE-2006-3076"
],
"1914": [],
"1916": [
"CVE-2006-2914"
],
"1918": [
"CVE-2006-3105",
"CVE-2006-3104",
"CVE-2006-3103",
"CVE-2006-3102"
],
"1919": [
"CVE-2006-3186"
],
"1920": [
"CVE-2006-3262"
],
"1921": [
"CVE-2006-7032"
],
"1922": [
"CVE-2006-7247"
],
"1923": [
"CVE-2006-3192"
],
"1925": [
"CVE-2006-7017",
"CVE-2006-1767",
"CVE-2006-0688"
],
"1926": [],
"1928": [
"CVE-2008-5199"
],
"1929": [
"CVE-2006-3144"
],
"1930": [
"CVE-2006-3213"
],
"1931": [
"CVE-2006-3580",
"CVE-2006-3184"
],
"1932": [],
"1933": [
"CVE-2006-3193"
],
"1934": [],
"1936": [
"CVE-2006-3421",
"CVE-2006-3162"
],
"1938": [
"CVE-2006-3221"
],
"1939": [
"CVE-2006-3221"
],
"1941": [
"CVE-2006-3262"
],
"1942": [
"CVE-2007-4127",
"CVE-2006-3210"
],
"1943": [
"CVE-2006-7024"
],
"1945": [],
"1946": [
"CVE-2006-3292"
],
"1948": [
"CVE-2006-3300"
],
"1950": [],
"1951": [
"CVE-2006-3266"
],
"1952": [
"CVE-2006-3269"
],
"1953": [
"CVE-2006-3304"
],
"1954": [
"CVE-2006-6232"
],
"1955": [
"CVE-2006-3294"
],
"1956": [
"CVE-2006-3340"
],
"1957": [
"CVE-2006-3309"
],
"1959": [
"CVE-2006-6962"
],
"1960": [
"CVE-2006-3364"
],
"1961": [
"CVE-2006-3341"
],
"1963": [
"CVE-2006-6225"
],
"1964": [
"CVE-2006-3362"
],
"1968": [
"CVE-2006-3347"
],
"1969": [
"CVE-2006-3361"
],
"1970": [
"CVE-2006-7021"
],
"1971": [
"CVE-2006-3375"
],
"1974": [
"CVE-2006-3421"
],
"1975": [
"CVE-2006-3394"
],
"1981": [
"CVE-2006-3396"
],
"1982": [
"CVE-2006-3422"
],
"1983": [
"CVE-2006-3478"
],
"1987": [
"CVE-2006-3147"
],
"1991": [
"CVE-2006-3533",
"CVE-2006-3532",
"CVE-2006-3531"
],
"1993": [
"CVE-2006-3572",
"CVE-2006-3571"
],
"1994": [
"CVE-2006-3528"
],
"1995": [
"CVE-2006-7208"
],
"1996": [
"CVE-2006-3520"
],
"1998": [],
"2002": [],
"2003": [],
"2007": [],
"2008": [
"CVE-2006-3611"
],
"2009": [
"CVE-2006-3685",
"CVE-2005-0859"
],
"2010": [
"CVE-2006-7071"
],
"2012": [
"CVE-2011-5035",
"CVE-2011-5034",
"CVE-2011-4885",
"CVE-2011-4858",
"CVE-2011-4084",
"CVE-2006-3775"
],
"2018": [
"CVE-2006-3755",
"CVE-2006-3754"
],
"2019": [
"CVE-2006-3735"
],
"2020": [
"CVE-2006-3736"
],
"2021": [
"CVE-2006-3773"
],
"2022": [],
"2023": [
"CVE-2006-3748"
],
"2024": [
"CVE-2006-3530"
],
"2025": [
"CVE-2006-3774"
],
"2026": [
"CVE-2006-3750"
],
"2027": [
"CVE-2006-3751"
],
"2028": [
"CVE-2006-3749"
],
"2029": [
"CVE-2006-5045"
],
"2030": [
"CVE-2006-3690"
],
"2032": [
"CVE-2006-3727"
],
"2033": [
"CVE-2006-7071"
],
"2035": [],
"2036": [
"CVE-2006-3772"
],
"2046": [
"CVE-2006-3771"
],
"2049": [
"CVE-2006-3793"
],
"2050": [
"CVE-2006-3832"
],
"2058": [
"CVE-2006-3917"
],
"2060": [
"CVE-2006-3911"
],
"2062": [
"CVE-2006-3847"
],
"2063": [],
"2064": [
"CVE-2006-3951"
],
"2066": [
"CVE-2006-3846"
],
"2068": [
"CVE-2006-3851"
],
"2069": [
"CVE-2006-5044"
],
"2071": [
"CVE-2006-3904"
],
"2072": [
"CVE-2006-7070"
],
"2077": [
"CVE-2006-3928"
],
"2078": [
"CVE-2006-3930"
],
"2081": [
"CVE-2006-3922"
],
"2083": [
"CVE-2006-5048"
],
"2084": [
"CVE-2006-3980"
],
"2085": [
"CVE-2006-3969"
],
"2086": [
"CVE-2006-3947"
],
"2087": [
"CVE-2006-4004"
],
"2088": [
"CVE-2006-3996"
],
"2089": [
"CVE-2006-3995"
],
"2090": [
"CVE-2006-3962"
],
"2092": [
"CVE-2006-3970"
],
"2095": [
"CVE-2006-3983"
],
"2096": [
"CVE-2006-3966"
],
"2097": [
"CVE-2006-3986"
],
"2098": [
"CVE-2006-4085",
"CVE-2006-4055",
"CVE-2006-3993"
],
"2099": [
"CVE-2006-3998"
],
"2100": [
"CVE-2006-3984"
],
"2101": [
"CVE-2006-3988"
],
"2102": [
"CVE-2006-3991"
],
"2103": [
"CVE-2006-3989"
],
"2104": [
"CVE-2006-3987"
],
"2105": [
"CVE-2006-3994"
],
"2109": [],
"2110": [],
"2113": [
"CVE-2006-4012"
],
"2114": [],
"2115": [
"CVE-2006-4011"
],
"2116": [
"CVE-2006-4055"
],
"2117": [],
"2118": [
"CVE-2006-4042"
],
"2119": [
"CVE-2006-4052"
],
"2120": [
"CVE-2006-4051"
],
"2121": [
"CVE-2006-4045"
],
"2122": [
"CVE-2006-4053"
],
"2123": [
"CVE-2006-4102"
],
"2125": [
"CVE-2006-4074"
],
"2127": [
"CVE-2006-4034"
],
"2128": [
"CVE-2006-4063",
"CVE-2006-4026"
],
"2129": [
"CVE-2006-4063"
],
"2130": [
"CVE-2006-4065",
"CVE-2006-4063"
],
"2131": [
"CVE-2006-4063",
"CVE-2006-4062"
],
"2132": [
"CVE-2006-4050"
],
"2133": [],
"2134": [
"CVE-2006-4073"
],
"2135": [
"CVE-2006-4059"
],
"2137": [],
"2138": [
"CVE-2006-4064"
],
"2139": [
"CVE-2006-4044"
],
"2141": [
"CVE-2006-4060"
],
"2142": [
"CVE-2006-4036"
],
"2143": [
"CVE-2006-3819"
],
"2146": [
"CVE-2006-4075"
],
"2148": [
"CVE-2006-4103"
],
"2149": [
"CVE-2006-4113"
],
"2150": [
"CVE-2006-4072"
],
"2151": [
"CVE-2006-4077"
],
"2153": [
"CVE-2006-4123"
],
"2154": [
"CVE-2006-4115"
],
"2155": [
"CVE-2006-4121"
],
"2157": [
"CVE-2006-4437"
],
"2158": [
"CVE-2006-4166"
],
"2159": [
"CVE-2006-4114"
],
"2161": [],
"2163": [],
"2165": [
"CVE-2006-4158"
],
"2166": [
"CVE-2006-4213",
"CVE-2002-2298"
],
"2167": [],
"2168": [
"CVE-2006-4164"
],
"2169": [
"CVE-2006-4216",
"CVE-2006-4159"
],
"2170": [
"CVE-2007-2312",
"CVE-2006-4142"
],
"2171": [
"CVE-2006-4209"
],
"2172": [
"CVE-2006-4130"
],
"2173": [
"CVE-2006-4160"
],
"2174": [
"CVE-2006-4198"
],
"2175": [
"CVE-2006-4196"
],
"2177": [
"CVE-2006-4129"
],
"2178": [
"CVE-2006-4191"
],
"2181": [
"CVE-2006-4210"
],
"2182": [
"CVE-2006-4203"
],
"2183": [
"CVE-2006-4205"
],
"2184": [
"CVE-2006-4195"
],
"2186": [
"CVE-2006-4202"
],
"2187": [],
"2188": [
"CVE-2006-4207"
],
"2189": [
"CVE-2006-4217"
],
"2190": [
"CVE-2006-4204"
],
"2191": [
"CVE-2006-4234"
],
"2192": [
"CVE-2006-4239"
],
"2196": [
"CVE-2006-4321"
],
"2198": [
"CVE-2006-4267"
],
"2199": [
"CVE-2006-4237"
],
"2200": [
"CVE-2006-4238"
],
"2201": [
"CVE-2006-4236"
],
"2202": [
"CVE-2006-4270"
],
"2203": [
"CVE-2006-4242"
],
"2205": [
"CVE-2006-3990"
],
"2206": [],
"2207": [
"CVE-2006-4288"
],
"2209": [
"CVE-2006-3949"
],
"2211": [
"CVE-2006-4291"
],
"2212": [],
"2213": [
"CVE-2006-4282"
],
"2214": [],
"2215": [
"CVE-2006-4348"
],
"2216": [
"CVE-2006-4311"
],
"2217": [
"CVE-2006-4363"
],
"2218": [
"CVE-2006-4448"
],
"2219": [],
"2220": [
"CVE-2006-4277",
"CVE-2006-4276"
],
"2221": [
"CVE-2006-4285"
],
"2222": [
"CVE-2006-4372"
],
"2224": [],
"2225": [
"CVE-2006-4296"
],
"2226": [
"CVE-2006-4287"
],
"2227": [
"CVE-2006-4278"
],
"2228": [
"CVE-2006-4300"
],
"2229": [
"CVE-2006-4329"
],
"2230": [
"CVE-2006-4284"
],
"2231": [],
"2232": [
"CVE-2006-4300"
],
"2235": [],
"2236": [],
"2239": [
"CVE-2006-4354"
],
"2240": [],
"2243": [],
"2247": [],
"2248": [
"CVE-2006-4367"
],
"2249": [
"CVE-2006-4373"
],
"2250": [
"CVE-2006-4369",
"CVE-2006-4368"
],
"2251": [
"CVE-2006-4365"
],
"2252": [
"CVE-2006-4418"
],
"2253": [
"CVE-2006-4420"
],
"2254": [
"CVE-2006-4425",
"CVE-2006-4424"
],
"2255": [
"CVE-2006-4427"
],
"2256": [],
"2257": [
"CVE-2006-7068"
],
"2259": [
"CVE-2006-4419"
],
"2260": [
"CVE-2006-4426"
],
"2261": [],
"2262": [
"CVE-2006-4536"
],
"2263": [
"CVE-2006-4441",
"CVE-2006-4440"
],
"2266": [
"CVE-2006-4490"
],
"2267": [
"CVE-2006-4444"
],
"2268": [],
"2269": [
"CVE-2006-4452"
],
"2270": [
"CVE-2006-4458"
],
"2271": [
"CVE-2006-4498"
],
"2272": [
"CVE-2006-4489"
],
"2273": [
"CVE-2006-4488"
],
"2275": [
"CVE-2006-4456"
],
"2279": [
"CVE-2006-4749",
"CVE-2006-4594"
],
"2280": [
"CVE-2006-4604"
],
"2281": [
"CVE-2006-4531"
],
"2282": [
"CVE-2006-4559",
"CVE-2006-4532"
],
"2285": [
"CVE-2006-4596"
],
"2287": [
"CVE-2006-4597"
],
"2288": [
"CVE-2006-4602"
],
"2289": [
"CVE-2006-4601"
],
"2290": [
"CVE-2006-4589"
],
"2291": [],
"2292": [
"CVE-2005-1312"
],
"2293": [
"CVE-2006-4583"
],
"2294": [
"CVE-2006-4641"
],
"2295": [],
"2296": [
"CVE-2006-4592"
],
"2297": [
"CVE-2006-4586",
"CVE-2006-4584"
],
"2298": [],
"2299": [],
"2300": [
"CVE-2006-4633",
"CVE-2006-4632"
],
"2301": [
"CVE-2006-4630"
],
"2304": [
"CVE-2006-4610"
],
"2305": [
"CVE-2006-4622"
],
"2306": [
"CVE-2006-4612"
],
"2307": [
"CVE-2006-4638"
],
"2308": [
"CVE-2006-4629"
],
"2309": [
"CVE-2006-4647"
],
"2310": [
"CVE-2006-4636"
],
"2311": [
"CVE-2006-4664"
],
"2312": [
"CVE-2006-4649",
"CVE-2006-4648"
],
"2313": [
"CVE-2006-4644"
],
"2314": [],
"2315": [
"CVE-2006-4645"
],
"2316": [
"CVE-2006-4672"
],
"2317": [
"CVE-2006-5291",
"CVE-2006-4656"
],
"2318": [
"CVE-2006-4746"
],
"2319": [
"CVE-2006-4716"
],
"2321": [],
"2322": [],
"2323": [
"CVE-2006-7081"
],
"2324": [
"CVE-2006-4637"
],
"2325": [
"CVE-2006-4678"
],
"2326": [
"CVE-2006-4666"
],
"2327": [
"CVE-2006-4670"
],
"2329": [
"CVE-2007-0704",
"CVE-2006-4669"
],
"2333": [
"CVE-2006-4721"
],
"2335": [
"CVE-2006-4719"
],
"2336": [
"CVE-2006-7069"
],
"2337": [
"CVE-2006-4715"
],
"2339": [
"CVE-2006-4714"
],
"2340": [
"CVE-2006-4713"
],
"2341": [
"CVE-2006-4722"
],
"2342": [
"CVE-2006-4720"
],
"2343": [
"CVE-2006-4770"
],
"2344": [
"CVE-2006-4750"
],
"2346": [
"CVE-2006-4764"
],
"2347": [
"CVE-2006-4742",
"CVE-2006-4741"
],
"2348": [],
"2349": [
"CVE-2006-4780"
],
"2350": [
"CVE-2006-4769"
],
"2351": [],
"2352": [
"CVE-2006-4782"
],
"2353": [
"CVE-2006-4779"
],
"2354": [
"CVE-2006-4889",
"CVE-2006-4788"
],
"2356": [
"CVE-2006-4824"
],
"2357": [
"CVE-2006-4869"
],
"2359": [
"CVE-2006-4827"
],
"2361": [
"CVE-2006-4885",
"CVE-2006-4826"
],
"2362": [
"CVE-2006-4793"
],
"2363": [
"CVE-2006-4823"
],
"2364": [
"CVE-2006-5919"
],
"2365": [
"CVE-2006-4766"
],
"2366": [
"CVE-2006-4834"
],
"2367": [
"CVE-2006-4858"
],
"2368": [
"CVE-2006-4845"
],
"2369": [
"CVE-2006-4828"
],
"2370": [
"CVE-2006-4859"
],
"2371": [
"CVE-2006-4853"
],
"2372": [
"CVE-2006-4850"
],
"2373": [
"CVE-2006-4912"
],
"2374": [
"CVE-2006-4922",
"CVE-2006-4921",
"CVE-2006-4920"
],
"2375": [],
"2376": [
"CVE-2006-4979",
"CVE-2006-4978",
"CVE-2006-4977",
"CVE-2006-4865"
],
"2377": [
"CVE-2006-4870"
],
"2378": [
"CVE-2006-4867"
],
"2379": [
"CVE-2006-5254"
],
"2380": [
"CVE-2006-4890"
],
"2381": [
"CVE-2006-4898"
],
"2382": [
"CVE-2006-4612"
],
"2383": [
"CVE-2006-4849"
],
"2384": [
"CVE-2006-4852"
],
"2385": [
"CVE-2006-4892"
],
"2386": [
"CVE-2006-4891"
],
"2387": [
"CVE-2006-4882"
],
"2388": [
"CVE-2006-4897"
],
"2389": [
"CVE-2006-4913"
],
"2390": [
"CVE-2006-4968"
],
"2391": [
"CVE-2006-4963"
],
"2392": [
"CVE-2006-4970"
],
"2393": [
"CVE-2006-4969"
],
"2394": [
"CVE-2006-4906"
],
"2395": [
"CVE-2006-4916"
],
"2396": [
"CVE-2006-4918"
],
"2397": [
"CVE-2006-4957"
],
"2398": [
"CVE-2006-4945"
],
"2399": [
"CVE-2006-4946"
],
"2402": [
"CVE-2006-4962",
"CVE-2006-4961",
"CVE-2006-4960"
],
"2405": [
"CVE-2006-4993"
],
"2406": [
"CVE-2006-5030"
],
"2407": [
"CVE-2006-5022"
],
"2409": [
"CVE-2006-5032"
],
"2410": [
"CVE-2006-4966"
],
"2411": [
"CVE-2006-4944"
],
"2413": [
"CVE-2006-5020"
],
"2414": [
"CVE-2006-4989",
"CVE-2006-4988",
"CVE-2006-4987"
],
"2415": [
"CVE-2006-7080",
"CVE-2006-7079"
],
"2416": [
"CVE-2006-5023"
],
"2417": [],
"2418": [
"CVE-2006-5017"
],
"2419": [
"CVE-2006-5053"
],
"2420": [
"CVE-2006-5065"
],
"2421": [
"CVE-2006-4202"
],
"2422": [
"CVE-2006-5061"
],
"2423": [
"CVE-2006-5054"
],
"2424": [
"CVE-2006-5055"
],
"2427": [
"CVE-2006-5078"
],
"2428": [
"CVE-2006-5062"
],
"2429": [
"CVE-2006-5077"
],
"2431": [
"CVE-2006-5087"
],
"2432": [
"CVE-2006-5068"
],
"2433": [
"CVE-2006-5068"
],
"2434": [
"CVE-2006-5070"
],
"2435": [
"CVE-2006-5100"
],
"2436": [
"CVE-2006-5092"
],
"2437": [
"CVE-2006-5079"
],
"2438": [],
"2439": [
"CVE-2006-5102"
],
"2441": [
"CVE-2006-5086",
"CVE-2006-5085"
],
"2442": [
"CVE-2006-5135"
],
"2443": [
"CVE-2006-5180"
],
"2446": [
"CVE-2006-5165"
],
"2447": [
"CVE-2006-5115"
],
"2449": [],
"2450": [
"CVE-2006-5093"
],
"2451": [
"CVE-2006-5125",
"CVE-2006-5124"
],
"2452": [],
"2453": [
"CVE-2006-5094"
],
"2454": [
"CVE-2006-5126"
],
"2455": [
"CVE-2006-5155"
],
"2456": [
"CVE-2006-5140"
],
"2457": [
"CVE-2006-5137"
],
"2459": [
"CVE-2006-5148"
],
"2461": [
"CVE-2006-5147"
],
"2462": [
"CVE-2006-5181",
"CVE-2006-5125",
"CVE-2006-5124"
],
"2465": [
"CVE-2006-5167"
],
"2468": [
"CVE-2006-5187"
],
"2469": [
"CVE-2008-1609",
"CVE-2006-7128"
],
"2470": [
"CVE-2006-5186"
],
"2471": [
"CVE-2006-5182"
],
"2472": [
"CVE-2006-5189"
],
"2473": [
"CVE-2006-5206",
"CVE-2006-5205"
],
"2474": [
"CVE-2008-1609",
"CVE-2006-7127"
],
"2475": [
"CVE-2006-5209"
],
"2476": [
"CVE-2006-5192"
],
"2477": [
"CVE-2006-5191"
],
"2478": [
"CVE-2006-5207"
],
"2479": [
"CVE-2006-5208"
],
"2480": [
"CVE-2006-5224"
],
"2481": [
"CVE-2006-5222"
],
"2483": [
"CVE-2006-5223"
],
"2484": [
"CVE-2006-5230"
],
"2485": [
"CVE-2006-5221"
],
"2486": [],
"2487": [
"CVE-2006-5236"
],
"2488": [
"CVE-2006-5261"
],
"2489": [
"CVE-2006-5257"
],
"2490": [
"CVE-2006-5226"
],
"2491": [
"CVE-2006-7135"
],
"2493": [
"CVE-2006-5240"
],
"2494": [
"CVE-2006-5244",
"CVE-2006-5243"
],
"2495": [
"CVE-2006-5244"
],
"2496": [
"CVE-2006-5220"
],
"2497": [
"CVE-2006-5241"
],
"2498": [],
"2499": [],
"2500": [
"CVE-2006-5263"
],
"2501": [
"CVE-2006-5314"
],
"2502": [
"CVE-2006-5316",
"CVE-2006-5315"
],
"2503": [
"CVE-2006-5259"
],
"2504": [
"CVE-2006-5317"
],
"2505": [
"CVE-2006-5318"
],
"2506": [
"CVE-2006-5319"
],
"2507": [
"CVE-2006-5320"
],
"2508": [
"CVE-2006-5289"
],
"2509": [
"CVE-2006-5292"
],
"2510": [
"CVE-2006-5256"
],
"2511": [
"CVE-2006-5471"
],
"2512": [
"CVE-2006-7130"
],
"2513": [],
"2514": [
"CVE-2006-5281"
],
"2516": [
"CVE-2006-5739"
],
"2517": [
"CVE-2006-5284"
],
"2518": [
"CVE-2006-5282"
],
"2519": [
"CVE-2006-5283"
],
"2520": [
"CVE-2006-5472"
],
"2521": [
"CVE-2006-5291",
"CVE-2006-4656"
],
"2522": [
"CVE-2006-5306"
],
"2525": [
"CVE-2006-7100"
],
"2526": [
"CVE-2006-5458"
],
"2527": [],
"2528": [
"CVE-2006-7156"
],
"2529": [
"CVE-2006-5307"
],
"2531": [
"CVE-2006-7147"
],
"2532": [
"CVE-2006-5312"
],
"2533": [
"CVE-2006-5301"
],
"2534": [
"CVE-2006-5302"
],
"2535": [
"CVE-2006-5310"
],
"2536": [
"CVE-2006-5308"
],
"2537": [
"CVE-2006-7148"
],
"2538": [
"CVE-2006-5387"
],
"2539": [
"CVE-2006-6632"
],
"2540": [
"CVE-2006-5384"
],
"2544": [
"CVE-2006-6593"
],
"2545": [
"CVE-2006-5415"
],
"2546": [
"CVE-2006-5305"
],
"2547": [
"CVE-2006-5385"
],
"2548": [],
"2549": [
"CVE-2006-5418"
],
"2550": [
"CVE-2006-5309"
],
"2551": [
"CVE-2006-5390"
],
"2552": [],
"2553": [
"CVE-2006-5413"
],
"2554": [],
"2555": [
"CVE-2006-6976"
],
"2556": [
"CVE-2006-6694"
],
"2557": [
"CVE-2006-5304"
],
"2558": [
"CVE-2006-7131"
],
"2559": [
"CVE-2006-5400"
],
"2560": [
"CVE-2006-5910"
],
"2561": [
"CVE-2006-5386"
],
"2562": [
"CVE-2006-5401"
],
"2563": [
"CVE-2006-7102"
],
"2564": [],
"2566": [
"CVE-2006-5493"
],
"2567": [
"CVE-2006-5383"
],
"2568": [
"CVE-2006-5388"
],
"2570": [
"CVE-2006-5392"
],
"2572": [
"CVE-2006-6631"
],
"2573": [
"CVE-2006-6045"
],
"2574": [
"CVE-2006-5398"
],
"2575": [],
"2576": [
"CVE-2008-7152",
"CVE-2006-5419"
],
"2577": [
"CVE-2006-5434"
],
"2578": [
"CVE-2006-6760"
],
"2579": [
"CVE-2006-5509",
"CVE-2006-5508"
],
"2582": [
"CVE-2006-5433"
],
"2583": [
"CVE-2006-5421"
],
"2584": [
"CVE-2006-5399"
],
"2585": [
"CVE-2006-5402"
],
"2588": [
"CVE-2006-5412"
],
"2589": [
"CVE-2006-5429"
],
"2590": [
"CVE-2006-5432"
],
"2591": [
"CVE-2006-5427"
],
"2592": [],
"2593": [],
"2594": [
"CVE-2006-6633"
],
"2595": [
"CVE-2006-5426"
],
"2596": [
"CVE-2006-5555"
],
"2598": [
"CVE-2006-5510"
],
"2599": [
"CVE-2006-5494"
],
"2600": [
"CVE-2006-5722",
"CVE-2006-5497"
],
"2602": [
"CVE-2006-7106",
"CVE-2002-1885"
],
"2603": [
"CVE-2006-5423"
],
"2604": [
"CVE-2006-5514"
],
"2605": [
"CVE-2006-5518"
],
"2606": [
"CVE-2006-5480"
],
"2607": [
"CVE-2006-5522"
],
"2608": [],
"2609": [
"CVE-2006-5517"
],
"2611": [
"CVE-2006-5495"
],
"2612": [
"CVE-2006-5543"
],
"2613": [
"CVE-2006-5519"
],
"2614": [
"CVE-2006-5521"
],
"2615": [
"CVE-2006-5485"
],
"2616": [
"CVE-2006-5511"
],
"2617": [
"CVE-2006-5525"
],
"2620": [
"CVE-2006-5523"
],
"2621": [
"CVE-2006-5526"
],
"2622": [
"CVE-2006-5548",
"CVE-2006-5547",
"CVE-2006-5546"
],
"2623": [
"CVE-2006-5562"
],
"2624": [
"CVE-2006-5506"
],
"2626": [
"CVE-2006-5587"
],
"2627": [],
"2628": [
"CVE-2006-6635"
],
"2630": [
"CVE-2006-5527"
],
"2631": [
"CVE-2006-5531"
],
"2632": [
"CVE-2006-5588"
],
"2640": [
"CVE-2006-5539"
],
"2642": [],
"2643": [],
"2644": [
"CVE-2006-5561"
],
"2645": [
"CVE-2006-5590"
],
"2646": [
"CVE-2006-5615"
],
"2647": [
"CVE-2006-5554"
],
"2648": [],
"2652": [],
"2653": [
"CVE-2006-5624"
],
"2654": [
"CVE-2006-5621"
],
"2655": [
"CVE-2006-5673"
],
"2656": [
"CVE-2006-5620"
],
"2658": [],
"2659": [
"CVE-2006-5625"
],
"2660": [
"CVE-2006-5622"
],
"2661": [
"CVE-2006-5676"
],
"2662": [
"CVE-2006-5629"
],
"2663": [],
"2664": [
"CVE-2006-7132"
],
"2665": [
"CVE-2006-7107"
],
"2666": [
"CVE-2006-5613"
],
"2667": [
"CVE-2006-5623"
],
"2668": [],
"2669": [
"CVE-2006-5670"
],
"2670": [
"CVE-2006-5762"
],
"2673": [
"CVE-2006-5636"
],
"2674": [
"CVE-2006-5672"
],
"2675": [
"CVE-2006-5707"
],
"2677": [
"CVE-2006-5618"
],
"2678": [
"CVE-2006-5637"
],
"2679": [
"CVE-2006-5638"
],
"2681": [
"CVE-2006-5627"
],
"2683": [
"CVE-2006-5641"
],
"2684": [
"CVE-2006-5640"
],
"2685": [
"CVE-2006-6938"
],
"2686": [
"CVE-2006-5665"
],
"2687": [
"CVE-2006-5666"
],
"2688": [
"CVE-2006-5634"
],
"2691": [
"CVE-2006-5667"
],
"2692": [
"CVE-2006-5669"
],
"2693": [],
"2694": [
"CVE-2006-5732"
],
"2696": [],
"2697": [],
"2698": [
"CVE-2006-5505"
],
"2701": [
"CVE-2006-5703",
"CVE-2006-5702"
],
"2702": [
"CVE-2006-5731"
],
"2703": [
"CVE-2006-5766"
],
"2704": [
"CVE-2006-6941",
"CVE-2006-5773",
"CVE-2006-5772"
],
"2706": [
"CVE-2006-5730"
],
"2707": [
"CVE-2006-5733"
],
"2709": [
"CVE-2006-5777"
],
"2710": [],
"2711": [
"CVE-2006-5786"
],
"2712": [
"CVE-2006-7112"
],
"2713": [
"CVE-2006-5767"
],
"2714": [],
"2717": [
"CVE-2006-5760"
],
"2718": [
"CVE-2006-5727"
],
"2719": [
"CVE-2006-5834"
],
"2720": [
"CVE-2006-5828"
],
"2721": [
"CVE-2006-7169"
],
"2722": [
"CVE-2006-5802"
],
"2724": [
"CVE-2006-5796"
],
"2725": [
"CVE-2006-5768"
],
"2726": [
"CVE-2006-7194"
],
"2727": [
"CVE-2006-5811",
"CVE-2006-5795"
],
"2728": [
"CVE-2006-5765"
],
"2731": [
"CVE-2006-5787"
],
"2732": [
"CVE-2006-7119"
],
"2733": [
"CVE-2006-5837"
],
"2736": [
"CVE-2006-5839"
],
"2739": [
"CVE-2006-5788"
],
"2740": [
"CVE-2006-6586"
],
"2741": [
"CVE-2006-5849"
],
"2742": [
"CVE-2006-5841"
],
"2744": [
"CVE-2006-5863"
],
"2745": [
"CVE-2006-5923"
],
"2746": [
"CVE-2006-5892"
],
"2747": [
"CVE-2006-5865"
],
"2748": [
"CVE-2006-5866"
],
"2750": [
"CVE-2006-5895"
],
"2751": [
"CVE-2006-5889"
],
"2752": [
"CVE-2006-6041"
],
"2754": [
"CVE-2006-5881"
],
"2755": [
"CVE-2006-5886"
],
"2756": [
"CVE-2006-5885"
],
"2757": [
"CVE-2006-5887"
],
"2758": [],
"2759": [
"CVE-2006-7101"
],
"2760": [
"CVE-2006-5894"
],
"2761": [
"CVE-2006-5880"
],
"2762": [
"CVE-2006-5879"
],
"2763": [
"CVE-2006-5891"
],
"2764": [
"CVE-2006-5890"
],
"2765": [
"CVE-2006-5888"
],
"2766": [
"CVE-2006-7185"
],
"2767": [
"CVE-2006-5893"
],
"2768": [],
"2769": [
"CVE-2006-6391"
],
"2772": [],
"2773": [
"CVE-2006-5934"
],
"2774": [
"CVE-2006-6029"
],
"2775": [
"CVE-2006-5928"
],
"2776": [],
"2777": [
"CVE-2006-5930"
],
"2778": [
"CVE-2006-5948"
],
"2779": [
"CVE-2006-5952"
],
"2780": [
"CVE-2007-1566",
"CVE-2006-5954"
],
"2781": [
"CVE-2006-5976",
"CVE-2006-5975"
],
"2782": [
"CVE-2006-5962"
],
"2786": [
"CVE-2006-6330",
"CVE-2006-6329",
"CVE-2006-6328"
],
"2790": [
"CVE-2006-6047"
],
"2791": [
"CVE-2006-7134"
],
"2794": [
"CVE-2006-6341"
],
"2795": [
"CVE-2006-6028"
],
"2796": [],
"2797": [
"CVE-2006-6038"
],
"2798": [
"CVE-2006-6039"
],
"2799": [
"CVE-2006-6065"
],
"2807": [
"CVE-2006-6051"
],
"2808": [
"CVE-2006-6281"
],
"2810": [
"CVE-2006-6280"
],
"2811": [
"CVE-2007-3141",
"CVE-2006-6042"
],
"2812": [],
"2813": [
"CVE-2006-6070"
],
"2814": [
"CVE-2006-6044"
],
"2817": [
"CVE-2006-6093"
],
"2818": [
"CVE-2006-6086"
],
"2819": [
"CVE-2006-6577"
],
"2820": [
"CVE-2006-6177"
],
"2822": [
"CVE-2006-6157"
],
"2823": [
"CVE-2006-6084"
],
"2826": [],
"2827": [
"CVE-2006-7136"
],
"2828": [
"CVE-2006-6115"
],
"2829": [
"CVE-2006-6117"
],
"2830": [
"CVE-2006-6116"
],
"2831": [
"CVE-2006-6078"
],
"2832": [
"CVE-2006-6151"
],
"2833": [
"CVE-2006-6212"
],
"2834": [
"CVE-2006-6220"
],
"2835": [
"CVE-2006-6214"
],
"2836": [
"CVE-2006-6149"
],
"2838": [
"CVE-2006-6154"
],
"2839": [
"CVE-2006-6150"
],
"2840": [
"CVE-2006-6213"
],
"2841": [
"CVE-2006-6237"
],
"2842": [
"CVE-2006-6289"
],
"2843": [
"CVE-2006-6255",
"CVE-2006-6202"
],
"2844": [
"CVE-2006-6254"
],
"2846": [
"CVE-2006-6160"
],
"2847": [
"CVE-2006-6140",
"CVE-2006-6138",
"CVE-2006-6137"
],
"2848": [
"CVE-2006-6193"
],
"2849": [
"CVE-2006-7152"
],
"2850": [
"CVE-2006-7183"
],
"2851": [
"CVE-2006-6216"
],
"2852": [
"CVE-2006-6203"
],
"2853": [
"CVE-2006-6191"
],
"2859": [],
"2862": [
"CVE-2006-7114"
],
"2863": [
"CVE-2006-7117",
"CVE-2006-7116"
],
"2864": [
"CVE-2006-6417"
],
"2867": [
"CVE-2006-6966"
],
"2869": [
"CVE-2006-6242"
],
"2871": [
"CVE-2006-6577"
],
"2876": [
"CVE-2006-6338"
],
"2877": [
"CVE-2006-6369"
],
"2878": [
"CVE-2006-6277"
],
"2881": [
"CVE-2006-6381",
"CVE-2006-6380"
],
"2882": [],
"2883": [
"CVE-2006-6376"
],
"2884": [
"CVE-2006-6368"
],
"2885": [
"CVE-2006-6295"
],
"2886": [
"CVE-2006-6360"
],
"2888": [
"CVE-2006-6445"
],
"2889": [
"CVE-2006-6390"
],
"2890": [
"CVE-2006-4605"
],
"2891": [
"CVE-2006-6546"
],
"2894": [
"CVE-2006-6550"
],
"2895": [
"CVE-2006-6453"
],
"2896": [
"CVE-2006-6551"
],
"2897": [
"CVE-2006-6544",
"CVE-2006-6462"
],
"2898": [
"CVE-2006-6426"
],
"2899": [],
"2902": [
"CVE-2006-6604",
"CVE-2006-6598"
],
"2903": [
"CVE-2006-6599"
],
"2904": [
"CVE-2006-6566"
],
"2905": [
"CVE-2006-6526"
],
"2906": [
"CVE-2006-6542"
],
"2907": [
"CVE-2006-6543"
],
"2908": [
"CVE-2006-6559"
],
"2909": [
"CVE-2006-6525",
"CVE-2006-6524"
],
"2913": [
"CVE-2006-6613"
],
"2917": [
"CVE-2006-6545"
],
"2919": [
"CVE-2006-6615"
],
"2920": [
"CVE-2006-6611"
],
"2921": [
"CVE-2006-6560"
],
"2923": [
"CVE-2006-6552"
],
"2924": [
"CVE-2006-6568",
"CVE-2006-6567"
],
"2925": [
"CVE-2006-6553"
],
"2927": [
"CVE-2006-6612"
],
"2930": [
"CVE-2006-6575"
],
"2931": [
"CVE-2006-6590"
],
"2937": [],
"2938": [
"CVE-2006-6722"
],
"2939": [
"CVE-2006-6645"
],
"2940": [
"CVE-2006-6650"
],
"2941": [
"CVE-2006-6644"
],
"2943": [
"CVE-2006-6720"
],
"2944": [
"CVE-2006-6666"
],
"2945": [
"CVE-2006-6716"
],
"2948": [
"CVE-2006-6648"
],
"2953": [
"CVE-2006-6661"
],
"2955": [
"CVE-2006-6739"
],
"2956": [
"CVE-2006-6740"
],
"2957": [],
"2958": [
"CVE-2006-6732"
],
"2960": [
"CVE-2006-6738"
],
"2962": [
"CVE-2006-6671"
],
"2963": [
"CVE-2006-6757"
],
"2964": [
"CVE-2006-6691"
],
"2965": [
"CVE-2006-6686"
],
"2968": [
"CVE-2006-1209"
],
"2969": [],
"2970": [
"CVE-2006-6711"
],
"2971": [
"CVE-2006-6710"
],
"2973": [
"CVE-2006-6715"
],
"2975": [
"CVE-2006-6756",
"CVE-2006-6755"
],
"2976": [
"CVE-2006-6726"
],
"2977": [
"CVE-2006-6741"
],
"2979": [
"CVE-2008-1635",
"CVE-2006-6764",
"CVE-2006-6763"
],
"2980": [
"CVE-2003-1314"
],
"2981": [
"CVE-2006-6786",
"CVE-2006-6785"
],
"2982": [
"CVE-2006-6877"
],
"2983": [
"CVE-2006-6830"
],
"2984": [
"CVE-2006-6801"
],
"2986": [
"CVE-2006-3027"
],
"2987": [
"CVE-2006-6204"
],
"2988": [
"CVE-2006-6805"
],
"2989": [
"CVE-2006-6803"
],
"2990": [
"CVE-2006-6806"
],
"2991": [
"CVE-2006-6802"
],
"2992": [
"CVE-2006-6804"
],
"2993": [
"CVE-2006-6792"
],
"2994": [
"CVE-2006-6822"
],
"2995": [
"CVE-2006-6820"
],
"2996": [
"CVE-2006-6821"
],
"2997": [
"CVE-2006-6813"
],
"2998": [
"CVE-2006-6787"
],
"2999": [
"CVE-2006-6790"
],
"3000": [
"CVE-2006-6765"
],
"3001": [
"CVE-2010-4782",
"CVE-2006-6807"
],
"3002": [
"CVE-2006-6781",
"CVE-2006-6780"
],
"3003": [
"CVE-2006-6770"
],
"3004": [
"CVE-2006-6873",
"CVE-2006-6872",
"CVE-2006-6871"
],
"3005": [
"CVE-2006-6796"
],
"3006": [
"CVE-2006-6789"
],
"3007": [
"CVE-2006-6771"
],
"3008": [
"CVE-2006-6774"
],
"3009": [
"CVE-2006-6850"
],
"3010": [
"CVE-2006-6795"
],
"3011": [
"CVE-2006-6773"
],
"3012": [
"CVE-2006-6793"
],
"3014": [
"CVE-2006-6887"
],
"3015": [
"CVE-2006-6349"
],
"3016": [
"CVE-2006-6849"
],
"3017": [
"CVE-2006-6880",
"CVE-2006-6879"
],
"3018": [],
"3019": [
"CVE-2006-6812"
],
"3020": [
"CVE-2006-6879",
"CVE-2006-6878"
],
"3025": [
"CVE-2006-6823"
],
"3026": [
"CVE-2006-6809"
],
"3027": [
"CVE-2006-4671"
],
"3028": [
"CVE-2006-6800"
],
"3029": [],
"3031": [
"CVE-2006-6831"
],
"3032": [
"CVE-2006-6846"
],
"3033": [
"CVE-2006-6842"
],
"3035": [
"CVE-2006-6848"
],
"3036": [
"CVE-2006-6856"
],
"3039": [
"CVE-2006-6866"
],
"3043": [
"CVE-2002-1656"
],
"3044": [
"CVE-2006-6890"
],
"3045": [],
"3046": [
"CVE-2006-6865"
],
"3047": [
"CVE-2006-6889"
],
"3048": [
"CVE-2006-6859"
],
"3049": [
"CVE-2007-0082"
],
"3050": [
"CVE-2006-6864"
],
"3051": [
"CVE-2006-6863"
],
"3053": [
"CVE-2006-6891"
],
"3054": [
"CVE-2006-6888"
],
"3057": [
"CVE-2006-6869"
],
"3059": [
"CVE-2006-6867"
],
"3060": [],
"3061": [
"CVE-2007-0052"
],
"3062": [
"CVE-2007-0053"
],
"3065": [
"CVE-1999-0953"
],
"3066": [
"CVE-2007-0091"
],
"3068": [
"CVE-2007-0049"
],
"3073": [
"CVE-2007-0129"
],
"3074": [
"CVE-2007-0092"
],
"3075": [
"CVE-2007-0098"
],
"3076": [
"CVE-2007-0093"
],
"3079": [
"CVE-2007-0135"
],
"3081": [
"CVE-2007-0128"
],
"3082": [
"CVE-2007-0130"
],
"3083": [
"CVE-2007-0134",
"CVE-2007-0133",
"CVE-2007-0132"
],
"3085": [
"CVE-2007-3558"
],
"3089": [
"CVE-2007-0144",
"CVE-2006-6911"
],
"3090": [
"CVE-2007-0143"
],
"3091": [
"CVE-2007-0173"
],
"3093": [
"CVE-2007-0172"
],
"3095": [
"CVE-2007-0107"
],
"3096": [
"CVE-2007-0171"
],
"3097": [
"CVE-2007-0170"
],
"3100": [
"CVE-2007-0181"
],
"3103": [
"CVE-2007-0205",
"CVE-2007-0202"
],
"3104": [
"CVE-2007-0167"
],
"3105": [
"CVE-2007-0196"
],
"3106": [
"CVE-2007-0226"
],
"3108": [
"CVE-2007-0200"
],
"3109": [
"CVE-2007-0233"
],
"3113": [
"CVE-2007-0232"
],
"3114": [
"CVE-2007-0314"
],
"3115": [
"CVE-2007-0225",
"CVE-2007-0224"
],
"3116": [
"CVE-2007-0261"
],
"3117": [
"CVE-2007-0298"
],
"3118": [
"CVE-2007-0300"
],
"3120": [
"CVE-2007-0304"
],
"3121": [
"CVE-2007-0307"
],
"3122": [
"CVE-2007-0306"
],
"3123": [
"CVE-2007-0301"
],
"3124": [
"CVE-2007-0340"
],
"3125": [
"CVE-2007-0329"
],
"3134": [
"CVE-2007-0337"
],
"3135": [
"CVE-2007-0305"
],
"3141": [
"CVE-2007-0354"
],
"3143": [
"CVE-2007-0388"
],
"3144": [
"CVE-2007-0388"
],
"3145": [
"CVE-2007-0361"
],
"3146": [
"CVE-2007-0388"
],
"3147": [
"CVE-2007-0359"
],
"3150": [
"CVE-2007-0360"
],
"3152": [
"CVE-2007-0395"
],
"3153": [
"CVE-2007-0370",
"CVE-2007-0369"
],
"3161": [
"CVE-2007-0495"
],
"3162": [
"CVE-2007-0500"
],
"3163": [
"CVE-2007-0496"
],
"3164": [
"CVE-2007-0499"
],
"3165": [
"CVE-2007-0498",
"CVE-2007-0491"
],
"3169": [
"CVE-2007-0485"
],
"3171": [
"CVE-2007-0501"
],
"3172": [
"CVE-2007-0502"
],
"3174": [
"CVE-2007-0497"
],
"3175": [
"CVE-2007-0489"
],
"3180": [
"CVE-2007-0535",
"CVE-2007-0504"
],
"3183": [
"CVE-2007-0508"
],
"3184": [
"CVE-2007-0511"
],
"3185": [
"CVE-2007-0559"
],
"3186": [
"CVE-2007-0560"
],
"3187": [
"CVE-2007-0566"
],
"3191": [
"CVE-2007-0558"
],
"3192": [
"CVE-2007-0561"
],
"3194": [
"CVE-2007-0600"
],
"3195": [
"CVE-2007-0554"
],
"3196": [
"CVE-2007-0598"
],
"3197": [
"CVE-2007-0590",
"CVE-2007-0589"
],
"3198": [
"CVE-2007-0591"
],
"3201": [
"CVE-2007-0568"
],
"3202": [
"CVE-2007-0570"
],
"3203": [
"CVE-2007-0620"
],
"3205": [
"CVE-2007-0573"
],
"3206": [
"CVE-2007-0577"
],
"3207": [
"CVE-2007-0572"
],
"3208": [
"CVE-2007-0697"
],
"3209": [
"CVE-2007-0576"
],
"3210": [
"CVE-2007-0582"
],
"3212": [
"CVE-2007-0571"
],
"3214": [
"CVE-2007-0581"
],
"3215": [
"CVE-2007-0580"
],
"3216": [
"CVE-2007-0569"
],
"3217": [
"CVE-2007-0584"
],
"3221": [
"CVE-2007-5845",
"CVE-2007-0639"
],
"3222": [
"CVE-2007-0585"
],
"3225": [
"CVE-2007-0637"
],
"3226": [
"CVE-2007-0638"
],
"3227": [
"CVE-2007-0663",
"CVE-2007-0631"
],
"3228": [
"CVE-2007-0633"
],
"3231": [
"CVE-2007-0656"
],
"3232": [
"CVE-2007-0687"
],
"3233": [
"CVE-2007-0678"
],
"3234": [
"CVE-2007-0676"
],
"3235": [
"CVE-2007-0680"
],
"3236": [
"CVE-2007-0662"
],
"3237": [
"CVE-2007-0677"
],
"3238": [
"CVE-2007-0679"
],
"3239": [
"CVE-2007-0681"
],
"3240": [
"CVE-2007-0682"
],
"3241": [
"CVE-2007-0688"
],
"3242": [
"CVE-2007-0683"
],
"3243": [
"CVE-2007-0684"
],
"3245": [
"CVE-2006-4733"
],
"3246": [
"CVE-2007-0702"
],
"3247": [
"CVE-2007-0701"
],
"3249": [
"CVE-2007-0703"
],
"3250": [
"CVE-2007-0699"
],
"3251": [
"CVE-2007-0757"
],
"3252": [
"CVE-2007-0760"
],
"3253": [
"CVE-2006-3683"
],
"3255": [
"CVE-2007-0764",
"CVE-2007-0763"
],
"3256": [
"CVE-2007-0765"
],
"3258": [
"CVE-2007-0761"
],
"3259": [
"CVE-2007-0762"
],
"3261": [
"CVE-2007-0786"
],
"3262": [
"CVE-2007-0812"
],
"3263": [
"CVE-2006-6517",
"CVE-2006-6516"
],
"3266": [
"CVE-2007-0785"
],
"3267": [
"CVE-2007-0810"
],
"3268": [
"CVE-2007-0797"
],
"3270": [
"CVE-2007-0809"
],
"3271": [
"CVE-2007-0804"
],
"3275": [
"CVE-2007-0824"
],
"3278": [
"CVE-2007-0826"
],
"3280": [
"CVE-2007-0837"
],
"3281": [
"CVE-2007-0839"
],
"3282": [
"CVE-2007-0845"
],
"3283": [
"CVE-2007-0847",
"CVE-2007-0846"
],
"3284": [
"CVE-2007-0848"
],
"3285": [
"CVE-2007-0867"
],
"3286": [
"CVE-2007-0904"
],
"3287": [
"CVE-2007-0865"
],
"3288": [
"CVE-2007-0864"
],
"3292": [
"CVE-2007-0881"
],
"3295": [
"CVE-2007-0920"
],
"3297": [
"CVE-2007-0983"
],
"3298": [
"CVE-2006-3176"
],
"3299": [
"CVE-2007-0985"
],
"3300": [],
"3301": [
"CVE-2007-0984"
],
"3305": [
"CVE-2007-0873"
],
"3309": [
"CVE-2007-0987",
"CVE-2007-0986"
],
"3310": [
"CVE-2007-0971"
],
"3311": [
"CVE-2007-0972"
],
"3312": [],
"3313": [],
"3314": [
"CVE-2007-1010"
],
"3315": [
"CVE-2005-2157"
],
"3317": [
"CVE-2007-1021"
],
"3318": [
"CVE-2007-1016",
"CVE-2007-1015"
],
"3321": [
"CVE-2007-1023"
],
"3322": [
"CVE-2007-1017"
],
"3323": [
"CVE-2007-1025"
],
"3324": [
"CVE-2007-1013"
],
"3325": [
"CVE-2007-1019"
],
"3326": [
"CVE-2007-1031"
],
"3327": [
"CVE-2007-1026"
],
"3328": [
"CVE-2007-1011"
],
"3332": [
"CVE-2007-1040"
],
"3334": [
"CVE-2007-1034"
],
"3336": [
"CVE-2007-1059"
],
"3337": [
"CVE-2007-5125",
"CVE-2007-1171"
],
"3338": [
"CVE-2007-1493",
"CVE-2007-1172"
],
"3339": [
"CVE-2007-1058"
],
"3344": [
"CVE-2007-1061"
],
"3345": [
"CVE-2007-1061"
],
"3346": [
"CVE-2007-1061"
],
"3348": [
"CVE-2007-1060"
],
"3351": [
"CVE-2007-1163"
],
"3352": [
"CVE-2007-1255",
"CVE-2007-1254"
],
"3353": [
"CVE-2007-1164"
],
"3354": [
"CVE-2007-1165"
],
"3355": [
"CVE-2007-1166"
],
"3357": [
"CVE-2007-1167"
],
"3360": [
"CVE-2007-1078"
],
"3361": [
"CVE-2007-1118"
],
"3365": [
"CVE-2007-1133"
],
"3366": [
"CVE-2007-1130"
],
"3367": [
"CVE-2007-1131"
],
"3370": [
"CVE-2007-1105"
],
"3371": [
"CVE-2007-1107"
],
"3372": [
"CVE-2007-1108"
],
"3373": [
"CVE-2007-1106"
],
"3374": [
"CVE-2007-1104"
],
"3379": [
"CVE-2007-1233"
],
"3382": [
"CVE-2007-1219"
],
"3387": [
"CVE-2007-1292"
],
"3390": [
"CVE-2007-1250"
],
"3393": [
"CVE-2006-6912"
],
"39567": [],
"3398": [
"CVE-2007-1299"
],
"3400": [],
"3402": [],
"3403": [
"CVE-2007-1293"
],
"3406": [
"CVE-2007-1340"
],
"3408": [
"CVE-2007-1298"
],
"3409": [
"CVE-2007-1297"
],
"3410": [
"CVE-2007-1296"
],
"3411": [
"CVE-2007-1295"
],
"3412": [
"CVE-2007-1303"
],
"3416": [
"CVE-2007-1339"
],
"3423": [
"CVE-2007-1372"
],
"3428": [
"CVE-2007-1394"
],
"3435": [
"CVE-2007-1392"
],
"3436": [
"CVE-2007-1391"
],
"3437": [
"CVE-2007-1410"
],
"3438": [
"CVE-2007-1393"
],
"3443": [
"CVE-2007-1415"
],
"3447": [
"CVE-2007-1434",
"CVE-2007-1433",
"CVE-2007-1432"
],
"3448": [
"CVE-2007-1423"
],
"3449": [
"CVE-2007-1417"
],
"3450": [
"CVE-2007-1493"
],
"3454": [
"CVE-2006-0164"
],
"3455": [
"CVE-2007-1428"
],
"3456": [
"CVE-2005-3952"
],
"3457": [
"CVE-2007-1425"
],
"3458": [
"CVE-2007-1427"
],
"3459": [
"CVE-2007-1455"
],
"3465": [
"CVE-2007-1446"
],
"3466": [
"CVE-2007-1445"
],
"3467": [
"CVE-2006-5612"
],
"3468": [
"CVE-2007-1439"
],
"3469": [
"CVE-2007-1570",
"CVE-2007-1438"
],
"3470": [
"CVE-2007-1572",
"CVE-2007-1440"
],
"3471": [
"CVE-2007-1571"
],
"3472": [
"CVE-2007-1458"
],
"3473": [
"CVE-2007-1459"
],
"3476": [
"CVE-2007-1524"
],
"3477": [
"CVE-2007-1517"
],
"3478": [
"CVE-2007-1525"
],
"3481": [
"CVE-2007-1471"
],
"3483": [
"CVE-2007-1518"
],
"3484": [
"CVE-2007-1487"
],
"3485": [
"CVE-2007-1513"
],
"3486": [
"CVE-2007-1472"
],
"3487": [
"CVE-2007-1516"
],
"3489": [
"CVE-2007-1480",
"CVE-2007-1479"
],
"3490": [
"CVE-2007-1482",
"CVE-2007-1481"
],
"3492": [
"CVE-2007-1483"
],
"3493": [
"CVE-2007-1469"
],
"3494": [
"CVE-2007-1478"
],
"3496": [
"CVE-2006-7172"
],
"3497": [
"CVE-2006-7172"
],
"3498": [
"CVE-2007-1556"
],
"3500": [
"CVE-2007-1510"
],
"3501": [
"CVE-2007-1620"
],
"3502": [
"CVE-2006-7173"
],
"3503": [
"CVE-2007-1613"
],
"3504": [
"CVE-2007-1621"
],
"3505": [
"CVE-2007-1635",
"CVE-2007-1634"
],
"3506": [
"CVE-2007-1553"
],
"3507": [
"CVE-2007-1618"
],
"3508": [
"CVE-2007-1647"
],
"3509": [
"CVE-2007-1615"
],
"3510": [
"CVE-2007-1617"
],
"3511": [
"CVE-2007-1619"
],
"3512": [
"CVE-2007-1626"
],
"3513": [
"CVE-2007-1612"
],
"3515": [
"CVE-2007-1616"
],
"3516": [
"CVE-2007-1552"
],
"3518": [
"CVE-2007-1633"
],
"3519": [
"CVE-2007-1555"
],
"3520": [
"CVE-2007-1566",
"CVE-2006-5954"
],
"3521": [
"CVE-2007-1539"
],
"3522": [
"CVE-2007-1577"
],
"3524": [
"CVE-2006-0308"
],
"3528": [
"CVE-2006-3317"
],
"3530": [
"CVE-2006-1781"
],
"3532": [
"CVE-2007-1628"
],
"3533": [
"CVE-2007-1600"
],
"3534": [
"CVE-2007-1630"
],
"3536": [
"CVE-2007-1629"
],
"3538": [
"CVE-2006-4606"
],
"3539": [
"CVE-2007-1596"
],
"3542": [
"CVE-2007-1640"
],
"3543": [
"CVE-2007-1641"
],
"3545": [
"CVE-2007-1643"
],
"3546": [
"CVE-2004-1552"
],
"3548": [
"CVE-2007-1636"
],
"3549": [
"CVE-2007-1705"
],
"3550": [
"CVE-2005-2062"
],
"3551": [
"CVE-2007-1712"
],
"3552": [
"CVE-2007-1698",
"CVE-2007-1697"
],
"3556": [
"CVE-2007-1696"
],
"3557": [
"CVE-2007-1699"
],
"3558": [
"CVE-2010-2359",
"CVE-2007-1706"
],
"3560": [
"CVE-2006-5043"
],
"3562": [
"CVE-2007-1707"
],
"3563": [
"CVE-2007-1708"
],
"3564": [
"CVE-2007-1704"
],
"3565": [
"CVE-2007-1703"
],
"3567": [
"CVE-2007-1702"
],
"3568": [
"CVE-2007-1715"
],
"3569": [],
"3574": [],
"3580": [
"CVE-2007-1725"
],
"3581": [
"CVE-2007-1726",
"CVE-2007-1725"
],
"3582": [
"CVE-2007-1720"
],
"3583": [
"CVE-2007-1721"
],
"3588": [
"CVE-2007-3311"
],
"3590": [
"CVE-2007-1776"
],
"3591": [
"CVE-2007-1778"
],
"3592": [
"CVE-2007-1771"
],
"3594": [
"CVE-2007-3311"
],
"3596": [
"CVE-2005-2246"
],
"3597": [
"CVE-2007-1838"
],
"3598": [
"CVE-2007-1837"
],
"3599": [
"CVE-2007-1839"
],
"3600": [
"CVE-2007-1787"
],
"3601": [
"CVE-2007-1801"
],
"3603": [],
"3605": [
"CVE-2007-1791"
],
"3607": [
"CVE-2007-1790"
],
"3608": [
"CVE-2007-1766"
],
"3611": [
"CVE-2007-1795"
],
"3612": [
"CVE-2007-1847"
],
"3613": [
"CVE-2007-1818"
],
"3614": [
"CVE-2007-1842"
],
"3618": [
"CVE-2007-1817"
],
"3619": [
"CVE-2007-1815"
],
"3620": [
"CVE-2007-1814"
],
"3621": [
"CVE-2007-1816"
],
"3622": [
"CVE-2005-3811"
],
"3623": [
"CVE-2007-1813"
],
"3624": [
"CVE-2007-1812"
],
"3625": [
"CVE-2007-1811"
],
"3626": [
"CVE-2007-1810"
],
"3628": [
"CVE-2007-1809"
],
"3629": [
"CVE-2007-1808"
],
"3630": [
"CVE-2007-1805"
],
"3631": [
"CVE-2005-1237"
],
"3632": [
"CVE-2007-1807"
],
"3633": [
"CVE-2007-1806"
],
"3638": [
"CVE-2007-1843"
],
"3639": [
"CVE-2007-1980"
],
"3640": [
"CVE-2007-1978"
],
"3641": [
"CVE-2007-1982",
"CVE-2007-1851"
],
"3644": [
"CVE-2007-1974",
"CVE-2005-0725"
],
"3645": [
"CVE-2007-1974",
"CVE-2005-0725"
],
"3646": [
"CVE-2007-1974",
"CVE-2005-0725"
],
"3653": [
"CVE-2007-1963"
],
"3655": [
"CVE-2007-1979"
],
"3656": [
"CVE-2007-1897"
],
"3657": [
"CVE-2007-1896",
"CVE-2007-1895"
],
"3658": [
"CVE-2002-1887"
],
"3659": [
"CVE-2007-1986"
],
"3660": [
"CVE-2007-1983"
],
"3663": [
"CVE-2007-1962"
],
"3665": [
"CVE-2007-1961"
],
"3666": [
"CVE-2007-1960"
],
"3667": [
"CVE-2007-2347"
],
"3668": [
"CVE-2007-2345"
],
"3669": [
"CVE-2007-2346"
],
"3670": [
"CVE-2007-2373"
],
"3671": [
"CVE-2007-2372",
"CVE-2007-2371"
],
"3672": [
"CVE-2007-2370"
],
"3673": [
"CVE-2007-2369",
"CVE-2007-2368"
],
"3676": [
"CVE-2007-1929"
],
"3677": [
"CVE-2007-1930"
],
"3678": [
"CVE-2007-1920"
],
"3679": [
"CVE-2007-1931"
],
"3681": [
"CVE-2007-1937"
],
"3683": [
"CVE-2007-1934"
],
"3685": [
"CVE-2007-1968"
],
"3686": [
"CVE-2007-1928"
],
"3687": [
"CVE-2007-1932"
],
"3689": [
"CVE-2007-1933"
],
"3691": [
"CVE-2007-1909"
],
"3694": [
"CVE-2007-1908"
],
"3696": [
"CVE-2007-1907"
],
"3697": [
"CVE-2007-1998"
],
"3699": [
"CVE-2007-2019"
],
"3700": [
"CVE-2007-1999"
],
"3701": [
"CVE-2007-2001",
"CVE-2007-2000"
],
"3702": [
"CVE-2007-2004",
"CVE-2007-2003",
"CVE-2007-2002",
"CVE-2006-0658",
"CVE-2005-0613"
],
"3703": [
"CVE-2007-2005"
],
"3704": [
"CVE-2007-2008",
"CVE-2007-2007",
"CVE-2007-2006"
],
"3705": [
"CVE-2007-2009"
],
"3706": [
"CVE-2007-1992"
],
"3707": [
"CVE-2007-2317"
],
"3710": [],
"3711": [
"CVE-2007-1996"
],
"3712": [
"CVE-2007-2044"
],
"3713": [
"CVE-2007-2049"
],
"3714": [
"CVE-2007-2043"
],
"3716": [
"CVE-2007-2313"
],
"3717": [
"CVE-2007-2307"
],
"3718": [
"CVE-2007-2050"
],
"3719": [],
"3721": [],
"3722": [
"CVE-2007-2302"
],
"3723": [
"CVE-2007-2015"
],
"3725": [
"CVE-2007-2149",
"CVE-2007-2148",
"CVE-2007-2147"
],
"3729": [
"CVE-2007-2305",
"CVE-2007-2304"
],
"3731": [
"CVE-2007-2299"
],
"3732": [
"CVE-2007-2298"
],
"3733": [
"CVE-2007-2458",
"CVE-2007-2457"
],
"3734": [
"CVE-2007-2319"
],
"3735": [
"CVE-2007-2093",
"CVE-2007-2092"
],
"3736": [
"CVE-2007-2089"
],
"3739": [
"CVE-2007-2320"
],
"3741": [
"CVE-2007-2087",
"CVE-2007-2086"
],
"3742": [
"CVE-2007-2303"
],
"3743": [],
"3744": [
"CVE-2007-2301"
],
"3745": [
"CVE-2007-2067"
],
"3747": [
"CVE-2007-2069"
],
"3748": [
"CVE-2007-2070"
],
"3749": [
"CVE-2007-2068"
],
"3750": [
"CVE-2007-2091"
],
"3751": [
"CVE-2007-2094"
],
"3752": [
"CVE-2007-2142"
],
"3753": [
"CVE-2007-2144"
],
"3754": [
"CVE-2007-2146",
"CVE-2007-2145"
],
"3756": [
"CVE-2007-2154"
],
"3758": [
"CVE-2007-2141"
],
"3759": [
"CVE-2007-2143"
],
"3760": [
"CVE-2007-2158"
],
"3761": [
"CVE-2007-2169"
],
"3762": [
"CVE-2007-2168",
"CVE-2007-2167"
],
"3763": [
"CVE-2007-2156"
],
"3764": [
"CVE-2007-2157"
],
"3765": [
"CVE-2007-2166"
],
"3766": [
"CVE-2007-2189"
],
"3767": [
"CVE-2007-2342"
],
"3771": [
"CVE-2007-2185"
],
"3773": [
"CVE-2007-2184"
],
"3774": [
"CVE-2007-2183"
],
"3775": [
"CVE-2007-2182"
],
"3778": [
"CVE-2007-2181"
],
"3780": [
"CVE-2007-2212",
"CVE-2007-2211"
],
"3781": [
"CVE-2007-2199"
],
"3783": [
"CVE-2007-2200"
],
"3785": [
"CVE-2007-2201"
],
"3786": [
"CVE-2007-2204"
],
"3794": [
"CVE-2007-2271"
],
"3795": [
"CVE-2007-2272"
],
"3796": [
"CVE-2007-2273"
],
"3799": [
"CVE-2007-2324"
],
"3800": [
"CVE-2007-2285"
],
"3802": [
"CVE-2007-2341"
],
"3803": [
"CVE-2007-2340"
],
"3805": [
"CVE-2007-2456"
],
"3806": [
"CVE-2007-2259"
],
"3809": [
"CVE-2007-2364"
],
"3813": [
"CVE-2007-2427"
],
"3814": [
"CVE-2007-2426"
],
"3816": [
"CVE-2007-2431",
"CVE-2007-2430"
],
"3817": [
"CVE-2007-2425"
],
"3818": [
"CVE-2007-2424"
],
"3820": [],
"3824": [
"CVE-2007-2484",
"CVE-2007-2483"
],
"3825": [
"CVE-2007-2482",
"CVE-2007-2481"
],
"3827": [
"CVE-2007-2471"
],
"3828": [
"CVE-2007-2485"
],
"3831": [
"CVE-2007-2486"
],
"3832": [
"CVE-2007-2507"
],
"3833": [
"CVE-2007-2493"
],
"3834": [],
"3835": [
"CVE-2007-2492"
],
"3837": [
"CVE-2007-2677"
],
"3838": [
"CVE-2007-2676"
],
"3839": [
"CVE-2007-2672"
],
"3840": [
"CVE-2007-2675"
],
"3841": [
"CVE-2006-2763"
],
"3842": [
"CVE-2007-2674"
],
"3843": [
"CVE-2007-2673"
],
"3846": [
"CVE-2007-2521"
],
"3847": [
"CVE-2007-2541"
],
"3848": [
"CVE-2007-2542"
],
"3849": [
"CVE-2007-2543"
],
"3850": [
"CVE-2007-2539",
"CVE-2007-2538"
],
"3852": [
"CVE-2007-2540"
],
"3853": [
"CVE-2007-2545"
],
"3854": [
"CVE-2007-2544"
],
"3855": [
"CVE-2007-2537"
],
"3857": [
"CVE-2007-2575"
],
"3858": [
"CVE-2007-2556"
],
"3859": [
"CVE-2007-2574"
],
"3860": [
"CVE-2007-2573"
],
"3861": [
"CVE-2007-2572"
],
"3862": [
"CVE-2007-2571"
],
"3863": [
"CVE-2007-2570"
],
"3864": [
"CVE-2007-2569"
],
"3865": [
"CVE-2007-2530"
],
"3867": [
"CVE-2007-2560"
],
"3868": [
"CVE-2007-2527"
],
"3869": [
"CVE-2007-2531"
],
"3870": [
"CVE-2007-2607"
],
"3874": [
"CVE-2007-2611"
],
"3875": [
"CVE-2007-2615"
],
"3876": [
"CVE-2007-2609"
],
"3878": [
"CVE-2007-2608"
],
"3879": [
"CVE-2007-2594"
],
"3884": [
"CVE-2007-2634",
"CVE-2007-2596"
],
"3885": [
"CVE-2007-2597"
],
"3886": [
"CVE-2007-2598"
],
"3887": [
"CVE-2007-2600",
"CVE-2007-2599"
],
"3894": [
"CVE-2007-2620"
],
"3895": [
"CVE-2007-2621"
],
"3896": [
"CVE-2007-2622"
],
"3900": [
"CVE-2007-2715"
],
"3901": [
"CVE-2007-2643"
],
"3902": [
"CVE-2007-2642"
],
"3903": [
"CVE-2007-2647"
],
"3905": [
"CVE-2007-2641"
],
"3906": [
"CVE-2007-2665",
"CVE-2005-2412"
],
"3907": [
"CVE-2007-2717"
],
"3908": [
"CVE-2007-2664"
],
"3909": [
"CVE-2007-2663"
],
"3911": [
"CVE-2007-2662"
],
"3914": [
"CVE-2007-2661"
],
"3915": [
"CVE-2007-2660",
"CVE-2007-2199"
],
"3918": [
"CVE-2007-2659"
],
"3919": [
"CVE-2007-2710",
"CVE-2007-2709"
],
"3920": [
"CVE-2007-2708"
],
"3923": [
"CVE-2007-2707"
],
"3924": [
"CVE-2007-2706"
],
"3928": [
"CVE-2007-2736"
],
"3931": [
"CVE-2007-2735"
],
"3932": [
"CVE-2007-2738"
],
"3933": [
"CVE-2007-2737"
],
"3935": [
"CVE-2007-2743"
],
"3936": [
"CVE-2007-2753",
"CVE-2007-2752"
],
"3941": [
"CVE-2007-2751"
],
"3942": [
"CVE-2007-2750"
],
"3943": [
"CVE-2007-2749"
],
"3944": [
"CVE-2007-2792"
],
"3946": [
"CVE-2007-2793"
],
"3947": [
"CVE-2007-2762"
],
"3948": [
"CVE-2007-2779"
],
"3949": [
"CVE-2007-2778"
],
"3953": [
"CVE-2007-2774"
],
"3955": [
"CVE-2007-2773"
],
"3956": [
"CVE-2007-2824"
],
"3957": [
"CVE-2007-2775"
],
"3958": [
"CVE-2007-2776"
],
"3959": [
"CVE-2007-2777"
],
"3960": [
"CVE-2007-2821"
],
"3962": [
"CVE-2008-6409",
"CVE-2007-6518",
"CVE-2007-2817",
"CVE-2007-2816"
],
"3963": [
"CVE-2007-2822"
],
"3964": [
"CVE-2008-6409",
"CVE-2007-2817",
"CVE-2007-2816"
],
"3970": [
"CVE-2007-2854"
],
"3971": [
"CVE-2007-2899"
],
"3972": [
"CVE-2007-2900"
],
"3974": [
"CVE-2007-2902",
"CVE-2007-2901"
],
"3980": [
"CVE-2007-2889"
],
"3981": [
"CVE-2007-2890"
],
"3983": [
"CVE-2007-2891"
],
"3987": [
"CVE-2007-2943"
],
"3988": [
"CVE-2007-2971"
],
"3989": [
"CVE-2007-2942"
],
"3990": [
"CVE-2007-2941"
],
"3991": [
"CVE-2007-2947"
],
"3992": [
"CVE-2007-2940"
],
"3994": [
"CVE-2007-2939"
],
"3995": [
"CVE-2007-2937"
],
"3997": [
"CVE-2007-2936"
],
"3998": [
"CVE-2007-2935"
],
"3999": [
"CVE-2007-2934"
],
"4000": [
"CVE-2007-2969"
],
"4003": [
"CVE-2007-2933"
],
"4004": [
"CVE-2007-2988"
],
"4005": [
"CVE-2007-2986"
],
"4006": [
"CVE-2007-2985"
],
"4007": [
"CVE-2007-2803"
],
"4019": [
"CVE-2007-3065"
],
"4020": [
"CVE-2007-3051"
],
"4022": [
"CVE-2007-3057"
],
"4025": [
"CVE-2007-3139",
"CVE-2007-3138"
],
"4026": [
"CVE-2007-3052"
],
"4029": [
"CVE-2007-3082"
],
"4030": [
"CVE-2007-3077"
],
"4031": [
"CVE-2007-2826"
],
"4034": [
"CVE-2007-3118"
],
"4035": [
"CVE-2007-3088"
],
"4036": [
"CVE-2007-3096"
],
"4037": [
"CVE-2007-3088"
],
"4039": [
"CVE-2007-3140"
],
"4040": [
"CVE-2007-3119"
],
"4041": [
"CVE-2007-3136"
],
"4054": [
"CVE-2007-3251",
"CVE-2007-3214"
],
"4055": [
"CVE-2007-3160"
],
"4057": [
"CVE-2007-3188"
],
"4059": [
"CVE-2007-3199"
],
"4062": [
"CVE-2007-3235",
"CVE-2007-3234"
],
"4063": [
"CVE-2007-3237"
],
"4064": [
"CVE-2007-3236"
],
"4068": [
"CVE-2007-3222"
],
"4069": [
"CVE-2007-3221"
],
"4070": [
"CVE-2007-3220"
],
"4071": [
"CVE-2007-3228"
],
"4072": [
"CVE-2007-3230"
],
"4074": [
"CVE-2007-3270"
],
"4075": [
"CVE-2007-3315",
"CVE-2007-3271"
],
"4076": [
"CVE-2007-3272"
],
"4078": [
"CVE-2007-3307"
],
"4079": [
"CVE-2007-3306"
],
"4081": [
"CVE-2007-3313",
"CVE-2007-3312"
],
"4082": [
"CVE-2007-3293",
"CVE-2007-3292",
"CVE-2007-3291",
"CVE-2007-3290"
],
"4083": [
"CVE-2007-3133"
],
"4084": [
"CVE-2007-3289"
],
"4085": [
"CVE-2007-3297"
],
"4086": [
"CVE-2007-3325"
],
"4089": [
"CVE-2007-3358"
],
"4090": [
"CVE-2007-3371"
],
"4091": [
"CVE-2007-3370"
],
"4092": [
"CVE-2005-3978"
],
"4095": [
"CVE-2007-3434",
"CVE-2007-3433"
],
"4096": [
"CVE-2007-3542",
"CVE-2007-3432"
],
"4097": [
"CVE-2007-3431"
],
"4098": [
"CVE-2007-3430"
],
"4099": [
"CVE-2007-3429"
],
"4100": [
"CVE-2007-3427",
"CVE-2007-3426",
"CVE-2007-3425"
],
"4102": [
"CVE-2007-3401"
],
"4103": [
"CVE-2007-3448",
"CVE-2007-3447",
"CVE-2007-3446"
],
"4104": [
"CVE-2007-3451",
"CVE-2007-3450",
"CVE-2007-3449"
],
"4105": [
"CVE-2007-3404"
],
"4106": [
"CVE-2007-3403"
],
"4107": [
"CVE-2007-3402"
],
"4108": [
"CVE-2007-3452"
],
"4111": [
"CVE-2007-2199"
],
"4112": [
"CVE-2007-3460"
],
"4113": [],
"4114": [
"CVE-2007-3461"
],
"4115": [
"CVE-2007-3505"
],
"4116": [
"CVE-2007-3547"
],
"4122": [
"CVE-2007-3590",
"CVE-2007-3589"
],
"4124": [
"CVE-2007-3535"
],
"4125": [
"CVE-2007-3534"
],
"4127": [
"CVE-2007-3549"
],
"4128": [
"CVE-2007-3526"
],
"4129": [
"CVE-2007-3524"
],
"4130": [
"CVE-2007-3515"
],
"4131": [
"CVE-2007-3523"
],
"4132": [
"CVE-2007-3522"
],
"4133": [
"CVE-2007-3521"
],
"4134": [
"CVE-2007-3520"
],
"4135": [
"CVE-2007-3519"
],
"4136": [
"CVE-2007-3518"
],
"4138": [
"CVE-2007-3563"
],
"4139": [
"CVE-2007-3562",
"CVE-2007-3530",
"CVE-2007-3529"
],
"4140": [
"CVE-2006-3142"
],
"4141": [
"CVE-2007-3582"
],
"4142": [
"CVE-2007-3583"
],
"4144": [
"CVE-2007-3586",
"CVE-2007-3585"
],
"4145": [
"CVE-2007-3587"
],
"4147": [
"CVE-2007-3584"
],
"4150": [
"CVE-2007-3611"
],
"4151": [
"CVE-2007-3621"
],
"4153": [
"CVE-2007-3610"
],
"4154": [
"CVE-2007-3609"
],
"4156": [
"CVE-2007-3632"
],
"4159": [
"CVE-2007-3631"
],
"4161": [
"CVE-2007-3646"
],
"4163": [
"CVE-2007-3630"
],
"4164": [
"CVE-2007-3683"
],
"4166": [
"CVE-2007-3687"
],
"4167": [
"CVE-2007-3682"
],
"4169": [
"CVE-2007-3697"
],
"4171": [
"CVE-2007-3702"
],
"4173": [
"CVE-2005-1924"
],
"4174": [
"CVE-2007-3772"
],
"4179": [
"CVE-2007-3814"
],
"4180": [
"CVE-2007-3813"
],
"4182": [
"CVE-2007-3812"
],
"4183": [
"CVE-2007-3811"
],
"4184": [
"CVE-2007-3810"
],
"4185": [
"CVE-2007-3809"
],
"4186": [
"CVE-2007-3808"
],
"4187": [
"CVE-2007-3840"
],
"4189": [
"CVE-2007-3882"
],
"4191": [
"CVE-2007-3881"
],
"4192": [
"CVE-2007-3939"
],
"4193": [
"CVE-2007-3933"
],
"4194": [
"CVE-2007-3932"
],
"4195": [
"CVE-2007-3934"
],
"4197": [
"CVE-2007-3935"
],
"4198": [
"CVE-2007-3937",
"CVE-2007-3936"
],
"4199": [
"CVE-2007-3938"
],
"4201": [
"CVE-2007-4046"
],
"4206": [
"CVE-2007-3979"
],
"4209": [
"CVE-2007-3981"
],
"4210": [
"CVE-2007-3980"
],
"4211": [
"CVE-2007-4919",
"CVE-2007-3974",
"CVE-2007-3973"
],
"4212": [],
"4213": [
"CVE-2007-3978",
"CVE-2007-3977",
"CVE-2007-3976"
],
"4219": [
"CVE-2007-4009"
],
"4220": [
"CVE-2007-4008"
],
"4221": [
"CVE-2007-4007"
],
"4224": [
"CVE-2007-4068"
],
"4225": [
"CVE-2007-4069"
],
"40466": [],
"4235": [
"CVE-2007-4057"
],
"4238": [
"CVE-2007-4056"
],
"4239": [
"CVE-2007-4055"
],
"4241": [
"CVE-2007-4054"
],
"4242": [
"CVE-2007-4053"
],
"4246": [
"CVE-2007-4156"
],
"4248": [
"CVE-2007-4128"
],
"4253": [
"CVE-2007-4183"
],
"4254": [
"CVE-2007-4171"
],
"4256": [
"CVE-2007-4253"
],
"4258": [
"CVE-2007-4210"
],
"4261": [
"CVE-2007-4256"
],
"4264": [
"CVE-2006-2046"
],
"4265": [
"CVE-2007-4258"
],
"4267": [
"CVE-2007-4231"
],
"4268": [
"CVE-2007-4232"
],
"4269": [
"CVE-2007-4279"
],
"4271": [
"CVE-2007-4287"
],
"4273": [
"CVE-2007-4320"
],
"4275": [
"CVE-2007-4312"
],
"4276": [
"CVE-2007-4313"
],
"4277": [
"CVE-2006-4962"
],
"4278": [
"CVE-2007-4314"
],
"4282": [
"CVE-2007-4369"
],
"4284": [
"CVE-2007-4362"
],
"4286": [
"CVE-2007-4368"
],
"4291": [
"CVE-2007-4386"
],
"4295": [
"CVE-2007-4439"
],
"4296": [
"CVE-2007-4456"
],
"4300": [
"CVE-2005-1032"
],
"4305": [
"CVE-2007-4506"
],
"4306": [
"CVE-2007-4505"
],
"4307": [
"CVE-2007-4504"
],
"4308": [
"CVE-2007-4503"
],
"4309": [
"CVE-2007-4509"
],
"4310": [
"CVE-2007-4502"
],
"4313": [
"CVE-2007-4597"
],
"4317": [
"CVE-2007-4585"
],
"4320": [],
"4326": [
"CVE-2007-4551",
"CVE-2007-4552"
],
"4327": [
"CVE-2007-4581"
],
"4329": [
"CVE-2007-4602"
],
"4330": [
"CVE-2007-4603"
],
"4331": [
"CVE-2007-4604"
],
"4332": [
"CVE-2007-4605"
],
"4333": [
"CVE-2007-4606"
],
"4336": [
"CVE-2007-4637"
],
"4338": [
"CVE-2007-4627"
],
"4339": [
"CVE-2007-4628"
],
"4340": [
"CVE-2007-4636"
],
"4341": [
"CVE-2007-4641",
"CVE-2007-4640"
],
"4342": [
"CVE-2007-4645"
],
"4343": [
"CVE-2007-4647"
],
"4346": [
"CVE-2007-4653"
],
"4349": [
"CVE-2007-4736"
],
"4350": [
"CVE-2007-4781"
],
"4352": [
"CVE-2007-4715"
],
"4353": [
"CVE-2007-4714"
],
"4356": [
"CVE-2007-4712"
],
"4358": [
"CVE-2007-4738",
"CVE-2007-4737"
],
"4363": [
"CVE-2007-4763"
],
"4365": [
"CVE-2007-4744"
],
"4368": [
"CVE-2007-4757"
],
"4370": [
"CVE-2007-4846"
],
"4371": [
"CVE-2007-4845"
],
"4374": [
"CVE-2007-4809"
],
"4376": [
"CVE-2007-4808"
],
"4377": [
"CVE-2007-4942",
"CVE-2007-4807",
"CVE-2007-4806"
],
"4378": [
"CVE-2007-4805"
],
"4380": [
"CVE-2007-4820"
],
"4381": [
"CVE-2007-4819",
"CVE-2007-4818"
],
"4382": [
"CVE-2007-4524"
],
"4383": [
"CVE-2007-4817"
],
"4384": [
"CVE-2007-4815"
],
"4385": [
"CVE-2007-4804"
],
"4386": [
"CVE-2007-4895"
],
"4387": [
"CVE-2007-4834"
],
"4390": [
"CVE-2007-4908",
"CVE-2007-4905",
"CVE-2007-4886"
],
"4395": [
"CVE-2007-4906"
],
"4396": [
"CVE-2007-4907"
],
"4397": [],
"4400": [
"CVE-2007-4922"
],
"4401": [
"CVE-2007-4923"
],
"4404": [
"CVE-2007-4966",
"CVE-2007-3913"
],
"4405": [
"CVE-2007-4921"
],
"4406": [
"CVE-2007-4934"
],
"4407": [
"CVE-2007-4920"
],
"4408": [
"CVE-2007-4919",
"CVE-2007-3974",
"CVE-2007-3973"
],
"4410": [
"CVE-2007-4918"
],
"4411": [
"CVE-2007-4957"
],
"4412": [
"CVE-2007-4956"
],
"4413": [
"CVE-2007-4956"
],
"4414": [
"CVE-2007-4956"
],
"4415": [
"CVE-2007-4955"
],
"4416": [
"CVE-2007-4954"
],
"4417": [
"CVE-2007-4953"
],
"4418": [
"CVE-2007-4952"
],
"4419": [
"CVE-2007-4933",
"CVE-2007-4932"
],
"4421": [
"CVE-2007-4978"
],
"4422": [
"CVE-2007-4979"
],
"4423": [],
"4425": [
"CVE-2007-4984"
],
"4430": [
"CVE-2007-5015"
],
"4433": [
"CVE-2007-5016"
],
"4434": [
"CVE-2007-5009"
],
"4435": [
"CVE-2007-5062"
],
"4436": [
"CVE-2007-5063"
],
"4439": [
"CVE-2007-5050"
],
"4440": [
"CVE-2007-5065"
],
"4441": [
"CVE-2007-5055",
"CVE-2007-5054",
"CVE-2007-5053",
"CVE-2005-4600"
],
"4442": [
"CVE-2007-5056"
],
"4443": [
"CVE-2007-5061"
],
"4444": [],
"4446": [
"CVE-2007-5102"
],
"4447": [
"CVE-2007-5069"
],
"4448": [
"CVE-2007-5099"
],
"4449": [
"CVE-2007-5068"
],
"4451": [
"CVE-2007-5098"
],
"4454": [
"CVE-2007-5089"
],
"4456": [
"CVE-2007-5117"
],
"4457": [
"CVE-2007-5122"
],
"4458": [
"CVE-2007-5123"
],
"4459": [
"CVE-2007-5131"
],
"4461": [
"CVE-2007-5138"
],
"4462": [
"CVE-2007-5139"
],
"4463": [
"CVE-2007-5140"
],
"4464": [
"CVE-2007-5157"
],
"4465": [
"CVE-2007-5149"
],
"4466": [
"CVE-2007-5278",
"CVE-2007-5231",
"CVE-2007-5230"
],
"4467": [
"CVE-2007-5222"
],
"4469": [
"CVE-2007-5177"
],
"4470": [
"CVE-2007-5178"
],
"4471": [
"CVE-2007-5173"
],
"4472": [
"CVE-2007-5174"
],
"4473": [
"CVE-2007-5175"
],
"4475": [
"CVE-2007-5187"
],
"4476": [
"CVE-2007-5186"
],
"4477": [
"CVE-2007-5185"
],
"4480": [
"CVE-2007-5261"
],
"4481": [
"CVE-2007-5221"
],
"4482": [
"CVE-2007-5233"
],
"4483": [
"CVE-2007-5234"
],
"4485": [
"CVE-2007-5271"
],
"4486": [
"CVE-2007-5272"
],
"4489": [
"CVE-2007-5363"
],
"4490": [
"CVE-2007-5307",
"CVE-2007-5306",
"CVE-2007-5305",
"CVE-2007-5304"
],
"4491": [
"CVE-2007-5298"
],
"4492": [
"CVE-2007-5313"
],
"4493": [
"CVE-2007-5299"
],
"4494": [
"CVE-2007-5321"
],
"4495": [
"CVE-2007-5294",
"CVE-2007-5293"
],
"4496": [
"CVE-2007-5309"
],
"4497": [
"CVE-2007-5310"
],
"4499": [
"CVE-2007-5362"
],
"4500": [
"CVE-2007-5312",
"CVE-2007-5311"
],
"4501": [
"CVE-2007-5308"
],
"4502": [
"CVE-2007-5314"
],
"4503": [
"CVE-2007-5315"
],
"4504": [
"CVE-2007-5316"
],
"4505": [
"CVE-2007-5374"
],
"4507": [
"CVE-2007-5412"
],
"4508": [
"CVE-2007-5407"
],
"4509": [
"CVE-2007-5423"
],
"4510": [
"CVE-2007-5416"
],
"4511": [
"CVE-2007-5408"
],
"4512": [
"CVE-2007-5409"
],
"4513": [
"CVE-2007-5453",
"CVE-2007-5452"
],
"4518": [
"CVE-2007-5388"
],
"4519": [
"CVE-2007-5387"
],
"4520": [
"CVE-2007-5390"
],
"4521": [
"CVE-2007-5457"
],
"4523": [
"CVE-2007-5458"
],
"4524": [
"CVE-2007-5451"
],
"4525": [],
"4527": [
"CVE-2007-5449"
],
"4528": [
"CVE-2007-5485"
],
"4529": [
"CVE-2007-5484",
"CVE-2007-5455"
],
"4536": [
"CVE-2007-5465"
],
"4538": [
"CVE-2007-5600",
"CVE-2007-5489"
],
"4539": [
"CVE-2007-5490"
],
"4543": [
"CVE-2007-5574"
],
"4544": [
"CVE-2007-5573"
],
"4545": [
"CVE-2007-5592"
],
"4546": [
"CVE-2007-5620"
],
"4547": [
"CVE-2007-5646"
],
"4548": [
"CVE-2007-5644",
"CVE-2007-5643"
],
"4549": [
"CVE-2007-5642",
"CVE-2007-5641"
],
"4550": [
"CVE-2007-5630"
],
"4551": [
"CVE-2007-5631"
],
"4554": [
"CVE-2007-5627"
],
"4555": [
"CVE-2007-5628"
],
"4557": [],
"4558": [
"CVE-2007-5674"
],
"4561": [
"CVE-2007-5774",
"CVE-2007-5773"
],
"4562": [
"CVE-2007-5772",
"CVE-2007-5771"
],
"4563": [
"CVE-2007-5676"
],
"4565": [
"CVE-2007-5697"
],
"4568": [
"CVE-2007-5684"
],
"4575": [
"CVE-2007-5786"
],
"4576": [
"CVE-2007-5785"
],
"4577": [
"CVE-2007-5784"
],
"4578": [
"CVE-2007-5783"
],
"4580": [
"CVE-2007-5782"
],
"4581": [
"CVE-2007-5781"
],
"4582": [
"CVE-2007-5780"
],
"4585": [
"CVE-2007-5721"
],
"4586": [
"CVE-2007-5720"
],
"4587": [
"CVE-2007-5719"
],
"4588": [
"CVE-2007-5754"
],
"4589": [
"CVE-2007-5752"
],
"4591": [
"CVE-2007-5812"
],
"4592": [
"CVE-2007-5813"
],
"4593": [
"CVE-2007-5800"
],
"4595": [
"CVE-2007-5802"
],
"4596": [
"CVE-2007-5823",
"CVE-2007-5822"
],
"4597": [
"CVE-2007-5821"
],
"4599": [
"CVE-2007-5820"
],
"4602": [
"CVE-2007-5845",
"CVE-2007-5844"
],
"4603": [
"CVE-2007-2304"
],
"4604": [
"CVE-2007-5843"
],
"4605": [
"CVE-2007-5842"
],
"4606": [
"CVE-2007-5841"
],
"4607": [
"CVE-2007-5840"
],
"4608": [
"CVE-2007-5914",
"CVE-2007-5913"
],
"4609": [
"CVE-2007-5887"
],
"4611": [
"CVE-2007-5974",
"CVE-2007-5912"
],
"4614": [
"CVE-2007-5973"
],
"4617": [
"CVE-2007-5999"
],
"4618": [
"CVE-2007-5998"
],
"4619": [
"CVE-2007-5997"
],
"4620": [
"CVE-2007-5996"
],
"4621": [
"CVE-2007-5995"
],
"4622": [
"CVE-2007-5992"
],
"4623": [
"CVE-2007-6004"
],
"4626": [
"CVE-2007-6027"
],
"4627": [
"CVE-2007-6058"
],
"4628": [
"CVE-2007-6057"
],
"4629": [],
"4630": [
"CVE-2007-6089"
],
"4631": [
"CVE-2007-6088"
],
"4632": [
"CVE-2007-6087",
"CVE-2007-6086",
"CVE-2007-6085"
],
"4633": [
"CVE-2007-6084"
],
"4634": [
"CVE-2007-6083"
],
"4635": [
"CVE-2007-6082"
],
"4636": [
"CVE-2007-6038"
],
"4637": [
"CVE-2007-6080",
"CVE-2007-6079"
],
"4638": [
"CVE-2007-6078"
],
"4639": [],
"4640": [
"CVE-2007-6105"
],
"4641": [
"CVE-2007-6106"
],
"4642": [
"CVE-2007-6133"
],
"4643": [],
"4644": [],
"4645": [
"CVE-2007-6137"
],
"4646": [
"CVE-2007-6134"
],
"4647": [
"CVE-2007-6176"
],
"4649": [
"CVE-2007-6217"
],
"4650": [
"CVE-2007-6139"
],
"4652": [
"CVE-2007-6129"
],
"4653": [
"CVE-2007-6128"
],
"4654": [],
"4655": [
"CVE-2007-6127",
"CVE-2007-6126"
],
"4656": [],
"4658": [],
"4659": [
"CVE-2007-6147"
],
"4660": [
"CVE-2007-6125",
"CVE-2007-6124"
],
"4661": [
"CVE-2007-6237"
],
"4662": [
"CVE-2007-6159"
],
"4665": [
"CVE-2007-6164"
],
"4666": [
"CVE-2007-6185"
],
"4667": [],
"4668": [
"CVE-2007-6172"
],
"4669": [
"CVE-2007-6184"
],
"4670": [
"CVE-2007-6177"
],
"4671": [
"CVE-2007-6178"
],
"4672": [
"CVE-2007-6179"
],
"4674": [
"CVE-2007-6221",
"CVE-2007-6188"
],
"4675": [
"CVE-2007-6187"
],
"4676": [
"CVE-2007-6215"
],
"4677": [
"CVE-2007-6213"
],
"4678": [
"CVE-2007-6202"
],
"4679": [
"CVE-2007-6212"
],
"4680": [
"CVE-2007-6214"
],
"4681": [
"CVE-2007-6234",
"CVE-2007-6233",
"CVE-2007-6232"
],
"4684": [
"CVE-2007-6232",
"CVE-2007-6231"
],
"4685": [
"CVE-2007-6230",
"CVE-2007-6229"
],
"4686": [
"CVE-2007-6223"
],
"4687": [
"CVE-2007-6240"
],
"4691": [
"CVE-2007-6362"
],
"4693": [
"CVE-2007-6367",
"CVE-2007-6366"
],
"4694": [
"CVE-2007-6368"
],
"4695": [
"CVE-2007-6369"
],
"4696": [
"CVE-2007-6290",
"CVE-2007-6289"
],
"4697": [
"CVE-2007-6292"
],
"4704": [
"CVE-2007-6400"
],
"4705": [
"CVE-2007-6399",
"CVE-2007-6398",
"CVE-2007-6397",
"CVE-2007-6396",
"CVE-2007-6395"
],
"4706": [
"CVE-2007-6394"
],
"4707": [
"CVE-2007-6393"
],
"4708": [
"CVE-2007-6392"
],
"4709": [
"CVE-2007-6391"
],
"4710": [],
"4711": [
"CVE-2007-6311",
"CVE-2007-6310"
],
"4712": [
"CVE-2007-6490",
"CVE-2007-6489",
"CVE-2007-6488"
],
"4714": [],
"4718": [
"CVE-2005-1924"
],
"4719": [
"CVE-2007-6344"
],
"4721": [
"CVE-2007-6318"
],
"4722": [
"CVE-2007-6347"
],
"4725": [
"CVE-2007-6325"
],
"4726": [
"CVE-2007-6324"
],
"4727": [],
"4728": [
"CVE-2007-6323"
],
"4729": [
"CVE-2007-6322"
],
"4730": [
"CVE-2007-6504",
"CVE-2007-6503",
"CVE-2007-6502",
"CVE-2007-6501",
"CVE-2007-6500",
"CVE-2007-6499",
"CVE-2007-6498",
"CVE-2007-6497",
"CVE-2007-6496",
"CVE-2007-6495",
"CVE-2007-6494"
],
"4731": [
"CVE-2007-6414"
],
"4733": [
"CVE-2007-6458"
],
"4734": [
"CVE-2007-6459"
],
"4735": [
"CVE-2007-6485"
],
"4736": [
"CVE-2007-6464"
],
"4737": [
"CVE-2007-6462"
],
"4738": [
"CVE-2007-6476",
"CVE-2007-6475",
"CVE-2007-6474"
],
"4739": [
"CVE-2007-6466"
],
"4740": [
"CVE-2007-6466"
],
"4741": [
"CVE-2007-6668"
],
"4743": [],
"4750": [
"CVE-2007-6472"
],
"4753": [
"CVE-2007-6479"
],
"4755": [],
"4758": [
"CVE-2007-6508"
],
"4762": [
"CVE-2007-6586"
],
"4763": [
"CVE-2007-6585"
],
"4764": [
"CVE-2007-6542"
],
"4765": [
"CVE-2007-6584",
"CVE-2007-6583"
],
"4766": [
"CVE-2007-6582"
],
"4767": [
"CVE-2007-6581"
],
"4768": [],
"4769": [],
"4770": [
"CVE-2007-6580"
],
"4771": [
"CVE-2007-6579"
],
"4772": [
"CVE-2007-6577"
],
"4774": [
"CVE-2007-6578"
],
"4775": [
"CVE-2007-6576"
],
"4776": [
"CVE-2007-6575"
],
"4777": [
"CVE-2007-6556"
],
"4778": [
"CVE-2007-6557"
],
"4779": [],
"4780": [],
"4781": [],
"4782": [
"CVE-2007-6615",
"CVE-2007-6614"
],
"4783": [
"CVE-2007-6555"
],
"4785": [
"CVE-2007-6554",
"CVE-2007-6553"
],
"4786": [
"CVE-2007-6552"
],
"4787": [
"CVE-2007-6544"
],
"4788": [
"CVE-2007-6551"
],
"4789": [
"CVE-2007-6550"
],
"4790": [
"CVE-2007-6548",
"CVE-2007-6547",
"CVE-2007-6546",
"CVE-2007-6545"
],
"4791": [
"CVE-2007-6543"
],
"4792": [
"CVE-2007-6544"
],
"4793": [
"CVE-2007-6565"
],
"4794": [
"CVE-2007-6567",
"CVE-2007-6566"
],
"4795": [
"CVE-2007-6568"
],
"4796": [
"CVE-2007-6624"
],
"4798": [
"CVE-2007-6623",
"CVE-2007-6622"
],
"4799": [
"CVE-2007-6621",
"CVE-2007-6620"
],
"4800": [
"CVE-2007-6632"
],
"4802": [
"CVE-2007-6604"
],
"4804": [
"CVE-2007-6603"
],
"4805": [
"CVE-2007-6602"
],
"4807": [],
"4808": [
"CVE-2007-6657"
],
"4809": [
"CVE-2007-6658"
],
"4810": [
"CVE-2007-6656"
],
"4811": [
"CVE-2007-6655"
],
"4812": [
"CVE-2007-6653"
],
"4813": [
"CVE-2007-6652"
],
"4814": [
"CVE-2007-6651",
"CVE-2007-6650"
],
"4815": [
"CVE-2007-6649"
],
"4816": [
"CVE-2007-6648"
],
"4817": [
"CVE-2007-6647"
],
"4821": [
"CVE-2007-6639"
],
"4822": [
"CVE-2007-6667"
],
"4823": [
"CVE-2007-6666"
],
"4824": [
"CVE-2007-6665"
],
"4826": [
"CVE-2007-6664"
],
"4827": [
"CVE-2007-6663"
],
"4828": [
"CVE-2008-0091"
],
"4830": [
"CVE-2008-0089"
],
"4831": [
"CVE-2008-0099"
],
"4832": [
"CVE-2008-0129"
],
"4833": [
"CVE-2008-0144"
],
"4834": [
"CVE-2008-0143"
],
"4835": [
"CVE-2008-0142",
"CVE-2008-0141"
],
"4836": [
"CVE-2008-0187"
],
"4837": [
"CVE-2008-7188"
],
"4838": [
"CVE-2008-0137"
],
"4840": [
"CVE-2008-0133"
],
"4841": [],
"4842": [
"CVE-2008-7155"
],
"4843": [],
"4844": [
"CVE-2008-0222"
],
"4845": [
"CVE-2008-0224"
],
"4846": [
"CVE-2008-0210",
"CVE-2008-0140"
],
"4847": [
"CVE-2008-0138"
],
"4848": [
"CVE-2008-4614",
"CVE-2008-4613",
"CVE-2008-4612"
],
"4849": [
"CVE-2008-0139"
],
"4850": [
"CVE-2006-1260"
],
"4851": [
"CVE-2008-4557"
],
"4852": [
"CVE-2008-0186",
"CVE-2008-0185"
],
"4853": [],
"4854": [
"CVE-2008-7163"
],
"4855": [
"CVE-2008-0158"
],
"4857": [
"CVE-2008-7209",
"CVE-2008-7208"
],
"4858": [
"CVE-2008-0157"
],
"4859": [
"CVE-2008-7157",
"CVE-2008-7156"
],
"4860": [
"CVE-2008-0159"
],
"4861": [
"CVE-2008-0149",
"CVE-2008-0148"
],
"4863": [
"CVE-2008-0147"
],
"4864": [
"CVE-2008-0233",
"CVE-2008-0232"
],
"4865": [
"CVE-2008-0155",
"CVE-2008-0154"
],
"4867": [
"CVE-2008-0219"
],
"4870": [
"CVE-2008-0230"
],
"4871": [
"CVE-2008-0246",
"CVE-2008-0245"
],
"4872": [
"CVE-2008-0249"
],
"4876": [
"CVE-2008-0231"
],
"4879": [
"CVE-2008-7154",
"CVE-2008-7153"
],
"4880": [
"CVE-2008-0282"
],
"4882": [
"CVE-2008-0280"
],
"4883": [
"CVE-2008-0283"
],
"4884": [
"CVE-2008-0351",
"CVE-2008-0350"
],
"4886": [
"CVE-2008-0255"
],
"4887": [
"CVE-2008-0290"
],
"4888": [
"CVE-2008-6064"
],
"4889": [
"CVE-2008-0287"
],
"4890": [
"CVE-2008-7210"
],
"4891": [
"CVE-2008-7153"
],
"4895": [
"CVE-2008-0288"
],
"4896": [],
"4897": [
"CVE-2008-0297"
],
"4898": [
"CVE-2008-0262"
],
"4899": [
"CVE-2008-0270"
],
"4900": [
"CVE-2008-0256"
],
"4901": [
"CVE-2008-0254"
],
"4902": [
"CVE-2008-0260",
"CVE-2008-0259"
],
"4904": [
"CVE-2008-0253"
],
"4905": [
"CVE-2008-0262"
],
"4907": [
"CVE-2008-0278"
],
"4908": [
"CVE-2008-0279"
],
"4910": [
"CVE-2008-0291"
],
"4912": [
"CVE-2008-0329"
],
"4914": [
"CVE-2008-0327"
],
"4915": [
"CVE-2008-0328"
],
"4916": [
"CVE-2008-0325"
],
"4917": [
"CVE-2008-0326"
],
"4919": [
"CVE-2008-0360",
"CVE-2008-0359"
],
"4920": [
"CVE-2008-0332"
],
"4921": [
"CVE-2008-0333"
],
"4922": [
"CVE-2008-0391",
"CVE-2008-0371"
],
"4924": [
"CVE-2008-0358"
],
"4925": [
"CVE-2008-0353"
],
"4926": [
"CVE-2008-0361"
],
"4927": [
"CVE-2008-0382"
],
"4928": [
"CVE-2008-0382"
],
"4929": [
"CVE-2008-0355"
],
"4930": [
"CVE-2008-0357"
],
"4933": [
"CVE-2008-0390"
],
"4936": [
"CVE-2008-0393"
],
"4937": [
"CVE-2008-0442",
"CVE-2008-0376"
],
"4939": [
"CVE-2008-0388"
],
"4940": [
"CVE-2008-0357"
],
"4942": [
"CVE-2007-6528"
],
"4943": [
"CVE-2008-0425"
],
"4944": [
"CVE-2008-0430"
],
"4945": [
"CVE-2008-0428",
"CVE-2008-0427"
],
"4950": [
"CVE-2008-0504"
],
"4951": [
"CVE-2008-0424"
],
"4952": [
"CVE-2008-0422"
],
"4953": [
"CVE-2008-0435"
],
"4954": [
"CVE-2008-0431"
],
"4955": [
"CVE-2008-0423"
],
"4956": [
"CVE-2008-0440",
"CVE-2008-0429"
],
"4957": [
"CVE-2008-0782"
],
"4958": [
"CVE-2008-0398",
"CVE-2008-0397"
],
"4960": [
"CVE-2008-0453"
],
"4961": [],
"4962": [
"CVE-2008-0478"
],
"4963": [],
"4964": [],
"4965": [
"CVE-2008-0461"
],
"4966": [
"CVE-2008-0421"
],
"4968": [
"CVE-2008-0447"
],
"4969": [
"CVE-2008-0446"
],
"4970": [
"CVE-2008-0480",
"CVE-2008-0466"
],
"4971": [
"CVE-2008-0481",
"CVE-2008-0473",
"CVE-2008-0466"
],
"4972": [
"CVE-2008-0479"
],
"4973": [
"CVE-2008-0452"
],
"4975": [
"CVE-2008-0458"
],
"4976": [
"CVE-2008-0459"
],
"4977": [
"CVE-2008-0464"
],
"4980": [
"CVE-2008-0465"
],
"4984": [
"CVE-2008-0469"
],
"4985": [
"CVE-2008-0468"
],
"4988": [
"CVE-2008-0739",
"CVE-2008-0738",
"CVE-2008-0737",
"CVE-2008-0736",
"CVE-2008-0547",
"CVE-2008-0546"
],
"4989": [
"CVE-2008-0542",
"CVE-2008-0541"
],
"4990": [
"CVE-2008-0538"
],
"4991": [
"CVE-2008-0545"
],
"4992": [
"CVE-2008-0490"
],
"4993": [
"CVE-2008-0491"
],
"5000": [
"CVE-2008-0501"
],
"5001": [
"CVE-2008-0521"
],
"5002": [
"CVE-2008-0498"
],
"5003": [
"CVE-2008-0503"
],
"5006": [
"CVE-2008-0513"
],
"5007": [
"CVE-2008-0510"
],
"5008": [
"CVE-2008-0512"
],
"5009": [
"CVE-2008-0511"
],
"5010": [
"CVE-2008-0514"
],
"5011": [
"CVE-2008-0579",
"CVE-2008-0515"
],
"5012": [
"CVE-2008-0502"
],
"5013": [
"CVE-2008-0507"
],
"5014": [
"CVE-2008-0518"
],
"5015": [
"CVE-2008-0519"
],
"5016": [
"CVE-2008-0517"
],
"5017": [
"CVE-2008-0520"
],
"5018": [
"CVE-2008-0770"
],
"5019": [],
"5020": [
"CVE-2008-0567"
],
"5021": [
"CVE-2008-0565"
],
"5022": [
"CVE-2008-0566"
],
"5026": [
"CVE-2008-0572"
],
"5027": [
"CVE-2008-0703"
],
"5029": [
"CVE-2008-0561"
],
"5030": [
"CVE-2008-0557"
],
"5031": [
"CVE-2008-0562"
],
"5033": [
"CVE-2008-0632"
],
"5034": [
"CVE-2008-0686"
],
"5035": [
"CVE-2008-0616"
],
"5037": [
"CVE-2008-0724",
"CVE-2008-0675"
],
"5039": [
"CVE-2008-0682"
],
"5040": [
"CVE-2008-0695"
],
"5041": [
"CVE-2008-0681"
],
"5042": [
"CVE-2008-0679",
"CVE-2008-0678"
],
"5047": [
"CVE-2008-0690"
],
"5050": [
"CVE-2008-0677",
"CVE-2008-0676"
],
"5053": [
"CVE-2008-0683"
],
"5055": [
"CVE-2008-0689"
],
"5056": [
"CVE-2008-0692"
],
"5057": [
"CVE-2008-0613",
"CVE-2008-0612"
],
"5058": [
"CVE-2008-0603"
],
"5059": [
"CVE-2008-0606"
],
"5060": [
"CVE-2008-0609"
],
"5061": [
"CVE-2008-0602"
],
"5062": [
"CVE-2008-0611"
],
"5064": [
"CVE-2008-0601"
],
"5065": [
"CVE-2008-0614"
],
"5066": [
"CVE-2008-5695"
],
"5068": [
"CVE-2008-0648"
],
"5070": [
"CVE-2008-0787"
],
"5071": [
"CVE-2008-0649"
],
"5072": [
"CVE-2008-0653"
],
"5073": [
"CVE-2008-0652"
],
"5074": [
"CVE-2008-0714"
],
"5075": [
"CVE-2008-0719"
],
"5076": [
"CVE-2008-0721"
],
"5080": [
"CVE-2008-0772"
],
"5081": [
"CVE-2008-0670"
],
"5082": [
"CVE-2008-0742"
],
"5083": [
"CVE-2008-0752"
],
"5084": [
"CVE-2008-0746"
],
"5088": [
"CVE-2008-0734"
],
"5089": [
"CVE-2008-0745"
],
"5090": [
"CVE-2007-5056"
],
"5091": [
"CVE-2007-5056"
],
"5094": [
"CVE-2008-0773"
],
"5095": [],
"5096": [
"CVE-2008-0776"
],
"5097": [
"CVE-2007-5056"
],
"5098": [
"CVE-2007-5056"
],
"5099": [],
"5101": [],
"5103": [
"CVE-2008-0831",
"CVE-2008-0754"
],
"5104": [
"CVE-2008-0761"
],
"5105": [
"CVE-2008-0735"
],
"5108": [
"CVE-2008-0794"
],
"5109": [
"CVE-2008-0795"
],
"5112": [
"CVE-2008-1231",
"CVE-2008-1230",
"CVE-2008-1229"
],
"5114": [
"CVE-2008-1177",
"CVE-2008-1176"
],
"5115": [
"CVE-2008-0796"
],
"5116": [
"CVE-2008-0798"
],
"5117": [
"CVE-2008-0801"
],
"5118": [
"CVE-2008-0800"
],
"5119": [
"CVE-2008-0799"
],
"5120": [
"CVE-2008-0802"
],
"5121": [
"CVE-2008-0803"
],
"5123": [
"CVE-2008-0822"
],
"5124": [
"CVE-2008-0818"
],
"5125": [
"CVE-2008-0821"
],
"5126": [],
"5127": [],
"5128": [
"CVE-2008-0832"
],
"5129": [
"CVE-2008-0814"
],
"5130": [
"CVE-2008-0811"
],
"5131": [
"CVE-2008-0835"
],
"5132": [
"CVE-2008-0829"
],
"5133": [
"CVE-2008-0841"
],
"5134": [
"CVE-2008-0833"
],
"5135": [
"CVE-2008-0939"
],
"5136": [
"CVE-2008-0805"
],
"5137": [
"CVE-2008-0813"
],
"5138": [
"CVE-2008-0918",
"CVE-2008-0839"
],
"5139": [],
"5140": [
"CVE-2008-0840"
],
"5145": [
"CVE-2008-0844"
],
"5146": [
"CVE-2008-0842"
],
"5147": [
"CVE-2008-0827"
],
"5148": [
"CVE-2008-0847"
],
"5149": [
"CVE-2008-5578",
"CVE-2008-5577",
"CVE-2008-5576"
],
"5154": [],
"5155": [
"CVE-2008-0880"
],
"5156": [
"CVE-2008-0878"
],
"5157": [
"CVE-2008-0874"
],
"5158": [
"CVE-2008-0873"
],
"5159": [
"CVE-2008-0881"
],
"5160": [
"CVE-2008-0916"
],
"5161": [
"CVE-2008-0906"
],
"5162": [
"CVE-2008-0905"
],
"5163": [
"CVE-2008-0907"
],
"5164": [
"CVE-2008-0857"
],
"5165": [
"CVE-2008-1484"
],
"5166": [
"CVE-2008-0911"
],
"5168": [
"CVE-2008-0922"
],
"5169": [],
"5170": [
"CVE-2008-0921"
],
"5171": [
"CVE-2008-0920",
"CVE-2008-0919"
],
"5172": [
"CVE-2008-0934"
],
"5173": [
"CVE-2008-1067",
"CVE-2008-0167"
],
"5174": [
"CVE-2008-1069"
],
"5175": [
"CVE-2008-1051"
],
"5176": [
"CVE-2008-1046"
],
"5177": [],
"5178": [
"CVE-2008-1137"
],
"5179": [
"CVE-2008-7240"
],
"5180": [
"CVE-2008-1043"
],
"5181": [],
"5182": [
"CVE-2008-1068"
],
"5183": [
"CVE-2008-1042"
],
"5185": [
"CVE-2008-1039"
],
"5186": [
"CVE-2008-1053"
],
"5187": [
"CVE-2008-3888"
],
"5189": [
"CVE-2008-1038"
],
"5192": [
"CVE-2008-5582"
],
"5194": [
"CVE-2008-1061",
"CVE-2008-1060",
"CVE-2008-1059"
],
"5195": [
"CVE-2008-1077"
],
"5196": [
"CVE-2008-1121"
],
"5197": [
"CVE-2008-1074"
],
"5198": [
"CVE-2008-1122"
],
"5199": [
"CVE-2008-1123"
],
"5200": [
"CVE-2008-1125",
"CVE-2008-1124"
],
"5202": [
"CVE-2008-1126"
],
"5203": [
"CVE-2008-7038"
],
"5204": [
"CVE-2008-1119"
],
"5206": [
"CVE-2008-1336"
],
"5207": [
"CVE-2008-6234"
],
"5208": [
"CVE-2008-1163"
],
"5209": [
"CVE-2008-1164"
],
"5211": [
"CVE-2008-1162"
],
"5214": [],
"5216": [],
"5218": [],
"5219": [
"CVE-2008-7124"
],
"5220": [
"CVE-2008-7124",
"CVE-2008-7123"
],
"5221": [],
"5222": [
"CVE-2007-3539"
],
"5223": [
"CVE-2008-1272"
],
"5226": [
"CVE-2008-1297"
],
"5231": [
"CVE-2008-1295"
],
"5232": [
"CVE-2008-0300"
],
"5233": [
"CVE-2008-0301"
],
"5234": [
"CVE-2008-1313"
],
"5236": [
"CVE-2008-1305"
],
"5237": [],
"5239": [
"CVE-2008-1513"
],
"5240": [
"CVE-2008-1316"
],
"5241": [],
"5242": [
"CVE-2008-7038"
],
"5243": [
"CVE-2008-1350"
],
"5244": [
"CVE-2008-1349"
],
"5245": [
"CVE-2008-1351"
],
"5246": [
"CVE-2008-1345",
"CVE-2008-1344"
],
"5247": [
"CVE-2008-1347",
"CVE-2008-1346"
],
"5252": [
"CVE-2008-1406"
],
"5253": [],
"5254": [
"CVE-2008-1404"
],
"5255": [
"CVE-2008-1407"
],
"5256": [
"CVE-2008-1398"
],
"5260": [
"CVE-2008-1405"
],
"5262": [
"CVE-2008-1415",
"CVE-2008-1414"
],
"5263": [
"CVE-2008-1408"
],
"5265": [
"CVE-2008-1409"
],
"5266": [
"CVE-2008-1416"
],
"5267": [],
"5273": [
"CVE-2008-1427"
],
"5274": [
"CVE-2008-1426"
],
"5275": [
"CVE-2008-1425"
],
"5276": [
"CVE-2008-1430"
],
"5277": [
"CVE-2008-1460"
],
"5278": [
"CVE-2008-1459"
],
"5279": [],
"5280": [
"CVE-2008-1465"
],
"5281": [
"CVE-2008-1507",
"CVE-2008-1506",
"CVE-2008-1496",
"CVE-2008-1495"
],
"5285": [
"CVE-2008-1462"
],
"5286": [
"CVE-2008-1430"
],
"5288": [
"CVE-2008-1492"
],
"5290": [
"CVE-2008-1551"
],
"5291": [],
"5292": [
"CVE-2008-1591"
],
"5293": [
"CVE-2008-1509"
],
"5294": [
"CVE-2008-1505"
],
"5295": [
"CVE-2008-1680",
"CVE-2008-1539"
],
"5296": [
"CVE-2008-1493"
],
"5297": [
"CVE-2008-1535"
],
"5298": [
"CVE-2008-6538"
],
"5299": [],
"5300": [],
"5301": [
"CVE-2008-1512"
],
"5302": [
"CVE-2008-1537"
],
"5303": [
"CVE-2008-1534"
],
"5304": [
"CVE-2008-1541"
],
"5305": [
"CVE-2008-6539"
],
"5308": [
"CVE-2008-1702"
],
"5309": [
"CVE-2008-1557",
"CVE-2008-1556",
"CVE-2008-1555"
],
"5310": [
"CVE-2008-1559"
],
"5311": [
"CVE-2008-1554"
],
"5312": [
"CVE-2008-1553"
],
"5317": [
"CVE-2008-1609",
"CVE-2006-7128",
"CVE-2006-7127"
],
"5318": [
"CVE-2008-6489"
],
"5319": [
"CVE-2008-1715"
],
"5322": [
"CVE-2008-1623"
],
"5323": [
"CVE-2008-1712"
],
"5324": [
"CVE-2008-1635"
],
"5325": [
"CVE-2008-1624"
],
"5326": [
"CVE-2008-1646"
],
"5328": [
"CVE-2008-1645"
],
"5329": [
"CVE-2008-1640"
],
"5331": [
"CVE-2008-1639"
],
"5333": [
"CVE-2008-1651",
"CVE-2008-1650",
"CVE-2008-1649"
],
"5334": [
"CVE-2008-1714"
],
"5335": [],
"5336": [],
"5337": [
"CVE-2008-4617"
],
"5339": [],
"5340": [],
"5345": [
"CVE-2008-1682"
],
"5347": [
"CVE-2008-1696"
],
"5348": [
"CVE-2008-1776"
],
"5350": [
"CVE-2008-6197"
],
"5351": [],
"5352": [
"CVE-2008-1759"
],
"5353": [
"CVE-2008-1758"
],
"5358": [
"CVE-2008-1874"
],
"5359": [
"CVE-2008-6209"
],
"5360": [
"CVE-2008-1799"
],
"5362": [
"CVE-2008-1872"
],
"5363": [],
"5364": [
"CVE-2008-1875",
"CVE-2008-1711"
],
"5365": [
"CVE-2008-1760"
],
"5367": [
"CVE-2008-1870"
],
"5368": [
"CVE-2008-1763"
],
"5369": [
"CVE-2008-1798"
],
"5370": [
"CVE-2008-6473"
],
"5371": [
"CVE-2008-1788"
],
"5372": [],
"5373": [
"CVE-2008-6202"
],
"5374": [],
"5375": [
"CVE-2008-1876"
],
"5376": [],
"5377": [
"CVE-2008-1871"
],
"5378": [],
"5379": [
"CVE-2008-6198"
],
"5380": [
"CVE-2008-1868",
"CVE-2008-1866"
],
"5381": [],
"5382": [
"CVE-2008-1867"
],
"5383": [
"CVE-2008-1869"
],
"5384": [
"CVE-2008-1785"
],
"5385": [
"CVE-2008-1789"
],
"5387": [
"CVE-2008-1783"
],
"5388": [
"CVE-2008-1784"
],
"5389": [
"CVE-2008-1863"
],
"5390": [
"CVE-2008-1864"
],
"5391": [
"CVE-2008-6475"
],
"5392": [
"CVE-2008-1856"
],
"5393": [
"CVE-2008-1773"
],
"5394": [
"CVE-2008-1857"
],
"5399": [
"CVE-2008-1782"
],
"5400": [
"CVE-2008-1858"
],
"5401": [
"CVE-2008-1791"
],
"5402": [
"CVE-2008-1859",
"CVE-2008-1790",
"CVE-2008-1772"
],
"5404": [],
"5405": [
"CVE-2008-1862",
"CVE-2008-1861"
],
"5406": [
"CVE-2008-1774"
],
"5407": [
"CVE-2008-6490"
],
"5408": [
"CVE-2008-1860"
],
"5409": [
"CVE-2008-6204"
],
"5410": [
"CVE-2008-1732"
],
"5411": [],
"5412": [],
"5413": [],
"5414": [
"CVE-2008-4778"
],
"5415": [
"CVE-2008-6210"
],
"5417": [],
"5418": [
"CVE-2008-1727"
],
"5419": [
"CVE-2008-1730"
],
"5420": [
"CVE-2008-1755"
],
"5421": [
"CVE-2008-1726"
],
"5422": [
"CVE-2008-1750"
],
"5423": [
"CVE-2008-1751"
],
"5425": [
"CVE-2008-6537"
],
"5426": [
"CVE-2008-4912"
],
"5428": [
"CVE-2008-1909"
],
"5429": [
"CVE-2008-1903"
],
"5431": [
"CVE-2008-1849",
"CVE-2008-1848"
],
"5432": [
"CVE-2008-1847"
],
"5433": [
"CVE-2008-1904"
],
"5434": [
"CVE-2008-1911"
],
"5435": [
"CVE-2008-4764"
],
"5436": [
"CVE-2008-4765"
],
"5437": [
"CVE-2008-1908",
"CVE-2008-1907",
"CVE-2008-1906"
],
"5439": [],
"5440": [
"CVE-2008-6477"
],
"5441": [],
"5443": [],
"5444": [
"CVE-2008-1838"
],
"5446": [
"CVE-2008-4703"
],
"5447": [
"CVE-2008-4778"
],
"5448": [
"CVE-2008-2036"
],
"5449": [
"CVE-2008-6201"
],
"5450": [
"CVE-2008-1936"
],
"5452": [
"CVE-2008-6593",
"CVE-2008-6592",
"CVE-2008-6590"
],
"5454": [
"CVE-2008-1913"
],
"5456": [
"CVE-2008-1896",
"CVE-2008-1895"
],
"5457": [
"CVE-2008-1889"
],
"5459": [
"CVE-2008-1989"
],
"5463": [
"CVE-2008-1963"
],
"5464": [
"CVE-2008-1921"
],
"5465": [
"CVE-2008-6199"
],
"5466": [
"CVE-2008-6524",
"CVE-2008-6523"
],
"5467": [
"CVE-2008-1971"
],
"5468": [
"CVE-2008-6081"
],
"5469": [
"CVE-2008-1961"
],
"5470": [
"CVE-2008-1918"
],
"5471": [
"CVE-2008-1919"
],
"5473": [],
"5474": [
"CVE-2008-1962"
],
"5475": [
"CVE-2008-1939"
],
"5476": [],
"5477": [
"CVE-2008-2091"
],
"5478": [
"CVE-2008-1993",
"CVE-2008-1992",
"CVE-2008-1991",
"CVE-2008-1990"
],
"5480": [
"CVE-2008-1915"
],
"5481": [
"CVE-2008-1934"
],
"5482": [
"CVE-2008-1613"
],
"5483": [
"CVE-2008-1958",
"CVE-2008-1957"
],
"5484": [
"CVE-2008-2095"
],
"5485": [
"CVE-2008-1954"
],
"5486": [
"CVE-2008-1982"
],
"5487": [
"CVE-2008-1975"
],
"5488": [
"CVE-2008-1935"
],
"5490": [],
"5491": [
"CVE-2008-2093"
],
"5493": [
"CVE-2008-4715"
],
"5494": [
"CVE-2008-2029",
"CVE-2008-2028",
"CVE-2008-2024"
],
"5495": [
"CVE-2008-2012"
],
"5497": [],
"5499": [
"CVE-2008-2082",
"CVE-2008-2081"
],
"5500": [
"CVE-2008-2013"
],
"5501": [],
"5502": [],
"5503": [
"CVE-2008-2048",
"CVE-2008-2047"
],
"5504": [
"CVE-2008-2088"
],
"5505": [
"CVE-2008-2084"
],
"5506": [
"CVE-2008-2018"
],
"5507": [
"CVE-2008-2023",
"CVE-2008-2022"
],
"5508": [
"CVE-2008-2065"
],
"5509": [
"CVE-2008-6642"
],
"5510": [
"CVE-2008-2217"
],
"5512": [
"CVE-2008-1559"
],
"5513": [],
"5514": [],
"5516": [
"CVE-2008-2083"
],
"5517": [
"CVE-2008-2087"
],
"5520": [
"CVE-2008-2063"
],
"5521": [
"CVE-2008-2045"
],
"5522": [
"CVE-2008-4913"
],
"5523": [
"CVE-2008-2216",
"CVE-2008-2215"
],
"5524": [
"CVE-2008-6651"
],
"5525": [
"CVE-2008-2074"
],
"5526": [
"CVE-2008-2220"
],
"5527": [
"CVE-2008-6653"
],
"5528": [
"CVE-2008-2076"
],
"5529": [
"CVE-2008-2073",
"CVE-2008-2072"
],
"5531": [
"CVE-2008-6656"
],
"5532": [
"CVE-2008-2192"
],
"5533": [
"CVE-2008-2175"
],
"5535": [
"CVE-2008-2185",
"CVE-2008-2184",
"CVE-2008-2183"
],
"5537": [
"CVE-2008-2177"
],
"5538": [
"CVE-2008-2181",
"CVE-2008-2180"
],
"5539": [
"CVE-2008-2193"
],
"5540": [
"CVE-2005-4195"
],
"5541": [
"CVE-2008-2191"
],
"5542": [
"CVE-2008-2190"
],
"5543": [
"CVE-2008-2189"
],
"5544": [
"CVE-2008-2198"
],
"5545": [
"CVE-2008-2199"
],
"5546": [
"CVE-2008-2096"
],
"5548": [
"CVE-2008-6582",
"CVE-2008-2197"
],
"5549": [
"CVE-2008-2116",
"CVE-2008-2115"
],
"5550": [
"CVE-2008-2195",
"CVE-2008-2194"
],
"5551": [
"CVE-2008-2114"
],
"5552": [
"CVE-2008-2113"
],
"5553": [
"CVE-2008-2124"
],
"5554": [
"CVE-2008-2129"
],
"5555": [
"CVE-2008-2225"
],
"5556": [
"CVE-2008-2132"
],
"5557": [
"CVE-2008-6652"
],
"5558": [
"CVE-2008-2128",
"CVE-2008-2127"
],
"5559": [
"CVE-2008-2135"
],
"5560": [
"CVE-2008-2125"
],
"5562": [],
"5564": [
"CVE-2008-6641"
],
"5565": [
"CVE-2008-2223"
],
"5566": [
"CVE-2008-2224"
],
"5567": [
"CVE-2008-2228"
],
"5568": [
"CVE-2008-6650"
],
"5575": [
"CVE-2008-5209"
],
"5576": [
"CVE-2008-2411"
],
"5577": [
"CVE-2008-2537"
],
"5578": [
"CVE-2008-2535",
"CVE-2008-2534",
"CVE-2008-2533"
],
"5579": [
"CVE-2008-5217"
],
"5580": [
"CVE-2008-6649",
"CVE-2008-6648",
"CVE-2008-6647"
],
"5581": [
"CVE-2008-2529"
],
"5582": [
"CVE-2008-6649",
"CVE-2008-6648",
"CVE-2008-6647"
],
"5583": [
"CVE-2008-5208"
],
"5586": [
"CVE-2008-5210"
],
"5587": [
"CVE-2008-2454"
],
"5588": [
"CVE-2008-2530"
],
"5589": [],
"5590": [
"CVE-2008-5213"
],
"5591": [
"CVE-2008-5212"
],
"5592": [],
"5594": [
"CVE-2008-5216"
],
"5595": [
"CVE-2008-5215",
"CVE-2008-5214"
],
"5596": [
"CVE-2008-2520"
],
"5597": [
"CVE-2008-2522"
],
"5598": [
"CVE-2008-2521"
],
"5599": [
"CVE-2008-2453"
],
"5600": [
"CVE-2008-2267"
],
"5601": [
"CVE-2008-2536"
],
"5602": [
"CVE-2008-2532"
],
"5603": [
"CVE-2008-2222"
],
"5604": [
"CVE-2008-2455"
],
"5605": [
"CVE-2008-2447"
],
"5606": [
"CVE-2008-2446",
"CVE-2008-2445"
],
"5607": [
"CVE-2008-2444"
],
"5608": [
"CVE-2008-2448"
],
"5609": [
"CVE-2008-2265"
],
"5610": [
"CVE-2008-2443"
],
"5611": [
"CVE-2008-2263"
],
"5613": [
"CVE-2008-2279",
"CVE-2008-2278"
],
"5614": [
"CVE-2008-2277"
],
"5615": [
"CVE-2008-2269"
],
"5616": [
"CVE-2008-2338"
],
"5617": [
"CVE-2008-2282"
],
"5618": [
"CVE-2007-5156"
],
"5620": [
"CVE-2008-2296",
"CVE-2008-2295"
],
"5621": [
"CVE-2008-2270"
],
"5623": [
"CVE-2008-2301"
],
"5624": [
"CVE-2008-2343",
"CVE-2008-2342",
"CVE-2008-2341",
"CVE-2008-2340"
],
"5626": [
"CVE-2008-2336"
],
"5627": [
"CVE-2008-2294"
],
"5628": [
"CVE-2008-2297"
],
"5629": [
"CVE-2008-2298"
],
"5630": [
"CVE-2008-2293"
],
"5631": [
"CVE-2008-2337"
],
"5633": [],
"5634": [
"CVE-2008-2349"
],
"5635": [
"CVE-2008-2356"
],
"5636": [],
"5637": [
"CVE-2008-2355"
],
"5638": [
"CVE-2008-2417"
],
"5639": [
"CVE-2008-2425",
"CVE-2008-2416"
],
"5640": [
"CVE-2008-2352"
],
"5641": [
"CVE-2008-2351"
],
"5642": [
"CVE-2008-2394"
],
"5643": [],
"5644": [],
"5645": [
"CVE-2008-2346"
],
"5646": [],
"5647": [
"CVE-2008-2353"
],
"5648": [
"CVE-2008-2348"
],
"5649": [
"CVE-2007-5752"
],
"5650": [
"CVE-2008-2347"
],
"5651": [
"CVE-2008-2396"
],
"5652": [
"CVE-2008-2395"
],
"5653": [
"CVE-2008-6632"
],
"5654": [
"CVE-2008-2393"
],
"5655": [
"CVE-2008-2459"
],
"5656": [],
"5657": [
"CVE-2008-3332",
"CVE-2008-3331",
"CVE-2008-2276"
],
"5658": [
"CVE-2008-2456"
],
"5659": [
"CVE-2008-2477"
],
"5660": [
"CVE-2008-2457"
],
"5661": [
"CVE-2008-2461"
],
"5662": [
"CVE-2008-1331"
],
"5663": [],
"5664": [
"CVE-2008-2506",
"CVE-2008-2505"
],
"5665": [
"CVE-2008-2504"
],
"5666": [
"CVE-2008-6438"
],
"5668": [
"CVE-2008-2496"
],
"5669": [
"CVE-2008-2482"
],
"5670": [
"CVE-2008-6633"
],
"5671": [
"CVE-2008-2481"
],
"5672": [
"CVE-2008-2480"
],
"5673": [
"CVE-2008-2484",
"CVE-2008-2483"
],
"5674": [
"CVE-2008-2488"
],
"5675": [
"CVE-2008-6634"
],
"5676": [
"CVE-2008-2487"
],
"5677": [
"CVE-2008-2778"
],
"5678": [
"CVE-2008-2774"
],
"5680": [
"CVE-2008-2782"
],
"5683": [
"CVE-2008-2501"
],
"5684": [],
"5685": [
"CVE-2008-2572"
],
"5688": [
"CVE-2007-5156"
],
"5689": [
"CVE-2008-5223"
],
"5690": [
"CVE-2008-6604"
],
"5691": [],
"5692": [
"CVE-2008-5226"
],
"5693": [],
"5696": [
"CVE-2006-1422"
],
"5697": [],
"5698": [
"CVE-2008-6427"
],
"5699": [
"CVE-2008-6422"
],
"5700": [
"CVE-2008-2650"
],
"5701": [
"CVE-2008-6421",
"CVE-2008-6420",
"CVE-2008-6419"
],
"5702": [],
"5703": [
"CVE-2008-2556"
],
"5704": [
"CVE-2008-6423"
],
"5705": [
"CVE-2008-2554"
],
"5706": [
"CVE-2008-2555"
],
"5707": [
"CVE-2008-6421"
],
"5708": [
"CVE-2008-6429"
],
"5710": [
"CVE-2008-2643"
],
"5711": [
"CVE-2008-6420"
],
"5713": [
"CVE-2008-6425"
],
"5714": [
"CVE-2008-6430"
],
"5715": [
"CVE-2008-2649"
],
"5716": [
"CVE-2008-2648",
"CVE-2008-2647",
"CVE-2008-2646"
],
"5717": [
"CVE-2008-2634"
],
"5719": [
"CVE-2008-2651"
],
"5721": [
"CVE-2008-2632"
],
"5722": [
"CVE-2008-2645"
],
"5723": [
"CVE-2008-2628"
],
"5724": [
"CVE-2008-2629"
],
"5725": [
"CVE-2008-2652",
"CVE-2008-2644"
],
"5728": [
"CVE-2008-2574"
],
"5729": [
"CVE-2008-2633"
],
"5730": [
"CVE-2008-2627"
],
"5731": [
"CVE-2008-2626"
],
"5733": [
"CVE-2008-6678",
"CVE-2008-6677",
"CVE-2008-6676",
"CVE-2008-6675",
"CVE-2008-6674",
"CVE-2008-6673"
],
"5734": [
"CVE-2008-5051",
"CVE-2008-2630"
],
"5736": [
"CVE-2008-2638"
],
"5737": [
"CVE-2008-2564"
],
"5739": [
"CVE-2013-1748",
"CVE-2008-2566",
"CVE-2008-2565"
],
"5740": [
"CVE-2008-2569"
],
"5742": [
"CVE-2008-2561",
"CVE-2008-2560"
],
"5743": [
"CVE-2008-2568"
],
"5744": [
"CVE-2008-2562"
],
"5745": [
"CVE-2008-5269"
],
"5748": [
"CVE-2008-6068"
],
"5752": [
"CVE-2008-2701"
],
"5753": [
"CVE-2008-2691"
],
"5754": [
"CVE-2008-2695",
"CVE-2008-2694"
],
"5755": [
"CVE-2008-2692"
],
"5756": [
"CVE-2008-7178"
],
"5757": [
"CVE-2008-2690",
"CVE-2008-2689"
],
"5758": [
"CVE-2008-2699"
],
"5759": [
"CVE-2008-2697"
],
"5760": [
"CVE-2008-2700"
],
"5761": [
"CVE-2008-2676"
],
"5762": [
"CVE-2008-2687"
],
"5763": [],
"5764": [
"CVE-2008-2678",
"CVE-2008-2677"
],
"5765": [
"CVE-2008-2688"
],
"5766": [
"CVE-2008-2682",
"CVE-2008-2681",
"CVE-2008-2680",
"CVE-2008-2679"
],
"5767": [
"CVE-2008-2686"
],
"5768": [
"CVE-2008-2673"
],
"5769": [
"CVE-2008-7180"
],
"5770": [
"CVE-2008-2742"
],
"5771": [
"CVE-2008-2672"
],
"5772": [
"CVE-2008-2671"
],
"5773": [
"CVE-2008-2669",
"CVE-2008-2668"
],
"5774": [
"CVE-2008-2670"
],
"5775": [
"CVE-2008-5268"
],
"5776": [
"CVE-2008-5267"
],
"5779": [
"CVE-2008-5272",
"CVE-2008-5271"
],
"5780": [
"CVE-2008-6739"
],
"5781": [
"CVE-2008-5274",
"CVE-2008-5273"
],
"5782": [
"CVE-2008-5265"
],
"5783": [
"CVE-2008-5270"
],
"5784": [
"CVE-2008-2993"
],
"5785": [
"CVE-2008-2754"
],
"5786": [],
"5787": [
"CVE-2008-2770"
],
"5788": [
"CVE-2008-2753"
],
"5789": [
"CVE-2008-2755"
],
"5791": [
"CVE-2009-1277",
"CVE-2008-2997",
"CVE-2008-2996"
],
"5792": [
"CVE-2008-7176"
],
"5794": [
"CVE-2008-2909"
],
"5796": [
"CVE-2008-2746"
],
"5797": [
"CVE-2008-6700",
"CVE-2008-6328",
"CVE-2008-6311"
],
"5798": [
"CVE-2008-2907"
],
"5799": [],
"5800": [
"CVE-2008-7181"
],
"5801": [
"CVE-2008-2818"
],
"5802": [
"CVE-2008-2906",
"CVE-2008-2858"
],
"5803": [
"CVE-2006-2763"
],
"5804": [
"CVE-2008-2916"
],
"5805": [
"CVE-2008-2917"
],
"5806": [
"CVE-2008-2919"
],
"5807": [
"CVE-2008-2914"
],
"5808": [
"CVE-2008-2905"
],
"5809": [
"CVE-2008-2915"
],
"5810": [
"CVE-2008-2912",
"CVE-2008-2911"
],
"5811": [
"CVE-2008-2901"
],
"5812": [
"CVE-2008-2904"
],
"5813": [
"CVE-2008-2814",
"CVE-2008-2813"
],
"5815": [
"CVE-2008-2918"
],
"5816": [],
"5818": [
"CVE-2008-6714"
],
"5819": [
"CVE-2008-2921",
"CVE-2008-2920"
],
"5820": [
"CVE-2008-2823"
],
"5821": [
"CVE-2008-2902",
"CVE-2008-2857"
],
"5822": [
"CVE-2008-2913"
],
"5823": [
"CVE-2008-2903"
],
"5824": [
"CVE-2008-6665"
],
"5826": [
"CVE-2008-6741"
],
"5828": [
"CVE-2008-2816"
],
"5829": [
"CVE-2008-6664"
],
"5830": [
"CVE-2008-2817"
],
"5831": [
"CVE-2008-2820"
],
"5832": [
"CVE-2008-2815"
],
"5833": [
"CVE-2008-2568"
],
"5834": [
"CVE-2008-2791"
],
"5835": [],
"5836": [
"CVE-2008-2789"
],
"5838": [
"CVE-2008-2796"
],
"5839": [
"CVE-2008-2793"
],
"5840": [
"CVE-2008-2790"
],
"5841": [
"CVE-2008-6735"
],
"5842": [
"CVE-2008-2865"
],
"5844": [],
"5845": [
"CVE-2008-6738"
],
"5846": [
"CVE-2008-2792"
],
"5847": [
"CVE-2008-2836"
],
"5848": [
"CVE-2008-2839",
"CVE-2008-2838"
],
"5849": [
"CVE-2008-2843",
"CVE-2008-2842"
],
"5850": [
"CVE-2008-2832"
],
"5852": [],
"5853": [
"CVE-2008-2847"
],
"5854": [
"CVE-2008-2845"
],
"5855": [
"CVE-2008-2853"
],
"5856": [
"CVE-2008-6669",
"CVE-2008-6668"
],
"5857": [
"CVE-2008-2844"
],
"5858": [
"CVE-2008-2846"
],
"5859": [
"CVE-2008-2864",
"CVE-2008-2863",
"CVE-2008-2862",
"CVE-2008-2861"
],
"5860": [
"CVE-2008-2856",
"CVE-2008-2855"
],
"5861": [
"CVE-2008-2970",
"CVE-2008-2969",
"CVE-2008-2968",
"CVE-2008-2967",
"CVE-2008-2878"
],
"5862": [],
"5863": [
"CVE-2008-2837"
],
"5864": [
"CVE-2008-2854"
],
"5865": [
"CVE-2008-2866"
],
"5866": [],
"5867": [
"CVE-2008-2860"
],
"5868": [],
"5869": [],
"5870": [
"CVE-2007-3535"
],
"5871": [
"CVE-2008-2896"
],
"5872": [
"CVE-2008-2887"
],
"5873": [
"CVE-2008-7172",
"CVE-2008-7171"
],
"5874": [],
"5875": [
"CVE-2008-2971"
],
"5876": [
"CVE-2008-2886",
"CVE-2008-2883"
],
"5877": [
"CVE-2008-2966",
"CVE-2008-2965"
],
"5878": [
"CVE-2008-2891"
],
"5879": [
"CVE-2008-6663"
],
"5880": [
"CVE-2008-2046"
],
"5881": [],
"5882": [],
"5883": [
"CVE-2008-2972"
],
"5884": [
"CVE-2008-2895"
],
"5885": [
"CVE-2008-2834"
],
"5886": [],
"5887": [
"CVE-2008-2833"
],
"5888": [
"CVE-2008-5125",
"CVE-2008-5123"
],
"5889": [
"CVE-2008-2890"
],
"5890": [
"CVE-2008-2893"
],
"5892": [
"CVE-2008-2900"
],
"5893": [
"CVE-2008-2892"
],
"5894": [],
"5895": [
"CVE-2008-2882",
"CVE-2008-2873",
"CVE-2008-2872"
],
"5896": [
"CVE-2008-2961"
],
"5897": [
"CVE-2008-2986"
],
"5898": [
"CVE-2008-2835"
],
"5899": [
"CVE-2008-2897"
],
"5900": [
"CVE-2008-2884"
],
"5901": [
"CVE-2008-2888"
],
"5902": [
"CVE-2008-6740"
],
"5903": [
"CVE-2008-2982",
"CVE-2008-2981",
"CVE-2008-2980"
],
"5904": [
"CVE-2008-2898"
],
"5905": [
"CVE-2008-2985",
"CVE-2008-2984"
],
"5906": [
"CVE-2008-2885"
],
"5907": [],
"5908": [
"CVE-2008-2989"
],
"5909": [
"CVE-2008-6745"
],
"5910": [],
"5911": [
"CVE-2008-2964"
],
"5912": [],
"5913": [
"CVE-2008-6193",
"CVE-2008-2963",
"CVE-2008-2962"
],
"5914": [
"CVE-2008-2983"
],
"5915": [
"CVE-2008-2990"
],
"5916": [
"CVE-2008-6636",
"CVE-2008-6635"
],
"5917": [
"CVE-2008-2976",
"CVE-2008-2975"
],
"5919": [
"CVE-2008-2974",
"CVE-2008-2973"
],
"5920": [
"CVE-2008-2979",
"CVE-2008-2978",
"CVE-2008-2977"
],
"5921": [
"CVE-2008-2877"
],
"5922": [],
"5923": [],
"5924": [
"CVE-2008-3185",
"CVE-2008-2881"
],
"5925": [
"CVE-2008-2870"
],
"5927": [
"CVE-2008-2868"
],
"5928": [
"CVE-2008-6427"
],
"5929": [
"CVE-2008-2867"
],
"5930": [
"CVE-2008-2869"
],
"5931": [],
"5932": [
"CVE-2008-2875"
],
"5933": [
"CVE-2008-2876"
],
"5934": [
"CVE-2008-2874"
],
"5935": [],
"5936": [
"CVE-2008-7167"
],
"5937": [
"CVE-2008-3497"
],
"5938": [
"CVE-2008-3118",
"CVE-2008-3117"
],
"5939": [
"CVE-2008-3498"
],
"5940": [
"CVE-2008-6734"
],
"5941": [
"CVE-2008-3506",
"CVE-2008-3505"
],
"5942": [
"CVE-2008-5196"
],
"5944": [],
"5945": [],
"5946": [
"CVE-2008-5166"
],
"5947": [
"CVE-2008-5168"
],
"5948": [
"CVE-2008-5174"
],
"5949": [
"CVE-2008-5169"
],
"5950": [
"CVE-2008-5170"
],
"5952": [
"CVE-2008-5171"
],
"5954": [
"CVE-2008-6667"
],
"5955": [
"CVE-2008-5167"
],
"5956": [
"CVE-2008-6734"
],
"5957": [
"CVE-2008-5202",
"CVE-2008-5201"
],
"5958": [
"CVE-2008-5193",
"CVE-2008-5192"
],
"5959": [
"CVE-2008-7179"
],
"5960": [
"CVE-2008-5191"
],
"5961": [
"CVE-2008-5197"
],
"5962": [
"CVE-2008-5204",
"CVE-2008-5203"
],
"5963": [
"CVE-2008-7169"
],
"5964": [
"CVE-2008-5194"
],
"5965": [
"CVE-2008-3132"
],
"5966": [
"CVE-2008-5200"
],
"5967": [
"CVE-2008-5195"
],
"5969": [
"CVE-2008-5198"
],
"5970": [
"CVE-2008-5190"
],
"5971": [
"CVE-2008-3133"
],
"5972": [],
"5973": [
"CVE-2008-3128"
],
"5974": [
"CVE-2008-3129"
],
"5975": [
"CVE-2008-3080",
"CVE-2007-1899"
],
"5976": [
"CVE-2008-3136"
],
"5977": [
"CVE-2008-3131"
],
"5980": [],
"5981": [
"CVE-2008-3127"
],
"5982": [
"CVE-2008-3031"
],
"5983": [],
"5984": [
"CVE-2008-3026"
],
"5985": [
"CVE-2008-3027"
],
"5986": [],
"5987": [
"CVE-2008-3030"
],
"5988": [
"CVE-2008-3025"
],
"5989": [
"CVE-2008-6481"
],
"5990": [],
"5991": [
"CVE-2008-3035"
],
"5992": [
"CVE-2008-3036"
],
"5993": [
"CVE-2008-3083"
],
"5994": [],
"5995": [],
"5996": [
"CVE-2008-3022"
],
"5997": [
"CVE-2008-3154"
],
"5998": [
"CVE-2008-6813"
],
"5999": [
"CVE-2008-6812"
],
"6000": [],
"6001": [],
"6002": [],
"6003": [
"CVE-2008-6841"
],
"6005": [],
"6006": [],
"6007": [
"CVE-2008-3088",
"CVE-2008-3087"
],
"6008": [
"CVE-2008-3093"
],
"6009": [
"CVE-2008-3165"
],
"6010": [
"CVE-2008-3089"
],
"6011": [
"CVE-2008-3181",
"CVE-2008-3180"
],
"6014": [
"CVE-2008-3152"
],
"6015": [
"CVE-2008-3178"
],
"6016": [
"CVE-2008-6834"
],
"6017": [
"CVE-2008-3153"
],
"6018": [
"CVE-2008-3150"
],
"6019": [
"CVE-2008-3152"
],
"6021": [
"CVE-2008-3124"
],
"6022": [
"CVE-2008-3123"
],
"6023": [
"CVE-2008-6911"
],
"6024": [
"CVE-2008-3167",
"CVE-2008-3166"
],
"6025": [
"CVE-2008-6923"
],
"6026": [
"CVE-2008-6825"
],
"6027": [
"CVE-2008-3125"
],
"6028": [
"CVE-2008-3166"
],
"6033": [
"CVE-2008-3203"
],
"6034": [
"CVE-2008-3119"
],
"6035": [
"CVE-2008-3189"
],
"6036": [
"CVE-2008-3183"
],
"6037": [
"CVE-2008-3179"
],
"6040": [
"CVE-2006-1278"
],
"6041": [],
"6042": [
"CVE-2008-5323",
"CVE-2008-5322",
"CVE-2008-3205"
],
"6044": [
"CVE-2008-4055",
"CVE-2008-3204"
],
"6047": [],
"6048": [],
"6049": [],
"6050": [
"CVE-2008-7086"
],
"6051": [],
"6053": [],
"6054": [],
"6055": [],
"6056": [
"CVE-2008-3213"
],
"6057": [
"CVE-2008-7301",
"CVE-2008-3193",
"CVE-2008-3192"
],
"6058": [
"CVE-2008-3200"
],
"6060": [
"CVE-2008-6833"
],
"6061": [
"CVE-2008-3320"
],
"6062": [
"CVE-2008-3319"
],
"6063": [
"CVE-2008-3322"
],
"6064": [
"CVE-2008-3318"
],
"6065": [
"CVE-2008-3321"
],
"6066": [
"CVE-2008-3317"
],
"6067": [
"CVE-2008-3241"
],
"6068": [
"CVE-2008-3191"
],
"6069": [
"CVE-2008-3238",
"CVE-2008-3237"
],
"6070": [
"CVE-2008-3212",
"CVE-2008-3211"
],
"6071": [
"CVE-2008-3190"
],
"6073": [
"CVE-2008-3304",
"CVE-2008-3303",
"CVE-2008-3302",
"CVE-2008-3301"
],
"6074": [
"CVE-2008-3194"
],
"6075": [
"CVE-2008-6249",
"CVE-2008-6248"
],
"6076": [],
"6078": [
"CVE-2008-3207"
],
"6079": [
"CVE-2008-6250"
],
"6080": [
"CVE-2008-3385"
],
"6081": [
"CVE-2008-6300"
],
"6082": [
"CVE-2008-7088",
"CVE-2008-0251"
],
"6084": [
"CVE-2008-7085"
],
"6085": [
"CVE-2008-3239"
],
"6086": [
"CVE-2008-3265"
],
"6087": [
"CVE-2008-3240"
],
"6088": [
"CVE-2008-3251"
],
"6091": [
"CVE-2008-3245"
],
"6092": [
"CVE-2008-3386"
],
"6095": [],
"6096": [
"CVE-2008-3254"
],
"6097": [
"CVE-2008-3250"
],
"6098": [
"CVE-2008-3291"
],
"6099": [
"CVE-2008-3256"
],
"6102": [
"CVE-2008-3387"
],
"6104": [
"CVE-2008-3309"
],
"6105": [
"CVE-2008-3266"
],
"6107": [
"CVE-2008-3384"
],
"6108": [
"CVE-2008-3382"
],
"6109": [
"CVE-2008-3403"
],
"6110": [
"CVE-2008-3267"
],
"6111": [
"CVE-2008-3383"
],
"6112": [
"CVE-2008-3293"
],
"6113": [
"CVE-2008-3250"
],
"6114": [
"CVE-2008-3346"
],
"6115": [
"CVE-2008-3292"
],
"6117": [
"CVE-2008-3308",
"CVE-2008-3307",
"CVE-2008-3306",
"CVE-2008-3305"
],
"6119": [
"CVE-2008-3310"
],
"6125": [
"CVE-2008-3351"
],
"6126": [
"CVE-2008-6288"
],
"6127": [
"CVE-2008-3362"
],
"6128": [
"CVE-2008-3352"
],
"6131": [
"CVE-2008-3400",
"CVE-2008-3399",
"CVE-2008-3398"
],
"6132": [
"CVE-2008-3355"
],
"6133": [
"CVE-2008-3378"
],
"6134": [
"CVE-2008-3377"
],
"6135": [
"CVE-2008-3417"
],
"6136": [],
"6137": [
"CVE-2008-3416"
],
"6138": [
"CVE-2008-3420"
],
"6139": [
"CVE-2008-3412"
],
"6140": [
"CVE-2008-3407",
"CVE-2008-3406"
],
"6141": [
"CVE-2008-3418"
],
"6142": [
"CVE-2008-3415"
],
"6143": [
"CVE-2008-3372"
],
"6144": [
"CVE-2008-3413"
],
"6145": [
"CVE-2008-3414"
],
"6146": [
"CVE-2008-3366"
],
"6147": [
"CVE-2008-3419"
],
"6148": [
"CVE-2008-3371"
],
"6149": [
"CVE-2008-3363"
],
"6150": [
"CVE-2008-3365"
],
"6153": [
"CVE-2008-3368"
],
"6154": [
"CVE-2008-3369"
],
"6156": [
"CVE-2008-3390"
],
"6158": [
"CVE-2008-6438"
],
"6159": [
"CVE-2008-3374"
],
"6160": [
"CVE-2008-3455"
],
"6161": [
"CVE-2008-3401"
],
"6162": [
"CVE-2008-3402"
],
"6163": [
"CVE-2008-3454"
],
"6164": [
"CVE-2008-3405"
],
"6165": [
"CVE-2008-3669"
],
"6166": [],
"6167": [
"CVE-2008-3670",
"CVE-2008-3649"
],
"6168": [],
"6169": [
"CVE-2008-3673",
"CVE-2008-3672"
],
"6170": [
"CVE-2008-3674"
],
"6171": [
"CVE-2008-3452"
],
"6172": [
"CVE-2008-7091"
],
"6173": [
"CVE-2008-7091",
"CVE-2008-7090",
"CVE-2008-7089",
"CVE-2008-6968"
],
"6176": [
"CVE-2008-3489"
],
"6177": [
"CVE-2008-3592",
"CVE-2008-3591"
],
"6178": [
"CVE-2008-3486",
"CVE-2008-3481"
],
"6179": [
"CVE-2008-3446"
],
"6180": [
"CVE-2008-3445"
],
"6182": [
"CVE-2008-3487"
],
"6183": [
"CVE-2008-3570"
],
"6184": [
"CVE-2008-3490"
],
"6185": [
"CVE-2008-3491"
],
"6186": [
"CVE-2008-3491"
],
"6187": [
"CVE-2008-3484"
],
"6189": [
"CVE-2008-3585"
],
"6190": [
"CVE-2008-3588"
],
"6191": [
"CVE-2008-0856",
"CVE-2006-5016"
],
"6192": [
"CVE-2008-3581",
"CVE-2008-3580"
],
"6193": [
"CVE-2008-3594"
],
"6194": [
"CVE-2008-3589"
],
"6199": [
"CVE-2008-3586"
],
"6200": [
"CVE-2008-3593"
],
"6203": [
"CVE-2008-3564"
],
"6204": [
"CVE-2008-3563"
],
"6205": [],
"6206": [
"CVE-2008-3508"
],
"6207": [
"CVE-2008-3507"
],
"6208": [
"CVE-2008-3555"
],
"6209": [
"CVE-2008-3509"
],
"6210": [
"CVE-2008-3509"
],
"6211": [],
"6213": [
"CVE-2008-3557"
],
"6214": [
"CVE-2008-3554"
],
"6215": [
"CVE-2008-4528",
"CVE-2008-4428",
"CVE-2008-4427",
"CVE-2008-4426",
"CVE-2008-4425"
],
"6219": [],
"6221": [
"CVE-2008-3603"
],
"6223": [
"CVE-2008-3601"
],
"6224": [
"CVE-2008-3595"
],
"6225": [
"CVE-2008-3602"
],
"6226": [
"CVE-2008-3598"
],
"6228": [
"CVE-2008-3599"
],
"6230": [
"CVE-2008-3604"
],
"6231": [
"CVE-2008-4528",
"CVE-2008-4428",
"CVE-2008-4427",
"CVE-2008-4426",
"CVE-2008-4425"
],
"6232": [
"CVE-2008-4423",
"CVE-2008-3918"
],
"6233": [
"CVE-2008-4436"
],
"6234": [
"CVE-2008-3681"
],
"6235": [
"CVE-2008-3675"
],
"6247": [
"CVE-2008-3708"
],
"6249": [
"CVE-2008-3706"
],
"6250": [
"CVE-2008-3721",
"CVE-2008-3720"
],
"6254": [
"CVE-2008-6023",
"CVE-2008-6022"
],
"6255": [
"CVE-2008-3711"
],
"6258": [
"CVE-2008-3713"
],
"6259": [
"CVE-2008-6518"
],
"6260": [
"CVE-2008-3718"
],
"6261": [
"CVE-2008-3764",
"CVE-2008-3763",
"CVE-2008-3762"
],
"6269": [
"CVE-2008-4112",
"CVE-2008-3195"
],
"6270": [
"CVE-2008-3719"
],
"6271": [
"CVE-2008-3725"
],
"6273": [
"CVE-2008-3768"
],
"6276": [
"CVE-2008-3749"
],
"6277": [
"CVE-2008-3748"
],
"6279": [
"CVE-2008-3772",
"CVE-2008-3771"
],
"6280": [
"CVE-2008-3767"
],
"6281": [
"CVE-2008-4154"
],
"6284": [
"CVE-2008-4156"
],
"6285": [
"CVE-2008-3788"
],
"6286": [
"CVE-2008-7058",
"CVE-2008-7057",
"CVE-2008-7056"
],
"6287": [
"CVE-2008-4740"
],
"6288": [
"CVE-2008-4155"
],
"6291": [],
"6292": [
"CVE-2008-7059"
],
"6294": [
"CVE-2008-3780",
"CVE-2008-3779"
],
"6295": [
"CVE-2008-3785"
],
"6296": [
"CVE-2008-3784"
],
"6297": [
"CVE-2008-3783"
],
"6298": [
"CVE-2008-3787"
],
"6300": [
"CVE-2008-3851"
],
"6301": [
"CVE-2008-7055",
"CVE-2008-7054"
],
"6303": [],
"6306": [],
"6307": [
"CVE-2008-3845"
],
"6309": [
"CVE-2008-3848"
],
"6310": [
"CVE-2008-4054"
],
"6311": [],
"6312": [
"CVE-2008-7099",
"CVE-2008-7098",
"CVE-2008-7097"
],
"6313": [
"CVE-2008-3926",
"CVE-2008-3925",
"CVE-2008-3924",
"CVE-2008-3923"
],
"6314": [
"CVE-2008-3859"
],
"6315": [
"CVE-2008-7114"
],
"6316": [],
"6320": [
"CVE-2008-3861"
],
"6321": [
"CVE-2008-4093"
],
"6325": [],
"6332": [
"CVE-2008-4083",
"CVE-2008-4082"
],
"6335": [
"CVE-2008-4091"
],
"6336": [
"CVE-2008-3945"
],
"6338": [
"CVE-2008-4089",
"CVE-2008-4088"
],
"6339": [
"CVE-2008-7118",
"CVE-2008-7117",
"CVE-2008-7116"
],
"6341": [
"CVE-2008-7119"
],
"6342": [
"CVE-2008-4084"
],
"6343": [
"CVE-2008-6991"
],
"6344": [],
"6346": [
"CVE-2008-6438"
],
"6347": [
"CVE-2008-4092"
],
"6348": [
"CVE-2008-4090"
],
"6349": [
"CVE-2008-4086"
],
"6350": [
"CVE-2008-4043"
],
"6351": [
"CVE-2008-4044"
],
"6352": [
"CVE-2008-6394"
],
"6354": [
"CVE-2008-4039"
],
"6356": [],
"6357": [
"CVE-2008-6978",
"CVE-2008-6977",
"CVE-2004-1553"
],
"6360": [],
"6361": [
"CVE-2008-3943"
],
"6362": [
"CVE-2008-3944"
],
"6363": [],
"6364": [
"CVE-2008-4144"
],
"6368": [
"CVE-2008-3922"
],
"6369": [
"CVE-2008-6983",
"CVE-2008-6982"
],
"6370": [
"CVE-2008-4186",
"CVE-2008-4185"
],
"6371": [
"CVE-2008-3951"
],
"6373": [
"CVE-2008-4462"
],
"6374": [
"CVE-2008-4467"
],
"6375": [
"CVE-2008-4468"
],
"6376": [
"CVE-2008-4465"
],
"6378": [
"CVE-2008-4463"
],
"6379": [
"CVE-2008-4460"
],
"6380": [
"CVE-2008-4464"
],
"6381": [
"CVE-2008-4469"
],
"6382": [
"CVE-2008-4466"
],
"6383": [
"CVE-2008-6016",
"CVE-2008-3952"
],
"6385": [
"CVE-2008-3953"
],
"6388": [
"CVE-2008-4461"
],
"6390": [
"CVE-2008-4183"
],
"6392": [
"CVE-2008-6971"
],
"6393": [
"CVE-2008-4457",
"CVE-2008-4164"
],
"6395": [
"CVE-2008-3955"
],
"6396": [
"CVE-2008-3954"
],
"6397": [
"CVE-2009-2762"
],
"6398": [
"CVE-2008-5838"
],
"6401": [
"CVE-2008-3954"
],
"6402": [
"CVE-2008-4080"
],
"6403": [
"CVE-2008-4379",
"CVE-2008-4378"
],
"6404": [
"CVE-2008-4376"
],
"6405": [
"CVE-2008-7001",
"CVE-2008-4377"
],
"6406": [
"CVE-2008-4081"
],
"6408": [
"CVE-2008-4374"
],
"6409": [
"CVE-2008-4372",
"CVE-2008-4371"
],
"6410": [],
"6411": [
"CVE-2008-4370",
"CVE-2008-4369"
],
"6412": [
"CVE-2008-4375"
],
"6413": [
"CVE-2008-4158"
],
"6416": [
"CVE-2008-4701",
"CVE-2008-4700"
],
"6417": [
"CVE-2008-4373"
],
"6419": [],
"6420": [
"CVE-2008-6978",
"CVE-2008-6977",
"CVE-2004-1553"
],
"6421": [
"CVE-2009-2762"
],
"6422": [
"CVE-2008-4157"
],
"6423": [
"CVE-2008-4159"
],
"6425": [
"CVE-2008-4702",
"CVE-2008-4591"
],
"6426": [
"CVE-2008-4074",
"CVE-2008-4073"
],
"6427": [
"CVE-2008-4592"
],
"6428": [
"CVE-2008-6990",
"CVE-2008-6989",
"CVE-2008-6988"
],
"6430": [
"CVE-2008-4075"
],
"6431": [
"CVE-2008-4072"
],
"6432": [
"CVE-2008-7005"
],
"6433": [
"CVE-2008-4074",
"CVE-2008-4073"
],
"6435": [
"CVE-2008-4592"
],
"6436": [],
"6437": [
"CVE-2008-4167"
],
"6438": [
"CVE-2008-4492"
],
"6439": [],
"6440": [],
"6442": [
"CVE-2008-4355"
],
"6443": [
"CVE-2008-4345"
],
"6444": [
"CVE-2008-4354"
],
"6445": [
"CVE-2008-7010"
],
"6446": [
"CVE-2008-4350"
],
"6447": [
"CVE-2008-4347"
],
"6448": [],
"6449": [
"CVE-2008-4357"
],
"6450": [],
"6451": [
"CVE-2008-4346",
"CVE-2008-4115"
],
"6452": [
"CVE-2008-4352",
"CVE-2008-4351"
],
"6453": [
"CVE-2008-4176"
],
"6455": [
"CVE-2008-4353"
],
"6456": [
"CVE-2008-7006"
],
"6457": [
"CVE-2008-7007"
],
"6460": [
"CVE-2008-4356"
],
"6461": [
"CVE-2008-4181"
],
"6462": [
"CVE-2008-4203"
],
"6464": [
"CVE-2008-4203"
],
"6465": [
"CVE-2008-4177"
],
"6466": [
"CVE-2008-4175"
],
"6467": [
"CVE-2008-4169"
],
"6468": [
"CVE-2008-4207",
"CVE-2008-4206",
"CVE-2008-4205"
],
"6469": [
"CVE-2008-4202"
],
"6470": [
"CVE-2008-4204"
],
"6473": [
"CVE-2008-4134"
],
"6475": [
"CVE-2008-4137"
],
"6478": [
"CVE-2008-4138"
],
"6480": [
"CVE-2008-4141"
],
"6482": [
"CVE-2008-4146"
],
"6483": [
"CVE-2008-4142"
],
"6485": [
"CVE-2008-4145"
],
"6486": [
"CVE-2008-4173"
],
"6487": [
"CVE-2008-4151"
],
"6488": [
"CVE-2008-4150"
],
"6489": [
"CVE-2008-4187"
],
"6490": [
"CVE-2008-4161"
],
"6492": [],
"6494": [
"CVE-2008-6471"
],
"6495": [],
"6499": [
"CVE-2008-5090"
],
"6500": [
"CVE-2008-6411"
],
"6501": [
"CVE-2008-5097"
],
"6502": [
"CVE-2008-6468"
],
"6503": [
"CVE-2008-6469"
],
"6504": [
"CVE-2008-6452"
],
"6505": [
"CVE-2008-6451"
],
"6507": [],
"6508": [
"CVE-2008-6464"
],
"6509": [
"CVE-2008-4112",
"CVE-2008-3195"
],
"6510": [
"CVE-2008-5088"
],
"6511": [
"CVE-2008-6454"
],
"6512": [
"CVE-2008-6467"
],
"6513": [
"CVE-2008-4245"
],
"6514": [
"CVE-2008-7021"
],
"6516": [
"CVE-2008-6466"
],
"6517": [
"CVE-2008-6030"
],
"6518": [
"CVE-2008-6042"
],
"6519": [
"CVE-2008-5968",
"CVE-2008-5967"
],
"6520": [
"CVE-2008-6453"
],
"6521": [
"CVE-2008-4244"
],
"6522": [
"CVE-2008-6037"
],
"6523": [],
"6524": [
"CVE-2008-6031"
],
"6525": [
"CVE-2008-6033"
],
"6526": [
"CVE-2008-5840"
],
"6527": [
"CVE-2008-6029"
],
"6528": [],
"6529": [
"CVE-2008-6032"
],
"6530": [
"CVE-2008-6025"
],
"6531": [
"CVE-2008-4341"
],
"6533": [
"CVE-2008-6036"
],
"6535": [
"CVE-2008-6028"
],
"6536": [
"CVE-2008-4241"
],
"6538": [
"CVE-2008-6403"
],
"6539": [
"CVE-2008-6402"
],
"6540": [
"CVE-2008-5841"
],
"6541": [],
"6542": [
"CVE-2008-6401"
],
"6543": [
"CVE-2008-6410"
],
"6544": [],
"6545": [
"CVE-2008-6405"
],
"6546": [
"CVE-2008-4244"
],
"6547": [
"CVE-2008-6409",
"CVE-2008-6408",
"CVE-2008-6407"
],
"6549": [
"CVE-2008-5992"
],
"6550": [
"CVE-2008-6414"
],
"6551": [
"CVE-2008-5990"
],
"6552": [
"CVE-2008-5991"
],
"6553": [
"CVE-2008-5989"
],
"6555": [
"CVE-2008-5988"
],
"6556": [
"CVE-2008-6002"
],
"6557": [
"CVE-2008-6001"
],
"6558": [
"CVE-2008-5993"
],
"6559": [
"CVE-2008-4318"
],
"6561": [
"CVE-2008-6004",
"CVE-2008-6003"
],
"6562": [
"CVE-2008-4330"
],
"6563": [
"CVE-2008-4331"
],
"6564": [],
"6566": [
"CVE-2008-4333",
"CVE-2008-4332"
],
"6567": [
"CVE-2008-4319"
],
"6568": [
"CVE-2008-4334"
],
"6569": [],
"6571": [
"CVE-2008-4329"
],
"6572": [
"CVE-2008-4336",
"CVE-2008-4335"
],
"6573": [],
"6574": [
"CVE-2008-4335"
],
"6575": [],
"6576": [
"CVE-2008-4666"
],
"6577": [
"CVE-2008-5069"
],
"6578": [
"CVE-2008-4713"
],
"6579": [
"CVE-2008-7027"
],
"6580": [
"CVE-2008-4714"
],
"6583": [
"CVE-2008-7019"
],
"6584": [
"CVE-2008-7024"
],
"6585": [
"CVE-2008-4719"
],
"6586": [
"CVE-2008-4484"
],
"6587": [
"CVE-2008-4720"
],
"6589": [
"CVE-2008-4736"
],
"6590": [],
"6591": [
"CVE-2008-7028"
],
"6592": [
"CVE-2008-4718"
],
"6593": [
"CVE-2008-4706"
],
"6594": [
"CVE-2008-4366"
],
"6595": [
"CVE-2008-4711"
],
"6596": [
"CVE-2008-5075"
],
"6598": [
"CVE-2008-4735"
],
"6599": [
"CVE-2008-4674"
],
"6601": [
"CVE-2008-4712"
],
"6602": [
"CVE-2008-4739"
],
"6603": [
"CVE-2008-4738"
],
"6604": [
"CVE-2008-4361"
],
"6605": [
"CVE-2008-4716"
],
"6606": [
"CVE-2008-5071"
],
"6607": [
"CVE-2008-4718"
],
"6608": [
"CVE-2008-4717"
],
"6610": [
"CVE-2008-4364"
],
"6611": [
"CVE-2008-4675"
],
"6612": [
"CVE-2008-5070"
],
"6613": [
"CVE-2008-4709"
],
"6617": [
"CVE-2008-4707"
],
"6618": [
"CVE-2008-4668"
],
"6620": [
"CVE-2008-5074"
],
"6621": [
"CVE-2008-4708"
],
"6623": [
"CVE-2008-4673"
],
"6624": [],
"6625": [
"CVE-2008-4721"
],
"6626": [
"CVE-2008-4665"
],
"6628": [
"CVE-2008-4667"
],
"6629": [
"CVE-2008-4743"
],
"6631": [
"CVE-2008-6011",
"CVE-2008-6010"
],
"6632": [
"CVE-2008-6006"
],
"6633": [
"CVE-2008-7026"
],
"6634": [
"CVE-2008-6011"
],
"6635": [
"CVE-2008-6009"
],
"6636": [
"CVE-2008-6014"
],
"6637": [
"CVE-2008-6007"
],
"6639": [
"CVE-2008-6012"
],
"6640": [
"CVE-2006-0123"
],
"6641": [
"CVE-2008-4455",
"CVE-2008-4454"
],
"6642": [
"CVE-2008-6091"
],
"6643": [
"CVE-2008-6100"
],
"6644": [
"CVE-2008-6093"
],
"6645": [
"CVE-2008-4483"
],
"6646": [
"CVE-2009-0820",
"CVE-2008-6132"
],
"6648": [
"CVE-2008-6099"
],
"6649": [
"CVE-2008-6092"
],
"6650": [
"CVE-2008-6102"
],
"6652": [
"CVE-2008-6162"
],
"6653": [
"CVE-2008-5678"
],
"6655": [
"CVE-2008-6163"
],
"6657": [
"CVE-2008-4523"
],
"6659": [
"CVE-2008-6133"
],
"6662": [
"CVE-2008-4524"
],
"6663": [
"CVE-2008-4526"
],
"6664": [
"CVE-2008-5677"
],
"6667": [
"CVE-2008-4528"
],
"6669": [
"CVE-2008-4522"
],
"6670": [
"CVE-2008-4509"
],
"6674": [
"CVE-2008-4509"
],
"6675": [
"CVE-2008-4516"
],
"6676": [],
"6677": [
"CVE-2008-4517"
],
"6678": [
"CVE-2008-4519",
"CVE-2008-4518"
],
"6679": [
"CVE-2008-4490"
],
"6680": [
"CVE-2008-4509"
],
"6681": [],
"6682": [
"CVE-2008-4521"
],
"6683": [
"CVE-2008-4527"
],
"6684": [],
"6685": [
"CVE-2008-4529"
],
"6687": [
"CVE-2008-4486"
],
"6691": [
"CVE-2008-5873",
"CVE-2008-4486"
],
"6692": [],
"6693": [
"CVE-2008-4492"
],
"6694": [
"CVE-2008-4496"
],
"6695": [
"CVE-2008-4495"
],
"6696": [
"CVE-2008-4498"
],
"6697": [
"CVE-2008-4497"
],
"6698": [
"CVE-2008-4494"
],
"6700": [
"CVE-2008-4502"
],
"6701": [
"CVE-2008-6155",
"CVE-2008-6154"
],
"6702": [
"CVE-2008-6156"
],
"6703": [
"CVE-2008-6139",
"CVE-2008-6138"
],
"6706": [
"CVE-2008-5663"
],
"6707": [
"CVE-2008-6189",
"CVE-2008-6187"
],
"6708": [
"CVE-2008-6188"
],
"6709": [
"CVE-2008-6088"
],
"6710": [
"CVE-2008-6087",
"CVE-2008-6086"
],
"6711": [
"CVE-2008-5663"
],
"6712": [],
"6713": [
"CVE-2008-6090"
],
"6714": [
"CVE-2008-4590"
],
"6715": [
"CVE-2008-6089"
],
"6720": [
"CVE-2008-4574"
],
"6721": [],
"6722": [],
"6723": [
"CVE-2008-6182"
],
"6724": [
"CVE-2008-6181"
],
"6725": [
"CVE-2008-4573"
],
"6728": [],
"6729": [
"CVE-2008-5708"
],
"6730": [
"CVE-2008-6184"
],
"6731": [
"CVE-2008-4569"
],
"6733": [
"CVE-2008-5581",
"CVE-2008-5580",
"CVE-2008-5579"
],
"6734": [
"CVE-2008-5936",
"CVE-2008-5883"
],
"6735": [
"CVE-2008-5966"
],
"6736": [
"CVE-2008-4570"
],
"6737": [
"CVE-2008-5965"
],
"6739": [
"CVE-2008-6180"
],
"6740": [
"CVE-2008-6183"
],
"6743": [
"CVE-2008-6643"
],
"6744": [
"CVE-2008-4662"
],
"6745": [],
"6746": [
"CVE-2008-6179"
],
"6747": [
"CVE-2008-4732"
],
"6748": [
"CVE-2008-5665"
],
"6749": [
"CVE-2007-2556"
],
"6751": [
"CVE-2008-4704"
],
"6754": [
"CVE-2008-4705"
],
"6755": [
"CVE-2008-4645"
],
"6758": [
"CVE-2008-4642"
],
"6759": [
"CVE-2008-4644",
"CVE-2008-4643"
],
"6760": [
"CVE-2008-4650"
],
"6762": [
"CVE-2008-4605",
"CVE-2008-4604"
],
"6763": [
"CVE-2008-4599"
],
"6764": [
"CVE-2008-6805"
],
"6765": [
"CVE-2008-4606"
],
"6766": [
"CVE-2008-4600"
],
"6767": [
"CVE-2008-4632"
],
"6768": [
"CVE-2008-4687"
],
"6769": [
"CVE-2008-4603"
],
"6770": [],
"6771": [],
"6772": [
"CVE-2008-4602"
],
"6777": [
"CVE-2008-4625"
],
"6778": [
"CVE-2008-5321"
],
"6779": [
"CVE-2008-4622"
],
"6780": [
"CVE-2008-4621"
],
"6781": [
"CVE-2008-4620"
],
"6782": [
"CVE-2008-4628"
],
"6783": [
"CVE-2008-6178",
"CVE-2005-0613"
],
"6784": [],
"6785": [
"CVE-2008-4624"
],
"6788": [
"CVE-2008-4626"
],
"6789": [
"CVE-2007-3939",
"CVE-2006-4715",
"CVE-2006-4714"
],
"6790": [
"CVE-2008-4627"
],
"6791": [
"CVE-2008-5320"
],
"6792": [
"CVE-2008-4623"
],
"6795": [
"CVE-2008-4653"
],
"6796": [
"CVE-2008-6078"
],
"6797": [
"CVE-2008-6177"
],
"6799": [],
"6802": [
"CVE-2008-6076"
],
"6803": [
"CVE-2008-6084"
],
"6806": [
"CVE-2008-6074"
],
"6808": [
"CVE-2008-6077"
],
"6809": [
"CVE-2008-6080"
],
"6810": [],
"6811": [],
"6814": [
"CVE-2008-6165"
],
"6816": [
"CVE-2008-6083"
],
"6817": [
"CVE-2008-6172"
],
"6818": [
"CVE-2008-4784"
],
"6819": [
"CVE-2008-6789",
"CVE-2008-6788"
],
"6820": [
"CVE-2008-6790",
"CVE-2008-6789",
"CVE-2008-6788"
],
"6821": [
"CVE-2008-6168",
"CVE-2008-6167"
],
"6822": [
"CVE-2008-5920",
"CVE-2008-5919",
"CVE-2008-5918"
],
"6823": [
"CVE-2008-7267"
],
"6826": [],
"6827": [
"CVE-2008-6166"
],
"6829": [
"CVE-2008-4753"
],
"6830": [
"CVE-2008-6822"
],
"6833": [
"CVE-2008-4758",
"CVE-2008-4757",
"CVE-2008-4756"
],
"6835": [
"CVE-2008-4759"
],
"6836": [
"CVE-2008-4752"
],
"6837": [],
"6839": [
"CVE-2008-4755"
],
"6842": [],
"6843": [
"CVE-2008-4754"
],
"6844": [
"CVE-2008-4760"
],
"6845": [
"CVE-2008-6826"
],
"6846": [
"CVE-2008-4780"
],
"6847": [],
"6848": [
"CVE-2008-4783"
],
"6849": [
"CVE-2008-4785"
],
"6850": [
"CVE-2008-4781"
],
"6852": [
"CVE-2008-4786"
],
"6853": [
"CVE-2008-4774",
"CVE-2008-4773",
"CVE-2008-4772"
],
"6854": [
"CVE-2008-4782"
],
"6855": [
"CVE-2008-6815"
],
"6856": [
"CVE-2008-6438"
],
"6857": [
"CVE-2008-5040"
],
"6858": [],
"6859": [
"CVE-2008-5066"
],
"6860": [
"CVE-2008-5065"
],
"6861": [],
"6862": [],
"6864": [
"CVE-2008-4873"
],
"6865": [],
"6866": [
"CVE-2008-6806"
],
"6867": [
"CVE-2008-6811"
],
"6868": [
"CVE-2008-6814"
],
"6869": [
"CVE-2008-4878",
"CVE-2008-4877"
],
"6874": [
"CVE-2008-6213"
],
"6876": [
"CVE-2008-6216",
"CVE-2008-6215"
],
"6877": [
"CVE-2008-6214"
],
"6879": [
"CVE-2008-6777"
],
"6881": [],
"6882": [
"CVE-2008-6857"
],
"6883": [
"CVE-2008-6860"
],
"6885": [
"CVE-2008-4906"
],
"6886": [
"CVE-2008-6804"
],
"6887": [],
"6888": [
"CVE-2008-4894",
"CVE-2008-4893"
],
"6889": [
"CVE-2008-6862"
],
"6890": [
"CVE-2008-6858"
],
"6891": [
"CVE-2008-6863"
],
"6892": [
"CVE-2008-6864"
],
"6893": [
"CVE-2008-6859"
],
"6894": [
"CVE-2008-6781"
],
"6895": [
"CVE-2008-6784"
],
"6896": [
"CVE-2008-4897",
"CVE-2008-4896"
],
"6897": [
"CVE-2008-6927",
"CVE-2008-6926"
],
"6898": [
"CVE-2008-4932"
],
"6900": [
"CVE-2008-6856"
],
"6901": [
"CVE-2008-6855"
],
"6902": [
"CVE-2008-6854"
],
"6903": [
"CVE-2008-6243"
],
"6904": [
"CVE-2008-6861"
],
"6905": [
"CVE-2008-6782"
],
"6906": [
"CVE-2008-6781"
],
"6907": [
"CVE-2008-6783"
],
"6908": [
"CVE-2008-6808"
],
"6909": [
"CVE-2008-6101"
],
"6910": [
"CVE-2008-6245"
],
"6911": [
"CVE-2008-6780"
],
"6912": [
"CVE-2008-4901"
],
"6913": [
"CVE-2008-6246"
],
"6914": [
"CVE-2008-6776"
],
"6915": [
"CVE-2008-6237"
],
"6916": [
"CVE-2008-5060",
"CVE-2008-5059"
],
"6917": [
"CVE-2008-4902"
],
"6918": [
"CVE-2008-6778"
],
"6919": [
"CVE-2008-6867"
],
"6920": [
"CVE-2008-6247"
],
"6922": [
"CVE-2008-6242"
],
"6923": [
"CVE-2008-6794"
],
"6924": [
"CVE-2008-6244"
],
"6925": [
"CVE-2008-5004"
],
"6928": [
"CVE-2008-6482"
],
"6929": [
"CVE-2009-4808"
],
"6930": [
"CVE-2008-6527"
],
"6931": [],
"6932": [
"CVE-2008-6721"
],
"6933": [
"CVE-2008-6553"
],
"6934": [
"CVE-2008-5003"
],
"6935": [
"CVE-2008-4895"
],
"6936": [
"CVE-2008-4900",
"CVE-2008-4895",
"CVE-2008-4884",
"CVE-2008-4883",
"CVE-2008-4882",
"CVE-2008-4881"
],
"6937": [
"CVE-2008-4883"
],
"6938": [
"CVE-2008-4882"
],
"6939": [],
"6940": [
"CVE-2008-4885"
],
"6941": [
"CVE-2008-3756"
],
"6942": [
"CVE-2008-4885"
],
"6943": [
"CVE-2008-4881"
],
"6944": [
"CVE-2008-4900"
],
"6945": [
"CVE-2008-3755"
],
"6946": [
"CVE-2008-4178"
],
"6947": [
"CVE-2008-4178"
],
"6948": [
"CVE-2008-4884"
],
"6949": [
"CVE-2008-3750"
],
"6950": [
"CVE-2008-4178"
],
"6951": [
"CVE-2008-4178"
],
"6952": [
"CVE-2008-4886"
],
"6953": [
"CVE-2008-4879"
],
"6954": [
"CVE-2008-6296"
],
"6955": [
"CVE-2008-6269"
],
"6956": [
"CVE-2008-6683"
],
"6957": [
"CVE-2008-4888",
"CVE-2008-4887"
],
"6958": [
"CVE-2008-4880"
],
"6960": [
"CVE-2008-4890"
],
"6961": [
"CVE-2008-4889"
],
"6962": [
"CVE-2008-6526"
],
"6964": [
"CVE-2008-6294",
"CVE-2008-6293",
"CVE-2008-6292"
],
"6965": [
"CVE-2008-6294",
"CVE-2008-6293",
"CVE-2008-6292"
],
"6966": [
"CVE-2008-6291"
],
"6967": [
"CVE-2008-6606"
],
"6968": [
"CVE-2008-6294",
"CVE-2008-6293",
"CVE-2008-6292"
],
"6969": [
"CVE-2008-6272",
"CVE-2008-6270"
],
"6971": [
"CVE-2008-6607",
"CVE-2008-6606"
],
"6972": [
"CVE-2006-2770"
],
"6973": [
"CVE-2008-6271"
],
"6974": [
"CVE-2008-6629",
"CVE-2008-6628",
"CVE-2008-6268",
"CVE-2008-6267"
],
"6975": [
"CVE-2008-6483"
],
"6976": [
"CVE-2008-6347"
],
"6977": [
"CVE-2008-6622"
],
"6978": [
"CVE-2008-6795"
],
"6979": [
"CVE-2007-6586"
],
"6980": [
"CVE-2008-6222"
],
"6981": [
"CVE-2008-6795"
],
"6982": [],
"6983": [
"CVE-2008-6624"
],
"6984": [
"CVE-2008-6625"
],
"6985": [
"CVE-2008-6626"
],
"6986": [
"CVE-2008-6627"
],
"6987": [
"CVE-2008-6236",
"CVE-2008-6220"
],
"6988": [
"CVE-2008-6289"
],
"6989": [
"CVE-2008-6623"
],
"6990": [
"CVE-2008-6290"
],
"6991": [],
"6992": [
"CVE-2008-6224",
"CVE-2008-6223"
],
"6993": [
"CVE-2008-6658",
"CVE-2008-6657"
],
"6995": [
"CVE-2008-6301"
],
"6996": [
"CVE-2008-5000"
],
"6997": [
"CVE-2008-6230"
],
"6998": [
"CVE-2008-6232",
"CVE-2008-6231"
],
"6999": [
"CVE-2008-6228",
"CVE-2008-6227"
],
"7000": [
"CVE-2008-6232",
"CVE-2008-6231"
],
"7001": [
"CVE-2008-6793"
],
"7002": [
"CVE-2008-6221"
],
"7003": [
"CVE-2008-6226"
],
"7004": [
"CVE-2008-5058"
],
"7005": [],
"7007": [
"CVE-2008-6233"
],
"7008": [
"CVE-2008-6796"
],
"7009": [
"CVE-2008-6225"
],
"7010": [
"CVE-2008-6484"
],
"7011": [
"CVE-2008-6659"
],
"7012": [],
"7013": [
"CVE-2008-6608"
],
"7014": [
"CVE-2008-5131"
],
"7015": [
"CVE-2008-5054"
],
"7016": [
"CVE-2008-6348"
],
"7017": [
"CVE-2008-6716",
"CVE-2008-6715"
],
"7018": [
"CVE-2008-6525"
],
"7019": [
"CVE-2008-5787"
],
"7020": [
"CVE-2008-4454"
],
"7021": [
"CVE-2008-6488",
"CVE-2008-6485"
],
"7022": [
"CVE-2008-5794"
],
"7023": [
"CVE-2008-5806"
],
"7024": [
"CVE-2008-6720"
],
"7025": [
"CVE-2008-5648"
],
"7026": [
"CVE-2008-6488",
"CVE-2008-6485"
],
"7027": [],
"7028": [
"CVE-2008-6723"
],
"7029": [
"CVE-2008-6349"
],
"7030": [
"CVE-2008-5046"
],
"7031": [
"CVE-2008-6551"
],
"7032": [
"CVE-2008-6717"
],
"7033": [
"CVE-2008-6718"
],
"7034": [
"CVE-2008-6719"
],
"7035": [
"CVE-2008-6351",
"CVE-2008-6350"
],
"7038": [
"CVE-2008-5793"
],
"7039": [
"CVE-2008-5790"
],
"7040": [
"CVE-2008-5789"
],
"7041": [
"CVE-2008-5803"
],
"7042": [],
"7043": [
"CVE-2008-5047"
],
"7044": [
"CVE-2008-5653"
],
"7045": [
"CVE-2008-5655",
"CVE-2008-5652"
],
"7046": [
"CVE-2008-5654"
],
"7047": [
"CVE-2008-5805"
],
"7048": [
"CVE-2008-5802"
],
"7049": [
"CVE-2008-5062",
"CVE-2008-5061"
],
"7050": [
"CVE-2008-5804"
],
"7052": [
"CVE-2008-5788"
],
"7053": [
"CVE-2008-5655",
"CVE-2008-5651"
],
"7057": [],
"7058": [
"CVE-2008-6915",
"CVE-2008-6914"
],
"7059": [
"CVE-2008-5792"
],
"7061": [
"CVE-2008-5785"
],
"7062": [
"CVE-2008-6913"
],
"7063": [
"CVE-2008-5784",
"CVE-2008-5783"
],
"7064": [],
"7065": [
"CVE-2008-6265"
],
"7066": [
"CVE-2008-6912"
],
"7067": [
"CVE-2008-6487"
],
"7068": [],
"7069": [
"CVE-2008-5784",
"CVE-2008-5783"
],
"7070": [
"CVE-2008-5042"
],
"7071": [
"CVE-2008-6917"
],
"7072": [
"CVE-2008-5782"
],
"7074": [
"CVE-2008-6960"
],
"7075": [
"CVE-2008-6511",
"CVE-2008-6510",
"CVE-2008-6509",
"CVE-2008-6508"
],
"7076": [
"CVE-2008-6949",
"CVE-2008-6948",
"CVE-2008-6947",
"CVE-2008-6946"
],
"7077": [
"CVE-2008-5063"
],
"7078": [
"CVE-2008-5051",
"CVE-2008-2630"
],
"7079": [
"CVE-2008-6934"
],
"7080": [
"CVE-2008-7043",
"CVE-2008-7042"
],
"7081": [
"CVE-2008-7051"
],
"7082": [
"CVE-2008-6929"
],
"7083": [
"CVE-2008-6931"
],
"7084": [
"CVE-2008-6928"
],
"7085": [
"CVE-2008-6930"
],
"7086": [
"CVE-2008-7046",
"CVE-2008-7045",
"CVE-2008-7044"
],
"7087": [
"CVE-2008-6966",
"CVE-2008-6965"
],
"7089": [
"CVE-2008-7041"
],
"7092": [
"CVE-2008-5643"
],
"7093": [
"CVE-2008-5494"
],
"7094": [
"CVE-2008-7052",
"CVE-2008-6798"
],
"7095": [],
"7096": [
"CVE-2008-5053"
],
"7097": [
"CVE-2008-0689"
],
"7098": [
"CVE-2008-5496"
],
"7101": [
"CVE-2008-6932"
],
"7102": [
"CVE-2008-5649"
],
"7103": [
"CVE-2008-5650"
],
"7105": [
"CVE-2008-3765"
],
"7106": [
"CVE-2008-6302"
],
"7107": [
"CVE-2008-6941",
"CVE-2008-6940",
"CVE-2008-6939"
],
"7110": [
"CVE-2008-6944",
"CVE-2008-6943",
"CVE-2008-6942"
],
"7111": [
"CVE-2008-6944",
"CVE-2008-6943",
"CVE-2008-6942"
],
"7112": [
"CVE-2008-6944",
"CVE-2008-6943",
"CVE-2008-6942"
],
"7113": [
"CVE-2008-5497"
],
"7114": [
"CVE-2008-5132"
],
"7116": [
"CVE-2008-5650",
"CVE-2006-6819"
],
"7117": [],
"7118": [
"CVE-2008-6963"
],
"7119": [
"CVE-2008-6958"
],
"7120": [
"CVE-2008-6950"
],
"7121": [
"CVE-2008-5491"
],
"7122": [],
"7123": [
"CVE-2008-6964"
],
"7124": [
"CVE-2008-5487",
"CVE-2008-5486"
],
"7128": [
"CVE-2008-5489"
],
"7130": [
"CVE-2008-6933"
],
"7131": [
"CVE-2008-5490"
],
"7133": [],
"7134": [
"CVE-2008-5493"
],
"7136": [
"CVE-2008-6956",
"CVE-2008-6955"
],
"7137": [
"CVE-2008-6257"
],
"7138": [
"CVE-2008-6261"
],
"7140": [
"CVE-2008-5218"
],
"7141": [
"CVE-2008-6259",
"CVE-2008-6258"
],
"7143": [
"CVE-2008-6251"
],
"7144": [
"CVE-2008-6254"
],
"7146": [
"CVE-2008-6332",
"CVE-2008-6326"
],
"7147": [
"CVE-2008-6263",
"CVE-2008-6262"
],
"7148": [
"CVE-2008-6260"
],
"7149": [
"CVE-2008-5219"
],
"7152": [
"CVE-2008-2125"
],
"7153": [
"CVE-2008-6253"
],
"7155": [
"CVE-2008-6305"
],
"7156": [
"CVE-2008-6307"
],
"7157": [],
"7158": [],
"7159": [
"CVE-2008-6308"
],
"7160": [
"CVE-2008-6330"
],
"7162": [
"CVE-2008-6952"
],
"7163": [
"CVE-2008-6310",
"CVE-2008-6309"
],
"7164": [
"CVE-2008-6329"
],
"7165": [
"CVE-2008-5220"
],
"7166": [
"CVE-2008-6310",
"CVE-2008-6309"
],
"7168": [
"CVE-2008-5418"
],
"7170": [
"CVE-2008-5221"
],
"7172": [
"CVE-2008-7049"
],
"7173": [
"CVE-2008-5335"
],
"7174": [],
"7175": [
"CVE-2008-7049"
],
"7176": [
"CVE-2008-6303"
],
"7179": [
"CVE-2008-7047"
],
"7180": [],
"7182": [
"CVE-2008-6116"
],
"7184": [
"CVE-2008-6114"
],
"7185": [
"CVE-2008-6957"
],
"7186": [
"CVE-2008-6111"
],
"7188": [],
"7189": [],
"7190": [
"CVE-2008-6112"
],
"7191": [
"CVE-2008-5308"
],
"7195": [
"CVE-2008-6115"
],
"7197": [],
"7198": [
"CVE-2008-5310"
],
"7199": [
"CVE-2008-5311"
],
"7200": [
"CVE-2008-5306"
],
"7201": [
"CVE-2008-5307"
],
"7202": [
"CVE-2008-6117"
],
"7204": [
"CVE-2008-5939",
"CVE-2008-5938"
],
"7205": [
"CVE-2008-6119",
"CVE-2008-6118"
],
"7206": [
"CVE-2008-7080"
],
"7208": [
"CVE-2008-5309"
],
"7210": [
"CVE-2008-6118"
],
"7211": [],
"7212": [],
"7214": [],
"7215": [
"CVE-2008-5338",
"CVE-2008-5337"
],
"7216": [
"CVE-2008-5336"
],
"7217": [
"CVE-2008-7064"
],
"7218": [
"CVE-2008-5334",
"CVE-2008-5333"
],
"7221": [
"CVE-2008-5332"
],
"7222": [
"CVE-2008-5293"
],
"7223": [
"CVE-2008-5294"
],
"7224": [
"CVE-2008-5287"
],
"7225": [
"CVE-2008-7073"
],
"7227": [
"CVE-2008-7072",
"CVE-2008-7071"
],
"7228": [
"CVE-2008-5290",
"CVE-2008-5289"
],
"7229": [
"CVE-2008-5288"
],
"7230": [
"CVE-2008-5289"
],
"7231": [
"CVE-2008-5291"
],
"7232": [],
"7233": [
"CVE-2008-7062"
],
"7234": [
"CVE-2008-5292"
],
"7235": [
"CVE-2008-5295"
],
"40987": [],
"7237": [
"CVE-2008-6282"
],
"7238": [
"CVE-2008-5630"
],
"7239": [
"CVE-2008-5637"
],
"7240": [
"CVE-2008-7075"
],
"7241": [
"CVE-2008-5639"
],
"7242": [
"CVE-2004-1552"
],
"7243": [
"CVE-2008-7075"
],
"7244": [
"CVE-2008-6370",
"CVE-2008-6369"
],
"7245": [],
"7246": [],
"7247": [],
"7248": [
"CVE-2008-6274"
],
"7250": [
"CVE-2008-6277"
],
"7251": [
"CVE-2008-7076"
],
"7252": [],
"7253": [
"CVE-2008-6809"
],
"7254": [
"CVE-2008-6390",
"CVE-2008-6371"
],
"7255": [
"CVE-2008-7067"
],
"7256": [
"CVE-2009-3973",
"CVE-2008-5629"
],
"7258": [
"CVE-2008-7063"
],
"7259": [],
"7260": [],
"7261": [],
"7263": [
"CVE-2008-6810"
],
"7265": [],
"7266": [
"CVE-2008-7069"
],
"7267": [
"CVE-2008-7077"
],
"7268": [
"CVE-2008-6281"
],
"7269": [
"CVE-2008-5628"
],
"7270": [
"CVE-2008-7083"
],
"7271": [
"CVE-2008-6372"
],
"7273": [
"CVE-2008-5634",
"CVE-2008-5632"
],
"7274": [
"CVE-2008-6889"
],
"7275": [
"CVE-2008-5633"
],
"7276": [
"CVE-2008-5959"
],
"7277": [],
"7278": [
"CVE-2008-5635"
],
"7279": [
"CVE-2008-5631"
],
"7280": [
"CVE-2008-6286"
],
"7281": [
"CVE-2008-5974",
"CVE-2008-5973"
],
"7282": [
"CVE-2008-5627"
],
"7283": [
"CVE-2008-5974"
],
"7284": [
"CVE-2008-6285"
],
"7285": [
"CVE-2008-5642"
],
"7286": [
"CVE-2008-6869"
],
"7287": [
"CVE-2008-5365"
],
"7288": [
"CVE-2008-6873"
],
"7289": [
"CVE-2008-5975",
"CVE-2008-5638"
],
"7290": [
"CVE-2008-5640"
],
"7291": [
"CVE-2008-7066"
],
"7292": [
"CVE-2008-6872"
],
"7293": [],
"7294": [
"CVE-2008-5636"
],
"7295": [
"CVE-2008-5958"
],
"7298": [
"CVE-2008-6380"
],
"7299": [
"CVE-2008-5641"
],
"7301": [
"CVE-2008-5632"
],
"7302": [
"CVE-2008-5972"
],
"7303": [
"CVE-2008-6387"
],
"7304": [
"CVE-2008-5953"
],
"7305": [
"CVE-2008-5954",
"CVE-2008-5952"
],
"7306": [
"CVE-2008-6613",
"CVE-2008-6612",
"CVE-2008-6611"
],
"7308": [],
"7310": [
"CVE-2008-6287"
],
"7311": [
"CVE-2008-6284"
],
"7312": [
"CVE-2008-6513"
],
"7315": [
"CVE-2008-3590"
],
"7316": [
"CVE-2008-6382"
],
"7317": [
"CVE-2008-6381"
],
"7318": [
"CVE-2008-5981"
],
"7319": [
"CVE-2008-5980",
"CVE-2008-5979",
"CVE-2008-5978"
],
"7322": [
"CVE-2008-6446"
],
"7323": [
"CVE-2008-5969"
],
"7324": [
"CVE-2008-6388"
],
"7325": [
"CVE-2008-6374"
],
"7326": [
"CVE-2008-6379"
],
"7327": [
"CVE-2008-6378"
],
"7328": [
"CVE-2008-5586"
],
"7331": [
"CVE-2008-5607"
],
"7332": [
"CVE-2008-6494"
],
"7333": [
"CVE-2008-6389"
],
"7335": [
"CVE-2008-6377"
],
"7336": [
"CVE-2008-5949"
],
"7337": [
"CVE-2008-5956",
"CVE-2008-5955"
],
"7338": [
"CVE-2008-5601"
],
"7339": [
"CVE-2008-5951",
"CVE-2008-5950"
],
"7340": [
"CVE-2008-6493"
],
"7341": [
"CVE-2008-5585"
],
"7342": [
"CVE-2008-5604"
],
"7343": [
"CVE-2008-5957"
],
"7344": [
"CVE-2008-5963",
"CVE-2008-5962"
],
"7345": [
"CVE-2008-5948"
],
"7346": [
"CVE-2008-6362"
],
"7348": [
"CVE-2008-6871",
"CVE-2008-6870"
],
"7349": [
"CVE-2008-5588"
],
"7350": [
"CVE-2008-5589"
],
"7351": [
"CVE-2008-5592",
"CVE-2008-5591"
],
"7352": [
"CVE-2008-5600",
"CVE-2008-5599"
],
"7353": [
"CVE-2008-5597"
],
"7354": [
"CVE-2008-6492"
],
"7356": [
"CVE-2008-5608",
"CVE-2008-5595"
],
"7357": [
"CVE-2008-5605"
],
"7359": [
"CVE-2008-5603"
],
"7360": [
"CVE-2008-5608"
],
"7361": [
"CVE-2008-5562"
],
"7363": [
"CVE-2008-5587"
],
"7364": [
"CVE-2008-5568"
],
"7365": [
"CVE-2008-5565"
],
"7366": [
"CVE-2008-5567"
],
"7367": [
"CVE-2008-6535"
],
"7368": [
"CVE-2008-5590"
],
"7369": [
"CVE-2008-6158"
],
"7370": [
"CVE-2008-5602"
],
"7371": [
"CVE-2008-5572"
],
"7372": [
"CVE-2008-5596"
],
"7373": [],
"7374": [
"CVE-2008-5594"
],
"7375": [
"CVE-2008-5593"
],
"7376": [
"CVE-2008-5606"
],
"7377": [
"CVE-2008-5598"
],
"7378": [],
"7379": [],
"7380": [
"CVE-2008-6884"
],
"7381": [],
"7382": [
"CVE-2008-5621"
],
"7383": [],
"7385": [],
"7386": [
"CVE-2008-6314"
],
"7388": [],
"7390": [
"CVE-2008-5571"
],
"7391": [
"CVE-2008-5573"
],
"7392": [
"CVE-2008-6317",
"CVE-2008-6316",
"CVE-2008-6315"
],
"7395": [
"CVE-2008-6892"
],
"7396": [
"CVE-2008-5561"
],
"7397": [
"CVE-2008-6327",
"CVE-2008-6312"
],
"7398": [
"CVE-2008-5560",
"CVE-2008-5559"
],
"7399": [
"CVE-2008-6318",
"CVE-2008-6317",
"CVE-2008-6316"
],
"7400": [
"CVE-2008-5570",
"CVE-2008-5566"
],
"7404": [],
"7406": [
"CVE-2008-6844"
],
"7407": [
"CVE-2008-5574"
],
"7408": [
"CVE-2008-6530",
"CVE-2008-6529"
],
"7409": [
"CVE-2008-6502",
"CVE-2008-6501"
],
"7411": [
"CVE-2008-6328",
"CVE-2008-6311"
],
"7412": [
"CVE-2008-6321",
"CVE-2008-6320"
],
"7413": [
"CVE-2008-6319"
],
"7414": [
"CVE-2008-6323"
],
"7415": [
"CVE-2008-6322"
],
"7416": [
"CVE-2008-6324"
],
"7417": [
"CVE-2008-6313"
],
"7418": [
"CVE-2008-6581"
],
"7419": [
"CVE-2008-6356"
],
"7420": [
"CVE-2008-6357"
],
"7421": [],
"7422": [
"CVE-2008-6361"
],
"7423": [
"CVE-2008-6366"
],
"7424": [
"CVE-2008-6365"
],
"7425": [
"CVE-2008-6364"
],
"7426": [],
"7427": [
"CVE-2008-6354"
],
"7428": [
"CVE-2008-6355"
],
"7429": [
"CVE-2008-6353"
],
"7430": [],
"7432": [
"CVE-2008-6352"
],
"7433": [
"CVE-2008-6358"
],
"7434": [],
"7435": [
"CVE-2008-6367"
],
"7436": [
"CVE-2008-5931",
"CVE-2008-5930"
],
"7437": [],
"7438": [
"CVE-2008-5929"
],
"7439": [
"CVE-2008-5921"
],
"7440": [
"CVE-2008-6580"
],
"7441": [
"CVE-2008-6883",
"CVE-2008-6882",
"CVE-2008-6881"
],
"7443": [
"CVE-2008-5927"
],
"7444": [
"CVE-2008-5763",
"CVE-2008-5762"
],
"7445": [
"CVE-2008-5886"
],
"7446": [
"CVE-2008-5885"
],
"7447": [
"CVE-2008-5926"
],
"7448": [],
"7449": [
"CVE-2008-5901"
],
"7450": [
"CVE-2008-5932"
],
"7451": [
"CVE-2008-5771",
"CVE-2008-5770"
],
"7453": [
"CVE-2008-5928",
"CVE-2008-5779",
"CVE-2008-5778"
],
"7455": [],
"7456": [
"CVE-2008-6900"
],
"7457": [],
"7458": [
"CVE-2008-5894"
],
"7459": [
"CVE-2008-5922"
],
"7461": [
"CVE-2008-5761",
"CVE-2008-5759"
],
"7462": [
"CVE-2008-5774"
],
"7463": [
"CVE-2008-6874"
],
"7464": [
"CVE-2008-5772"
],
"7465": [
"CVE-2008-5934",
"CVE-2008-5933"
],
"7466": [
"CVE-2008-5780"
],
"7468": [
"CVE-2008-5898"
],
"7469": [
"CVE-2008-5899"
],
"7470": [
"CVE-2008-5897"
],
"7471": [
"CVE-2008-5900"
],
"7472": [
"CVE-2008-5896"
],
"7473": [],
"7474": [
"CVE-2008-5779"
],
"7475": [
"CVE-2008-6906",
"CVE-2008-6905"
],
"7476": [
"CVE-2008-5895"
],
"7478": [
"CVE-2008-7003"
],
"7479": [
"CVE-2008-5768"
],
"7480": [
"CVE-2008-5777"
],
"7481": [
"CVE-2008-5765",
"CVE-2008-5764"
],
"7482": [
"CVE-2008-5776",
"CVE-2008-5775"
],
"7483": [
"CVE-2008-5781"
],
"7484": [],
"7485": [
"CVE-2008-5893",
"CVE-2008-5892"
],
"7486": [
"CVE-2008-5889",
"CVE-2008-5888"
],
"7487": [
"CVE-2008-5766"
],
"7488": [
"CVE-2003-1571"
],
"7489": [
"CVE-2008-5778"
],
"7490": [],
"7491": [
"CVE-2008-5773"
],
"7493": [
"CVE-2008-6057"
],
"7494": [],
"7495": [
"CVE-2008-5767"
],
"7497": [
"CVE-2008-6743"
],
"7499": [],
"7500": [
"CVE-2008-6768"
],
"7502": [],
"7504": [
"CVE-2008-6050"
],
"7506": [
"CVE-2008-6049"
],
"7507": [
"CVE-2008-6787"
],
"7508": [],
"7509": [
"CVE-2008-6785"
],
"7510": [
"CVE-2008-6902",
"CVE-2008-6901"
],
"7511": [
"CVE-2008-6907"
],
"7512": [],
"7513": [
"CVE-2008-5738"
],
"7514": [
"CVE-2008-6017"
],
"7515": [
"CVE-2008-5879",
"CVE-2008-5878",
"CVE-2008-5877"
],
"7517": [
"CVE-2008-5890"
],
"7518": [
"CVE-2008-5880"
],
"7519": [
"CVE-2008-6018"
],
"7522": [
"CVE-2008-5851"
],
"7523": [
"CVE-2008-6752"
],
"7524": [
"CVE-2008-6335"
],
"7525": [
"CVE-2008-6334"
],
"7526": [
"CVE-2008-5855",
"CVE-2008-5854"
],
"7527": [
"CVE-2008-5861"
],
"7528": [],
"7529": [
"CVE-2008-5860",
"CVE-2008-5859",
"CVE-2008-5847"
],
"7530": [
"CVE-2008-5863"
],
"7531": [
"CVE-2008-6751"
],
"7532": [
"CVE-2008-5853"
],
"7534": [
"CVE-2008-5852"
],
"7537": [
"CVE-2008-5732"
],
"7538": [
"CVE-2008-5865",
"CVE-2008-5864"
],
"7539": [
"CVE-2008-5865",
"CVE-2008-5864"
],
"7540": [],
"7541": [
"CVE-2008-6333"
],
"7542": [
"CVE-2008-6336"
],
"7543": [
"CVE-2008-5752"
],
"7544": [
"CVE-2008-5739"
],
"7545": [
"CVE-2008-6773",
"CVE-2008-6772",
"CVE-2008-6771",
"CVE-2008-6770",
"CVE-2008-6769"
],
"7546": [
"CVE-2008-6337"
],
"7548": [
"CVE-2008-6345"
],
"7549": [
"CVE-2008-5619"
],
"7551": [
"CVE-2008-5737"
],
"7552": [],
"7553": [
"CVE-2008-5619"
],
"7557": [
"CVE-2008-6729"
],
"7558": [
"CVE-2008-6851"
],
"7559": [
"CVE-2008-5727"
],
"7560": [
"CVE-2008-5742",
"CVE-2008-5730",
"CVE-2008-5729",
"CVE-2008-5728"
],
"7561": [
"CVE-2008-6849",
"CVE-2008-6848"
],
"7562": [
"CVE-2008-6921"
],
"7563": [
"CVE-2008-6920"
],
"7565": [
"CVE-2008-5726"
],
"7567": [
"CVE-2008-5875",
"CVE-2008-5874",
"CVE-2008-5865",
"CVE-2008-5864"
],
"7568": [
"CVE-2008-5875",
"CVE-2008-5874"
],
"7569": [],
"7570": [
"CVE-2008-5816"
],
"7572": [
"CVE-2008-6852"
],
"7573": [
"CVE-2008-6148"
],
"7574": [
"CVE-2008-6149"
],
"7575": [
"CVE-2008-5875",
"CVE-2008-5874",
"CVE-2008-5865",
"CVE-2008-5864"
],
"7576": [
"CVE-2008-1918"
],
"7579": [
"CVE-2008-5856"
],
"7580": [
"CVE-2008-5748"
],
"7586": [
"CVE-2008-6582",
"CVE-2008-2197"
],
"7587": [
"CVE-2008-5811"
],
"7593": [
"CVE-2008-6146"
],
"7595": [],
"7596": [
"CVE-2008-5751"
],
"7597": [
"CVE-2008-6143"
],
"7598": [
"CVE-2008-5733"
],
"7599": [
"CVE-2008-6147"
],
"7600": [
"CVE-2008-6731"
],
"7601": [
"CVE-2008-6763"
],
"7602": [
"CVE-2008-5817"
],
"7603": [
"CVE-2008-5819"
],
"7604": [
"CVE-2008-5818"
],
"7605": [
"CVE-2008-6919"
],
"7606": [],
"7607": [
"CVE-2008-6727"
],
"7609": [
"CVE-2008-6151"
],
"7610": [
"CVE-2008-6152"
],
"7611": [
"CVE-2008-6853"
],
"7612": [],
"7613": [
"CVE-2008-6157",
"CVE-2008-6150"
],
"7614": [
"CVE-2008-6750",
"CVE-2008-6749"
],
"7615": [
"CVE-2008-6241"
],
"7616": [
"CVE-2008-6730"
],
"7619": [
"CVE-2008-5820"
],
"7620": [
"CVE-2008-6918"
],
"7621": [
"CVE-2008-5815"
],
"7622": [
"CVE-2008-6761"
],
"7624": [
"CVE-2008-6142"
],
"7625": [
"CVE-2008-6726",
"CVE-2008-6725"
],
"7626": [],
"7627": [
"CVE-2008-6153"
],
"7628": [
"CVE-2008-6765",
"CVE-2008-6758"
],
"7629": [],
"7631": [],
"7633": [],
"7635": [
"CVE-2009-0703"
],
"7636": [
"CVE-2009-0711",
"CVE-2009-0710",
"CVE-2009-0709"
],
"7638": [],
"7639": [],
"7640": [
"CVE-2009-0597"
],
"7641": [
"CVE-2009-0705"
],
"7642": [
"CVE-2009-0707"
],
"7644": [],
"7645": [],
"7648": [
"CVE-2009-0596",
"CVE-2009-0595",
"CVE-2009-0594"
],
"7650": [],
"7653": [],
"7657": [],
"7658": [
"CVE-2009-0592"
],
"7659": [
"CVE-2009-0704"
],
"7660": [
"CVE-2009-0598"
],
"7663": [
"CVE-2009-0593"
],
"7664": [],
"7665": [],
"7666": [],
"7667": [],
"7668": [
"CVE-2009-0701"
],
"7669": [],
"7670": [
"CVE-2009-0702"
],
"7672": [
"CVE-2009-0107",
"CVE-2009-0106"
],
"7674": [
"CVE-2009-0108"
],
"7678": [],
"7679": [
"CVE-2009-0110"
],
"7680": [
"CVE-2009-0105",
"CVE-2009-0104"
],
"7682": [
"CVE-2009-0109"
],
"7683": [
"CVE-2009-0121",
"CVE-2009-0111"
],
"7686": [
"CVE-2009-0493"
],
"7687": [
"CVE-2009-0103",
"CVE-2008-5881"
],
"7689": [
"CVE-2009-0826"
],
"7690": [
"CVE-2009-0827"
],
"7691": [
"CVE-2009-0113"
],
"7697": [
"CVE-2009-0831"
],
"7698": [
"CVE-2009-0832"
],
"7699": [
"CVE-2009-0829",
"CVE-2009-0828"
],
"7700": [],
"7703": [],
"7704": [],
"7705": [],
"7711": [],
"7716": [],
"7717": [],
"7718": [],
"7719": [],
"7722": [],
"7723": [],
"7724": [],
"7725": [],
"7726": [],
"7728": [],
"7729": [],
"7730": [],
"7731": [],
"7732": [],
"7733": [],
"7734": [
"CVE-2009-0494"
],
"7735": [],
"7736": [],
"7738": [],
"7740": [],
"7741": [],
"7743": [
"CVE-2009-0495"
],
"7744": [
"CVE-2009-0498"
],
"7746": [
"CVE-2009-0726"
],
"7752": [],
"7753": [],
"7754": [],
"7758": [
"CVE-2009-0326"
],
"7759": [],
"7761": [
"CVE-2009-5103",
"CVE-2009-5102"
],
"7764": [],
"7766": [],
"7767": [
"CVE-2009-0428",
"CVE-2009-0427",
"CVE-2009-0426"
],
"7768": [],
"7769": [],
"7770": [],
"7771": [],
"7772": [],
"7773": [
"CVE-2009-0427"
],
"7774": [],
"7775": [],
"7777": [],
"7778": [
"CVE-2009-0422"
],
"7780": [
"CVE-2009-0275",
"CVE-2009-0251",
"CVE-2009-0250"
],
"7782": [],
"7783": [],
"7784": [],
"7786": [
"CVE-2009-0423"
],
"7787": [
"CVE-2009-0428"
],
"7788": [],
"7789": [],
"7791": [],
"7792": [
"CVE-2009-0290"
],
"7793": [
"CVE-2009-0421"
],
"7795": [
"CVE-2009-0420"
],
"7796": [],
"7797": [
"CVE-2009-0425"
],
"7798": [
"CVE-2009-0327"
],
"7800": [],
"7801": [
"CVE-2009-0252"
],
"7802": [
"CVE-2009-0281"
],
"7803": [],
"7805": [
"CVE-2009-0249",
"CVE-2009-0248"
],
"7806": [
"CVE-2009-0337",
"CVE-2009-0336",
"CVE-2009-0335",
"CVE-2009-0334"
],
"7807": [],
"7809": [],
"7810": [],
"7811": [],
"7813": [
"CVE-2009-0340"
],
"7814": [
"CVE-2009-0324"
],
"7815": [
"CVE-2009-0730"
],
"7816": [
"CVE-2009-0328"
],
"7817": [],
"7818": [
"CVE-2009-0330"
],
"7819": [
"CVE-2009-0331"
],
"7820": [],
"7821": [],
"7824": [
"CVE-2009-0329"
],
"7828": [],
"7829": [],
"7830": [],
"7831": [
"CVE-2009-0325"
],
"7832": [],
"7833": [
"CVE-2009-0333"
],
"7834": [],
"7835": [
"CVE-2009-0383"
],
"7836": [],
"7837": [],
"7838": [],
"7840": [
"CVE-2009-0381"
],
"7841": [
"CVE-2009-0380"
],
"7844": [],
"7846": [
"CVE-2009-0379"
],
"7847": [
"CVE-2009-0378",
"CVE-2009-0377"
],
"7849": [
"CVE-2009-0384"
],
"7850": [
"CVE-2009-0280"
],
"7851": [
"CVE-2009-0279"
],
"7859": [
"CVE-2009-0372"
],
"7860": [],
"7861": [],
"7862": [
"CVE-2009-0284"
],
"7863": [
"CVE-2009-0286"
],
"7864": [],
"7866": [],
"7867": [
"CVE-2009-0295"
],
"7872": [],
"7873": [
"CVE-2009-0296"
],
"7874": [
"CVE-2009-0292"
],
"7876": [
"CVE-2009-0407"
],
"7877": [
"CVE-2009-0293"
],
"7878": [
"CVE-2009-0299"
],
"7879": [
"CVE-2009-0371"
],
"7880": [
"CVE-2009-0297"
],
"7881": [
"CVE-2009-0373"
],
"7883": [
"CVE-2009-0291"
],
"7884": [],
"7885": [],
"7886": [],
"7892": [
"CVE-2009-0406"
],
"7893": [],
"7894": [
"CVE-2009-0403",
"CVE-2009-0399"
],
"7895": [
"CVE-2009-3167"
],
"7896": [],
"7897": [],
"7898": [],
"7899": [
"CVE-2009-0409"
],
"7900": [
"CVE-2009-0400"
],
"7901": [
"CVE-2009-0405"
],
"7905": [],
"7908": [],
"7909": [],
"7911": [],
"7916": [
"CVE-2009-0395"
],
"7917": [
"CVE-2009-0394"
],
"7922": [],
"7924": [],
"7925": [],
"7927": [],
"7930": [],
"7931": [],
"7932": [
"CVE-2009-0451"
],
"7933": [],
"7936": [
"CVE-2009-1451",
"CVE-2009-1450"
],
"7938": [],
"7939": [
"CVE-2009-0457"
],
"7940": [
"CVE-2009-0459",
"CVE-2009-0458"
],
"7941": [
"CVE-2009-0459",
"CVE-2009-0458"
],
"7944": [],
"7945": [],
"7946": [
"CVE-2009-0456"
],
"7947": [],
"7948": [
"CVE-2009-0517"
],
"7949": [],
"18164": [
"CVE-2010-4804"
],
"7951": [
"CVE-2009-0461",
"CVE-2009-0460"
],
"7952": [
"CVE-2009-0461",
"CVE-2009-0460"
],
"7953": [
"CVE-2009-0462"
],
"7954": [
"CVE-2009-0463"
],
"7955": [
"CVE-2009-0464"
],
"7956": [
"CVE-2009-0479",
"CVE-2009-0453",
"CVE-2009-0452"
],
"7959": [],
"7960": [],
"7961": [
"CVE-2009-0446"
],
"7963": [
"CVE-2009-0447"
],
"7964": [
"CVE-2009-0646"
],
"7965": [
"CVE-2009-0441"
],
"7967": [],
"7968": [
"CVE-2009-0445"
],
"7969": [
"CVE-2009-0572"
],
"7972": [],
"7976": [
"CVE-2009-0645"
],
"7977": [
"CVE-2009-0448"
],
"7978": [],
"7979": [
"CVE-2009-0444"
],
"7980": [
"CVE-2009-0442"
],
"7981": [],
"7982": [
"CVE-2009-0761",
"CVE-2009-0760"
],
"7984": [
"CVE-2009-0768"
],
"7987": [],
"7991": [],
"7992": [],
"7993": [
"CVE-2009-0767",
"CVE-2009-0766",
"CVE-2009-0765",
"CVE-2009-0764",
"CVE-2009-0763"
],
"7996": [],
"7997": [],
"7998": [
"CVE-2009-0602"
],
"7999": [
"CVE-2009-0643",
"CVE-2009-0610"
],
"8000": [],
"8001": [
"CVE-2009-0571",
"CVE-2009-0570"
],
"8002": [
"CVE-2009-0574"
],
"8003": [],
"8004": [],
"8005": [
"CVE-2009-0639"
],
"8006": [],
"8007": [
"CVE-2009-0528"
],
"8009": [],
"8011": [
"CVE-2009-0516"
],
"8012": [
"CVE-2009-0531"
],
"8014": [
"CVE-2009-0604"
],
"8015": [],
"8016": [
"CVE-2009-0527",
"CVE-2009-0526"
],
"8017": [
"CVE-2009-0530",
"CVE-2009-0529"
],
"8018": [
"CVE-2009-1256",
"CVE-2009-0534"
],
"8019": [],
"8020": [
"CVE-2009-0515"
],
"8025": [
"CVE-2009-0514",
"CVE-2009-0513"
],
"8026": [
"CVE-2009-0294"
],
"8027": [
"CVE-2009-5093"
],
"8028": [],
"8029": [
"CVE-2009-0535"
],
"8030": [
"CVE-2009-0735"
],
"8031": [],
"8032": [
"CVE-2009-0722"
],
"8033": [
"CVE-2009-0738"
],
"8034": [
"CVE-2009-0739"
],
"8035": [
"CVE-2009-0740"
],
"8036": [],
"8038": [
"CVE-2009-0815"
],
"8039": [],
"8040": [],
"8042": [],
"8043": [
"CVE-2009-5090"
],
"8044": [],
"8045": [],
"8046": [],
"8047": [],
"8048": [],
"8049": [
"CVE-2009-5089",
"CVE-2009-5088"
],
"8050": [
"CVE-2009-5091"
],
"8052": [
"CVE-2009-5095"
],
"8053": [],
"8054": [
"CVE-2009-5094"
],
"8057": [],
"8060": [
"CVE-2008-6178"
],
"8061": [],
"8062": [],
"8063": [],
"8064": [],
"8065": [],
"8066": [],
"8068": [
"CVE-2009-0678",
"CVE-2009-0677",
"CVE-2009-0674",
"CVE-2009-0673",
"CVE-2009-0672"
],
"8069": [],
"8070": [],
"8071": [
"CVE-2009-0864",
"CVE-2009-0863"
],
"8072": [],
"8073": [
"CVE-2009-0866"
],
"8075": [],
"8076": [
"CVE-2009-0750"
],
"8083": [],
"8085": [],
"8086": [],
"8087": [],
"8088": [],
"8089": [],
"8092": [
"CVE-2009-0807"
],
"8093": [],
"8094": [
"CVE-2009-0731"
],
"8095": [],
"8098": [
"CVE-2009-0727"
],
"8100": [
"CVE-2009-0728"
],
"8101": [
"CVE-2009-0810"
],
"8104": [],
"8105": [
"CVE-2008-4528",
"CVE-2008-4428",
"CVE-2008-4427",
"CVE-2008-4426",
"CVE-2008-4425"
],
"8107": [],
"8109": [],
"8110": [],
"8111": [],
"8112": [],
"8113": [],
"8114": [],
"8115": [],
"8116": [],
"8120": [],
"8123": [],
"8124": [],
"8127": [],
"8128": [
"CVE-2009-4805",
"CVE-2009-4801"
],
"8130": [
"CVE-2009-4806"
],
"8131": [],
"8132": [],
"8133": [
"CVE-2009-4808",
"CVE-2009-4807"
],
"8134": [],
"8136": [],
"8139": [],
"8140": [],
"8141": [],
"8145": [],
"8150": [],
"8151": [],
"8161": [
"CVE-2009-0853",
"CVE-2009-0852",
"CVE-2009-0851"
],
"8164": [],
"8165": [
"CVE-2009-0883"
],
"8166": [],
"8167": [
"CVE-2009-0881"
],
"8168": [
"CVE-2009-0886"
],
"8170": [
"CVE-2009-0882"
],
"8172": [],
"8181": [],
"8182": [
"CVE-2009-4883"
],
"8183": [
"CVE-2008-7192"
],
"8184": [],
"8185": [
"CVE-2009-4886"
],
"8186": [
"CVE-2009-4889"
],
"8188": [
"CVE-2009-4892"
],
"8194": [],
"8195": [],
"8196": [
"CVE-2009-1030"
],
"8197": [],
"8198": [],
"8202": [],
"8204": [
"CVE-2010-1109"
],
"8207": [
"CVE-2009-1038"
],
"8209": [
"CVE-2009-1026"
],
"8210": [],
"8216": [
"CVE-2009-1025",
"CVE-2009-1024"
],
"8217": [
"CVE-2009-1038"
],
"8220": [
"CVE-2009-1023"
],
"8226": [
"CVE-2009-0964",
"CVE-2009-0963"
],
"8228": [
"CVE-2009-0965"
],
"8229": [
"CVE-2009-0968"
],
"8230": [
"CVE-2009-0966"
],
"8237": [],
"8238": [
"CVE-2009-1032"
],
"8239": [],
"8240": [
"CVE-2010-4151",
"CVE-2009-1033"
],
"8243": [
"CVE-2009-1050",
"CVE-2009-1049"
],
"8244": [
"CVE-2009-1049"
],
"8247": [
"CVE-2009-1088"
],
"8252": [
"CVE-2009-1067",
"CVE-2009-1066"
],
"8254": [
"CVE-2009-2311"
],
"8255": [],
"8258": [
"CVE-2009-2310"
],
"8268": [],
"8271": [
"CVE-2008-6842"
],
"8272": [
"CVE-2009-2309"
],
"8276": [],
"8277": [],
"8278": [
"CVE-2009-2313"
],
"8279": [],
"8282": [],
"8287": [],
"8288": [],
"8289": [],
"8290": [
"CVE-2009-1246"
],
"8291": [
"CVE-2009-1248",
"CVE-2009-1247"
],
"8292": [],
"8293": [],
"8296": [
"CVE-2009-1228"
],
"8297": [
"CVE-2009-1171"
],
"8298": [],
"8302": [
"CVE-2009-4796"
],
"8304": [
"CVE-2009-1229"
],
"8305": [
"CVE-2006-6446"
],
"8307": [
"CVE-2009-4799",
"CVE-2009-4798"
],
"8309": [
"CVE-2009-4793",
"CVE-2009-4792"
],
"8315": [],
"8317": [
"CVE-2009-1512",
"CVE-2009-1508"
],
"8318": [
"CVE-2009-4797"
],
"8319": [
"CVE-2009-4791"
],
"8323": [
"CVE-2009-4794"
],
"8324": [
"CVE-2009-1230",
"CVE-2009-1226"
],
"8326": [],
"8327": [],
"8328": [
"CVE-2009-1222"
],
"8329": [],
"8330": [
"CVE-2009-4883"
],
"8331": [
"CVE-2009-1224"
],
"8334": [
"CVE-2009-1510"
],
"8341": [
"CVE-2009-1509"
],
"8342": [],
"8346": [
"CVE-2009-4957"
],
"8347": [
"CVE-2009-1283",
"CVE-2009-1282",
"CVE-2009-1281"
],
"8348": [],
"8349": [],
"8350": [
"CVE-2009-1278",
"CVE-2009-1277",
"CVE-2008-2996"
],
"8351": [
"CVE-2009-1259"
],
"8353": [
"CVE-2009-1263"
],
"8355": [
"CVE-2009-1256",
"CVE-2009-0534"
],
"8357": [
"CVE-2009-1498"
],
"8361": [],
"8362": [],
"8364": [],
"8365": [],
"8366": [
"CVE-2009-1499"
],
"8367": [
"CVE-2009-1496"
],
"8372": [],
"8373": [],
"8374": [
"CVE-2009-1495"
],
"8376": [],
"8377": [],
"8379": [],
"8380": [],
"8382": [
"CVE-2009-1323",
"CVE-2009-1314"
],
"8383": [],
"8385": [],
"8386": [],
"8387": [],
"8388": [],
"8389": [],
"8394": [
"CVE-2009-4209",
"CVE-2009-1369",
"CVE-2009-1368",
"CVE-2009-1367",
"CVE-2008-6126"
],
"8395": [],
"8396": [
"CVE-2009-2337"
],
"8397": [],
"8399": [],
"8408": [],
"8409": [],
"8414": [],
"8415": [],
"8417": [],
"8418": [
"CVE-2009-1322",
"CVE-2009-1321"
],
"8423": [
"CVE-2009-1318"
],
"8424": [
"CVE-2009-1316",
"CVE-2009-1315"
],
"8425": [
"CVE-2006-4608",
"CVE-2006-4607",
"CVE-2006-4606",
"CVE-2006-4605"
],
"8431": [
"CVE-2009-1319"
],
"8432": [
"CVE-2009-1317"
],
"8433": [],
"8435": [],
"8436": [],
"8437": [],
"8438": [],
"8439": [],
"8440": [],
"8441": [],
"8442": [],
"8443": [],
"8446": [
"CVE-2009-2338"
],
"8448": [],
"8449": [],
"8450": [],
"8453": [
"CVE-2009-1408"
],
"8454": [
"CVE-2009-1916",
"CVE-2009-1361"
],
"8455": [
"CVE-2009-1345"
],
"8457": [
"CVE-2009-1346"
],
"8459": [],
"8460": [
"CVE-2009-1452"
],
"8461": [
"CVE-2009-1362",
"CVE-2009-1347"
],
"8464": [
"CVE-2009-1453"
],
"8468": [],
"8471": [],
"8472": [],
"8473": [],
"8474": [
"CVE-2009-1447"
],
"8475": [
"CVE-2010-4996",
"CVE-2009-4935"
],
"8476": [],
"8477": [],
"8480": [],
"8481": [
"CVE-2009-1483"
],
"8482": [
"CVE-2009-1411"
],
"8483": [],
"8486": [],
"8487": [
"CVE-2009-4933"
],
"8488": [],
"8491": [],
"8492": [
"CVE-2009-4927"
],
"8493": [
"CVE-2009-1489",
"CVE-2009-1488",
"CVE-2009-1487"
],
"8494": [],
"8495": [
"CVE-2009-1409"
],
"8496": [
"CVE-2009-4929"
],
"8497": [
"CVE-2009-4925"
],
"8498": [],
"8499": [],
"8501": [
"CVE-2009-1403"
],
"8502": [
"CVE-2009-1405",
"CVE-2009-1404"
],
"8503": [
"CVE-2009-1406"
],
"8504": [
"CVE-2009-1407"
],
"8505": [
"CVE-2009-1410"
],
"8506": [
"CVE-2009-3590"
],
"8508": [],
"8509": [],
"8510": [],
"8513": [],
"8514": [
"CVE-2009-1446"
],
"8515": [],
"8516": [
"CVE-2009-1445",
"CVE-2009-1444"
],
"8517": [],
"8521": [],
"8529": [
"CVE-2009-1504"
],
"8530": [],
"8532": [],
"8533": [
"CVE-2009-1480"
],
"8538": [],
"8539": [
"CVE-2009-1621"
],
"8543": [],
"8545": [
"CVE-2009-1624",
"CVE-2009-1623"
],
"8546": [
"CVE-2009-1625"
],
"8547": [
"CVE-2009-1626"
],
"8548": [
"CVE-2009-1622"
],
"8549": [
"CVE-2009-1486"
],
"8550": [
"CVE-2009-1617"
],
"8551": [
"CVE-2009-1619"
],
"8552": [
"CVE-2009-1618"
],
"8553": [],
"8555": [
"CVE-2009-1550"
],
"8557": [],
"8558": [
"CVE-2009-2451"
],
"8559": [],
"8563": [
"CVE-2009-1506"
],
"8565": [
"CVE-2009-1500"
],
"8566": [
"CVE-2009-1502"
],
"8567": [],
"8571": [
"CVE-2009-1503"
],
"8576": [
"CVE-2009-1613"
],
"8577": [
"CVE-2009-1615",
"CVE-2009-1614",
"CVE-2009-1613"
],
"8585": [],
"8586": [
"CVE-2009-2573"
],
"8587": [
"CVE-2009-2574"
],
"8593": [
"CVE-2009-1519"
],
"8596": [
"CVE-2009-4760"
],
"8599": [
"CVE-2009-1549"
],
"8600": [
"CVE-2009-1548"
],
"8602": [
"CVE-2009-1551"
],
"8603": [
"CVE-2009-1659"
],
"8604": [
"CVE-2009-1587"
],
"8605": [
"CVE-2009-1582"
],
"8608": [],
"8609": [],
"8610": [],
"8615": [
"CVE-2009-1585",
"CVE-2009-1584",
"CVE-2009-1583"
],
"8616": [
"CVE-2009-1584"
],
"8618": [
"CVE-2009-1607"
],
"8619": [
"CVE-2009-2567"
],
"8622": [
"CVE-2009-1912"
],
"8626": [
"CVE-2009-1670"
],
"8627": [
"CVE-2009-1638"
],
"8635": [],
"8636": [
"CVE-2009-1799"
],
"8638": [
"CVE-2009-1637"
],
"8639": [
"CVE-2009-1610"
],
"8642": [
"CVE-2009-1662"
],
"8643": [
"CVE-2009-1658"
],
"8645": [
"CVE-2009-1913"
],
"8647": [
"CVE-2009-1609"
],
"8648": [
"CVE-2009-1910"
],
"8649": [
"CVE-2009-1911"
],
"8652": [],
"8653": [],
"8654": [],
"8655": [
"CVE-2009-1661"
],
"8658": [
"CVE-2009-1781",
"CVE-2009-1780",
"CVE-2009-1779"
],
"8659": [
"CVE-2009-1678",
"CVE-2009-1677",
"CVE-2009-1669"
],
"8664": [
"CVE-2009-1778"
],
"8667": [
"CVE-2009-1653"
],
"8668": [
"CVE-2009-2003"
],
"8671": [
"CVE-2009-2010"
],
"8672": [
"CVE-2009-1818"
],
"8674": [],
"8675": [
"CVE-2009-2003"
],
"8676": [
"CVE-2009-1816"
],
"8679": [
"CVE-2009-1650"
],
"8680": [
"CVE-2009-1649"
],
"8681": [
"CVE-2009-1774"
],
"8682": [],
"8683": [
"CVE-2009-1813"
],
"8684": [],
"8685": [],
"8686": [],
"8687": [],
"8688": [],
"8689": [
"CVE-2009-1652",
"CVE-2009-1651"
],
"8690": [
"CVE-2009-1665",
"CVE-2009-1664",
"CVE-2009-1663",
"CVE-2009-1655",
"CVE-2009-1654"
],
"8691": [
"CVE-2009-1767"
],
"8692": [],
"8694": [],
"8697": [
"CVE-2009-1822"
],
"8699": [],
"8700": [
"CVE-2009-1768"
],
"8702": [
"CVE-2009-1820",
"CVE-2009-1819"
],
"8705": [
"CVE-2009-1821"
],
"8706": [
"CVE-2009-1814"
],
"8707": [
"CVE-2009-1825",
"CVE-2009-1810",
"CVE-2009-1809"
],
"8708": [
"CVE-2009-1826",
"CVE-2009-1812",
"CVE-2009-1811"
],
"8709": [
"CVE-2009-1742"
],
"8710": [
"CVE-2009-1787"
],
"8711": [],
"8713": [],
"8714": [
"CVE-2009-1771",
"CVE-2009-1770"
],
"8715": [
"CVE-2009-1765"
],
"8717": [],
"8718": [],
"8719": [],
"8724": [
"CVE-2009-1766"
],
"8725": [],
"8726": [
"CVE-2009-1764"
],
"8727": [
"CVE-2009-1746"
],
"8728": [],
"8730": [
"CVE-2009-1750"
],
"8731": [
"CVE-2009-1736"
],
"8734": [],
"8735": [
"CVE-2009-1739"
],
"8736": [],
"8737": [
"CVE-2009-1735",
"CVE-2009-1734"
],
"8738": [],
"8739": [],
"8740": [],
"8741": [
"CVE-2009-1741"
],
"8743": [
"CVE-2009-2239"
],
"8744": [
"CVE-2009-1752"
],
"8745": [
"CVE-2009-1749",
"CVE-2009-1748"
],
"8746": [],
"8747": [],
"8748": [
"CVE-2009-1751"
],
"8749": [
"CVE-2009-2238"
],
"8750": [],
"8751": [
"CVE-2009-1747"
],
"8752": [],
"8755": [
"CVE-2009-2234"
],
"8756": [
"CVE-2009-2243",
"CVE-2009-2242",
"CVE-2009-2241"
],
"8759": [
"CVE-2009-1843"
],
"8761": [
"CVE-2009-2236"
],
"8762": [
"CVE-2009-2235"
],
"8763": [],
"8764": [],
"8766": [
"CVE-2009-2293"
],
"8769": [],
"8771": [],
"8773": [],
"8774": [
"CVE-2009-4674"
],
"8775": [
"CVE-2009-4675"
],
"8776": [],
"8778": [],
"8779": [
"CVE-2009-2290"
],
"8781": [
"CVE-2009-1960"
],
"8784": [],
"8785": [
"CVE-2009-4665"
],
"8787": [],
"8788": [
"CVE-2009-4673",
"CVE-2009-3358"
],
"8790": [
"CVE-2009-1936"
],
"8791": [
"CVE-2009-4672"
],
"8792": [
"CVE-2009-4666"
],
"8793": [],
"8795": [],
"8796": [],
"8797": [
"CVE-2009-4671",
"CVE-2009-4670",
"CVE-2009-4669"
],
"8801": [],
"8802": [
"CVE-2009-1853"
],
"8803": [
"CVE-2009-1852"
],
"8805": [],
"8807": [],
"8808": [
"CVE-2009-1850"
],
"8809": [],
"8810": [
"CVE-2009-4667"
],
"8811": [],
"8812": [
"CVE-2009-1960"
],
"8813": [
"CVE-2009-1854"
],
"8814": [
"CVE-2009-1848"
],
"8815": [
"CVE-2009-1847"
],
"8816": [
"CVE-2009-1846"
],
"8817": [],
"8818": [
"CVE-2009-4939"
],
"8819": [
"CVE-2009-4936"
],
"8820": [],
"8821": [],
"8823": [
"CVE-2009-2600"
],
"8825": [
"CVE-2009-2604"
],
"8827": [],
"8828": [
"CVE-2009-4203"
],
"8829": [
"CVE-2009-4940"
],
"8830": [
"CVE-2009-4206"
],
"8831": [
"CVE-2009-2605"
],
"8834": [
"CVE-2009-2599"
],
"8836": [
"CVE-2009-3040"
],
"8838": [],
"8839": [
"CVE-2009-4208"
],
"8840": [
"CVE-2009-2603"
],
"8841": [
"CVE-2009-1949",
"CVE-2009-1948",
"CVE-2009-1947"
],
"8843": [],
"8844": [
"CVE-2009-2598"
],
"8847": [
"CVE-2009-2601"
],
"8848": [],
"8849": [
"CVE-2009-2602"
],
"8850": [
"CVE-2009-1941"
],
"8851": [
"CVE-2009-1946"
],
"8852": [
"CVE-2009-2606"
],
"8853": [
"CVE-2009-2037"
],
"8854": [
"CVE-2009-2598"
],
"8855": [],
"8856": [
"CVE-2009-4205",
"CVE-2009-4204"
],
"8857": [
"CVE-2009-1945"
],
"8858": [
"CVE-2009-1952",
"CVE-2009-1951"
],
"8859": [
"CVE-2009-1950"
],
"8860": [],
"8864": [
"CVE-2009-4198"
],
"8865": [
"CVE-2009-2168",
"CVE-2009-2167"
],
"8866": [],
"8867": [
"CVE-2009-4200"
],
"8868": [
"CVE-2009-2166"
],
"8869": [],
"8870": [
"CVE-2009-4202"
],
"8871": [
"CVE-2009-4836"
],
"8872": [
"CVE-2009-4199"
],
"8874": [],
"8876": [],
"8877": [],
"8878": [],
"8879": [],
"8882": [],
"8883": [],
"8884": [
"CVE-2009-2164"
],
"8885": [
"CVE-2009-2164"
],
"8886": [
"CVE-2009-2018"
],
"8889": [
"CVE-2009-2024"
],
"8890": [
"CVE-2009-2022"
],
"8891": [
"CVE-2009-2014"
],
"8892": [
"CVE-2009-2021"
],
"8893": [
"CVE-2009-2017"
],
"8894": [
"CVE-2009-2016"
],
"8895": [
"CVE-2009-2640"
],
"8898": [
"CVE-2009-2015"
],
"8900": [
"CVE-2009-2013"
],
"8901": [
"CVE-2009-2020",
"CVE-2009-2019"
],
"8902": [
"CVE-2009-2040"
],
"8903": [
"CVE-2009-2025"
],
"8904": [],
"8905": [],
"8906": [
"CVE-2009-2023"
],
"8908": [
"CVE-2009-2637"
],
"8911": [
"CVE-2009-2638"
],
"8912": [
"CVE-2009-2634"
],
"8913": [],
"8914": [],
"8915": [],
"8917": [
"CVE-2009-2639",
"CVE-2009-2080"
],
"8918": [],
"8919": [
"CVE-2009-2635"
],
"8920": [
"CVE-2009-2633"
],
"8921": [
"CVE-2009-1151"
],
"8923": [],
"8924": [
"CVE-2009-2641"
],
"8925": [
"CVE-2009-2642"
],
"8926": [],
"8927": [
"CVE-2009-2036"
],
"8928": [
"CVE-2009-2081"
],
"8929": [],
"8931": [
"CVE-2009-2101"
],
"8932": [
"CVE-2009-2034",
"CVE-2009-2033"
],
"8933": [],
"8935": [
"CVE-2009-2142"
],
"8936": [
"CVE-2009-2132",
"CVE-2009-2131"
],
"8937": [
"CVE-2009-2150",
"CVE-2009-2149",
"CVE-2009-2148"
],
"8939": [
"CVE-2009-2147"
],
"8941": [
"CVE-2009-2134",
"CVE-2009-2133"
],
"8942": [
"CVE-2009-2141",
"CVE-2009-2138"
],
"8943": [
"CVE-2009-2145"
],
"8944": [],
"8946": [
"CVE-2009-2100"
],
"8947": [
"CVE-2009-2154",
"CVE-2009-2153"
],
"8948": [
"CVE-2009-2095"
],
"8949": [
"CVE-2009-2146"
],
"8950": [
"CVE-2009-1777",
"CVE-2009-1776"
],
"8951": [
"CVE-2009-2111"
],
"8952": [
"CVE-2009-2110"
],
"8953": [
"CVE-2009-2130",
"CVE-2009-2129",
"CVE-2009-2127",
"CVE-2009-2124",
"CVE-2009-2123"
],
"8954": [
"CVE-2009-2152",
"CVE-2009-2151"
],
"8956": [],
"8958": [
"CVE-2009-2161",
"CVE-2009-2160",
"CVE-2009-2159",
"CVE-2009-2158",
"CVE-2009-2157",
"CVE-2009-2156"
],
"8959": [
"CVE-2009-2099"
],
"8961": [
"CVE-2009-2122"
],
"8962": [
"CVE-2009-2096"
],
"8965": [
"CVE-2009-2172"
],
"8966": [
"CVE-2009-2098"
],
"8967": [],
"8968": [
"CVE-2009-2102"
],
"8974": [],
"8975": [
"CVE-2009-2112"
],
"8977": [
"CVE-2009-2120"
],
"8978": [
"CVE-2009-2177",
"CVE-2009-2176"
],
"8979": [
"CVE-2009-2109"
],
"8980": [
"CVE-2009-2113"
],
"8981": [
"CVE-2009-2117"
],
"8984": [],
"8987": [
"CVE-2009-2231"
],
"8988": [
"CVE-2009-2180"
],
"8990": [
"CVE-2009-2179",
"CVE-2009-2178"
],
"8992": [
"CVE-2009-1151"
],
"8993": [],
"8994": [
"CVE-2009-2233"
],
"8995": [
"CVE-2009-2183",
"CVE-2009-2182",
"CVE-2009-2181"
],
"8996": [
"CVE-2009-2184"
],
"8997": [
"CVE-2009-2229",
"CVE-2009-2228"
],
"8998": [],
"8999": [],
"9000": [
"CVE-2009-2209"
],
"9001": [
"CVE-2009-2230"
],
"9004": [
"CVE-2009-2255"
],
"9005": [
"CVE-2009-2254"
],
"9008": [
"CVE-2009-2219",
"CVE-2009-2218"
],
"9009": [],
"9010": [],
"9011": [],
"9012": [
"CVE-2009-2220"
],
"9014": [
"CVE-2009-2402",
"CVE-2009-2401"
],
"9015": [
"CVE-2009-2223"
],
"9016": [
"CVE-2009-2609"
],
"9017": [
"CVE-2009-2607"
],
"9018": [
"CVE-2009-2611"
],
"9019": [],
"9020": [],
"9021": [
"CVE-2009-2618"
],
"9022": [
"CVE-2009-2393",
"CVE-2009-2392",
"CVE-2009-2391"
],
"9023": [
"CVE-2009-2608",
"CVE-2009-2259",
"CVE-2008-2565"
],
"9024": [
"CVE-2009-2366"
],
"9025": [
"CVE-2009-2263"
],
"9026": [],
"9027": [
"CVE-2009-2394"
],
"9028": [
"CVE-2009-2400"
],
"9030": [
"CVE-2009-2395"
],
"9032": [
"CVE-2009-2361"
],
"9035": [],
"9036": [
"CVE-2009-2398"
],
"9037": [
"CVE-2009-2325"
],
"9040": [
"CVE-2009-2390"
],
"9041": [
"CVE-2009-2397"
],
"9042": [
"CVE-2009-2389"
],
"9043": [
"CVE-2009-2396"
],
"9044": [
"CVE-2009-2399"
],
"9048": [],
"9049": [],
"9050": [
"CVE-2009-2385"
],
"9051": [
"CVE-2009-2378"
],
"9052": [
"CVE-2009-2379"
],
"9053": [
"CVE-2009-2382"
],
"9054": [
"CVE-2009-2383"
],
"9055": [
"CVE-2009-2308"
],
"9056": [
"CVE-2009-2307"
],
"9057": [],
"9058": [
"CVE-2009-2276"
],
"9059": [],
"9062": [],
"9063": [],
"9068": [
"CVE-2009-2329",
"CVE-2009-2328",
"CVE-2009-2327",
"CVE-2009-2326"
],
"9069": [
"CVE-2009-2333",
"CVE-2009-2332",
"CVE-2009-2331",
"CVE-2009-2330"
],
"9073": [],
"9074": [
"CVE-2009-2344"
],
"9075": [],
"9076": [],
"9077": [],
"9079": [
"CVE-2009-2388",
"CVE-2009-2340"
],
"9080": [
"CVE-2009-2341"
],
"9081": [
"CVE-2009-2339"
],
"9086": [],
"9087": [],
"9088": [],
"9089": [
"CVE-2009-3535"
],
"9091": [
"CVE-2009-2585"
],
"9092": [],
"9094": [],
"9095": [
"CVE-2009-4874",
"CVE-2009-4854"
],
"9098": [
"CVE-2009-2443"
],
"9099": [
"CVE-2009-3531"
],
"9101": [
"CVE-2009-3756",
"CVE-2009-3755",
"CVE-2009-3754"
],
"9103": [
"CVE-2009-3825"
],
"9105": [
"CVE-2009-3528"
],
"9107": [
"CVE-2009-3543"
],
"9109": [
"CVE-2009-3750"
],
"9110": [
"CVE-2009-2334"
],
"9111": [
"CVE-2009-2427"
],
"9112": [],
"9115": [
"CVE-2009-3597"
],
"9118": [
"CVE-2009-2424",
"CVE-2009-2423"
],
"9119": [
"CVE-2009-3534"
],
"9121": [
"CVE-2009-3713"
],
"9122": [
"CVE-2009-3753",
"CVE-2009-3752",
"CVE-2009-3751"
],
"9125": [
"CVE-2009-3712"
],
"9126": [],
"9127": [],
"9129": [
"CVE-2009-2594",
"CVE-2009-2593"
],
"9130": [],
"9132": [],
"9138": [],
"9140": [
"CVE-2009-2925"
],
"9144": [
"CVE-2009-3823"
],
"9145": [],
"9150": [
"CVE-2009-4748"
],
"9151": [],
"9153": [
"CVE-2009-2557"
],
"9154": [
"CVE-2009-4566",
"CVE-2009-4564"
],
"9155": [
"CVE-2009-3541"
],
"9156": [
"CVE-2009-3824"
],
"9159": [
"CVE-2009-3949"
],
"9161": [
"CVE-2009-2558"
],
"9162": [
"CVE-2009-4560"
],
"9164": [],
"9165": [
"CVE-2009-4561"
],
"9166": [
"CVE-2009-4563",
"CVE-2009-4562"
],
"9171": [
"CVE-2009-3595"
],
"9174": [
"CVE-2009-4749"
],
"9176": [],
"9179": [
"CVE-2009-2552"
],
"9180": [
"CVE-2009-2553"
],
"9182": [
"CVE-2009-3596"
],
"9183": [
"CVE-2009-3719",
"CVE-2009-3718"
],
"9184": [],
"9185": [
"CVE-2009-4683",
"CVE-2009-4682"
],
"9187": [
"CVE-2009-2554"
],
"9193": [],
"9194": [
"CVE-2009-3530",
"CVE-2009-3529"
],
"9195": [
"CVE-2009-4695",
"CVE-2009-4694",
"CVE-2009-4692"
],
"9196": [
"CVE-2009-4697",
"CVE-2009-4696"
],
"9202": [
"CVE-2009-4687"
],
"9203": [
"CVE-2009-4876"
],
"9204": [
"CVE-2009-4693"
],
"9205": [
"CVE-2009-3716",
"CVE-2009-3715",
"CVE-2009-3714"
],
"9211": [
"CVE-2009-2439"
],
"9217": [
"CVE-2009-2591"
],
"9219": [
"CVE-2009-2770"
],
"9225": [],
"9226": [
"CVE-2009-4681",
"CVE-2009-4680"
],
"9227": [],
"9231": [],
"9235": [],
"9236": [
"CVE-2009-0299"
],
"9237": [
"CVE-2009-3219",
"CVE-2009-3218"
],
"9238": [],
"9239": [],
"9243": [],
"9244": [],
"9246": [
"CVE-2009-2881"
],
"9248": [
"CVE-2009-2883"
],
"9249": [
"CVE-2009-4714",
"CVE-2009-4713",
"CVE-2009-4698"
],
"9250": [
"CVE-2009-2851"
],
"9251": [],
"9252": [
"CVE-2009-2892"
],
"9254": [
"CVE-2008-0821"
],
"9255": [],
"9256": [
"CVE-2009-4987"
],
"9257": [
"CVE-2009-2922"
],
"9258": [
"CVE-2009-3155",
"CVE-2009-3154"
],
"9259": [],
"9260": [
"CVE-2009-4739",
"CVE-2009-4700",
"CVE-2009-4699"
],
"9261": [
"CVE-2009-4698"
],
"9262": [
"CVE-2009-2778",
"CVE-2009-2777"
],
"9263": [
"CVE-2009-2895"
],
"9266": [
"CVE-2009-3217",
"CVE-2009-3216"
],
"9267": [],
"9269": [
"CVE-2009-2773"
],
"9270": [
"CVE-2009-3224"
],
"9271": [
"CVE-2009-3223"
],
"9273": [
"CVE-2009-3430"
],
"9274": [
"CVE-2009-4735"
],
"9275": [
"CVE-2009-4734"
],
"9276": [
"CVE-2009-3215"
],
"9279": [],
"9280": [],
"9281": [
"CVE-2009-4722"
],
"9282": [],
"9283": [],
"9284": [],
"9287": [
"CVE-2009-2774"
],
"9288": [
"CVE-2009-2775"
],
"9289": [
"CVE-2009-2786"
],
"9290": [],
"9292": [
"CVE-2009-3423"
],
"9293": [
"CVE-2009-3421"
],
"9294": [
"CVE-2009-3422"
],
"9296": [
"CVE-2011-4908"
],
"9297": [
"CVE-2009-2769"
],
"9307": [
"CVE-2009-3151"
],
"9308": [
"CVE-2009-3511"
],
"9309": [],
"9310": [
"CVE-2009-2784"
],
"9311": [
"CVE-2009-3507",
"CVE-2009-3506"
],
"9312": [
"CVE-2009-3515",
"CVE-2009-3514"
],
"9313": [
"CVE-2009-2792"
],
"9314": [
"CVE-2009-3508"
],
"9315": [
"CVE-2009-2787"
],
"9316": [
"CVE-2009-3510"
],
"9320": [
"CVE-2009-2781"
],
"9322": [
"CVE-2009-3424"
],
"9324": [
"CVE-2009-2782"
],
"9325": [
"CVE-2009-3148"
],
"9326": [],
"9327": [
"CVE-2009-2788"
],
"9328": [
"CVE-2009-4721"
],
"9331": [
"CVE-2009-2791"
],
"9332": [
"CVE-2009-4727"
],
"9333": [
"CVE-2009-4723"
],
"9334": [
"CVE-2009-4726"
],
"9335": [
"CVE-2009-4732"
],
"9336": [
"CVE-2009-4733"
],
"9337": [
"CVE-2009-3158"
],
"9338": [
"CVE-2009-3420",
"CVE-2009-3419"
],
"9339": [
"CVE-2009-4552",
"CVE-2009-4551"
],
"9340": [
"CVE-2009-4730",
"CVE-2009-4729"
],
"9341": [
"CVE-2009-4728"
],
"9342": [
"CVE-2009-2920"
],
"9344": [
"CVE-2009-3150"
],
"9347": [
"CVE-2009-4725"
],
"9348": [],
"9349": [
"CVE-2009-4719"
],
"9350": [
"CVE-2009-3426",
"CVE-2009-3425"
],
"9351": [
"CVE-2009-4724"
],
"9353": [
"CVE-2009-2921"
],
"9355": [
"CVE-2009-3149"
],
"9356": [],
"9357": [],
"9358": [
"CVE-2009-4986"
],
"9365": [
"CVE-2009-4978",
"CVE-2009-4977"
],
"9367": [],
"9369": [
"CVE-2009-4982"
],
"9370": [
"CVE-2009-4985",
"CVE-2009-4984"
],
"9371": [
"CVE-2009-2736",
"CVE-2009-2735"
],
"9372": [],
"9378": [],
"9380": [
"CVE-2009-4855"
],
"9383": [
"CVE-2009-4993",
"CVE-2009-4992"
],
"9384": [
"CVE-2009-4862"
],
"9385": [],
"9387": [
"CVE-2009-5003"
],
"9389": [
"CVE-2009-4871"
],
"9390": [
"CVE-2009-4860"
],
"9394": [],
"9395": [
"CVE-2009-4870"
],
"9396": [
"CVE-2009-4544",
"CVE-2009-4543"
],
"9397": [
"CVE-2009-4542",
"CVE-2009-4541"
],
"9398": [],
"9399": [
"CVE-2009-4872"
],
"9400": [
"CVE-2009-4546",
"CVE-2009-4545"
],
"9404": [],
"9405": [],
"9406": [
"CVE-2009-4540"
],
"9407": [],
"9408": [
"CVE-2009-4550"
],
"9410": [
"CVE-2009-2762"
],
"9413": [
"CVE-2009-3417"
],
"9416": [
"CVE-2009-3042"
],
"9419": [],
"9421": [],
"9424": [
"CVE-2009-3418"
],
"9425": [
"CVE-2009-3182",
"CVE-2009-3181",
"CVE-2009-3180",
"CVE-2009-3171",
"CVE-2009-3167"
],
"9430": [],
"9431": [
"CVE-2009-2852"
],
"9433": [
"CVE-2009-3182"
],
"9434": [
"CVE-2009-2929",
"CVE-2009-2928"
],
"9437": [],
"9438": [
"CVE-2009-2926"
],
"9440": [
"CVE-2009-2927"
],
"9441": [],
"9444": [
"CVE-2009-2923"
],
"9445": [],
"9447": [
"CVE-2009-3203"
],
"9448": [
"CVE-2009-3041"
],
"9450": [
"CVE-2009-3250",
"CVE-2009-3249",
"CVE-2009-3248",
"CVE-2009-3247"
],
"9451": [],
"9452": [],
"9453": [
"CVE-2009-2924"
],
"9459": [],
"9460": [],
"9461": [],
"9462": [
"CVE-2009-3211"
],
"9463": [],
"9464": [],
"9465": [
"CVE-2009-3208"
],
"9469": [],
"9470": [
"CVE-2009-3209"
],
"9471": [
"CVE-2009-3205"
],
"9472": [],
"9474": [],
"9475": [],
"9481": [
"CVE-2009-3975"
],
"9482": [
"CVE-2009-3966"
],
"9484": [
"CVE-2009-3970"
],
"9485": [
"CVE-2009-2960"
],
"9490": [
"CVE-2009-4961"
],
"9491": [],
"9493": [
"CVE-2009-3199"
],
"9494": [],
"9497": [
"CVE-2009-3968"
],
"9499": [
"CVE-2009-3965"
],
"9502": [
"CVE-2009-3964"
],
"9504": [
"CVE-2009-3971"
],
"9505": [],
"9510": [
"CVE-2009-3972"
],
"9511": [
"CVE-2009-3973",
"CVE-2008-5629"
],
"9512": [],
"40383": [],
"9518": [
"CVE-2009-4958"
],
"9522": [
"CVE-2009-4614"
],
"9523": [],
"9524": [
"CVE-2009-4974",
"CVE-2009-4973"
],
"9525": [
"CVE-2009-4627"
],
"9527": [],
"9529": [
"CVE-2009-3185"
],
"9530": [],
"9531": [
"CVE-2009-3191",
"CVE-2009-3190"
],
"9532": [],
"9533": [
"CVE-2009-3188"
],
"9534": [
"CVE-2009-3193"
],
"9535": [
"CVE-2009-3116",
"CVE-2009-3081"
],
"9538": [
"CVE-2009-3117",
"CVE-2009-3082"
],
"9544": [],
"9552": [],
"9553": [
"CVE-2009-3252"
],
"9555": [
"CVE-2009-3246"
],
"9556": [],
"9562": [],
"9563": [
"CVE-2009-3054"
],
"9564": [
"CVE-2009-3053"
],
"9565": [
"CVE-2009-4478",
"CVE-2009-4477"
],
"9566": [
"CVE-2009-3056"
],
"9569": [
"CVE-2009-3052"
],
"9570": [
"CVE-2009-3064"
],
"9571": [
"CVE-2009-3063"
],
"9572": [
"CVE-2009-3055"
],
"9576": [
"CVE-2009-4621"
],
"9577": [
"CVE-2009-3065"
],
"9578": [
"CVE-2009-3062"
],
"9582": [
"CVE-2009-4471"
],
"9583": [
"CVE-2009-4472"
],
"9588": [
"CVE-2009-4474"
],
"9590": [
"CVE-2009-4834"
],
"9591": [],
"9593": [
"CVE-2009-4475"
],
"9599": [
"CVE-2009-3173"
],
"9600": [
"CVE-2009-3174"
],
"9601": [
"CVE-2009-4625"
],
"9602": [
"CVE-2009-4628"
],
"9603": [
"CVE-2009-3175"
],
"9604": [
"CVE-2009-4620"
],
"9605": [
"CVE-2009-4106"
],
"9609": [],
"9611": [
"CVE-2009-4626"
],
"9612": [],
"9623": [
"CVE-2009-4623"
],
"9625": [
"CVE-2009-3666",
"CVE-2009-3665",
"CVE-2009-3664"
],
"9629": [],
"9630": [
"CVE-2009-4616",
"CVE-2009-4615"
],
"9631": [
"CVE-2009-4624"
],
"9632": [
"CVE-2009-4617"
],
"9633": [
"CVE-2009-4618"
],
"9634": [
"CVE-2009-3358"
],
"9635": [
"CVE-2009-4622"
],
"9636": [
"CVE-2009-3367",
"CVE-2009-3366"
],
"9637": [
"CVE-2009-3494"
],
"9639": [
"CVE-2009-3356"
],
"9640": [
"CVE-2009-3349",
"CVE-2009-3348"
],
"9647": [
"CVE-2009-3361"
],
"9648": [
"CVE-2009-3368",
"CVE-2009-3357"
],
"9653": [
"CVE-2009-3335"
],
"9654": [
"CVE-2009-3342"
],
"9656": [
"CVE-2009-3365"
],
"9665": [
"CVE-2009-3336"
],
"9669": [
"CVE-2009-3659"
],
"9674": [],
"9675": [
"CVE-2009-3343"
],
"9681": [
"CVE-2009-3660"
],
"9692": [],
"9693": [
"CVE-2009-3661"
],
"9696": [
"CVE-2009-3667"
],
"9697": [
"CVE-2009-3669"
],
"9698": [],
"9699": [],
"9700": [
"CVE-2009-3321"
],
"9702": [
"CVE-2009-3314"
],
"9703": [
"CVE-2009-3312"
],
"9706": [
"CVE-2009-3318"
],
"9708": [
"CVE-2009-3317"
],
"9710": [
"CVE-2009-3309"
],
"9711": [
"CVE-2009-3313"
],
"9712": [
"CVE-2009-3315"
],
"9713": [
"CVE-2009-3316"
],
"9714": [
"CVE-2009-3333"
],
"9715": [
"CVE-2009-3310"
],
"9716": [
"CVE-2009-3306"
],
"9719": [
"CVE-2009-3308"
],
"9720": [
"CVE-2009-3307"
],
"9721": [
"CVE-2009-3325"
],
"9722": [
"CVE-2009-3331"
],
"9723": [
"CVE-2009-3332"
],
"9724": [
"CVE-2009-3323"
],
"9726": [
"CVE-2009-3330"
],
"9727": [
"CVE-2009-3326"
],
"9728": [
"CVE-2009-3324"
],
"9729": [
"CVE-2009-3492"
],
"9730": [
"CVE-2009-3328",
"CVE-2009-3327"
],
"9732": [
"CVE-2009-3334"
],
"9733": [
"CVE-2009-3446"
],
"9801": [],
"9809": [
"CVE-2009-3642"
],
"9812": [],
"9818": [],
"9819": [],
"9820": [],
"9821": [],
"9822": [
"CVE-2009-3443"
],
"9824": [],
"9825": [
"CVE-2009-3444"
],
"9826": [],
"9828": [
"CVE-2009-3440",
"CVE-2009-3439"
],
"9830": [],
"9832": [
"CVE-2009-3434"
],
"9833": [
"CVE-2009-3438"
],
"9834": [
"CVE-2009-3499"
],
"9835": [],
"9836": [
"CVE-2009-3502"
],
"9837": [],
"9838": [
"CVE-2009-3500"
],
"9839": [
"CVE-2009-3705"
],
"9840": [],
"9841": [
"CVE-2009-3503"
],
"9847": [],
"9849": [],
"9850": [
"CVE-2009-3913"
],
"9854": [
"CVE-2009-3912"
],
"9855": [],
"9856": [
"CVE-2009-4554"
],
"9857": [
"CVE-2009-4743"
],
"9861": [
"CVE-2009-2288"
],
"9863": [
"CVE-2009-2733"
],
"9867": [
"CVE-2009-3802"
],
"9872": [
"CVE-2009-1479"
],
"9873": [
"CVE-2009-3902"
],
"9875": [
"CVE-2009-3904"
],
"9876": [
"CVE-2009-3806"
],
"9877": [],
"9880": [],
"9885": [],
"9887": [
"CVE-2009-4610"
],
"9888": [
"CVE-2009-3822"
],
"9889": [
"CVE-2009-3817"
],
"9890": [],
"9891": [
"CVE-2009-3835"
],
"9892": [],
"9897": [
"CVE-2009-4535"
],
"9898": [],
"9903": [
"CVE-2009-3789"
],
"9904": [],
"9906": [
"CVE-2008-2905"
],
"9907": [
"CVE-1999-1053"
],
"9908": [
"CVE-2006-2685"
],
"9909": [
"CVE-2006-2237"
],
"9911": [],
"9912": [
"CVE-2005-0116"
],
"9916": [],
"9922": [
"CVE-2009-4512"
],
"9926": [
"CVE-2011-4908"
],
"9933": [],
"9958": [
"CVE-2006-5675"
],
"9961": [],
"16007": [],
"9962": [],
"9963": [],
"9964": [
"CVE-2009-3804"
],
"9965": [],
"9967": [
"CVE-2009-3830"
],
"33434": [
"CVE-2014-2612"
],
"9975": [],
"9978": [],
"9979": [
"CVE-2009-3787"
],
"9981": [
"CVE-2009-3748"
],
"10002": [
"CVE-2009-4250",
"CVE-2009-4249",
"CVE-2009-4175",
"CVE-2009-4173",
"CVE-2009-4172"
],
"10003": [
"CVE-2009-4742"
],
"10006": [
"CVE-2009-4746",
"CVE-2009-4745"
],
"10012": [
"CVE-2009-5067"
],
"10013": [
"CVE-2009-2898"
],
"10016": [],
"10031": [
"CVE-2007-3010"
],
"10042": [
"CVE-2009-2734"
],
"10043": [],
"10045": [],
"10046": [],
"10049": [],
"10050": [
"CVE-2009-3694"
],
"10051": [],
"10052": [],
"10057": [
"CVE-2009-4747"
],
"10058": [],
"10059": [],
"10061": [
"CVE-2009-3565"
],
"10064": [
"CVE-2009-3645"
],
"10067": [
"CVE-2009-3644"
],
"10069": [
"CVE-2009-2269"
],
"10074": [],
"10075": [],
"33477": [],
"33428": [
"CVE-2007-6483"
],
"10082": [],
"10085": [
"CVE-2009-4849"
],
"10088": [],
"10089": [
"CVE-2009-3890"
],
"10090": [],
"10094": [
"CVE-2009-3730"
],
"10096": [],
"10101": [
"CVE-2009-4089",
"CVE-2009-4088"
],
"10105": [],
"40083": [],
"10161": [],
"10165": [
"CVE-2009-4058"
],
"10166": [],
"10167": [
"CVE-2009-4229"
],
"10168": [
"CVE-2009-4767"
],
"10169": [
"CVE-2015-4181",
"CVE-2009-4050"
],
"10170": [
"CVE-2009-4086"
],
"10177": [
"CVE-2009-4057"
],
"10178": [
"CVE-2009-4094"
],
"10180": [
"CVE-2009-4093",
"CVE-2009-4092",
"CVE-2009-4091"
],
"10181": [],
"10183": [
"CVE-2011-4906"
],
"10189": [
"CVE-2009-4056"
],
"10192": [
"CVE-2009-4059"
],
"10209": [
"CVE-2009-3828"
],
"40303": [],
"40304": [],
"10214": [],
"10216": [
"CVE-2009-4223"
],
"10217": [
"CVE-2009-4779"
],
"10218": [
"CVE-2009-4082"
],
"10219": [
"CVE-2009-4085"
],
"10220": [
"CVE-2009-4220"
],
"10222": [],
"10224": [
"CVE-2009-4120"
],
"10225": [],
"10227": [],
"10228": [
"CVE-2009-4170"
],
"10230": [],
"10231": [
"CVE-2009-4096"
],
"10232": [
"CVE-2009-4099"
],
"10233": [
"CVE-2009-4222"
],
"10234": [
"CVE-2010-2543",
"CVE-2009-4032"
],
"10236": [],
"10238": [
"CVE-2009-4104"
],
"10241": [],
"10245": [
"CVE-2009-4221"
],
"10246": [
"CVE-2009-4231",
"CVE-2009-4224"
],
"10247": [
"CVE-2009-4234"
],
"10248": [],
"10249": [],
"10250": [
"CVE-2009-4217"
],
"10252": [
"CVE-2009-4785"
],
"10253": [
"CVE-2009-4155"
],
"10254": [],
"10256": [],
"10259": [
"CVE-2009-4156"
],
"10260": [],
"10261": [],
"10262": [],
"10263": [],
"10272": [
"CVE-2009-4784"
],
"10273": [
"CVE-2009-4789"
],
"10274": [
"CVE-2013-0192",
"CVE-2009-5068"
],
"10275": [],
"10276": [
"CVE-2009-4197",
"CVE-2009-4196"
],
"10277": [],
"10284": [],
"10285": [],
"10286": [],
"10287": [],
"10288": [],
"10289": [],
"10290": [
"CVE-2009-4783",
"CVE-2009-4782"
],
"10291": [
"CVE-2009-4157"
],
"10292": [],
"10293": [],
"10294": [],
"10297": [],
"10299": [
"CVE-2009-4263"
],
"10302": [],
"10304": [],
"10305": [
"CVE-2009-4266"
],
"10306": [],
"10307": [],
"10312": [],
"10314": [],
"10318": [],
"10324": [
"CVE-2009-4571"
],
"10325": [],
"10329": [
"CVE-2009-4264"
],
"10330": [
"CVE-2009-4569"
],
"10331": [],
"10337": [],
"10341": [],
"10347": [],
"10350": [],
"10351": [],
"10354": [
"CVE-2009-4567"
],
"10356": [],
"10357": [
"CVE-2009-3061"
],
"10358": [
"CVE-2009-4256"
],
"10361": [
"CVE-2009-4613",
"CVE-2009-4600"
],
"10364": [
"CVE-2009-4238",
"CVE-2009-4237"
],
"10366": [
"CVE-2009-4599"
],
"10367": [
"CVE-2009-4598"
],
"10368": [],
"10369": [
"CVE-2009-4604"
],
"10370": [
"CVE-2009-4597",
"CVE-2009-4596",
"CVE-2009-4595"
],
"10372": [],
"10376": [],
"10378": [
"CVE-2009-4315"
],
"10379": [
"CVE-2009-4908",
"CVE-2009-4907"
],
"10383": [],
"10384": [
"CVE-2008-6242"
],
"10386": [
"CVE-2005-0549",
"CVE-2005-0548"
],
"10388": [],
"10389": [],
"10390": [],
"10391": [
"CVE-2008-6498"
],
"10393": [
"CVE-2009-4386"
],
"14948": [
"CVE-2010-4893"
],
"10395": [],
"10398": [],
"10400": [],
"10403": [
"CVE-2006-6377"
],
"10404": [],
"10406": [
"CVE-2009-4905"
],
"10407": [],
"10408": [],
"10410": [
"CVE-2009-4427"
],
"10412": [
"CVE-2009-4906"
],
"10414": [],
"10417": [],
"10418": [],
"10419": [],
"10420": [],
"10421": [],
"10422": [
"CVE-2009-4319"
],
"10424": [],
"10425": [],
"10426": [],
"10427": [
"CVE-2008-1985"
],
"10428": [],
"10429": [],
"10430": [],
"10431": [
"CVE-2009-4502"
],
"10432": [
"CVE-2009-4501",
"CVE-2009-4499",
"CVE-2009-4498"
],
"10433": [
"CVE-2009-4827"
],
"10436": [
"CVE-2009-4349"
],
"10437": [
"CVE-2007-0518"
],
"10438": [
"CVE-2009-4828"
],
"10439": [
"CVE-2009-4385",
"CVE-2009-4384"
],
"10440": [],
"10442": [],
"10444": [
"CVE-2009-4826"
],
"10445": [],
"10446": [
"CVE-2009-4351"
],
"10447": [],
"10448": [],
"10449": [],
"10450": [],
"10452": [],
"10453": [],
"10454": [],
"10455": [],
"10456": [],
"10457": [
"CVE-2009-2614"
],
"10458": [
"CVE-2009-4366",
"CVE-2009-4365",
"CVE-2009-4364"
],
"10461": [
"CVE-2009-4366",
"CVE-2009-4365",
"CVE-2009-4364"
],
"10462": [],
"10463": [],
"10464": [
"CVE-2009-2365"
],
"10465": [],
"10467": [],
"10470": [],
"10472": [],
"10473": [
"CVE-2009-2619"
],
"10474": [],
"10476": [],
"10478": [
"CVE-2009-4434",
"CVE-2009-4433"
],
"10479": [
"CVE-2009-4375"
],
"10480": [
"CVE-2009-4372"
],
"10481": [],
"10482": [],
"10483": [],
"10485": [
"CVE-2009-4429"
],
"10488": [
"CVE-2009-3703"
],
"10492": [],
"10493": [],
"10494": [],
"10495": [
"CVE-2008-3679"
],
"10496": [
"CVE-2006-4524"
],
"10497": [],
"10498": [],
"10499": [],
"10500": [],
"10501": [],
"10502": [],
"10503": [],
"10504": [],
"10505": [],
"10507": [],
"10511": [],
"10512": [
"CVE-2009-3701"
],
"10513": [
"CVE-2009-4367"
],
"10514": [
"CVE-2007-5026"
],
"10515": [],
"10516": [],
"10517": [],
"10520": [
"CVE-2009-4437"
],
"10522": [],
"10523": [],
"10525": [],
"10526": [
"CVE-2005-2062"
],
"10527": [],
"10528": [
"CVE-2008-6809"
],
"10529": [
"CVE-2009-4436"
],
"10531": [],
"10532": [
"CVE-2011-4275",
"CVE-2009-4140"
],
"10533": [
"CVE-2009-4430"
],
"10534": [
"CVE-2009-4403"
],
"10535": [
"CVE-2009-4424"
],
"10537": [],
"10540": [],
"10543": [],
"10545": [],
"10546": [],
"10547": [],
"10548": [],
"10549": [],
"10550": [],
"10552": [],
"10555": [],
"10558": [],
"10560": [
"CVE-2006-0087"
],
"10561": [
"CVE-2008-5781"
],
"10562": [],
"10564": [],
"10566": [],
"10567": [],
"10568": [
"CVE-2009-4818"
],
"10569": [
"CVE-2009-4426"
],
"10570": [],
"10571": [],
"10572": [
"CVE-2006-5236"
],
"10573": [
"CVE-2009-4825"
],
"10574": [
"CVE-2007-4527"
],
"10575": [],
"10576": [
"CVE-2009-4820"
],
"10578": [
"CVE-2009-4817"
],
"10582": [],
"10583": [],
"10584": [
"CVE-2009-4819"
],
"10585": [],
"10586": [
"CVE-2009-4432"
],
"10587": [
"CVE-2009-4431"
],
"10588": [],
"10590": [
"CVE-2008-2501"
],
"10591": [],
"10592": [],
"10594": [],
"10597": [
"CVE-2008-3748"
],
"10598": [
"CVE-2009-4468",
"CVE-2009-4467",
"CVE-2009-4466",
"CVE-2009-4465"
],
"10599": [
"CVE-2009-4816"
],
"10600": [],
"10601": [
"CVE-2008-6785"
],
"10604": [
"CVE-2009-4421"
],
"10606": [
"CVE-2009-4423"
],
"10609": [],
"10611": [],
"10612": [],
"10614": [],
"10615": [
"CVE-2007-1034"
],
"10621": [],
"10624": [],
"10625": [],
"10626": [
"CVE-2009-4447"
],
"10629": [],
"10630": [],
"10632": [],
"10633": [],
"10637": [
"CVE-2009-5019"
],
"10638": [],
"10639": [
"CVE-2008-0135"
],
"10640": [],
"10645": [
"CVE-2009-4458"
],
"10647": [],
"10648": [],
"10649": [
"CVE-2009-4453"
],
"10652": [],
"10653": [
"CVE-2009-4678"
],
"10654": [],
"10655": [],
"10656": [
"CVE-2005-3937"
],
"10658": [],
"10660": [],
"10661": [],
"10665": [],
"10666": [],
"10667": [
"CVE-2005-0952",
"CVE-2004-1975",
"CVE-2004-1551"
],
"10668": [
"CVE-2009-4469"
],
"10669": [],
"10670": [],
"10671": [],
"10672": [
"CVE-2009-4451"
],
"10673": [],
"10674": [],
"10675": [],
"10677": [],
"10679": [],
"10680": [],
"10681": [],
"10682": [],
"10683": [],
"10684": [],
"10685": [],
"10686": [
"CVE-2007-3061"
],
"10687": [],
"10688": [
"CVE-2009-4461"
],
"10689": [],
"10690": [],
"10691": [],
"10692": [],
"10693": [],
"10694": [],
"10695": [],
"10696": [],
"10697": [],
"10698": [],
"10699": [],
"10700": [],
"10701": [],
"10703": [],
"10704": [],
"10705": [],
"10706": [],
"10707": [],
"10708": [],
"10710": [
"CVE-2009-4456"
],
"10711": [],
"10712": [],
"10713": [],
"10716": [],
"10717": [],
"10718": [],
"10719": [],
"10720": [],
"10721": [],
"10722": [],
"10725": [],
"10726": [],
"10727": [],
"10728": [],
"10729": [],
"10730": [],
"10731": [],
"10732": [],
"10733": [],
"10734": [
"CVE-2009-4576"
],
"10735": [],
"10736": [],
"10737": [
"CVE-2009-4578"
],
"10738": [
"CVE-2009-4575"
],
"10739": [],
"10740": [],
"10741": [],
"10742": [
"CVE-2009-4583"
],
"10743": [],
"10750": [],
"10751": [
"CVE-2008-6210"
],
"10752": [],
"10753": [],
"10754": [
"CVE-2009-4679"
],
"10755": [],
"10756": [],
"10757": [],
"10758": [],
"10760": [],
"10762": [],
"10763": [],
"10767": [],
"10770": [],
"10771": [],
"10772": [],
"10773": [],
"10774": [],
"10775": [],
"10776": [],
"10777": [],
"10778": [],
"10779": [],
"10780": [],
"10781": [],
"10784": [],
"10788": [],
"10789": [],
"10790": [],
"10792": [],
"10793": [
"CVE-2009-4581"
],
"10794": [],
"10795": [],
"10796": [],
"10798": [],
"10800": [],
"10802": [],
"10803": [],
"10805": [],
"10806": [
"CVE-2009-4450"
],
"10807": [
"CVE-2009-4582"
],
"10808": [],
"10809": [
"CVE-2009-4574"
],
"10810": [],
"10811": [],
"10812": [],
"10813": [],
"10816": [],
"10817": [],
"10819": [],
"10821": [],
"10822": [],
"10823": [
"CVE-2009-4585"
],
"10824": [],
"10828": [],
"10830": [],
"10831": [],
"10832": [
"CVE-2008-6264"
],
"10833": [],
"10835": [],
"10836": [],
"10837": [],
"10838": [],
"10839": [],
"10841": [],
"10844": [],
"10845": [],
"10846": [],
"10847": [],
"10850": [],
"10861": [],
"10869": [],
"10871": [],
"10872": [],
"10873": [],
"10874": [],
"10876": [],
"10877": [],
"10878": [],
"10880": [],
"10882": [],
"10883": [],
"10884": [],
"10885": [],
"10889": [],
"10891": [],
"10897": [],
"10899": [],
"10901": [],
"10903": [],
"10905": [],
"10906": [],
"10910": [],
"10912": [],
"10921": [],
"10923": [],
"10924": [],
"10928": [],
"10929": [],
"10930": [
"CVE-2010-0980"
],
"10931": [],
"10938": [],
"10940": [],
"10941": [],
"10942": [
"CVE-2010-0982"
],
"10943": [
"CVE-2010-0157"
],
"10944": [
"CVE-2010-2255"
],
"10945": [],
"10946": [
"CVE-2010-2259"
],
"10948": [
"CVE-2010-0985"
],
"10949": [],
"10950": [
"CVE-2010-0981"
],
"10952": [],
"10953": [
"CVE-2010-0945"
],
"10955": [],
"10962": [],
"10964": [
"CVE-2010-2254"
],
"10965": [],
"10966": [],
"10967": [
"CVE-2010-0983"
],
"10968": [],
"10971": [
"CVE-2010-0158"
],
"10972": [
"CVE-2010-0984",
"CVE-2010-0976"
],
"10974": [],
"10976": [],
"10977": [],
"10978": [
"CVE-2010-5017"
],
"10979": [],
"10981": [],
"10983": [
"CVE-2010-2257",
"CVE-2010-2256"
],
"10984": [],
"10986": [],
"10988": [
"CVE-2010-1363"
],
"10991": [],
"10999": [],
"11002": [
"CVE-2010-1070"
],
"11003": [],
"11005": [
"CVE-2010-0978"
],
"11008": [],
"11012": [],
"11013": [],
"11014": [],
"11015": [
"CVE-2010-1065"
],
"11016": [],
"11017": [],
"11018": [],
"11019": [],
"11023": [
"CVE-2010-1064"
],
"11024": [
"CVE-2010-0694"
],
"11025": [
"CVE-2010-1066"
],
"11026": [
"CVE-2010-1073"
],
"11028": [],
"11030": [
"CVE-2010-0936"
],
"11031": [],
"11033": [],
"11035": [],
"11036": [],
"11045": [],
"11047": [],
"11048": [],
"11051": [],
"11057": [
"CVE-2010-0279"
],
"11060": [],
"11061": [],
"11063": [],
"11068": [
"CVE-2010-0946"
],
"11069": [],
"11071": [],
"11075": [],
"11076": [],
"11080": [
"CVE-2010-1069"
],
"11081": [],
"11082": [
"CVE-2010-0380",
"CVE-2010-0376",
"CVE-2010-0375"
],
"11083": [
"CVE-2010-1071"
],
"11085": [],
"11086": [],
"11087": [],
"11088": [
"CVE-2010-0944"
],
"11089": [
"CVE-2010-0942"
],
"11090": [
"CVE-2010-0943"
],
"11094": [],
"11096": [
"CVE-2010-0939"
],
"11097": [],
"11098": [
"CVE-2010-1067"
],
"11101": [],
"11104": [],
"11107": [],
"11110": [],
"11111": [
"CVE-2010-1360"
],
"11113": [],
"11116": [],
"11120": [],
"11124": [],
"11126": [],
"11127": [],
"11134": [],
"11135": [],
"11136": [],
"11140": [
"CVE-2010-0372"
],
"11141": [
"CVE-2010-0287",
"CVE-2010-0288"
],
"11147": [],
"11148": [],
"11155": [],
"11156": [],
"11157": [],
"11158": [],
"11159": [],
"11162": [],
"11163": [],
"11164": [
"CVE-2009-2894"
],
"11166": [],
"11168": [],
"11169": [
"CVE-2010-0390"
],
"11177": [],
"11178": [
"CVE-2010-0373"
],
"11183": [],
"11184": [],
"11185": [],
"11186": [],
"11187": [],
"11188": [],
"11189": [],
"11198": [],
"11211": [],
"11212": [],
"11213": [],
"11215": [],
"11216": [
"CVE-2010-0458"
],
"11218": [],
"11222": [
"CVE-2010-0456"
],
"11223": [],
"11224": [],
"11225": [],
"11226": [],
"11235": [
"CVE-2010-0457"
],
"11236": [],
"11237": [
"CVE-2010-0461"
],
"11238": [],
"11239": [],
"11240": [],
"11243": [
"CVE-2010-0459"
],
"11244": [],
"11249": [],
"11258": [],
"11261": [],
"11262": [],
"11263": [],
"11270": [],
"11271": [],
"11274": [],
"11277": [
"CVE-2010-0467"
],
"11278": [
"CVE-2010-0608"
],
"11279": [],
"11280": [
"CVE-2010-0803"
],
"11282": [
"CVE-2010-0467"
],
"11284": [],
"11286": [],
"11287": [
"CVE-2010-0796"
],
"11289": [
"CVE-2010-0800"
],
"11290": [
"CVE-2010-0799"
],
"11292": [
"CVE-2010-0795"
],
"11294": [
"CVE-2010-0632"
],
"11295": [],
"11296": [],
"11297": [
"CVE-2010-0802"
],
"11298": [],
"11299": [],
"11300": [],
"11301": [],
"11303": [],
"11305": [],
"11306": [
"CVE-2010-0630"
],
"11307": [],
"11308": [],
"11309": [],
"11310": [],
"11311": [
"CVE-2010-1611"
],
"11316": [],
"11318": [],
"11319": [],
"11321": [],
"11322": [],
"11323": [
"CVE-2010-0631"
],
"11324": [],
"11325": [],
"11326": [],
"11327": [],
"11329": [
"CVE-2010-1047"
],
"11330": [
"CVE-2010-1044"
],
"11334": [
"CVE-2010-1052",
"CVE-2010-1051",
"CVE-2010-1050"
],
"11336": [],
"11337": [
"CVE-2010-0610"
],
"11339": [],
"11340": [],
"11341": [],
"11344": [],
"11345": [
"CVE-2010-1053"
],
"11346": [
"CVE-2010-0611"
],
"11348": [],
"11349": [],
"11350": [],
"11352": [
"CVE-2010-1045"
],
"11353": [],
"11354": [],
"11355": [],
"11356": [
"CVE-2010-1046"
],
"11357": [
"CVE-2010-1049",
"CVE-2010-1048"
],
"11358": [],
"11359": [
"CVE-2010-1043"
],
"11360": [],
"11361": [
"CVE-2010-0765"
],
"11365": [],
"11366": [],
"11367": [],
"11368": [],
"11369": [],
"11375": [],
"11376": [],
"11377": [],
"11378": [],
"11380": [
"CVE-2010-0605"
],
"11382": [
"CVE-2010-0764"
],
"11383": [],
"11385": [],
"11393": [
"CVE-2010-0701"
],
"11394": [],
"11395": [],
"11396": [],
"11398": [],
"11399": [],
"11401": [
"CVE-2010-0762"
],
"11402": [
"CVE-2010-0761"
],
"11403": [
"CVE-2010-0642",
"CVE-2010-0641"
],
"11404": [],
"11405": [
"CVE-2008-1470"
],
"11406": [
"CVE-2010-0665"
],
"11409": [
"CVE-2010-0690"
],
"11410": [
"CVE-2010-0763"
],
"11411": [],
"11412": [
"CVE-2010-0693"
],
"11414": [],
"11415": [],
"11416": [],
"11424": [],
"11425": [],
"11429": [],
"11430": [],
"11431": [],
"11434": [
"CVE-2010-0674",
"CVE-2008-0843"
],
"11436": [
"CVE-2010-0672"
],
"11437": [
"CVE-2010-0681",
"CVE-2010-0680"
],
"11440": [],
"11441": [
"CVE-2010-0682"
],
"11442": [],
"11443": [],
"11444": [],
"11445": [
"CVE-2010-0691"
],
"11446": [],
"11447": [
"CVE-2010-0696"
],
"11449": [],
"11450": [],
"11452": [
"CVE-2010-0678",
"CVE-2010-0677"
],
"11455": [],
"11456": [],
"11458": [
"CVE-2010-0673"
],
"11460": [],
"11461": [],
"11462": [],
"11463": [],
"11464": [],
"11466": [],
"11473": [
"CVE-2010-0671"
],
"11474": [],
"11476": [],
"11477": [
"CVE-2010-0709"
],
"11478": [
"CVE-2010-0709"
],
"11479": [],
"11480": [],
"11481": [],
"11482": [],
"11483": [],
"11484": [],
"11485": [],
"11486": [],
"11487": [],
"11488": [
"CVE-2010-0721"
],
"11489": [
"CVE-2010-0720"
],
"11490": [],
"11494": [],
"11495": [],
"11496": [],
"11498": [
"CVE-2010-0760",
"CVE-2010-0759"
],
"11502": [],
"11503": [],
"11504": [],
"11507": [
"CVE-2010-0698"
],
"11508": [
"CVE-2010-0702"
],
"11509": [],
"11511": [
"CVE-2010-1081"
],
"11515": [],
"11516": [
"CVE-2010-0707"
],
"11517": [],
"11518": [
"CVE-2010-0758"
],
"11519": [],
"11521": [
"CVE-2010-0723"
],
"11522": [
"CVE-2010-0723"
],
"11523": [],
"11524": [
"CVE-2010-0725",
"CVE-2010-0724"
],
"11526": [
"CVE-2010-1077"
],
"11527": [],
"11528": [],
"11530": [],
"11543": [],
"11544": [],
"11547": [
"CVE-2010-0722"
],
"11548": [],
"11549": [
"CVE-2010-0753"
],
"11550": [],
"11551": [],
"11553": [],
"11554": [],
"11555": [],
"11557": [],
"11558": [],
"11559": [],
"11560": [
"CVE-2012-1913",
"CVE-2010-0757",
"CVE-2010-0756",
"CVE-2010-0755",
"CVE-2010-0754"
],
"11563": [],
"11564": [],
"11565": [],
"11568": [],
"11569": [
"CVE-2010-1114",
"CVE-2010-1113"
],
"11570": [],
"11571": [],
"11575": [],
"11576": [],
"11577": [
"CVE-2010-1368"
],
"11578": [],
"11579": [],
"11580": [],
"11582": [
"CVE-2010-1094"
],
"11583": [],
"11584": [
"CVE-2010-2134"
],
"11585": [
"CVE-2010-1537"
],
"11586": [
"CVE-2010-1538"
],
"11587": [
"CVE-2010-2138",
"CVE-2010-2137"
],
"11588": [
"CVE-2010-1091",
"CVE-2010-1090"
],
"11589": [
"CVE-2010-1369"
],
"11592": [
"CVE-2010-1092"
],
"11593": [
"CVE-2010-1366"
],
"11595": [],
"11596": [],
"11599": [
"CVE-2010-1364"
],
"11600": [
"CVE-2010-1365"
],
"11602": [
"CVE-2010-2135"
],
"11603": [
"CVE-2007-2792"
],
"11604": [],
"11605": [],
"11606": [],
"11609": [
"CVE-2010-1089"
],
"11610": [],
"11611": [],
"11612": [],
"11613": [],
"11614": [],
"11616": [
"CVE-2010-2133"
],
"11619": [],
"11620": [],
"11621": [
"CVE-2010-1272"
],
"11623": [
"CVE-2010-1271"
],
"11624": [],
"11625": [
"CVE-2010-1540"
],
"11627": [],
"11631": [],
"11634": [],
"11635": [
"CVE-2010-0952"
],
"11636": [
"CVE-2009-4018"
],
"11637": [],
"11638": [],
"11641": [
"CVE-2010-0953"
],
"11643": [
"CVE-2010-0951"
],
"11646": [
"CVE-2010-0948"
],
"11648": [
"CVE-2010-0955"
],
"11654": [],
"11655": [
"CVE-2010-0958"
],
"11657": [],
"11660": [],
"11666": [],
"11667": [],
"11671": [
"CVE-2010-5062"
],
"11672": [],
"11674": [
"CVE-2010-5060"
],
"11676": [],
"11677": [],
"11678": [
"CVE-2010-0975",
"CVE-2010-0974"
],
"11679": [],
"11680": [],
"11681": [],
"11684": [],
"11685": [
"CVE-2010-0971"
],
"11686": [],
"11687": [],
"11688": [],
"11689": [
"CVE-2010-0964"
],
"11691": [],
"11692": [],
"11693": [],
"11695": [],
"11696": [],
"11698": [],
"11699": [],
"11701": [],
"11702": [],
"11704": [],
"11707": [],
"11708": [],
"11709": [],
"11710": [],
"11711": [],
"11715": [
"CVE-2010-1341"
],
"11718": [],
"11719": [],
"11721": [
"CVE-2010-0968",
"CVE-2010-0967"
],
"11722": [
"CVE-2010-1057"
],
"11723": [],
"11725": [],
"11726": [],
"11727": [],
"11729": [],
"40084": [
"CVE-2016-6174"
],
"11730": [],
"11731": [],
"11732": [],
"11733": [
"CVE-2010-0973"
],
"11735": [
"CVE-2010-0966"
],
"18428": [],
"11737": [
"CVE-2010-0970"
],
"11738": [
"CVE-2010-0972"
],
"11739": [],
"11740": [],
"11741": [],
"11743": [],
"11744": [],
"11745": [],
"11746": [],
"11747": [],
"11748": [],
"11749": [],
"11752": [],
"11754": [
"CVE-2010-1058"
],
"11755": [
"CVE-2010-1055"
],
"11756": [],
"11757": [
"CVE-2010-1219"
],
"11758": [],
"11759": [],
"11760": [
"CVE-2010-1056"
],
"11761": [],
"11766": [],
"11767": [],
"11768": [],
"11771": [],
"11772": [],
"11773": [
"CVE-2010-1062"
],
"11774": [],
"11775": [
"CVE-2010-1060"
],
"11776": [
"CVE-2010-1270",
"CVE-2010-1269"
],
"11777": [
"CVE-2010-3314",
"CVE-2010-3313"
],
"11778": [],
"11780": [],
"11781": [],
"11782": [],
"11783": [],
"11784": [],
"11785": [
"CVE-2010-1345",
"CVE-2010-1344"
],
"11788": [],
"11790": [],
"11793": [],
"11795": [],
"11799": [],
"11801": [],
"11802": [],
"11805": [
"CVE-2010-1270",
"CVE-2010-1269"
],
"11806": [],
"11807": [],
"11808": [],
"11811": [],
"11813": [],
"11814": [
"CVE-2010-1217"
],
"11815": [],
"11816": [
"CVE-2010-1855"
],
"11823": [],
"11824": [
"CVE-2010-1338"
],
"11825": [],
"11826": [],
"11829": [],
"11830": [],
"11831": [
"CVE-2010-1267",
"CVE-2010-1266"
],
"11832": [
"CVE-2010-1216"
],
"11833": [],
"11835": [
"CVE-2010-1346"
],
"11836": [],
"14128": [
"CVE-2010-4968"
],
"11837": [
"CVE-2010-1365"
],
"11840": [],
"11841": [],
"11844": [],
"11845": [],
"11846": [],
"11847": [],
"11848": [
"CVE-2010-1335"
],
"11850": [],
"11851": [
"CVE-2010-1875"
],
"11852": [],
"11853": [
"CVE-2010-1858"
],
"11862": [],
"11863": [],
"11864": [],
"11865": [],
"11866": [],
"11867": [],
"11868": [],
"11871": [],
"11873": [],
"11874": [
"CVE-2010-1336"
],
"11875": [],
"11876": [
"CVE-2010-1268"
],
"11881": [
"CVE-2010-1343"
],
"11882": [
"CVE-2010-1342"
],
"11883": [],
"11884": [
"CVE-2010-1265"
],
"11885": [],
"11888": [],
"11889": [],
"11892": [],
"11894": [],
"11895": [],
"11896": [],
"11897": [],
"11898": [],
"11899": [],
"11902": [],
"11903": [
"CVE-2010-2677",
"CVE-2010-2676"
],
"11904": [],
"11905": [],
"11906": [
"CVE-2007-5235"
],
"11908": [],
"11912": [
"CVE-2010-1270",
"CVE-2010-1269"
],
"11914": [],
"11915": [],
"11916": [],
"11917": [],
"11918": [],
"11919": [],
"11920": [],
"11922": [
"CVE-2010-2673"
],
"11923": [
"CVE-2010-2675",
"CVE-2010-2674"
],
"11924": [],
"11925": [],
"11927": [],
"11928": [],
"11929": [],
"11931": [],
"11934": [],
"11935": [],
"11938": [
"CVE-2010-1309",
"CVE-2008-7254"
],
"11939": [],
"11940": [],
"11941": [],
"11942": [],
"11943": [],
"11946": [],
"11947": [
"CVE-2010-2335",
"CVE-2010-1300"
],
"11948": [],
"11949": [],
"11950": [],
"11954": [],
"11960": [],
"11962": [],
"11963": [],
"11964": [
"CVE-2008-1425"
],
"11965": [],
"11967": [],
"11968": [],
"11978": [
"CVE-2010-1302"
],
"11979": [
"CVE-2010-1301"
],
"11980": [],
"11989": [],
"11990": [],
"11991": [],
"11992": [],
"11993": [],
"11994": [
"CVE-2010-1299"
],
"11995": [],
"11996": [],
"11997": [
"CVE-2010-1873"
],
"11998": [
"CVE-2010-1304"
],
"11999": [
"CVE-2010-1315"
],
"12002": [],
"12003": [],
"12004": [],
"12005": [],
"12006": [],
"12007": [],
"12009": [
"CVE-2010-3884"
],
"12015": [],
"12016": [],
"12017": [],
"12018": [
"CVE-2010-1299"
],
"12019": [],
"12021": [],
"12022": [],
"12026": [],
"12028": [
"CVE-2009-3119"
],
"12029": [],
"12031": [],
"12034": [],
"12036": [],
"12037": [
"CVE-2010-1350"
],
"12038": [],
"12039": [],
"12041": [],
"12042": [],
"12043": [],
"12045": [],
"12047": [
"CVE-2010-1351"
],
"12048": [],
"12049": [
"CVE-2010-1528"
],
"12050": [],
"12052": [],
"12054": [
"CVE-2010-1531"
],
"12055": [
"CVE-2010-1983"
],
"12056": [],
"12057": [],
"12058": [
"CVE-2010-1306"
],
"12060": [],
"12061": [
"CVE-2008-7176"
],
"12062": [],
"12065": [
"CVE-2010-1305"
],
"12066": [
"CVE-2010-1308"
],
"12067": [
"CVE-2010-1534"
],
"12068": [
"CVE-2010-1353"
],
"12069": [],
"12070": [
"CVE-2010-1307"
],
"12071": [],
"12075": [],
"12076": [],
"12077": [
"CVE-2010-1312"
],
"12078": [
"CVE-2010-1529"
],
"12082": [
"CVE-2010-1313"
],
"12083": [
"CVE-2010-1977"
],
"12084": [
"CVE-2010-1352"
],
"12085": [
"CVE-2010-1980"
],
"12086": [
"CVE-2010-1314"
],
"12087": [
"CVE-2010-1981"
],
"12088": [
"CVE-2010-1979"
],
"12089": [],
"12092": [],
"12094": [],
"12097": [
"CVE-2010-5053"
],
"12098": [
"CVE-2010-1186"
],
"12100": [],
"12101": [],
"12102": [
"CVE-2010-1354"
],
"12105": [],
"12106": [],
"12107": [],
"12108": [],
"12111": [],
"12112": [],
"12113": [
"CVE-2010-1494",
"CVE-2010-1493"
],
"12115": [],
"12118": [
"CVE-2010-1532"
],
"12120": [
"CVE-2010-2920"
],
"12121": [
"CVE-2010-1982"
],
"12123": [],
"12124": [],
"12128": [],
"12132": [
"CVE-2010-1716"
],
"12133": [],
"12134": [],
"12135": [],
"12136": [
"CVE-2010-1874"
],
"12137": [],
"12138": [],
"12139": [],
"12140": [],
"12141": [],
"12142": [
"CVE-2010-1533"
],
"12143": [],
"12144": [],
"12145": [
"CVE-2010-1478"
],
"12146": [
"CVE-2010-1469"
],
"12147": [
"CVE-2010-1475"
],
"12148": [
"CVE-2010-1480",
"CVE-2010-1479"
],
"12149": [],
"12150": [
"CVE-2010-1476"
],
"12151": [
"CVE-2010-1535"
],
"12153": [],
"12155": [],
"12157": [],
"12158": [
"CVE-2010-5016"
],
"12159": [
"CVE-2010-1468"
],
"12160": [
"CVE-2004-1796"
],
"12162": [],
"12163": [],
"12164": [
"CVE-2005-1882"
],
"12166": [
"CVE-2010-1470"
],
"12167": [
"CVE-2010-1472"
],
"12168": [
"CVE-2010-1714"
],
"12169": [],
"12170": [
"CVE-2010-1471"
],
"12171": [
"CVE-2010-1473"
],
"12172": [],
"12173": [],
"12174": [
"CVE-2010-1715"
],
"12175": [],
"12176": [],
"12177": [
"CVE-2010-1722"
],
"12178": [],
"12179": [],
"12180": [],
"12181": [],
"12182": [
"CVE-2010-1474"
],
"12183": [],
"12184": [
"CVE-2010-1559",
"CVE-2010-1477"
],
"12185": [],
"12187": [],
"12190": [
"CVE-2010-1873"
],
"12191": [
"CVE-2010-1350"
],
"12192": [],
"12193": [
"CVE-2010-1467",
"CVE-2010-1466"
],
"12194": [],
"12195": [],
"12197": [],
"12198": [],
"12199": [],
"12200": [
"CVE-2010-1720"
],
"12212": [],
"12218": [],
"12219": [],
"12220": [
"CVE-2010-5055"
],
"12221": [
"CVE-2010-0955"
],
"12222": [],
"12223": [],
"12224": [],
"12226": [],
"12227": [],
"12230": [],
"12231": [],
"12232": [
"CVE-2010-1461"
],
"12233": [
"CVE-2010-1719"
],
"12234": [
"CVE-2010-1600"
],
"12235": [
"CVE-2010-1957"
],
"12236": [
"CVE-2010-1601"
],
"12237": [],
"12238": [
"CVE-2010-1955"
],
"12239": [
"CVE-2010-1952"
],
"12241": [],
"12242": [],
"12245": [],
"12246": [
"CVE-2010-1721"
],
"12249": [
"CVE-2010-1951"
],
"12251": [],
"12254": [],
"12256": [],
"12257": [],
"12260": [
"CVE-2010-1711",
"CVE-2010-1710"
],
"12262": [],
"12266": [],
"12267": [],
"12268": [],
"12269": [
"CVE-2010-1496"
],
"12270": [],
"12272": [
"CVE-2006-5918"
],
"12276": [],
"12277": [],
"12278": [],
"12279": [],
"12280": [
"CVE-2010-1498",
"CVE-2010-1497"
],
"12282": [
"CVE-2010-1718"
],
"12283": [
"CVE-2010-1602"
],
"12284": [
"CVE-2010-1603"
],
"12285": [
"CVE-2010-1956"
],
"12286": [
"CVE-2010-1495"
],
"12287": [
"CVE-2010-1954"
],
"12288": [
"CVE-2010-1953"
],
"12289": [
"CVE-2010-1723"
],
"12290": [],
"12291": [
"CVE-2010-1717"
],
"12292": [],
"12295": [],
"12296": [],
"12299": [
"CVE-2010-5056"
],
"12301": [
"CVE-2010-5058",
"CVE-2010-5057"
],
"12303": [
"CVE-2010-1499"
],
"12305": [
"CVE-2010-1950",
"CVE-2010-1949"
],
"12306": [
"CVE-2010-1877"
],
"12313": [
"CVE-2010-1947",
"CVE-2010-1946"
],
"12315": [],
"12316": [
"CVE-2010-1607"
],
"12317": [
"CVE-2010-1878"
],
"12318": [
"CVE-2010-1491"
],
"12319": [],
"12322": [],
"12323": [
"CVE-2010-1712"
],
"12325": [],
"12329": [
"CVE-2010-1486"
],
"12330": [
"CVE-2010-0432"
],
"12333": [
"CVE-2009-2439"
],
"12338": [
"CVE-2010-1431"
],
"12339": [],
"12345": [
"CVE-2008-6848"
],
"12346": [
"CVE-2009-2779"
],
"12349": [
"CVE-2010-1876"
],
"12350": [],
"12351": [],
"12353": [],
"12354": [
"CVE-2010-1599"
],
"12355": [],
"12358": [],
"12359": [],
"12360": [],
"12361": [],
"12364": [
"CVE-2010-1935"
],
"12365": [
"CVE-2010-1934",
"CVE-2010-1928"
],
"12366": [
"CVE-2010-1948",
"CVE-2010-1945"
],
"12369": [
"CVE-2007-2826"
],
"12370": [
"CVE-2010-1606",
"CVE-2010-1604"
],
"12371": [
"CVE-2010-1702"
],
"12372": [
"CVE-2007-4085"
],
"12373": [],
"12374": [],
"12376": [],
"12378": [],
"12381": [],
"12383": [],
"12384": [],
"12385": [
"CVE-2006-4584"
],
"12386": [],
"12387": [],
"12395": [
"CVE-2010-1704",
"CVE-2010-1703"
],
"12396": [
"CVE-2010-1936"
],
"12398": [
"CVE-2010-1927",
"CVE-2010-1926"
],
"12399": [
"CVE-2010-1364"
],
"12400": [
"CVE-2008-2633"
],
"12402": [
"CVE-2009-4822"
],
"12407": [
"CVE-2010-5059"
],
"12410": [
"CVE-2010-1713"
],
"12411": [
"CVE-2010-1708"
],
"12412": [],
"12413": [],
"12414": [
"CVE-2010-1706"
],
"12415": [
"CVE-2010-1654"
],
"12416": [
"CVE-2010-1662",
"CVE-2010-1661"
],
"12419": [],
"12420": [],
"12421": [
"CVE-2010-1652"
],
"12423": [
"CVE-2010-1660"
],
"12424": [],
"12426": [
"CVE-2010-1659"
],
"12427": [
"CVE-2010-1658"
],
"12428": [
"CVE-2010-1657"
],
"12429": [
"CVE-2010-1656"
],
"12430": [
"CVE-2010-1653"
],
"12432": [],
"12433": [],
"12434": [],
"12435": [],
"12436": [],
"12438": [
"CVE-2006-3271"
],
"12439": [
"CVE-2005-3817"
],
"12440": [],
"12441": [
"CVE-2010-2039"
],
"12442": [],
"12443": [
"CVE-2010-1705"
],
"12444": [
"CVE-2010-1701"
],
"12445": [],
"12446": [],
"12447": [],
"12448": [],
"12449": [],
"12450": [
"CVE-2010-0817"
],
"12451": [
"CVE-2010-2853"
],
"12452": [
"CVE-2010-1583"
],
"12453": [],
"12454": [],
"12455": [],
"12456": [
"CVE-2009-1362",
"CVE-2009-1347"
],
"12458": [
"CVE-2010-1743",
"CVE-2010-1742"
],
"12459": [
"CVE-2010-1726"
],
"12460": [
"CVE-2010-1744"
],
"12461": [
"CVE-2010-1727"
],
"12462": [
"CVE-2007-0053"
],
"12463": [],
"12464": [
"CVE-2010-0711"
],
"12465": [
"CVE-2010-1739"
],
"12466": [],
"12467": [],
"12468": [
"CVE-2010-1725"
],
"12471": [],
"12472": [],
"12473": [
"CVE-2010-1746"
],
"12474": [],
"12475": [
"CVE-2010-1999"
],
"12476": [
"CVE-2010-1944"
],
"12478": [],
"12479": [],
"12481": [],
"12484": [
"CVE-2010-1740"
],
"12485": [],
"12486": [
"CVE-2010-1921",
"CVE-2010-1920"
],
"12488": [
"CVE-2010-1737"
],
"12489": [],
"14025": [
"CVE-2010-2610"
],
"12496": [],
"12499": [],
"12500": [],
"12504": [],
"12506": [],
"12507": [
"CVE-2014-9558"
],
"12510": [
"CVE-2004-1315"
],
"12514": [],
"12515": [],
"12517": [],
"12519": [],
"12520": [
"CVE-2009-1443"
],
"12521": [],
"12522": [],
"12523": [],
"12525": [],
"12526": [],
"12532": [],
"12533": [],
"12534": [],
"12535": [],
"12539": [],
"12542": [],
"12543": [
"CVE-2009-3504"
],
"12544": [],
"12545": [
"CVE-2010-1924"
],
"12547": [],
"12550": [],
"12551": [],
"12552": [
"CVE-2010-1925"
],
"12553": [],
"12556": [],
"12557": [],
"12558": [
"CVE-2010-1922"
],
"12560": [
"CVE-2008-1858"
],
"12561": [
"CVE-2008-5088",
"CVE-2008-1909"
],
"12562": [],
"12563": [],
"12565": [],
"12566": [],
"12567": [],
"12568": [],
"12569": [],
"12570": [],
"12571": [],
"12572": [],
"12574": [],
"12575": [],
"12576": [],
"12577": [],
"12579": [],
"12583": [],
"12584": [],
"12585": [],
"12586": [],
"12590": [
"CVE-2010-2044"
],
"12591": [],
"12592": [],
"12593": [],
"12594": [],
"12595": [
"CVE-2010-2045"
],
"12596": [],
"12597": [
"CVE-2010-5047"
],
"12598": [
"CVE-2010-2129"
],
"12599": [],
"14364": [],
"12601": [
"CVE-2010-5028"
],
"12606": [],
"12607": [
"CVE-2010-2128"
],
"12608": [],
"12609": [],
"12610": [
"CVE-2010-1143"
],
"12611": [
"CVE-2010-2050"
],
"12612": [],
"12613": [],
"12615": [],
"12617": [],
"12618": [
"CVE-2010-2122"
],
"12619": [],
"12620": [
"CVE-2010-2016"
],
"12623": [
"CVE-2010-2122"
],
"12624": [],
"12628": [],
"12629": [],
"12630": [],
"12631": [],
"12632": [],
"12633": [],
"12634": [],
"12635": [],
"12636": [],
"12637": [],
"12639": [],
"12640": [],
"12641": [
"CVE-2010-2047"
],
"12642": [],
"12643": [],
"12644": [],
"12645": [],
"12646": [],
"12647": [],
"12648": [],
"12651": [
"CVE-2010-2018"
],
"12654": [],
"12656": [],
"12658": [],
"12659": [],
"12660": [
"CVE-2010-0475"
],
"12661": [
"CVE-2010-2051"
],
"12664": [],
"12665": [],
"12666": [],
"12667": [],
"12671": [],
"12672": [],
"12674": [],
"14341": [],
"12676": [],
"28046": [
"CVE-2006-7052"
],
"28047": [
"CVE-2006-3185"
],
"28048": [
"CVE-2006-3314"
],
"28128": [],
"12679": [],
"12680": [],
"12684": [
"CVE-2010-2124"
],
"12686": [],
"12688": [
"CVE-2010-2127"
],
"12689": [
"CVE-2010-2103"
],
"12690": [],
"12691": [],
"14322": [
"CVE-2010-2700",
"CVE-2010-2699"
],
"12692": [],
"12693": [],
"12694": [],
"12695": [],
"12696": [],
"12697": [],
"12699": [],
"12700": [],
"12701": [],
"12702": [
"CVE-2010-2042"
],
"12703": [
"CVE-2010-5039"
],
"12706": [],
"12707": [],
"12709": [],
"12711": [],
"12712": [],
"12713": [],
"12714": [],
"12715": [
"CVE-2010-2099"
],
"12716": [],
"12717": [],
"12718": [],
"12719": [],
"12720": [],
"12721": [],
"12722": [],
"12723": [
"CVE-2010-1720"
],
"12724": [],
"12725": [],
"12726": [],
"12727": [
"CVE-2010-2015"
],
"12728": [
"CVE-2010-2091"
],
"12729": [],
"12730": [],
"12731": [],
"12732": [],
"12734": [],
"12735": [
"CVE-2010-2141"
],
"12736": [],
"12737": [],
"12743": [],
"12744": [],
"12746": [],
"12748": [],
"12749": [],
"12750": [],
"12754": [],
"12755": [],
"12756": [],
"12761": [],
"12763": [],
"12766": [],
"12767": [],
"12768": [],
"12769": [],
"12770": [],
"12771": [],
"12772": [],
"12773": [],
"12776": [],
"12777": [],
"12779": [
"CVE-2010-2148",
"CVE-2010-2147"
],
"12780": [
"CVE-2010-5032"
],
"12781": [],
"12782": [
"CVE-2010-5028"
],
"12785": [],
"12786": [
"CVE-2010-5033"
],
"12787": [
"CVE-2010-5041",
"CVE-2010-5040"
],
"12788": [],
"12790": [
"CVE-2010-2314"
],
"12791": [],
"12792": [],
"12793": [],
"12794": [],
"12796": [
"CVE-2010-5032"
],
"12797": [],
"12798": [],
"12801": [],
"12805": [
"CVE-2010-2144"
],
"12806": [
"CVE-2010-2154"
],
"12807": [],
"12808": [],
"12809": [
"CVE-2010-2143"
],
"12811": [],
"12812": [],
"12813": [],
"12814": [],
"12817": [],
"12818": [],
"12819": [],
"12820": [
"CVE-2010-2146"
],
"12822": [
"CVE-2009-4599"
],
"12823": [],
"12833": [],
"12839": [],
"12840": [],
"12841": [],
"12842": [],
"12843": [],
"12845": [],
"12848": [
"CVE-2010-2313"
],
"12849": [],
"12850": [],
"12855": [
"CVE-2010-2315"
],
"12856": [],
"12857": [],
"12858": [],
"12859": [],
"12861": [],
"12866": [],
"12867": [],
"12868": [],
"40091": [],
"30170": [
"CVE-2007-3212"
],
"18593": [],
"18594": [],
"14247": [],
"13736": [],
"13737": [
"CVE-2010-5043",
"CVE-2010-5042"
],
"13738": [],
"13739": [
"CVE-2010-2317",
"CVE-2010-2316",
"CVE-2007-3137"
],
"13740": [
"CVE-2010-5036",
"CVE-2010-5035"
],
"13741": [
"CVE-2010-5034"
],
"13744": [],
"13745": [
"CVE-2010-5044"
],
"13746": [
"CVE-2010-5044"
],
"13747": [],
"13748": [],
"13749": [
"CVE-2010-2319"
],
"13750": [],
"13751": [],
"13752": [],
"13754": [],
"13762": [
"CVE-2010-5037"
],
"13766": [
"CVE-2010-5000"
],
"13769": [],
"13770": [],
"13771": [],
"13772": [],
"13773": [],
"13776": [],
"13777": [],
"13778": [],
"13779": [],
"13781": [],
"13782": [],
"13783": [],
"13784": [
"CVE-2010-2312"
],
"13785": [
"CVE-2010-2356",
"CVE-2010-2355",
"CVE-2010-2354"
],
"13786": [],
"13788": [],
"13789": [
"CVE-2010-5013"
],
"14294": [],
"13790": [],
"14333": [],
"13792": [],
"13793": [
"CVE-2010-2342"
],
"13794": [],
"27972": [
"CVE-2006-2899"
],
"27973": [
"CVE-2006-2877"
],
"27974": [
"CVE-2006-2877"
],
"13796": [],
"13797": [],
"13798": [],
"13799": [],
"13800": [],
"13801": [
"CVE-2010-5027",
"CVE-2010-5026"
],
"13802": [
"CVE-2010-2357"
],
"13803": [],
"13804": [],
"13805": [],
"13807": [],
"13810": [],
"13812": [
"CVE-2010-5011",
"CVE-2010-5010"
],
"13813": [],
"13814": [],
"13815": [
"CVE-2010-4967"
],
"13816": [],
"13819": [],
"13826": [],
"13827": [],
"13829": [],
"13830": [
"CVE-2010-5012"
],
"13831": [],
"13832": [
"CVE-2010-4998"
],
"13833": [],
"13835": [],
"13840": [],
"13841": [],
"13842": [
"CVE-2010-2338"
],
"13843": [
"CVE-2010-5008"
],
"13844": [],
"13845": [
"CVE-2010-2336",
"CVE-2010-2335",
"CVE-2010-2334",
"CVE-2010-1300"
],
"13846": [],
"13847": [],
"13848": [],
"13849": [
"CVE-2010-1300"
],
"13852": [],
"13854": [
"CVE-2010-5009",
"CVE-2010-5007"
],
"13855": [],
"13856": [
"CVE-2010-2334"
],
"13857": [
"CVE-2010-1300"
],
"13858": [],
"13859": [
"CVE-2010-5021"
],
"13860": [
"CVE-2010-5023"
],
"13861": [],
"13862": [],
"13863": [],
"13864": [],
"13865": [],
"13866": [],
"13867": [],
"13880": [
"CVE-2010-5045"
],
"13881": [],
"13882": [],
"13883": [],
"13884": [],
"13885": [],
"13886": [],
"13889": [
"CVE-2010-2358"
],
"13890": [
"CVE-2010-2341"
],
"13891": [],
"13892": [],
"13893": [],
"13894": [
"CVE-2010-5019",
"CVE-2010-5018"
],
"13897": [],
"13898": [],
"13899": [],
"13900": [],
"13901": [],
"13902": [],
"13904": [],
"13911": [],
"13912": [],
"13916": [],
"13918": [
"CVE-2010-1622"
],
"13922": [],
"13923": [],
"13925": [],
"13926": [],
"13927": [],
"13929": [
"CVE-2010-4981"
],
"13930": [],
"13931": [],
"13933": [],
"13935": [
"CVE-2010-2464"
],
"13936": [
"CVE-2010-5014"
],
"13937": [],
"13938": [],
"14848": [],
"13944": [],
"13945": [
"CVE-2010-5020",
"CVE-2010-0804"
],
"13946": [
"CVE-2010-2461"
],
"13947": [],
"13948": [
"CVE-2010-2462"
],
"13949": [
"CVE-2010-2460"
],
"13951": [],
"13952": [],
"13954": [
"CVE-2010-2438"
],
"13955": [],
"13956": [],
"13957": [],
"14363": [],
"14359": [],
"13960": [],
"13961": [],
"13962": [],
"13964": [
"CVE-2010-2456"
],
"13966": [],
"13967": [],
"13969": [],
"13970": [
"CVE-2010-2459",
"CVE-2010-2458"
],
"13971": [],
"13973": [],
"13975": [],
"13976": [],
"13977": [],
"13978": [
"CVE-2010-2609"
],
"13979": [],
"13980": [
"CVE-2010-5287"
],
"13981": [
"CVE-2010-2507"
],
"13982": [],
"13983": [],
"13986": [],
"13987": [],
"13988": [],
"13990": [
"CVE-2010-2688",
"CVE-2010-2687"
],
"13991": [],
"13992": [],
"13993": [
"CVE-2010-2457",
"CVE-2005-3868"
],
"14512": [],
"13995": [
"CVE-2010-2687"
],
"13996": [],
"13997": [
"CVE-2010-4365",
"CVE-2010-2513"
],
"13999": [],
"14000": [],
"14001": [],
"14004": [],
"14005": [
"CVE-2010-2511"
],
"14007": [],
"14008": [
"CVE-2010-2512"
],
"14009": [],
"14011": [],
"14015": [],
"14016": [
"CVE-2010-2618"
],
"14017": [
"CVE-2010-2682"
],
"14018": [
"CVE-2010-2508"
],
"14019": [],
"14020": [
"CVE-2010-2510",
"CVE-2010-2509"
],
"14026": [],
"14027": [],
"14028": [],
"14030": [],
"14033": [],
"14035": [],
"14047": [],
"14048": [
"CVE-2010-2691"
],
"14049": [],
"14050": [],
"14051": [],
"14053": [],
"14054": [
"CVE-2010-5022"
],
"14055": [
"CVE-2010-2681"
],
"14056": [],
"14057": [],
"14058": [],
"14059": [
"CVE-2010-2613"
],
"14060": [],
"14085": [],
"14086": [],
"14062": [],
"14063": [],
"14064": [
"CVE-2010-2680"
],
"14073": [],
"14070": [],
"14074": [
"CVE-2010-5004"
],
"14075": [],
"14076": [],
"14078": [],
"14079": [
"CVE-2010-2611"
],
"14080": [],
"14084": [
"CVE-2010-4997"
],
"14089": [
"CVE-2010-2685",
"CVE-2010-2684"
],
"14094": [],
"14095": [],
"14096": [],
"14106": [],
"14107": [
"CVE-2010-4972"
],
"14104": [
"CVE-2010-5029"
],
"14101": [],
"14103": [],
"14109": [],
"14110": [],
"14111": [],
"14112": [
"CVE-2010-2683"
],
"14115": [],
"14117": [
"CVE-2010-1931"
],
"14118": [],
"14274": [
"CVE-2010-2857"
],
"14123": [
"CVE-2010-2689"
],
"14124": [],
"14125": [],
"14126": [
"CVE-2010-2690"
],
"14127": [
"CVE-2010-2622"
],
"14141": [],
"14132": [],
"14144": [
"CVE-2010-2623"
],
"14145": [],
"14146": [],
"14147": [],
"14149": [],
"14151": [],
"14152": [],
"14154": [],
"14155": [],
"14209": [],
"14165": [],
"14163": [
"CVE-2010-4980"
],
"14164": [
"CVE-2010-4983"
],
"14160": [],
"14177": [],
"14162": [
"CVE-2010-2624"
],
"14176": [],
"14166": [],
"14171": [],
"14172": [],
"14170": [],
"14168": [],
"14169": [],
"14183": [],
"14192": [
"CVE-2010-4989"
],
"14184": [],
"14186": [
"CVE-2010-4988"
],
"14187": [
"CVE-2010-4993"
],
"14188": [],
"14193": [],
"14208": [],
"14196": [
"CVE-2010-4975"
],
"14197": [],
"14198": [],
"14199": [
"CVE-2010-2719"
],
"14201": [
"CVE-2010-2720"
],
"14202": [],
"14203": [
"CVE-2010-2715",
"CVE-2010-2714"
],
"14204": [
"CVE-2010-4996",
"CVE-2009-4935"
],
"14205": [
"CVE-2010-4999"
],
"14206": [
"CVE-2010-5001"
],
"14207": [],
"14210": [
"CVE-2010-4990"
],
"14211": [
"CVE-2010-4991"
],
"14213": [],
"14214": [],
"14217": [
"CVE-2010-4970"
],
"14250": [
"CVE-2010-4995"
],
"14223": [],
"14224": [
"CVE-2010-2670"
],
"14225": [],
"14226": [],
"14227": [],
"14228": [],
"14229": [],
"14230": [],
"33410": [
"CVE-2009-4429"
],
"14232": [],
"14233": [],
"14237": [
"CVE-2010-2656",
"CVE-2010-2655",
"CVE-2010-2654"
],
"14238": [],
"14239": [
"CVE-2010-4974"
],
"14240": [],
"14241": [
"CVE-2010-4969"
],
"14242": [],
"14243": [],
"14244": [
"CVE-2010-2721"
],
"14245": [],
"14249": [
"CVE-2010-5003"
],
"14251": [
"CVE-2010-2716"
],
"14285": [
"CVE-2010-3213"
],
"14255": [],
"14259": [],
"14260": [
"CVE-2010-2698",
"CVE-2010-2697",
"CVE-2010-2696"
],
"14262": [
"CVE-2010-4986"
],
"14264": [],
"14263": [
"CVE-2010-2848",
"CVE-2010-2847",
"CVE-2010-2846"
],
"14265": [
"CVE-2010-4992"
],
"14270": [],
"14271": [],
"14277": [],
"14278": [],
"14279": [],
"14280": [],
"14281": [
"CVE-2010-4987"
],
"14283": [],
"14284": [],
"14289": [],
"14293": [],
"14291": [],
"14434": [],
"14312": [
"CVE-2010-2694"
],
"14296": [
"CVE-2010-2845"
],
"14316": [],
"14299": [],
"14306": [],
"14308": [],
"14310": [],
"14313": [],
"14315": [],
"14335": [],
"14318": [],
"14319": [],
"14320": [],
"14324": [],
"14325": [
"CVE-2010-4985",
"CVE-2010-4984"
],
"14326": [
"CVE-2010-4982"
],
"14327": [],
"14328": [],
"14329": [],
"14330": [],
"14331": [
"CVE-2010-2282"
],
"14336": [],
"14337": [],
"14338": [],
"14342": [
"CVE-2010-2615"
],
"14355": [],
"14350": [],
"14351": [],
"14353": [],
"14354": [
"CVE-2010-2917"
],
"14356": [],
"14357": [],
"14362": [],
"14365": [],
"14366": [],
"14368": [],
"14369": [],
"14370": [
"CVE-2010-2905"
],
"14371": [
"CVE-2010-2906"
],
"14374": [],
"14375": [],
"14376": [],
"14377": [],
"14378": [
"CVE-2010-4959"
],
"14381": [],
"14382": [],
"14383": [],
"14420": [],
"14421": [],
"14389": [],
"14390": [],
"14391": [],
"14392": [
"CVE-2010-2912",
"CVE-2010-2911"
],
"14393": [],
"14394": [],
"14395": [
"CVE-2010-2919"
],
"14404": [
"CVE-2010-2912",
"CVE-2010-2911"
],
"14405": [],
"14401": [],
"14410": [],
"14415": [],
"14419": [],
"14423": [],
"14425": [],
"14426": [],
"14427": [],
"14432": [],
"14430": [],
"14435": [
"CVE-2010-2915"
],
"14436": [
"CVE-2010-2916"
],
"14437": [],
"14438": [
"CVE-2010-4948"
],
"14439": [],
"14440": [],
"14441": [
"CVE-2010-2924"
],
"14442": [],
"14443": [],
"14444": [],
"14445": [],
"14446": [],
"14448": [
"CVE-2010-2921"
],
"14449": [
"CVE-2010-2907"
],
"14450": [],
"14453": [
"CVE-2005-0929",
"CVE-2004-0239"
],
"14454": [],
"14455": [],
"14457": [],
"14458": [],
"14459": [],
"14461": [
"CVE-2010-2922"
],
"14462": [
"CVE-2010-2910"
],
"14463": [],
"14465": [
"CVE-2010-2926"
],
"14466": [
"CVE-2010-2908"
],
"14467": [
"CVE-2010-2923"
],
"14469": [],
"14470": [],
"14471": [],
"14472": [],
"14483": [],
"14474": [
"CVE-2010-2925"
],
"14476": [
"CVE-2010-2918"
],
"14481": [
"CVE-2010-2909"
],
"14485": [
"CVE-2010-2850"
],
"14488": [],
"14490": [],
"14494": [
"CVE-2010-2933"
],
"14495": [],
"14499": [],
"14500": [],
"14501": [],
"14502": [],
"14518": [],
"14521": [],
"14523": [],
"14528": [],
"14530": [
"CVE-2010-4945"
],
"14531": [],
"14534": [],
"14558": [],
"14541": [],
"14547": [
"CVE-2010-2709"
],
"14557": [],
"14556": [
"CVE-2010-4925"
],
"14559": [
"CVE-2010-4955"
],
"14560": [
"CVE-2008-5949"
],
"14569": [],
"14562": [
"CVE-2010-3030",
"CVE-2010-3026"
],
"14563": [],
"14564": [],
"14565": [
"CVE-2010-3024"
],
"14570": [],
"14572": [
"CVE-2010-3027"
],
"14578": [
"CVE-2010-3029"
],
"14585": [],
"14598": [
"CVE-2010-4941"
],
"14589": [
"CVE-2010-5083"
],
"14592": [],
"14595": [],
"14596": [
"CVE-2010-4937"
],
"14606": [],
"14614": [
"CVE-2010-4924"
],
"14615": [],
"14618": [
"CVE-2010-4943"
],
"14617": [],
"14622": [],
"14628": [],
"14629": [],
"14636": [],
"14637": [
"CVE-2010-4934"
],
"14639": [
"CVE-2010-4939"
],
"14640": [],
"14643": [],
"14644": [],
"14645": [],
"14647": [
"CVE-2010-4931"
],
"14648": [],
"14650": [],
"14654": [],
"14655": [],
"14656": [],
"14659": [],
"14672": [
"CVE-2010-4298",
"CVE-2010-3742",
"CVE-2010-3307"
],
"14684": [],
"14686": [],
"14707": [],
"14694": [],
"14702": [],
"14703": [],
"14704": [],
"14709": [],
"14712": [],
"14714": [],
"14716": [],
"14717": [],
"14718": [],
"14722": [],
"14828": [
"CVE-2008-2094"
],
"14737": [],
"14742": [],
"14818": [],
"14817": [],
"14806": [],
"14799": [],
"14801": [],
"14802": [],
"14811": [],
"14808": [],
"14809": [
"CVE-2010-4878"
],
"14810": [
"CVE-2010-4884"
],
"14815": [
"CVE-2010-3204"
],
"14819": [],
"14820": [
"CVE-2008-5841"
],
"14821": [],
"14822": [
"CVE-2010-3206"
],
"14823": [
"CVE-2010-3205"
],
"14826": [
"CVE-2010-3207"
],
"14827": [],
"14829": [],
"14833": [],
"14834": [],
"14835": [
"CVE-2010-3210"
],
"14837": [],
"14838": [
"CVE-2010-3212"
],
"14839": [],
"14841": [
"CVE-2010-3209"
],
"14845": [
"CVE-2010-3203"
],
"14846": [
"CVE-2010-3211"
],
"14849": [
"CVE-2010-4876"
],
"14854": [],
"14851": [
"CVE-2010-4879"
],
"14870": [],
"14860": [],
"14867": [],
"14876": [],
"14879": [],
"14884": [],
"14887": [],
"14890": [],
"14891": [
"CVE-2010-4911"
],
"14893": [
"CVE-2010-4914"
],
"14894": [
"CVE-2010-4917"
],
"14896": [
"CVE-2010-4918"
],
"14897": [
"CVE-2010-4895",
"CVE-2010-4894"
],
"14898": [],
"14901": [
"CVE-2010-4902"
],
"14902": [
"CVE-2010-4902"
],
"14913": [],
"14908": [
"CVE-2010-4921"
],
"14910": [
"CVE-2010-4905"
],
"14911": [
"CVE-2010-4898"
],
"14932": [
"CVE-2010-4910"
],
"14914": [
"CVE-2010-4919"
],
"14915": [],
"14919": [
"CVE-2010-4920"
],
"14922": [
"CVE-2010-4904"
],
"14923": [],
"14931": [],
"14927": [],
"14933": [
"CVE-2010-4915"
],
"14934": [],
"14935": [
"CVE-2010-4916",
"CVE-2010-4913"
],
"14942": [
"CVE-2010-1093"
],
"14943": [],
"14952": [],
"14954": [],
"15442": [],
"15443": [],
"14960": [
"CVE-2010-3456"
],
"14962": [],
"14964": [
"CVE-2010-3426"
],
"14965": [
"CVE-2010-3419"
],
"14968": [
"CVE-2010-3458",
"CVE-2010-3457"
],
"14969": [],
"14973": [],
"14977": [],
"14980": [
"CVE-2010-3404"
],
"14985": [],
"14986": [],
"14988": [
"CVE-2010-3428"
],
"14989": [],
"14991": [],
"14995": [],
"14996": [],
"14997": [
"CVE-2010-4912"
],
"14998": [
"CVE-2010-3422"
],
"14999": [],
"15004": [
"CVE-2010-3467"
],
"15006": [
"CVE-2010-3461"
],
"15011": [
"CVE-2010-3481",
"CVE-2010-3480"
],
"15014": [],
"36828": [],
"15018": [
"CVE-2010-3603",
"CVE-2010-3602"
],
"15029": [],
"15037": [],
"15039": [
"CVE-2010-4954"
],
"15040": [
"CVE-2010-4928",
"CVE-2010-4927"
],
"15041": [],
"15044": [],
"15046": [],
"15049": [
"CVE-2010-3479"
],
"15050": [],
"15100": [
"CVE-2010-4944"
],
"15058": [],
"15060": [
"CVE-2010-4752",
"CVE-2010-4751",
"CVE-2010-3485",
"CVE-2010-3484"
],
"15064": [
"CVE-2010-3483",
"CVE-2010-3482"
],
"15067": [],
"15070": [
"CVE-2010-3601"
],
"15075": [
"CVE-2010-3608"
],
"15078": [],
"15080": [],
"15082": [],
"15084": [
"CVE-2010-4926"
],
"15085": [
"CVE-2010-4929"
],
"15090": [
"CVE-2010-4940"
],
"15091": [
"CVE-2010-4933"
],
"15092": [],
"15093": [],
"15098": [
"CVE-2010-3490"
],
"15114": [],
"15102": [],
"15106": [],
"15157": [
"CVE-2010-4865"
],
"15118": [],
"15119": [],
"15110": [
"CVE-2010-4942"
],
"15120": [
"CVE-2010-3468"
],
"15121": [],
"15124": [],
"15126": [
"CVE-2010-4935"
],
"15130": [],
"15128": [
"CVE-2010-4947",
"CVE-2010-4946"
],
"15198": [],
"15135": [],
"15143": [],
"15139": [],
"15141": [],
"15144": [],
"15145": [],
"15146": [],
"15147": [],
"15151": [
"CVE-2010-4861"
],
"15152": [],
"15153": [],
"15154": [
"CVE-2010-4860"
],
"15160": [],
"15162": [],
"15163": [
"CVE-2010-4862"
],
"15164": [],
"15165": [],
"15166": [],
"15169": [],
"15174": [],
"15173": [],
"15171": [],
"15175": [
"CVE-2010-4866"
],
"15199": [],
"15183": [],
"15177": [],
"15185": [
"CVE-2010-3425"
],
"15189": [
"CVE-2010-3486"
],
"15191": [],
"15194": [],
"15200": [],
"15204": [
"CVE-2010-4858"
],
"15205": [],
"15207": [],
"15208": [],
"15209": [],
"15210": [
"CVE-2010-4857"
],
"15284": [
"CVE-2010-4143"
],
"15217": [],
"15218": [
"CVE-2010-4855"
],
"15219": [
"CVE-2010-4856"
],
"15220": [
"CVE-2010-4797"
],
"15222": [
"CVE-2010-5280"
],
"15223": [
"CVE-2010-4799"
],
"15224": [
"CVE-2010-4795",
"CVE-2010-4794"
],
"15225": [],
"15268": [],
"39571": [],
"15269": [],
"15227": [
"CVE-2010-4791"
],
"15592": [],
"15593": [],
"15594": [
"CVE-2010-4774"
],
"15595": [],
"15596": [],
"15597": [],
"15602": [],
"15605": [],
"15230": [
"CVE-2010-4793"
],
"15232": [
"CVE-2010-4798"
],
"15233": [
"CVE-2010-4800"
],
"15234": [
"CVE-2010-4801"
],
"15606": [],
"15607": [
"CVE-2010-4006"
],
"15237": [
"CVE-2010-2618"
],
"15239": [],
"15240": [
"CVE-2010-5285",
"CVE-2010-5284"
],
"15247": [],
"15249": [],
"15251": [],
"15608": [
"CVE-2010-4298"
],
"15254": [],
"15270": [
"CVE-2010-4145",
"CVE-2010-4144"
],
"15610": [
"CVE-2010-4365",
"CVE-2010-2513"
],
"15280": [],
"15276": [],
"15277": [],
"15278": [
"CVE-2004-1580"
],
"15281": [],
"15290": [
"CVE-2010-3514"
],
"15300": [],
"15295": [],
"15308": [],
"15309": [
"CVE-2010-4869"
],
"15310": [],
"15313": [],
"15320": [],
"15321": [],
"15322": [],
"15323": [],
"15324": [],
"15325": [],
"15326": [],
"15327": [
"CVE-2010-4185"
],
"15328": [
"CVE-2010-4870"
],
"15329": [],
"15330": [
"CVE-2010-4874"
],
"15331": [],
"15332": [],
"15335": [
"CVE-2008-5751"
],
"15338": [
"CVE-2010-4273"
],
"15340": [],
"15343": [],
"15345": [],
"15348": [],
"15350": [],
"15351": [],
"15353": [],
"15354": [],
"15355": [],
"15360": [],
"15361": [],
"15366": [
"CVE-2010-4268"
],
"15367": [
"CVE-2010-4272"
],
"15369": [],
"15370": [],
"15381": [
"CVE-2010-4269"
],
"15382": [],
"15385": [],
"15386": [],
"15387": [],
"15389": [],
"15391": [],
"15395": [
"CVE-2010-4635"
],
"15396": [],
"15397": [
"CVE-2010-4186"
],
"15398": [],
"15399": [
"CVE-2010-4636"
],
"15400": [],
"15917": [],
"40388": [],
"15404": [],
"15405": [
"CVE-2010-4633"
],
"15409": [],
"15412": [],
"15413": [
"CVE-2010-5318",
"CVE-2010-5317"
],
"15414": [],
"15415": [],
"15416": [],
"15430": [
"CVE-2010-4853"
],
"15439": [],
"15440": [],
"15441": [],
"15447": [],
"15448": [
"CVE-2010-4632",
"CVE-2010-4631",
"CVE-2008-2688"
],
"15451": [],
"15452": [],
"15453": [
"CVE-2010-1345"
],
"15454": [],
"15455": [],
"15456": [],
"15496": [
"CVE-2010-4976"
],
"15459": [],
"15460": [
"CVE-2008-6222"
],
"15466": [
"CVE-2010-4638"
],
"15465": [],
"15468": [],
"15469": [],
"15470": [],
"15484": [],
"15472": [],
"15473": [
"CVE-2010-3891"
],
"15490": [],
"15486": [],
"15488": [
"CVE-2010-2892"
],
"15492": [],
"15497": [
"CVE-2010-4872"
],
"15500": [],
"15501": [
"CVE-2010-4837"
],
"15502": [
"CVE-2010-4838"
],
"15506": [
"CVE-2010-4232"
],
"15507": [
"CVE-2010-4233"
],
"15509": [],
"15510": [
"CVE-2010-4810"
],
"15512": [
"CVE-2010-4809"
],
"15513": [
"CVE-2010-4839"
],
"15515": [],
"15516": [],
"15517": [
"CVE-2010-4808"
],
"15518": [],
"15519": [
"CVE-2010-4835",
"CVE-2010-4834"
],
"15524": [],
"15531": [
"CVE-2010-4814"
],
"15526": [
"CVE-2010-4776"
],
"15550": [],
"15551": [],
"15552": [],
"15543": [
"CVE-2010-4366"
],
"15544": [
"CVE-2009-5019"
],
"15545": [],
"15549": [],
"15553": [],
"15554": [],
"15555": [],
"15557": [],
"15559": [],
"15560": [],
"15561": [],
"15563": [],
"15564": [],
"15565": [],
"15567": [],
"15568": [],
"15570": [],
"15571": [],
"15572": [],
"15573": [],
"15574": [],
"15577": [],
"15578": [
"CVE-2010-4770"
],
"15585": [
"CVE-2010-4769"
],
"16087": [],
"15588": [
"CVE-2010-4772",
"CVE-2010-4771"
],
"15590": [],
"15614": [],
"15611": [],
"15612": [
"CVE-2010-4357"
],
"15615": [],
"15621": [
"CVE-2010-4360",
"CVE-2010-4359"
],
"15623": [],
"15625": [
"CVE-2010-4734"
],
"15627": [
"CVE-2010-4356"
],
"15629": [
"CVE-2010-4362"
],
"15633": [
"CVE-2010-4850"
],
"15636": [
"CVE-2010-4313"
],
"15637": [],
"15638": [],
"15639": [
"CVE-2010-4279"
],
"15640": [
"CVE-2010-4278"
],
"15641": [
"CVE-2010-4280"
],
"15642": [
"CVE-2010-4280"
],
"15643": [
"CVE-2010-4283",
"CVE-2010-4282",
"CVE-2010-4281"
],
"15644": [
"CVE-2010-4852",
"CVE-2010-4851"
],
"15645": [
"CVE-2010-4781",
"CVE-2010-4780"
],
"15646": [
"CVE-2010-4401",
"CVE-2010-4400",
"CVE-2010-4399"
],
"15647": [],
"15650": [
"CVE-2010-4849"
],
"15651": [],
"15653": [
"CVE-2010-3267",
"CVE-2010-3266"
],
"15654": [],
"15656": [
"CVE-2010-4406"
],
"15659": [],
"15660": [],
"15661": [
"CVE-2010-4782",
"CVE-2006-6807"
],
"15665": [],
"15666": [],
"15673": [],
"15675": [],
"15677": [
"CVE-2010-4829"
],
"15678": [
"CVE-2010-4830"
],
"15679": [],
"15680": [],
"15681": [],
"15682": [],
"15683": [],
"15684": [],
"15685": [],
"15686": [
"CVE-2010-4736"
],
"15687": [
"CVE-2010-4735"
],
"15688": [
"CVE-2010-4737"
],
"15690": [],
"15691": [
"CVE-2010-4330"
],
"15699": [
"CVE-2010-4480"
],
"33671": [],
"15701": [],
"15703": [],
"15744": [
"CVE-2010-3906"
],
"15710": [
"CVE-2010-3449"
],
"15711": [],
"15714": [
"CVE-2010-4517"
],
"15715": [],
"15720": [],
"15718": [],
"15719": [],
"15721": [],
"15728": [
"CVE-2010-4507"
],
"15735": [
"CVE-2010-4349",
"CVE-2010-4348"
],
"15736": [
"CVE-2010-4350"
],
"15737": [],
"15740": [
"CVE-2010-4332"
],
"15741": [
"CVE-2010-4333"
],
"15742": [
"CVE-2010-5315"
],
"15743": [
"CVE-2010-4750",
"CVE-2010-4749"
],
"15748": [],
"15749": [
"CVE-2010-4719"
],
"15752": [],
"15753": [],
"15754": [
"CVE-2010-4721"
],
"15755": [
"CVE-2010-4844"
],
"15756": [
"CVE-2010-4847"
],
"15766": [
"CVE-2010-4275"
],
"15765": [],
"15768": [],
"15769": [
"CVE-2010-4614"
],
"15770": [
"CVE-2010-4842"
],
"15771": [],
"15772": [
"CVE-2010-4846"
],
"15773": [
"CVE-2010-4845"
],
"15775": [
"CVE-2010-4619"
],
"15776": [],
"15777": [
"CVE-2010-4615"
],
"15779": [],
"15781": [],
"15783": [],
"15784": [],
"15789": [],
"15790": [
"CVE-2010-4843"
],
"15791": [
"CVE-2010-4617"
],
"15793": [],
"15795": [],
"15797": [
"CVE-2010-4613",
"CVE-2010-4612"
],
"15798": [],
"15799": [
"CVE-2010-4608",
"CVE-2010-4607"
],
"15800": [
"CVE-2010-4611",
"CVE-2010-4610",
"CVE-2010-4609"
],
"15801": [],
"15804": [],
"15807": [],
"15808": [],
"15810": [],
"15811": [],
"15812": [],
"15813": [],
"15814": [],
"15815": [],
"15816": [],
"15818": [],
"15819": [],
"15820": [],
"15822": [],
"15824": [],
"15825": [],
"15826": [],
"15827": [],
"15828": [],
"15838": [],
"15830": [],
"15831": [],
"15832": [],
"15835": [],
"15836": [],
"15837": [],
"15840": [],
"15843": [],
"15846": [],
"15847": [],
"15848": [],
"15849": [],
"15850": [],
"15852": [],
"15853": [],
"15856": [
"CVE-2012-2344",
"CVE-2010-5099",
"CVE-2010-3714"
],
"15857": [],
"15858": [],
"15863": [],
"15864": [],
"15865": [],
"15915": [],
"15886": [],
"15887": [],
"15889": [],
"15890": [],
"15891": [
"CVE-2011-0519"
],
"15892": [],
"15893": [],
"15896": [],
"15902": [],
"15907": [],
"15913": [
"CVE-2011-0405"
],
"15961": [
"CVE-2011-0443"
],
"15918": [],
"15920": [],
"15921": [],
"15922": [
"CVE-2011-0407"
],
"15923": [],
"15924": [],
"15938": [
"CVE-2011-0506"
],
"15939": [],
"15942": [],
"15943": [],
"15945": [
"CVE-2011-0505"
],
"15958": [],
"15960": [],
"15964": [
"CVE-2011-0518"
],
"15968": [
"CVE-2011-0504",
"CVE-2011-0503"
],
"15969": [
"CVE-2011-5318"
],
"15970": [],
"15966": [],
"15967": [],
"15971": [],
"15981": [],
"15979": [],
"15987": [
"CVE-2007-6515"
],
"16020": [
"CVE-2011-0646"
],
"15989": [],
"15993": [],
"15995": [],
"15996": [],
"15997": [],
"15999": [
"CVE-2011-0516"
],
"16000": [
"CVE-2010-4331"
],
"16001": [],
"16003": [
"CVE-2011-0510"
],
"16004": [
"CVE-2011-0512"
],
"16006": [
"CVE-2011-5284",
"CVE-2011-5283"
],
"16010": [
"CVE-2011-0511"
],
"16011": [
"CVE-2010-4335"
],
"16013": [
"CVE-2011-0642"
],
"17209": [],
"16016": [
"CVE-2011-0635"
],
"16039": [],
"16018": [],
"16019": [
"CVE-2011-0645",
"CVE-2011-0644"
],
"16027": [],
"16028": [],
"16034": [],
"16037": [
"CVE-2011-0643"
],
"16060": [],
"16044": [],
"16047": [],
"16110": [],
"16049": [
"CVE-2011-0903"
],
"16050": [],
"16051": [],
"16054": [],
"16058": [],
"16059": [],
"16061": [],
"16062": [],
"16069": [],
"16074": [],
"16076": [],
"16077": [],
"16080": [],
"16272": [],
"16088": [],
"16090": [],
"16091": [],
"16094": [],
"16096": [
"CVE-2011-5313"
],
"16097": [
"CVE-2011-0535"
],
"16102": [],
"16106": [],
"16109": [],
"16113": [],
"16114": [],
"16116": [],
"16117": [],
"16122": [],
"16221": [],
"16127": [],
"16128": [],
"16130": [],
"16131": [],
"16134": [],
"16135": [],
"16136": [],
"16139": [],
"16140": [],
"16167": [],
"16168": [],
"16143": [
"CVE-2011-1048"
],
"16144": [],
"16183": [],
"16165": [],
"16148": [],
"16152": [],
"16154": [
"CVE-2009-0932"
],
"16155": [],
"16156": [],
"16157": [],
"16158": [
"CVE-2011-1062"
],
"16159": [],
"16160": [
"CVE-2011-1100"
],
"16170": [],
"16171": [
"CVE-2011-1055"
],
"16172": [],
"16175": [],
"16178": [
"CVE-2010-4738"
],
"16179": [
"CVE-2010-4738"
],
"16181": [
"CVE-2013-1916"
],
"16225": [],
"16196": [],
"16197": [],
"16198": [],
"16199": [],
"16200": [],
"16201": [],
"16202": [],
"16205": [],
"16206": [],
"16207": [],
"16222": [],
"16223": [],
"16220": [],
"16218": [],
"16213": [],
"16214": [],
"16217": [],
"16232": [],
"16233": [],
"16235": [
"CVE-2011-1047"
],
"16236": [],
"16241": [],
"16246": [],
"16247": [],
"16249": [],
"16250": [],
"16251": [],
"16252": [],
"16256": [],
"16257": [],
"16265": [],
"16266": [],
"16267": [],
"16268": [],
"16273": [],
"16274": [
"CVE-2010-0738"
],
"16276": [],
"16279": [],
"16280": [
"CVE-2009-3249"
],
"16281": [],
"41784": [
"CVE-2017-7402"
],
"16313": [],
"41801": [
"CVE-2017-2367"
],
"41802": [
"CVE-2017-2445"
],
"41803": [
"CVE-2017-2457"
],
"41799": [
"CVE-2017-2364"
],
"41800": [
"CVE-2017-2442"
],
"16788": [
"CVE-2009-2265"
],
"16856": [
"CVE-2009-2765"
],
"16857": [
"CVE-2007-3010"
],
"16858": [
"CVE-2000-0322",
"CVE-2000-0248"
],
"41782": [
"CVE-2017-6884"
],
"16881": [],
"16882": [
"CVE-2005-1921"
],
"16883": [
"CVE-2005-2733"
],
"16885": [
"CVE-2006-4602"
],
"16886": [
"CVE-2006-2237"
],
"16889": [],
"16890": [
"CVE-2005-2086",
"CVE-2004-1315"
],
"16891": [
"CVE-2003-0050"
],
"16892": [
"CVE-2005-2877"
],
"16893": [
"CVE-2005-2847"
],
"16894": [
"CVE-2004-1037"
],
"16895": [
"CVE-2005-2612"
],
"16896": [
"CVE-2005-0511"
],
"16897": [
"CVE-2006-2685"
],
"16899": [],
"16901": [
"CVE-2006-1551"
],
"16902": [
"CVE-2010-4335"
],
"16904": [
"CVE-2008-6825"
],
"16905": [
"CVE-2005-0116"
],
"16906": [],
"16907": [
"CVE-2005-3757"
],
"16908": [
"CVE-2009-2288"
],
"16909": [
"CVE-2008-0506"
],
"16911": [
"CVE-2007-5423"
],
"16912": [
"CVE-2008-2905"
],
"16913": [
"CVE-2009-1151"
],
"16914": [
"CVE-1999-1053"
],
"16917": [],
"16923": [],
"16931": [],
"16946": [],
"16933": [
"CVE-2011-1099"
],
"16934": [],
"16935": [],
"16937": [],
"16938": [],
"16941": [],
"16947": [],
"16948": [],
"16949": [],
"16950": [],
"16953": [],
"16954": [],
"16955": [
"CVE-2010-3486"
],
"16959": [
"CVE-2010-4437"
],
"16961": [],
"16962": [],
"16963": [],
"16968": [],
"16969": [],
"16975": [],
"16980": [],
"16982": [],
"16987": [],
"16988": [
"CVE-2011-5267"
],
"16989": [],
"16992": [],
"16995": [],
"16997": [],
"17000": [],
"17002": [],
"17003": [],
"17005": [],
"17006": [],
"17007": [],
"17009": [],
"17011": [
"CVE-2011-1569"
],
"17014": [],
"17015": [],
"17016": [],
"17018": [],
"17026": [
"CVE-2011-1524",
"CVE-2011-0545"
],
"17035": [],
"17036": [],
"17046": [],
"17050": [],
"17051": [],
"17054": [],
"17055": [],
"17056": [
"CVE-2011-4342"
],
"17057": [],
"17061": [
"CVE-2011-1556"
],
"17062": [],
"17069": [],
"17076": [],
"17077": [],
"17079": [],
"17080": [],
"17081": [],
"17084": [
"CVE-2011-1546"
],
"17085": [
"CVE-2011-1665"
],
"17091": [],
"17092": [],
"17093": [],
"17094": [],
"17095": [],
"17096": [],
"17123": [],
"17098": [
"CVE-2011-1670"
],
"17099": [],
"17100": [],
"17101": [],
"17102": [
"CVE-2011-1667"
],
"17103": [],
"17106": [],
"17107": [],
"17108": [],
"17431": [],
"17110": [],
"17111": [
"CVE-2011-5025"
],
"17112": [],
"17113": [],
"17114": [],
"17115": [],
"17116": [],
"17117": [],
"17118": [
"CVE-2011-5160"
],
"17119": [
"CVE-2011-1669"
],
"17125": [],
"17126": [],
"17127": [
"CVE-2011-1715",
"CVE-2011-1714"
],
"17128": [],
"17129": [],
"17132": [],
"17134": [],
"17135": [],
"17136": [],
"17137": [],
"17178": [],
"17179": [],
"17180": [],
"17141": [],
"17146": [],
"17165": [],
"17170": [],
"17172": [],
"17173": [],
"17174": [],
"17176": [],
"17183": [],
"17197": [],
"17198": [],
"17190": [],
"17191": [],
"17192": [],
"17193": [
"CVE-2012-1416"
],
"17200": [],
"17202": [],
"17203": [],
"17204": [],
"17205": [],
"17206": [],
"17207": [],
"17211": [],
"17212": [],
"17213": [],
"17214": [],
"17215": [],
"17216": [],
"17218": [],
"17220": [],
"17221": [],
"17226": [],
"17228": [],
"17231": [],
"17319": [],
"17235": [],
"17236": [],
"17237": [],
"17238": [],
"17239": [],
"17242": [],
"17248": [],
"17250": [],
"17251": [],
"17259": [],
"17264": [],
"17265": [],
"17267": [],
"17276": [
"CVE-2011-1511"
],
"17284": [],
"17285": [],
"17288": [],
"17289": [],
"17292": [],
"17293": [],
"17295": [],
"17296": [],
"17297": [],
"17299": [],
"17301": [],
"17303": [],
"17307": [],
"17308": [],
"17309": [],
"17311": [],
"17312": [],
"17314": [],
"17316": [],
"17320": [],
"17321": [],
"17322": [],
"17324": [
"CVE-2008-3922"
],
"17325": [],
"17327": [],
"17330": [],
"17335": [],
"17336": [],
"17338": [],
"17341": [],
"17343": [],
"17344": [],
"17346": [],
"17347": [],
"17349": [
"CVE-2012-2765"
],
"17350": [],
"43191": [],
"17360": [],
"17367": [],
"17375": [],
"17376": [],
"17377": [],
"17378": [],
"17379": [],
"17380": [],
"17382": [],
"17388": [],
"17389": [],
"17390": [
"CVE-2011-5212",
"CVE-2011-5211"
],
"17393": [],
"17394": [],
"17395": [],
"17402": [],
"17403": [],
"17404": [
"CVE-2010-3271"
],
"17406": [],
"17408": [],
"17410": [],
"17411": [],
"17412": [],
"17413": [],
"17414": [],
"17418": [],
"17423": [],
"17426": [],
"17428": [],
"17435": [],
"17436": [],
"17437": [
"CVE-2011-2757",
"CVE-2011-2755"
],
"17442": [
"CVE-2011-2757",
"CVE-2011-2755"
],
"17443": [],
"17444": [],
"17445": [],
"17446": [],
"17452": [],
"17453": [],
"17457": [],
"17464": [
"CVE-2008-6149"
],
"17465": [],
"17466": [],
"17472": [],
"17475": [],
"17477": [],
"17478": [],
"17479": [],
"17480": [],
"17481": [],
"17482": [],
"17483": [],
"17484": [],
"17485": [],
"17487": [],
"17493": [],
"17495": [],
"17496": [],
"17500": [],
"17503": [
"CVE-2011-2757",
"CVE-2011-2755"
],
"17508": [],
"17510": [
"CVE-2011-2506",
"CVE-2011-2505"
],
"17514": [
"CVE-2011-2506",
"CVE-2011-2505"
],
"17515": [],
"17518": [],
"17522": [],
"17523": [],
"17524": [],
"17525": [],
"17528": [],
"17529": [],
"17530": [],
"17531": [],
"17532": [],
"17533": [],
"17553": [],
"17554": [],
"17551": [
"CVE-2011-2260"
],
"17555": [],
"17556": [],
"17560": [],
"17562": [],
"17574": [],
"17570": [],
"17571": [],
"17572": [],
"17573": [],
"17577": [
"CVE-2011-2522"
],
"17579": [],
"17584": [],
"17586": [],
"17587": [],
"17590": [],
"17591": [],
"17592": [],
"17593": [
"CVE-2013-0332"
],
"17595": [],
"17594": [],
"17597": [],
"17602": [
"CVE-2011-4106"
],
"17603": [],
"17606": [],
"17613": [],
"17615": [
"CVE-2011-0807"
],
"17616": [],
"17617": [
"CVE-2011-5286"
],
"17637": [],
"17627": [],
"17628": [],
"17629": [],
"17630": [],
"17631": [],
"17633": [],
"17639": [],
"17640": [],
"17644": [],
"17646": [],
"17653": [],
"17666": [],
"17660": [],
"17661": [],
"17662": [],
"17667": [],
"17673": [],
"17674": [],
"17675": [],
"17677": [],
"17678": [],
"17679": [],
"17680": [],
"17681": [],
"17682": [],
"17683": [],
"17684": [],
"17685": [],
"17686": [],
"17687": [],
"17688": [],
"17689": [],
"17695": [],
"17694": [],
"17698": [
"CVE-2010-0904"
],
"17702": [
"CVE-2009-2335"
],
"17703": [],
"17704": [],
"17705": [],
"17706": [],
"17707": [],
"17708": [],
"17709": [],
"17710": [],
"17711": [],
"17713": [],
"17714": [],
"17716": [],
"17720": [],
"17722": [],
"17724": [],
"17725": [],
"17728": [],
"17729": [],
"17730": [],
"17731": [],
"17733": [],
"17734": [],
"17736": [],
"17737": [],
"17738": [],
"17739": [],
"17740": [],
"17741": [],
"17743": [
"CVE-2011-2763"
],
"17748": [],
"17749": [],
"17750": [],
"17751": [],
"17752": [],
"17753": [],
"17755": [],
"17756": [],
"17757": [],
"17758": [],
"17759": [],
"17760": [],
"17761": [],
"17763": [],
"17764": [],
"17766": [],
"17767": [],
"17771": [],
"17773": [],
"17774": [],
"17778": [],
"17779": [],
"17782": [],
"17786": [],
"17789": [],
"17790": [],
"17791": [],
"17792": [],
"17793": [],
"17794": [],
"17797": [],
"17798": [],
"17800": [],
"17801": [],
"21787": [],
"17807": [],
"17808": [],
"17809": [],
"17811": [
"CVE-2011-3394",
"CVE-2011-3393"
],
"17813": [],
"17814": [
"CVE-2010-4839"
],
"17816": [],
"17818": [],
"17822": [],
"17823": [],
"17824": [],
"17825": [],
"17829": [],
"17828": [
"CVE-2012-6625"
],
"17832": [],
"17840": [
"CVE-2011-3502"
],
"17846": [],
"17850": [
"CVE-2010-5281"
],
"17851": [],
"17852": [],
"17858": [],
"17859": [],
"17857": [],
"17860": [],
"17861": [
"CVE-2011-3981"
],
"17862": [],
"17863": [],
"17864": [],
"17865": [],
"17866": [],
"17867": [],
"17868": [],
"17869": [
"CVE-2012-1205"
],
"17871": [
"CVE-2011-2577",
"CVE-2011-2544",
"CVE-2011-2543"
],
"17872": [
"CVE-2011-4106"
],
"17873": [
"CVE-2011-1892"
],
"17874": [],
"17882": [],
"17887": [],
"17888": [
"CVE-2011-4671"
],
"17891": [],
"17894": [],
"17895": [],
"17897": [
"CVE-2011-3645"
],
"17900": [],
"17898": [],
"17905": [],
"17906": [],
"17909": [],
"17911": [],
"17919": [
"CVE-2011-5168"
],
"17920": [],
"17921": [],
"17922": [
"CVE-2011-1653"
],
"17924": [
"CVE-2010-0738"
],
"17925": [],
"17926": [],
"17927": [
"CVE-2011-4572"
],
"18033": [],
"17935": [],
"17937": [],
"17938": [],
"17941": [],
"17943": [],
"17944": [
"CVE-2011-4570"
],
"17946": [
"CVE-2011-4026"
],
"17947": [],
"17949": [],
"17950": [],
"17951": [],
"17952": [],
"17970": [],
"17972": [],
"17973": [],
"17955": [],
"17956": [],
"17957": [],
"17958": [],
"17959": [],
"17961": [
"CVE-2011-5278",
"CVE-2011-5277"
],
"17962": [
"CVE-2011-4569"
],
"17980": [],
"17983": [],
"17984": [],
"17987": [],
"17994": [],
"17989": [],
"17992": [
"CVE-2011-4066"
],
"17995": [],
"17997": [],
"17998": [],
"17999": [],
"18000": [],
"18001": [],
"18002": [],
"18003": [],
"18004": [],
"18005": [
"CVE-2011-4024"
],
"18009": [
"CVE-2011-5139"
],
"18012": [],
"18013": [],
"18018": [
"CVE-2006-4278"
],
"18020": [
"CVE-2011-4094"
],
"18021": [
"CVE-2011-4075",
"CVE-2011-4074"
],
"18022": [],
"18042": [
"CVE-2011-5113"
],
"18046": [
"CVE-2011-4830",
"CVE-2011-4829"
],
"18031": [
"CVE-2011-4075"
],
"18032": [],
"18035": [
"CVE-2011-5185"
],
"18036": [],
"18037": [
"CVE-2008-6132"
],
"18039": [
"CVE-2011-4803"
],
"18045": [
"CVE-2011-4807",
"CVE-2011-4806",
"CVE-2005-3948"
],
"18047": [],
"18048": [
"CVE-2011-4823"
],
"18050": [
"CVE-2011-4809",
"CVE-2011-4808"
],
"18053": [
"CVE-2011-5257"
],
"18055": [],
"18056": [
"CVE-2011-5186"
],
"18058": [
"CVE-2011-5112"
],
"18061": [
"CVE-2012-4746"
],
"18063": [
"CVE-2011-4812",
"CVE-2011-4811"
],
"18065": [
"CVE-2011-5116"
],
"18066": [
"CVE-2011-4832"
],
"18069": [
"CVE-2011-4095"
],
"18070": [
"CVE-2011-4831"
],
"18075": [
"CVE-2011-4825"
],
"18076": [],
"18077": [],
"18081": [
"CVE-2011-4813"
],
"18083": [
"CVE-2011-4825"
],
"18084": [
"CVE-2011-4825"
],
"18085": [
"CVE-2011-4825"
],
"18088": [
"CVE-2011-4810"
],
"18090": [],
"18091": [
"CVE-2011-5183"
],
"18095": [],
"18099": [
"CVE-2011-4713"
],
"18100": [
"CVE-2011-4334",
"CVE-2011-4333"
],
"18101": [],
"18108": [
"CVE-2011-3833",
"CVE-2011-3829"
],
"18110": [
"CVE-2011-2917"
],
"18111": [],
"18132": [
"CVE-2011-5075",
"CVE-2011-4337"
],
"18114": [
"CVE-2011-4671"
],
"18115": [
"CVE-2011-4710"
],
"18117": [
"CVE-2011-4801"
],
"18118": [
"CVE-2011-5005"
],
"18121": [
"CVE-2011-5147"
],
"18122": [
"CVE-2011-5262"
],
"18126": [
"CVE-2011-4673"
],
"18127": [
"CVE-2011-5109"
],
"18128": [
"CVE-2011-4672"
],
"18129": [
"CVE-2011-5110"
],
"18131": [],
"18148": [
"CVE-2009-0302"
],
"18149": [
"CVE-2011-4453"
],
"18151": [
"CVE-2011-4825"
],
"18153": [
"CVE-2011-4715"
],
"18155": [
"CVE-2011-4674"
],
"18156": [
"CVE-2011-5103"
],
"19400": [],
"18167": [],
"18177": [
"CVE-2011-4452",
"CVE-2011-4451",
"CVE-2011-4450",
"CVE-2011-4449",
"CVE-2011-4448"
],
"18185": [
"CVE-2011-4714"
],
"18192": [],
"18193": [],
"18198": [
"CVE-2011-5130"
],
"18202": [],
"18207": [],
"18208": [
"CVE-2011-5130"
],
"18215": [],
"18217": [],
"18218": [],
"18210": [],
"18212": [],
"18213": [],
"18214": [],
"18222": [],
"18224": [
"CVE-2011-5135"
],
"18230": [
"CVE-2012-0699"
],
"18231": [],
"18232": [],
"18233": [],
"18236": [],
"18239": [],
"18243": [
"CVE-2011-4453"
],
"18246": [
"CVE-2011-5230"
],
"18247": [
"CVE-2011-5031"
],
"18248": [
"CVE-2011-5219"
],
"18249": [
"CVE-2011-5229",
"CVE-2011-5228"
],
"18250": [
"CVE-2011-5218"
],
"18251": [],
"18259": [
"CVE-2011-5040",
"CVE-2011-5039"
],
"18260": [],
"18261": [
"CVE-2011-5150",
"CVE-2011-5149"
],
"18262": [
"CVE-2011-3587"
],
"18265": [
"CVE-2011-4558"
],
"18266": [
"CVE-2011-5197",
"CVE-2011-5196",
"CVE-2011-5195"
],
"18274": [
"CVE-2012-2115",
"CVE-2011-5161",
"CVE-2011-5160"
],
"18276": [],
"18277": [],
"18412": [
"CVE-2012-5318",
"CVE-2012-1125"
],
"18287": [
"CVE-2011-5148"
],
"18288": [
"CVE-2011-5140"
],
"18290": [
"CVE-2011-5026"
],
"18292": [
"CVE-2011-5200"
],
"18293": [
"CVE-2011-5204",
"CVE-2011-5203"
],
"18297": [],
"18298": [
"CVE-2012-5098"
],
"18300": [
"CVE-2009-2436"
],
"18982": [],
"18308": [
"CVE-2011-4614"
],
"18314": [],
"18983": [],
"18979": [],
"18980": [],
"18320": [
"CVE-2012-5291"
],
"19381": [
"CVE-2012-0694"
],
"18322": [
"CVE-2012-5347"
],
"18985": [],
"18329": [
"CVE-2012-0394",
"CVE-2012-0393",
"CVE-2012-0392",
"CVE-2012-0391"
],
"18330": [
"CVE-2012-5350",
"CVE-2012-5349"
],
"18335": [
"CVE-2012-5348"
],
"18338": [
"CVE-2012-5288"
],
"18340": [],
"18341": [
"CVE-2012-6644"
],
"18342": [
"CVE-2012-5293"
],
"18343": [
"CVE-2012-1025",
"CVE-2012-1024"
],
"18344": [
"CVE-2012-6038",
"CVE-2012-5918"
],
"18347": [
"CVE-2012-6500"
],
"18348": [
"CVE-2012-6523",
"CVE-2012-6522"
],
"18350": [
"CVE-2012-6499"
],
"18352": [
"CVE-2012-6039"
],
"18353": [],
"18355": [
"CVE-2012-0896",
"CVE-2012-0895"
],
"18356": [],
"18357": [],
"18373": [],
"18374": [],
"18371": [
"CVE-2011-4107"
],
"18380": [],
"18975": [
"CVE-2011-4825"
],
"18383": [
"CVE-2012-6524"
],
"18384": [
"CVE-2012-6525"
],
"18385": [
"CVE-2012-0905"
],
"18386": [
"CVE-2012-0906"
],
"18389": [],
"18390": [],
"18700": [
"CVE-2012-1673"
],
"18392": [
"CVE-2012-1153"
],
"18394": [
"CVE-2012-0913"
],
"18395": [],
"18396": [],
"18402": [
"CVE-2012-5315"
],
"18403": [],
"18404": [
"CVE-2012-5326"
],
"18405": [
"CVE-2012-0935"
],
"18407": [
"CVE-2012-1011",
"CVE-2012-1010"
],
"18410": [
"CVE-2012-5231"
],
"18699": [
"CVE-2012-2156"
],
"18413": [],
"18701": [
"CVE-2012-5386",
"CVE-2012-1671"
],
"18416": [
"CVE-2012-0286",
"CVE-2012-0285"
],
"18417": [
"CVE-2012-0937",
"CVE-2012-0782",
"CVE-2011-4899",
"CVE-2011-4898"
],
"18418": [
"CVE-2012-5005"
],
"18419": [
"CVE-2012-5228",
"CVE-2012-4247",
"CVE-2012-4246",
"CVE-2011-1682",
"CVE-2011-0748"
],
"18422": [
"CVE-2012-5227",
"CVE-2012-5226"
],
"18424": [
"CVE-2012-5223"
],
"18429": [],
"18430": [],
"18431": [],
"18432": [
"CVE-2012-0980"
],
"18435": [
"CVE-2012-0981"
],
"18434": [],
"18438": [
"CVE-2012-0983"
],
"18439": [],
"18441": [
"CVE-2012-0982"
],
"18443": [],
"18444": [
"CVE-2011-5074",
"CVE-2011-5073",
"CVE-2011-5072"
],
"18447": [
"CVE-2012-0389"
],
"18451": [
"CVE-2012-1005"
],
"18452": [
"CVE-2012-1007",
"CVE-2012-1006"
],
"18455": [
"CVE-2012-1059"
],
"18456": [],
"18464": [
"CVE-2012-1220"
],
"18465": [
"CVE-2012-1017"
],
"18466": [
"CVE-2012-1029"
],
"18467": [
"CVE-2012-1026"
],
"18468": [
"CVE-2012-1058"
],
"18470": [],
"18473": [
"CVE-2012-1047"
],
"18480": [
"CVE-2012-1226"
],
"18483": [
"CVE-2012-1304",
"CVE-2012-1208"
],
"18499": [
"CVE-2012-1308"
],
"18487": [
"CVE-2012-1416"
],
"18494": [],
"18495": [],
"18497": [],
"18498": [
"CVE-2012-1203"
],
"18502": [
"CVE-2012-1414"
],
"18503": [],
"18504": [
"CVE-2012-5320"
],
"18561": [],
"18563": [
"CVE-2012-1305",
"CVE-2012-1304",
"CVE-2012-1208"
],
"18506": [],
"18508": [
"CVE-2012-4927"
],
"18513": [
"CVE-2012-1415"
],
"18509": [
"CVE-2012-5319"
],
"18510": [],
"18511": [
"CVE-2012-1309"
],
"18516": [],
"18517": [],
"18519": [
"CVE-2012-2236"
],
"18518": [
"CVE-2011-2944"
],
"18522": [],
"18523": [
"CVE-2012-1790"
],
"18526": [],
"18527": [
"CVE-2012-1297"
],
"18536": [
"CVE-2012-1498"
],
"18702": [
"CVE-2012-1672"
],
"18540": [
"CVE-2012-1417"
],
"18544": [
"CVE-2012-4926",
"CVE-2012-4925"
],
"18545": [],
"18560": [],
"18549": [
"CVE-2012-1124"
],
"18564": [
"CVE-2007-6752"
],
"18553": [
"CVE-2012-4996",
"CVE-2012-4993"
],
"18554": [
"CVE-2012-2105"
],
"18556": [],
"18558": [
"CVE-2012-5000"
],
"18559": [
"CVE-2012-4997"
],
"18566": [],
"18567": [
"CVE-2011-4837",
"CVE-2011-4835"
],
"18571": [
"CVE-2006-2758",
"CVE-2005-3747"
],
"18575": [
"CVE-2012-1900"
],
"18578": [
"CVE-2012-2903",
"CVE-2012-1912",
"CVE-2012-1911",
"CVE-2008-2566",
"CVE-2008-2565"
],
"18574": [],
"18582": [],
"18583": [],
"18616": [
"CVE-2012-5334"
],
"18618": [],
"18589": [],
"18595": [],
"18590": [
"CVE-2005-2892"
],
"18591": [],
"18592": [],
"18597": [
"CVE-2012-1922",
"CVE-2012-1921"
],
"18598": [],
"18599": [
"CVE-2012-5331",
"CVE-2012-5330"
],
"18603": [],
"18605": [],
"18607": [],
"18608": [],
"18609": [
"CVE-2012-1901"
],
"18613": [
"CVE-2007-2675"
],
"18614": [
"CVE-2012-5333"
],
"18632": [],
"18626": [],
"18631": [],
"18932": [
"CVE-2012-0297"
],
"18638": [],
"18639": [
"CVE-2012-2741",
"CVE-2012-2740"
],
"18644": [
"CVE-2012-6667"
],
"18646": [],
"18647": [
"CVE-2012-1670"
],
"18648": [
"CVE-2012-6665",
"CVE-2012-1669"
],
"18649": [
"CVE-2012-4870",
"CVE-2012-4869"
],
"18650": [
"CVE-2012-4869"
],
"18651": [
"CVE-2012-1922",
"CVE-2012-1921"
],
"18652": [
"CVE-2012-1898",
"CVE-2012-1897"
],
"18655": [
"CVE-2012-1300"
],
"18659": [
"CVE-2012-4869"
],
"18660": [],
"18676": [],
"18670": [
"CVE-2012-5912"
],
"18667": [
"CVE-2012-0699"
],
"18668": [
"CVE-2012-6679"
],
"18680": [
"CVE-2012-1614",
"CVE-2012-1613"
],
"18682": [],
"18685": [
"CVE-2012-5891"
],
"18686": [
"CVE-2012-1979"
],
"18687": [
"CVE-2012-5900",
"CVE-2012-5899",
"CVE-2012-5898"
],
"18689": [],
"18690": [
"CVE-2012-2109"
],
"18694": [
"CVE-2012-1978"
],
"18708": [],
"18711": [
"CVE-2012-6522"
],
"18715": [
"CVE-2011-1571"
],
"18720": [
"CVE-2012-4325"
],
"18722": [
"CVE-2012-4746"
],
"18724": [],
"18725": [],
"18728": [
"CVE-2011-4571"
],
"18729": [],
"18732": [],
"18736": [
"CVE-2012-2226"
],
"18737": [],
"18741": [],
"18742": [],
"18743": [],
"18745": [],
"18750": [
"CVE-2012-1261",
"CVE-2012-1260",
"CVE-2012-1259",
"CVE-2012-1258"
],
"18752": [
"CVE-2012-4679",
"CVE-2012-1935",
"CVE-2012-1934",
"CVE-2012-1933"
],
"18753": [
"CVE-2012-0984"
],
"18772": [
"CVE-2012-5919",
"CVE-2012-5894"
],
"18764": [
"CVE-2012-0551"
],
"18766": [
"CVE-2012-0550"
],
"18768": [],
"18770": [
"CVE-2012-4867"
],
"18773": [],
"18775": [
"CVE-2012-1496",
"CVE-2012-1495"
],
"18778": [
"CVE-2012-6516"
],
"18782": [
"CVE-2012-2209",
"CVE-2012-2208"
],
"18788": [
"CVE-2012-6505",
"CVE-2012-6504"
],
"18787": [
"CVE-2012-6506"
],
"18797": [
"CVE-2012-1495"
],
"18798": [],
"18791": [
"CVE-2012-1936"
],
"18793": [],
"18800": [
"CVE-2012-3835",
"CVE-2012-3834",
"CVE-2012-2599"
],
"18801": [
"CVE-2012-6510",
"CVE-2012-6509",
"CVE-2012-6508"
],
"18802": [
"CVE-2012-4259"
],
"18803": [],
"18804": [
"CVE-2012-6519",
"CVE-2012-6518",
"CVE-2012-6517"
],
"18806": [],
"18814": [
"CVE-2012-3840",
"CVE-2012-3839"
],
"18809": [],
"18813": [],
"18815": [],
"18820": [
"CVE-2012-1002"
],
"18824": [],
"18822": [
"CVE-2012-3831",
"CVE-2012-3830"
],
"18827": [
"CVE-2012-3838",
"CVE-2012-3837",
"CVE-2012-3836"
],
"18828": [
"CVE-2012-2227"
],
"18832": [],
"18871": [
"CVE-2012-4281",
"CVE-2012-2939",
"CVE-2012-2938"
],
"18859": [
"CVE-2012-2765"
],
"18840": [],
"18841": [],
"18842": [],
"18843": [
"CVE-2012-4258"
],
"18844": [
"CVE-2012-4262",
"CVE-2012-4261",
"CVE-2012-4260"
],
"18845": [
"CVE-2012-2925"
],
"18850": [
"CVE-2012-6047"
],
"18865": [
"CVE-2011-4449"
],
"18857": [],
"18858": [
"CVE-2012-2924",
"CVE-2012-2923"
],
"18868": [
"CVE-2012-4267"
],
"18872": [
"CVE-2012-4266",
"CVE-2012-4265"
],
"18873": [
"CVE-2012-2909",
"CVE-2012-2908"
],
"18874": [
"CVE-2012-4280",
"CVE-2012-4279",
"CVE-2012-4278"
],
"18875": [
"CVE-2012-2338"
],
"18881": [],
"18882": [
"CVE-2012-6626"
],
"18884": [
"CVE-2012-2332",
"CVE-2012-2331"
],
"18886": [
"CVE-2012-2629"
],
"18888": [
"CVE-2012-2316",
"CVE-2012-2315"
],
"18889": [
"CVE-2012-2905"
],
"18899": [],
"18900": [
"CVE-2012-6560",
"CVE-2012-6559"
],
"18911": [
"CVE-2012-6557"
],
"18912": [
"CVE-2012-6556"
],
"18913": [],
"18908": [
"CVE-2012-6555"
],
"18922": [
"CVE-2012-1153"
],
"18921": [
"CVE-2012-2952"
],
"18927": [
"CVE-2012-2216"
],
"18950": [],
"18934": [],
"18935": [],
"18937": [],
"18944": [],
"18941": [],
"18948": [],
"18953": [],
"18955": [
"CVE-2012-3791"
],
"18957": [],
"18960": [],
"18961": [],
"18970": [],
"18965": [],
"18974": [],
"18987": [],
"18988": [],
"18989": [],
"18990": [],
"18991": [],
"18993": [],
"18994": [
"CVE-2012-3814"
],
"18997": [
"CVE-2012-3574"
],
"18998": [],
"18999": [],
"19012": [],
"19013": [],
"19005": [],
"19003": [],
"19007": [],
"19008": [],
"19009": [],
"19016": [],
"19029": [],
"19018": [
"CVE-2012-3588"
],
"19019": [
"CVE-2012-3575"
],
"19020": [],
"19021": [],
"19022": [],
"19023": [
"CVE-2012-3576"
],
"19011": [],
"19031": [],
"19035": [],
"19036": [],
"19038": [
"CVE-2012-0299"
],
"19050": [
"CVE-2012-6649"
],
"19051": [],
"19052": [],
"19053": [],
"19054": [],
"19055": [],
"19056": [],
"19057": [],
"19058": [],
"19059": [],
"19060": [],
"19065": [
"CVE-2012-0297"
],
"19154": [],
"19100": [],
"19386": [],
"19132": [
"CVE-2012-4258"
],
"19133": [],
"19134": [],
"19135": [],
"19174": [],
"40432": [],
"19178": [],
"19179": [],
"19180": [],
"19185": [],
"19187": [],
"19188": [],
"19189": [],
"43474": [],
"43150": [
"CVE-2017-16843"
],
"19263": [],
"19264": [],
"19292": [],
"19294": [],
"19406": [
"CVE-2012-0298",
"CVE-2012-0297"
],
"19321": [
"CVE-2012-2172",
"CVE-2012-2171"
],
"19324": [],
"19325": [],
"19329": [],
"19330": [],
"19339": [],
"19394": [
"CVE-2011-2751"
],
"19398": [],
"19408": [
"CVE-2012-3363"
],
"19403": [
"CVE-2012-0694"
],
"19431": [],
"19432": [
"CVE-2008-6508"
],
"19452": [],
"19455": [
"CVE-2012-5972"
],
"19481": [],
"19793": [],
"19524": [],
"19525": [],
"19526": [
"CVE-2012-4031"
],
"19548": [],
"19549": [],
"19550": [],
"19572": [],
"19573": [
"CVE-2012-0911",
"CVE-2012-3996"
],
"19574": [],
"19597": [],
"19598": [],
"19600": [],
"30094": [
"CVE-2007-0694"
],
"19626": [],
"19628": [],
"19629": [
"CVE-2012-3350"
],
"19630": [
"CVE-2012-3996",
"CVE-2012-0911"
],
"19631": [
"CVE-2012-3399"
],
"19671": [],
"19715": [],
"19758": [
"CVE-2011-4542"
],
"19768": [],
"19769": [],
"19771": [],
"19774": [],
"19775": [
"CVE-2010-4980"
],
"19790": [],
"19791": [],
"19792": [],
"19825": [],
"19964": [],
"19829": [],
"19859": [],
"19862": [],
"19863": [
"CVE-2012-4399"
],
"19864": [],
"19865": [],
"19898": [],
"20010": [
"CVE-2012-2570"
],
"19927": [],
"19985": [],
"20011": [
"CVE-2012-2602",
"CVE-2012-2577"
],
"20029": [],
"20033": [
"CVE-2012-2962"
],
"20035": [
"CVE-2012-4344",
"CVE-2012-2601",
"CVE-2012-2589"
],
"20037": [],
"20038": [
"CVE-2012-2574"
],
"20044": [
"CVE-2012-2961"
],
"20055": [],
"20062": [
"CVE-2012-3835",
"CVE-2012-3834",
"CVE-2012-2599"
],
"20063": [
"CVE-2012-6658",
"CVE-2012-2956"
],
"20064": [
"CVE-2012-2957"
],
"20083": [],
"20087": [
"CVE-2012-3435"
],
"20111": [],
"20123": [
"CVE-2012-4178"
],
"20124": [],
"20158": [
"CVE-2000-0745"
],
"20166": [],
"20170": [],
"20171": [
"CVE-2008-0474"
],
"20172": [],
"20173": [],
"20197": [],
"20198": [],
"20199": [],
"20208": [
"CVE-2000-0872"
],
"20260": [],
"20268": [],
"20270": [],
"20278": [
"CVE-2000-0919"
],
"20320": [],
"40892": [],
"20342": [],
"20343": [],
"20344": [],
"20345": [],
"20346": [],
"20347": [
"CVE-2012-3873"
],
"20348": [
"CVE-2012-2592"
],
"20349": [
"CVE-2012-2591"
],
"20350": [
"CVE-2012-2590"
],
"20351": [
"CVE-2012-2588"
],
"20352": [
"CVE-2012-2587"
],
"20353": [
"CVE-2012-2586"
],
"20356": [
"CVE-2012-2585"
],
"20357": [
"CVE-2012-2584"
],
"20358": [
"CVE-2012-2583"
],
"20359": [
"CVE-2012-2582"
],
"20360": [
"CVE-2012-2580"
],
"20361": [
"CVE-2012-2579"
],
"20362": [
"CVE-2012-2578"
],
"20363": [
"CVE-2012-2575"
],
"20364": [
"CVE-2012-2573"
],
"20365": [
"CVE-2012-2572"
],
"20366": [
"CVE-2012-2571"
],
"20367": [
"CVE-2012-2569"
],
"20368": [
"CVE-2012-2955",
"CVE-2012-2202"
],
"20390": [],
"20391": [],
"20393": [],
"20398": [],
"20416": [],
"20419": [],
"20421": [],
"20422": [],
"20428": [],
"20431": [],
"21316": [],
"20474": [],
"20476": [],
"20477": [
"CVE-2012-3294"
],
"20478": [
"CVE-2012-2206"
],
"20538": [
"CVE-2001-1044"
],
"20539": [],
"20706": [
"CVE-2012-2977"
],
"20541": [],
"20704": [],
"20544": [],
"20545": [],
"20546": [],
"20549": [
"CVE-2012-4668",
"CVE-2012-3508"
],
"20550": [],
"20573": [],
"20574": [],
"20575": [],
"20576": [],
"20578": [],
"20579": [
"CVE-2012-2573"
],
"20580": [],
"20586": [
"CVE-2000-1228"
],
"20587": [
"CVE-2000-1234"
],
"20588": [
"CVE-2000-1230"
],
"20598": [],
"20627": [],
"20643": [],
"20665": [],
"20666": [],
"20667": [],
"20668": [],
"20669": [],
"20709": [],
"20710": [],
"20712": [],
"20671": [],
"20672": [],
"20673": [],
"20713": [],
"20675": [
"CVE-2006-0469"
],
"20677": [
"CVE-2012-4680"
],
"20707": [
"CVE-2012-2977"
],
"20708": [],
"20703": [],
"20729": [
"CVE-2001-0383"
],
"20761": [],
"20762": [],
"20759": [
"CVE-2012-4385",
"CVE-2012-4384"
],
"20760": [],
"40423": [],
"20785": [],
"20787": [],
"20788": [],
"20789": [],
"20790": [],
"20848": [
"CVE-2001-1334"
],
"20855": [],
"20856": [],
"20857": [],
"20859": [],
"20862": [],
"20863": [],
"20864": [],
"20866": [],
"20871": [],
"20872": [],
"20873": [],
"20874": [],
"20877": [],
"20913": [],
"20918": [],
"20925": [
"CVE-2001-0555"
],
"20942": [],
"20956": [],
"20959": [
"CVE-2012-4751",
"CVE-2012-4600"
],
"20981": [],
"20983": [],
"20987": [
"CVE-2001-0760"
],
"20995": [
"CVE-2001-1408"
],
"20996": [
"CVE-2001-1045"
],
"21005": [
"CVE-2012-4749",
"CVE-2012-4748"
],
"21007": [],
"21022": [
"CVE-2001-1370"
],
"21032": [],
"21033": [],
"21038": [],
"21046": [
"CVE-2001-1472"
],
"21833": [],
"21052": [
"CVE-2012-1500"
],
"21053": [],
"21054": [],
"21056": [
"CVE-2012-4240"
],
"21065": [
"CVE-2001-1471"
],
"21079": [],
"21081": [],
"21082": [
"CVE-2011-5028"
],
"21084": [],
"21085": [],
"21119": [
"CVE-2001-1460"
],
"21132": [],
"21133": [],
"21134": [],
"21135": [
"CVE-2012-2275"
],
"21148": [],
"21157": [
"CVE-2001-0900"
],
"21165": [
"CVE-2001-1524"
],
"21166": [
"CVE-2001-1524"
],
"21168": [
"CVE-2001-1525"
],
"21184": [
"CVE-2001-1199"
],
"21187": [
"CVE-2001-1212"
],
"21521": [],
"21206": [
"CVE-2002-1995"
],
"21208": [
"CVE-2002-0117"
],
"21209": [
"CVE-2002-0118"
],
"21220": [],
"21221": [
"CVE-2010-1480",
"CVE-2010-1479"
],
"21222": [],
"21230": [
"CVE-2002-0206"
],
"21233": [
"CVE-2002-2032"
],
"21241": [
"CVE-2002-2106"
],
"21250": [],
"21251": [],
"21257": [
"CVE-2002-2113"
],
"21267": [
"CVE-2012-4773"
],
"21269": [],
"21270": [],
"21271": [],
"21272": [],
"21273": [
"CVE-2012-5864",
"CVE-2012-5863",
"CVE-2012-5862",
"CVE-2012-5861"
],
"21277": [
"CVE-2002-2084"
],
"21278": [
"CVE-2002-2084"
],
"21279": [],
"40416": [],
"21299": [
"CVE-2002-0319"
],
"21300": [
"CVE-2002-0316"
],
"21301": [
"CVE-2002-0330"
],
"21304": [
"CVE-2002-0328"
],
"21308": [
"CVE-2002-0329"
],
"21312": [
"CVE-2002-0413"
],
"21317": [],
"21319": [
"CVE-2012-2996",
"CVE-2012-2995"
],
"22073": [],
"21324": [],
"21327": [],
"21329": [],
"21330": [
"CVE-2012-3859"
],
"21343": [
"CVE-2002-0451"
],
"21349": [
"CVE-2002-0483"
],
"21352": [
"CVE-2002-0492"
],
"21357": [
"CVE-2002-2015"
],
"21358": [
"CVE-2002-0516"
],
"21374": [
"CVE-2002-0554"
],
"21377": [
"CVE-2002-0553"
],
"21380": [
"CVE-2002-2021"
],
"21381": [],
"21382": [],
"21383": [],
"21391": [
"CVE-2002-0588"
],
"21392": [],
"21393": [],
"21394": [],
"21395": [],
"21396": [],
"21397": [
"CVE-2002-0589"
],
"21399": [
"CVE-2002-0590"
],
"21400": [
"CVE-2002-0607"
],
"21401": [
"CVE-2002-0535"
],
"21403": [
"CVE-2002-0535"
],
"21405": [
"CVE-2002-2011"
],
"21406": [
"CVE-2002-0730"
],
"21411": [
"CVE-2002-0731"
],
"21417": [],
"21418": [],
"21421": [
"CVE-2002-1757"
],
"21423": [],
"21424": [],
"21425": [
"CVE-2002-0613"
],
"21426": [
"CVE-2002-0599"
],
"21427": [],
"22216": [
"CVE-2012-5193",
"CVE-2012-5192"
],
"21433": [
"CVE-2002-0732"
],
"21434": [
"CVE-2002-1720"
],
"21435": [
"CVE-2002-1727"
],
"21436": [
"CVE-2002-0734"
],
"21447": [],
"21448": [],
"21449": [
"CVE-2002-2343"
],
"21454": [],
"21455": [
"CVE-2002-0772"
],
"21457": [
"CVE-2002-0773"
],
"21459": [
"CVE-2002-0764"
],
"21460": [],
"21461": [],
"21463": [],
"21464": [
"CVE-2002-0775"
],
"21473": [
"CVE-2002-0771"
],
"21474": [
"CVE-2002-1829",
"CVE-2002-0330"
],
"21478": [
"CVE-2002-1830"
],
"21479": [],
"21480": [
"CVE-2002-0388"
],
"21486": [
"CVE-2002-0902"
],
"21487": [
"CVE-2002-1837"
],
"21493": [
"CVE-2002-0879"
],
"21494": [
"CVE-2002-0919",
"CVE-2002-0918"
],
"21495": [
"CVE-2002-0919"
],
"21509": [
"CVE-2002-2055"
],
"21514": [
"CVE-2002-0959"
],
"21517": [
"CVE-2002-0961"
],
"21519": [
"CVE-2002-0931"
],
"21524": [],
"21525": [
"CVE-2002-0962"
],
"21526": [
"CVE-2002-0931"
],
"21527": [
"CVE-2002-0932"
],
"21528": [
"CVE-2002-0962"
],
"21529": [
"CVE-2002-1878"
],
"21532": [
"CVE-2002-0922"
],
"21533": [
"CVE-2002-0923"
],
"21535": [
"CVE-2002-0948"
],
"21543": [
"CVE-2002-0951"
],
"21545": [
"CVE-2012-4051"
],
"21546": [
"CVE-2012-2998"
],
"21552": [
"CVE-2002-1702"
],
"21553": [
"CVE-2002-1703"
],
"21557": [
"CVE-2002-1704"
],
"21558": [
"CVE-2002-1966"
],
"21562": [
"CVE-2002-0926"
],
"21563": [
"CVE-2002-2019",
"CVE-2002-1991"
],
"21564": [
"CVE-2002-0953"
],
"21567": [
"CVE-2002-1993"
],
"21570": [
"CVE-2002-1708"
],
"21573": [
"CVE-2002-0955"
],
"21587": [
"CVE-2002-1006"
],
"21588": [
"CVE-2002-1007"
],
"21590": [
"CVE-2002-0995"
],
"21609": [
"CVE-2002-1036"
],
"21610": [
"CVE-2002-1034",
"CVE-2002-1033"
],
"21617": [
"CVE-2002-2165"
],
"21621": [
"CVE-2002-1027"
],
"21622": [
"CVE-2002-1070"
],
"21628": [],
"21640": [
"CVE-2002-1058"
],
"21646": [],
"21658": [
"CVE-2002-1427"
],
"21659": [
"CVE-2002-1410"
],
"21660": [
"CVE-2002-2176"
],
"21661": [
"CVE-2002-1428"
],
"21665": [],
"21668": [
"CVE-2002-1429"
],
"40361": [
"CVE-2015-8309"
],
"40364": [],
"40366": [],
"40367": [],
"21676": [
"CVE-2002-1412"
],
"21679": [
"CVE-2002-1868"
],
"21702": [
"CVE-2002-1432"
],
"21708": [
"CVE-2002-1457"
],
"21715": [],
"21716": [],
"21723": [
"CVE-2002-1423"
],
"21724": [
"CVE-2002-1422"
],
"21727": [
"CVE-2002-1113"
],
"21728": [
"CVE-2002-1434"
],
"21729": [
"CVE-2003-0154"
],
"21730": [
"CVE-2003-0153"
],
"21834": [
"CVE-2012-5159"
],
"21740": [],
"21742": [
"CVE-2012-4902",
"CVE-2012-4901"
],
"21743": [],
"21744": [
"CVE-2012-6534"
],
"21745": [
"CVE-2002-1435"
],
"21755": [
"CVE-2002-2424"
],
"21766": [
"CVE-2002-1499"
],
"21768": [
"CVE-2002-2420"
],
"21769": [
"CVE-2002-1494"
],
"21776": [],
"21778": [
"CVE-2002-1482"
],
"21779": [
"CVE-2002-1505"
],
"21780": [
"CVE-2002-1480"
],
"21783": [
"CVE-2002-1481"
],
"21786": [],
"21802": [
"CVE-2002-1493"
],
"21809": [],
"21811": [
"CVE-2002-1131"
],
"21817": [
"CVE-2002-1495"
],
"21886": [
"CVE-2002-1884"
],
"21822": [],
"21825": [
"CVE-2002-1135"
],
"21829": [
"CVE-2002-1802"
],
"21835": [],
"21836": [],
"21855": [],
"21859": [
"CVE-2002-1803"
],
"21860": [
"CVE-2002-1804"
],
"21861": [
"CVE-2002-1805"
],
"21862": [],
"21863": [
"CVE-2002-1806"
],
"21864": [
"CVE-2002-2178"
],
"21866": [],
"21891": [],
"21873": [],
"21874": [
"CVE-2002-1660"
],
"21875": [
"CVE-2002-1533"
],
"21877": [
"CVE-2002-1527"
],
"21878": [
"CVE-2002-1526"
],
"21879": [
"CVE-2002-1525"
],
"21890": [],
"21893": [
"CVE-2002-1886"
],
"21894": [
"CVE-2002-1798"
],
"21895": [
"CVE-2002-1178"
],
"21896": [
"CVE-2002-1798"
],
"21899": [
"CVE-2002-2178"
],
"21900": [
"CVE-2002-2319"
],
"21901": [
"CVE-2002-2143"
],
"21903": [],
"21905": [
"CVE-2002-1887"
],
"21906": [
"CVE-2002-2321"
],
"21912": [
"CVE-2002-2335"
],
"21914": [
"CVE-2002-2339"
],
"21918": [],
"21920": [
"CVE-2003-0002"
],
"21921": [],
"21924": [
"CVE-2002-1529"
],
"21925": [
"CVE-2002-1530"
],
"21926": [
"CVE-2002-2348"
],
"21930": [],
"21929": [],
"21931": [
"CVE-2002-2349"
],
"21933": [
"CVE-2002-1799"
],
"21946": [
"CVE-2002-1922"
],
"21950": [
"CVE-2002-1845"
],
"21956": [
"CVE-2002-1958"
],
"21957": [
"CVE-2002-1929"
],
"21960": [
"CVE-2002-1560"
],
"21961": [
"CVE-2002-2362"
],
"21962": [
"CVE-2002-2193"
],
"21966": [
"CVE-2002-1581"
],
"21967": [
"CVE-2002-2200"
],
"21968": [
"CVE-2002-2200"
],
"21969": [
"CVE-2002-2200"
],
"21970": [
"CVE-2002-2200"
],
"21976": [
"CVE-2002-1211"
],
"21977": [
"CVE-2002-1242"
],
"21979": [
"CVE-2002-1559"
],
"21989": [],
"21990": [],
"21992": [],
"21995": [
"CVE-2002-2190"
],
"22003": [],
"22004": [],
"22005": [],
"22009": [
"CVE-2002-1818"
],
"22015": [
"CVE-2002-2399"
],
"22017": [
"CVE-2002-2287"
],
"22030": [
"CVE-2004-1824"
],
"22037": [],
"22038": [],
"22039": [],
"22040": [],
"22041": [
"CVE-2012-3186",
"CVE-2012-3185",
"CVE-2012-3184",
"CVE-2012-3183"
],
"22042": [
"CVE-2002-2235"
],
"22043": [],
"22044": [],
"22045": [],
"22047": [],
"22048": [
"CVE-2002-2249"
],
"22050": [
"CVE-2002-1334"
],
"22051": [
"CVE-2002-1334"
],
"22052": [
"CVE-2002-2296"
],
"22065": [
"CVE-2002-2255"
],
"22070": [
"CVE-2012-4751",
"CVE-2012-4600"
],
"22071": [],
"22075": [],
"22076": [],
"22077": [],
"22080": [],
"22083": [
"CVE-2002-2246"
],
"22086": [
"CVE-2002-2247"
],
"22087": [
"CVE-2002-2288"
],
"22088": [
"CVE-2002-2304"
],
"22089": [],
"22090": [],
"22092": [],
"22097": [],
"22098": [],
"22099": [],
"22102": [],
"22103": [],
"22104": [],
"22107": [],
"22108": [],
"22109": [
"CVE-2002-2129"
],
"22111": [
"CVE-2002-2219"
],
"22114": [
"CVE-2002-2134"
],
"22115": [
"CVE-2003-1251"
],
"22116": [
"CVE-2003-1251"
],
"22125": [
"CVE-2003-1278"
],
"22126": [],
"22127": [],
"22133": [],
"22134": [
"CVE-2003-1252"
],
"22137": [],
"22146": [],
"22148": [
"CVE-2003-1533"
],
"22149": [],
"22150": [],
"22151": [
"CVE-2012-1503"
],
"22152": [],
"22153": [],
"22156": [
"CVE-2012-5388",
"CVE-2012-5387"
],
"22157": [],
"22158": [],
"22159": [
"CVE-2012-5452",
"CVE-2012-4773",
"CVE-2012-4772",
"CVE-2012-4771"
],
"22160": [
"CVE-2012-5453",
"CVE-2012-5167"
],
"22163": [
"CVE-2003-1347"
],
"22164": [
"CVE-2003-1347"
],
"22165": [
"CVE-2003-1347"
],
"22166": [
"CVE-2003-1347"
],
"22167": [],
"22168": [],
"22169": [],
"22170": [],
"22175": [],
"22176": [],
"22177": [],
"22180": [],
"22181": [],
"22182": [
"CVE-2003-1530"
],
"22186": [],
"22279": [
"CVE-2003-1412"
],
"22192": [],
"22195": [],
"22198": [
"CVE-2003-0038"
],
"22199": [
"CVE-2003-0038"
],
"22202": [
"CVE-2003-1348"
],
"22204": [
"CVE-2000-0912"
],
"22206": [
"CVE-2003-1436"
],
"22208": [],
"22209": [
"CVE-2003-1532"
],
"22211": [
"CVE-2003-1400"
],
"40414": [],
"22222": [
"CVE-2003-1409"
],
"22227": [
"CVE-2002-0612"
],
"22228": [
"CVE-2002-0611"
],
"22241": [
"CVE-2003-1410"
],
"22242": [
"CVE-2003-1411"
],
"22252": [
"CVE-2003-1401"
],
"22253": [
"CVE-2003-1405"
],
"22254": [
"CVE-2003-1405"
],
"22256": [
"CVE-2003-1406"
],
"22257": [
"CVE-2003-1406"
],
"22260": [
"CVE-2003-1425"
],
"22261": [
"CVE-2003-1425"
],
"22262": [
"CVE-2003-1425"
],
"22263": [
"CVE-2003-1425"
],
"22266": [
"CVE-2003-1435"
],
"22267": [
"CVE-2003-1244"
],
"22268": [
"CVE-2003-1372"
],
"22277": [
"CVE-2003-1371"
],
"22281": [
"CVE-2003-1245"
],
"22282": [
"CVE-2003-1239"
],
"22283": [
"CVE-2003-1240"
],
"22284": [
"CVE-2003-1240"
],
"22285": [
"CVE-2003-1240"
],
"22293": [
"CVE-2003-1256"
],
"22295": [
"CVE-2003-1385"
],
"22297": [],
"22298": [],
"22300": [],
"22315": [],
"22316": [],
"22317": [],
"40413": [],
"22318": [],
"22336": [],
"22337": [],
"22339": [],
"22343": [],
"22347": [],
"22348": [],
"22349": [],
"22357": [],
"22364": [],
"22372": [],
"22373": [],
"22374": [],
"22377": [],
"22378": [
"CVE-2003-1548"
],
"22380": [],
"22382": [
"CVE-2003-1203"
],
"22383": [],
"22385": [],
"22386": [],
"22387": [
"CVE-2003-1536"
],
"22389": [
"CVE-2003-1550"
],
"22391": [],
"22392": [],
"22393": [],
"22396": [],
"22398": [
"CVE-2012-5692"
],
"22399": [],
"22403": [],
"22405": [],
"22408": [
"CVE-2003-1541"
],
"22411": [],
"22412": [
"CVE-2003-1181"
],
"40412": [
"CVE-2016-7400"
],
"22413": [],
"22414": [],
"22421": [],
"22422": [
"CVE-2003-1545"
],
"22423": [],
"22424": [],
"22427": [
"CVE-2012-6653"
],
"22521": [],
"22429": [],
"22430": [],
"22431": [],
"22436": [],
"22437": [],
"22438": [],
"22439": [],
"43148": [],
"43149": [
"CVE-2017-16841"
],
"22443": [],
"22444": [
"CVE-2003-1535"
],
"22445": [
"CVE-2003-1555"
],
"22451": [],
"22457": [],
"22459": [
"CVE-2003-0536"
],
"22461": [],
"22463": [],
"22473": [],
"22474": [],
"22477": [],
"22478": [],
"22481": [],
"22482": [],
"22484": [],
"22486": [],
"22487": [],
"22490": [
"CVE-2012-5686",
"CVE-2012-5685",
"CVE-2012-5684",
"CVE-2012-5683"
],
"22491": [],
"22501": [],
"22492": [],
"22493": [],
"22498": [],
"22499": [
"CVE-2003-0770"
],
"22500": [
"CVE-2003-0770"
],
"22507": [],
"22513": [],
"22517": [],
"22519": [],
"22520": [],
"22571": [
"CVE-2003-0243"
],
"22524": [],
"22529": [
"CVE-2003-0215"
],
"22534": [
"CVE-2003-1488"
],
"22539": [
"CVE-2003-1453"
],
"22543": [],
"22544": [
"CVE-2003-1469"
],
"22545": [
"CVE-2003-1456"
],
"22547": [
"CVE-2012-5692"
],
"22548": [],
"22549": [],
"22554": [
"CVE-2003-0118"
],
"22555": [
"CVE-2003-0118"
],
"22557": [],
"22558": [],
"22559": [],
"22572": [
"CVE-2003-0243"
],
"22577": [
"CVE-2003-1459"
],
"22578": [
"CVE-2003-1459"
],
"22579": [
"CVE-2003-0283"
],
"22583": [],
"22588": [
"CVE-2003-0278"
],
"22589": [
"CVE-2004-0269"
],
"22590": [],
"22592": [
"CVE-2003-0277"
],
"22595": [],
"22597": [
"CVE-2003-1210"
],
"22598": [
"CVE-2003-1468"
],
"22599": [
"CVE-2003-0295"
],
"22600": [],
"22603": [],
"22605": [
"CVE-2003-0303"
],
"22606": [
"CVE-2003-0304"
],
"22607": [
"CVE-2003-0310"
],
"22612": [
"CVE-2003-0320"
],
"22618": [],
"22625": [],
"22632": [
"CVE-2003-0375"
],
"22639": [
"CVE-2003-0377"
],
"22641": [
"CVE-2003-0394"
],
"22642": [
"CVE-2003-0395"
],
"22651": [],
"22654": [],
"22656": [],
"22663": [],
"22669": [
"CVE-2003-0416"
],
"22671": [],
"22672": [],
"22673": [],
"22675": [],
"22684": [],
"22687": [],
"22688": [],
"22689": [],
"22692": [],
"22693": [],
"22697": [],
"22698": [
"CVE-2004-0304"
],
"22702": [],
"22704": [],
"22705": [],
"22708": [
"CVE-2006-0755"
],
"22709": [],
"22713": [
"CVE-2012-6585",
"CVE-2012-6584"
],
"22710": [],
"22711": [
"CVE-2012-6589",
"CVE-2012-6588"
],
"22712": [
"CVE-2012-6587",
"CVE-2012-6586"
],
"22715": [],
"22716": [],
"22717": [],
"22724": [],
"22725": [
"CVE-2002-1954"
],
"22730": [],
"22731": [],
"22735": [],
"22736": [],
"22741": [
"CVE-2012-5700",
"CVE-2012-5699",
"CVE-2012-5698"
],
"22742": [],
"22743": [],
"22744": [],
"22746": [],
"22747": [
"CVE-2003-1213"
],
"22750": [],
"22752": [],
"22760": [],
"22761": [],
"22762": [],
"22829": [],
"22767": [],
"22770": [],
"22766": [],
"22772": [],
"22776": [
"CVE-2003-1086"
],
"22777": [
"CVE-2003-0495"
],
"22778": [
"CVE-2003-0492"
],
"22791": [],
"22792": [],
"22793": [],
"22798": [],
"22799": [
"CVE-2003-0488"
],
"22804": [
"CVE-2003-0488"
],
"22805": [],
"22808": [],
"22809": [],
"22810": [],
"22812": [],
"22818": [
"CVE-2003-0481"
],
"22819": [
"CVE-2003-0482"
],
"22820": [
"CVE-2003-0375"
],
"22821": [
"CVE-2003-0483"
],
"22826": [],
"22828": [],
"22841": [],
"22842": [],
"22843": [],
"22845": [],
"22849": [],
"22852": [],
"22853": [],
"22857": [],
"22864": [],
"22865": [],
"22866": [
"CVE-2003-0523"
],
"22868": [
"CVE-2003-1304"
],
"22874": [
"CVE-2003-0521"
],
"22877": [],
"22879": [],
"23035": [],
"23036": [],
"22881": [],
"22885": [],
"22886": [],
"22887": [],
"22888": [
"CVE-2003-0560"
],
"22889": [
"CVE-2003-0560"
],
"22895": [],
"22896": [],
"22901": [],
"22906": [],
"22907": [],
"22910": [
"CVE-2003-0590"
],
"22942": [],
"22948": [],
"22953": [],
"22955": [],
"22956": [],
"22958": [],
"22963": [],
"22940": [],
"22941": [],
"22921": [],
"22922": [],
"22925": [
"CVE-2003-0586"
],
"22927": [],
"22929": [],
"22961": [
"CVE-2003-0614"
],
"23008": [],
"23009": [],
"23010": [],
"23011": [
"CVE-2003-1088"
],
"23012": [],
"23013": [
"CVE-2003-0735"
],
"23014": [
"CVE-2003-0736"
],
"23015": [
"CVE-2003-0736"
],
"23016": [
"CVE-2003-0736"
],
"22936": [],
"22937": [],
"22960": [],
"22972": [],
"22977": [],
"22986": [],
"22990": [
"CVE-2003-1031"
],
"22992": [],
"22995": [],
"22997": [
"CVE-2004-1957"
],
"22998": [],
"23000": [],
"23001": [],
"23004": [],
"23005": [],
"23017": [
"CVE-2003-0736"
],
"23018": [
"CVE-2003-1089"
],
"23020": [],
"23021": [],
"23025": [],
"23026": [],
"23027": [],
"23028": [],
"23029": [],
"23032": [],
"23033": [],
"23031": [],
"23039": [],
"23055": [],
"23057": [],
"23058": [],
"23059": [],
"23060": [],
"23061": [],
"23064": [
"CVE-2003-0752"
],
"23065": [],
"23067": [
"CVE-2003-1317"
],
"23072": [],
"23084": [],
"23085": [],
"23099": [],
"23103": [],
"23105": [],
"23106": [],
"23109": [
"CVE-2012-0308"
],
"23110": [
"CVE-2012-4347"
],
"23111": [],
"23120": [
"CVE-2003-0769"
],
"23125": [],
"23127": [
"CVE-2003-0763"
],
"23128": [],
"23129": [],
"23132": [
"CVE-2013-1627"
],
"23140": [],
"23153": [],
"23158": [],
"23159": [],
"23160": [],
"23163": [],
"23164": [],
"40403": [],
"23175": [],
"23180": [],
"23184": [],
"23192": [],
"23193": [],
"23194": [],
"23195": [],
"23202": [],
"23205": [],
"23206": [],
"23207": [],
"23208": [],
"23213": [],
"23214": [],
"23217": [],
"23218": [
"CVE-2003-1313"
],
"23219": [],
"23220": [],
"23232": [],
"23233": [],
"23237": [],
"23238": [
"CVE-2003-1227"
],
"23244": [
"CVE-2003-1498"
],
"23249": [],
"23250": [],
"23252": [
"CVE-2012-5849"
],
"23253": [
"CVE-2012-5865"
],
"23256": [],
"23259": [
"CVE-2003-1504"
],
"23260": [],
"23261": [
"CVE-2003-1499"
],
"23262": [
"CVE-2003-1513"
],
"23264": [
"CVE-1999-0819"
],
"23266": [
"CVE-2003-1517"
],
"23268": [
"CVE-2003-1519"
],
"23269": [
"CVE-2003-1520"
],
"23275": [
"CVE-2003-1506"
],
"23284": [],
"23286": [],
"23287": [],
"23289": [],
"23313": [
"CVE-2003-1197"
],
"23294": [
"CVE-2003-1136"
],
"23302": [
"CVE-2003-1148"
],
"23315": [
"CVE-2003-0624"
],
"23319": [
"CVE-2003-1162"
],
"23322": [],
"23324": [
"CVE-2012-4991"
],
"23326": [
"CVE-2003-1166"
],
"23330": [
"CVE-2003-1175"
],
"23331": [
"CVE-2003-1176"
],
"23332": [
"CVE-2003-1182"
],
"23333": [
"CVE-2003-1187"
],
"23335": [
"CVE-2003-1196"
],
"23336": [
"CVE-2003-1145"
],
"23338": [
"CVE-2003-1146"
],
"23353": [],
"23354": [],
"23355": [],
"23356": [
"CVE-2012-5469"
],
"23384": [],
"23382": [],
"23386": [],
"23359": [],
"23362": [
"CVE-2012-5967"
],
"23363": [],
"23367": [],
"23370": [],
"23372": [],
"23381": [],
"23395": [],
"23402": [],
"23403": [],
"23406": [],
"23407": [],
"23408": [],
"23409": [],
"23410": [],
"23415": [],
"23416": [],
"23418": [],
"23420": [],
"23421": [],
"23425": [],
"23428": [],
"23429": [],
"23430": [],
"23432": [],
"23434": [],
"23440": [],
"23443": [],
"23445": [
"CVE-2003-1219"
],
"23447": [],
"23448": [
"CVE-2013-1744"
],
"23453": [],
"23454": [],
"23455": [],
"23456": [],
"23457": [],
"23458": [],
"23459": [],
"23462": [],
"23463": [],
"23466": [],
"23467": [],
"23629": [
"CVE-2004-2347"
],
"23631": [],
"23473": [],
"23474": [],
"23475": [
"CVE-2004-2130"
],
"23476": [
"CVE-2003-1131"
],
"23477": [],
"23478": [],
"23483": [],
"23484": [],
"23485": [],
"23486": [],
"23487": [],
"23488": [],
"23494": [],
"23630": [
"CVE-2004-0237"
],
"23498": [],
"23499": [],
"23628": [
"CVE-2007-1156"
],
"23507": [
"CVE-2004-0073"
],
"23513": [
"CVE-2004-1782"
],
"23515": [
"CVE-2004-1786"
],
"23516": [
"CVE-2004-1788"
],
"23517": [
"CVE-2004-1796"
],
"23518": [
"CVE-2004-1796"
],
"23519": [
"CVE-2004-1797"
],
"23520": [
"CVE-2004-0030"
],
"23691": [
"CVE-2004-2076"
],
"23525": [
"CVE-2004-0032"
],
"23526": [
"CVE-2004-0033"
],
"23535": [],
"23536": [
"CVE-2004-0071"
],
"23537": [
"CVE-2004-0070"
],
"23546": [],
"23547": [
"CVE-2004-2746"
],
"23548": [],
"23549": [],
"23550": [],
"23551": [],
"23553": [],
"23554": [
"CVE-2004-2754"
],
"23558": [],
"23561": [],
"23571": [],
"23572": [],
"23573": [
"CVE-2012-5244",
"CVE-2012-5243",
"CVE-2012-5242"
],
"23575": [
"CVE-2012-5874"
],
"23599": [
"CVE-2004-2124"
],
"23606": [
"CVE-2004-2756"
],
"23607": [],
"23613": [
"CVE-2004-2127"
],
"23615": [
"CVE-2004-2132"
],
"23616": [],
"23617": [
"CVE-2004-0128"
],
"23618": [
"CVE-2004-2750"
],
"23619": [
"CVE-2004-0246"
],
"23620": [
"CVE-2004-0246"
],
"23621": [
"CVE-2004-0246"
],
"23623": [],
"23624": [],
"23625": [],
"23687": [
"CVE-2004-2071"
],
"23688": [],
"23635": [
"CVE-2004-2170"
],
"23636": [
"CVE-2004-0241"
],
"23637": [
"CVE-2004-0241"
],
"23639": [
"CVE-2004-0242"
],
"23640": [
"CVE-2004-0129"
],
"23644": [
"CVE-2004-0249"
],
"23645": [
"CVE-2004-2175"
],
"23646": [
"CVE-2004-2175"
],
"23647": [
"CVE-2004-0251"
],
"23653": [
"CVE-2004-0254"
],
"23657": [
"CVE-2004-2072"
],
"23659": [
"CVE-2004-0261"
],
"23663": [],
"23669": [
"CVE-2004-0265"
],
"23670": [
"CVE-2004-0266"
],
"23673": [],
"23676": [
"CVE-2004-0271"
],
"23677": [
"CVE-2004-0271"
],
"23680": [
"CVE-2004-0269"
],
"23683": [
"CVE-2004-0132"
],
"23684": [
"CVE-2004-0132"
],
"23685": [
"CVE-2004-0275"
],
"23696": [],
"23697": [
"CVE-2004-0285"
],
"23698": [
"CVE-2004-0285"
],
"23699": [
"CVE-2004-0285"
],
"23702": [
"CVE-2004-2172"
],
"23703": [
"CVE-2005-0994"
],
"23704": [
"CVE-2005-0994"
],
"23705": [
"CVE-2004-0293"
],
"23706": [
"CVE-2004-0293"
],
"23710": [
"CVE-2004-0291"
],
"23711": [
"CVE-2004-0300"
],
"23712": [
"CVE-2004-0301"
],
"23718": [
"CVE-2004-0300"
],
"23719": [
"CVE-2004-0300"
],
"23720": [
"CVE-2004-0300"
],
"23722": [
"CVE-2004-0302"
],
"23723": [
"CVE-2004-0302"
],
"23724": [
"CVE-2004-0302"
],
"23725": [
"CVE-2004-0303"
],
"23726": [
"CVE-2004-0303"
],
"23727": [
"CVE-2004-0303"
],
"23729": [
"CVE-2004-0305"
],
"23742": [
"CVE-2004-0327"
],
"23744": [
"CVE-2004-0319"
],
"23745": [
"CVE-2004-0322"
],
"23746": [
"CVE-2004-0322"
],
"23747": [
"CVE-2004-0322"
],
"23748": [
"CVE-2004-0323"
],
"23749": [],
"23753": [
"CVE-2004-2374"
],
"23767": [],
"23770": [],
"23773": [],
"23774": [
"CVE-2004-0344"
],
"23775": [
"CVE-2004-0343"
],
"23781": [],
"23782": [],
"24047": [
"CVE-2004-1962"
],
"24048": [
"CVE-2004-1960"
],
"24046": [],
"23791": [
"CVE-2004-0348"
],
"23792": [
"CVE-2004-0358"
],
"23795": [],
"23797": [],
"23798": [],
"40402": [],
"23806": [
"CVE-2004-2308"
],
"23807": [
"CVE-2004-1770"
],
"23809": [
"CVE-2004-2385"
],
"23810": [
"CVE-2004-2334"
],
"23812": [
"CVE-2004-1827"
],
"23813": [
"CVE-2004-1813"
],
"23814": [
"CVE-2004-1817"
],
"23815": [
"CVE-2004-1820"
],
"23816": [
"CVE-2004-1821"
],
"23817": [
"CVE-2004-1818"
],
"23818": [
"CVE-2004-1822"
],
"23819": [
"CVE-2004-1822"
],
"23820": [
"CVE-2004-1822"
],
"23821": [
"CVE-2004-2350"
],
"23822": [
"CVE-2004-1823"
],
"23823": [
"CVE-2004-1823"
],
"23824": [
"CVE-2004-1825"
],
"23825": [],
"23828": [
"CVE-2012-6433"
],
"23829": [
"CVE-2012-6434"
],
"23831": [],
"23834": [
"CVE-2004-1826"
],
"23835": [
"CVE-2004-1842"
],
"23843": [
"CVE-2004-1828"
],
"23844": [
"CVE-2004-1830"
],
"23845": [
"CVE-2004-1829"
],
"23851": [
"CVE-2004-1843"
],
"23852": [
"CVE-2004-1843"
],
"23853": [
"CVE-2004-1844"
],
"40401": [],
"23854": [
"CVE-2004-1844"
],
"23857": [
"CVE-2004-1845"
],
"23858": [
"CVE-2004-1845"
],
"23859": [
"CVE-2004-1845"
],
"23860": [
"CVE-2004-1846"
],
"23861": [
"CVE-2004-1846"
],
"23862": [
"CVE-2004-1846"
],
"23863": [
"CVE-2004-1847"
],
"23865": [],
"23866": [],
"23867": [
"CVE-2004-1835"
],
"23868": [
"CVE-2004-1836"
],
"23869": [],
"23870": [],
"23872": [],
"23875": [
"CVE-2004-1859"
],
"23885": [
"CVE-2004-1870"
],
"23886": [],
"23888": [],
"23890": [
"CVE-2004-1867"
],
"23891": [
"CVE-2004-1873"
],
"23894": [],
"23895": [
"CVE-2004-0374"
],
"23897": [
"CVE-2004-1878"
],
"23898": [
"CVE-2004-1881"
],
"23899": [
"CVE-2004-1882"
],
"23901": [],
"23907": [
"CVE-2004-1888"
],
"23908": [],
"23913": [],
"23914": [],
"23924": [
"CVE-2012-6493"
],
"23928": [
"CVE-2004-1912"
],
"23929": [
"CVE-2004-1912"
],
"23930": [
"CVE-2004-1912"
],
"23931": [
"CVE-2004-1912"
],
"23932": [
"CVE-2004-1913"
],
"23933": [
"CVE-2004-1914"
],
"23934": [
"CVE-2004-1911"
],
"23935": [
"CVE-2004-1911"
],
"23937": [
"CVE-2004-2447"
],
"23938": [
"CVE-2004-2447"
],
"23939": [
"CVE-2004-2447"
],
"23940": [
"CVE-2004-2447"
],
"23941": [
"CVE-2004-2447"
],
"23942": [
"CVE-2004-2447"
],
"23947": [
"CVE-2004-1924"
],
"23948": [
"CVE-2004-1928"
],
"23949": [
"CVE-2004-1927"
],
"23950": [
"CVE-2004-1926"
],
"23951": [
"CVE-2004-1926"
],
"23952": [
"CVE-2004-1923"
],
"23953": [
"CVE-2004-1924"
],
"23954": [
"CVE-2004-1924"
],
"23955": [
"CVE-2004-1924"
],
"23956": [
"CVE-2004-1924"
],
"23957": [
"CVE-2004-1924"
],
"23958": [
"CVE-2004-1924"
],
"23959": [
"CVE-2004-1924"
],
"23960": [
"CVE-2004-1924"
],
"23961": [
"CVE-2004-1924"
],
"23962": [
"CVE-2004-1924"
],
"23963": [
"CVE-2004-1925"
],
"23964": [
"CVE-2004-1925"
],
"23965": [
"CVE-2004-1925"
],
"23966": [
"CVE-2004-1925"
],
"23967": [],
"23968": [
"CVE-2013-2299"
],
"23970": [
"CVE-2012-4915"
],
"23971": [
"CVE-2004-1925"
],
"23972": [
"CVE-2004-1925"
],
"23973": [
"CVE-2004-1925"
],
"23974": [
"CVE-2004-1925"
],
"23975": [
"CVE-2004-1925"
],
"23976": [
"CVE-2004-1925"
],
"23977": [
"CVE-2004-1925"
],
"23978": [
"CVE-2004-1925"
],
"33401": [
"CVE-2009-4381"
],
"23982": [
"CVE-2004-1925"
],
"23983": [
"CVE-2004-1925"
],
"23984": [
"CVE-2004-1925"
],
"23986": [],
"23988": [
"CVE-2004-1937"
],
"23990": [
"CVE-2004-1930"
],
"23991": [],
"23998": [
"CVE-2004-1929"
],
"23993": [],
"23994": [],
"23995": [],
"23997": [],
"24001": [
"CVE-2004-1939"
],
"24003": [],
"24004": [],
"24005": [],
"24006": [],
"24007": [],
"24008": [
"CVE-2004-1935"
],
"24009": [
"CVE-2004-1934"
],
"24016": [
"CVE-2004-1938"
],
"24026": [
"CVE-2004-1943"
],
"24034": [
"CVE-2004-1955"
],
"24035": [
"CVE-2004-1953"
],
"24036": [
"CVE-2004-1954"
],
"24037": [
"CVE-2004-1957"
],
"24039": [],
"24044": [],
"24049": [],
"24050": [
"CVE-2004-1952"
],
"24052": [
"CVE-2004-1965"
],
"24053": [
"CVE-2004-1965"
],
"24054": [
"CVE-2004-1965"
],
"24055": [
"CVE-2004-1965"
],
"24056": [
"CVE-2004-1966"
],
"24057": [
"CVE-2004-1966"
],
"24058": [
"CVE-2004-1966"
],
"24059": [
"CVE-2004-1966"
],
"24060": [
"CVE-2004-1972"
],
"24061": [
"CVE-2004-1968"
],
"24068": [
"CVE-2004-0519"
],
"24071": [
"CVE-2004-1978"
],
"24072": [
"CVE-2004-1985"
],
"24073": [
"CVE-2004-1986"
],
"24074": [
"CVE-2004-1988"
],
"24075": [
"CVE-2004-1989"
],
"24081": [
"CVE-2004-1995"
],
"24082": [
"CVE-2004-1996"
],
"24083": [
"CVE-2004-2363"
],
"24086": [
"CVE-2013-5123",
"CVE-2013-4266"
],
"24087": [],
"24088": [
"CVE-2004-2364"
],
"24089": [
"CVE-2004-2364"
],
"24090": [
"CVE-2004-2364"
],
"24091": [
"CVE-2004-2364"
],
"24092": [
"CVE-2004-2364"
],
"24094": [
"CVE-2004-2254"
],
"24099": [
"CVE-2004-2007"
],
"24100": [
"CVE-2004-2008"
],
"24104": [],
"24108": [
"CVE-2009-4571",
"CVE-2008-0681"
],
"43146": [
"CVE-2017-7851"
],
"24122": [
"CVE-2004-2017"
],
"24124": [
"CVE-2004-2288"
],
"24126": [
"CVE-2004-2021"
],
"24127": [
"CVE-2004-2018"
],
"24131": [
"CVE-2004-2287"
],
"24134": [],
"24138": [
"CVE-2004-2028"
],
"24139": [
"CVE-2004-2030"
],
"24151": [
"CVE-2004-2036"
],
"24152": [
"CVE-2004-2038"
],
"24153": [
"CVE-2004-2040"
],
"24154": [
"CVE-2004-2040"
],
"24186": [],
"24188": [],
"24157": [],
"24158": [
"CVE-2013-0397"
],
"24164": [
"CVE-2004-2636"
],
"24166": [
"CVE-2004-2044"
],
"24167": [
"CVE-2004-0639"
],
"24168": [],
"24169": [
"CVE-2004-2355"
],
"24172": [],
"24175": [
"CVE-2004-2507"
],
"24176": [
"CVE-2004-2547"
],
"24177": [
"CVE-2004-2548"
],
"24180": [],
"24183": [],
"24184": [
"CVE-2004-2699"
],
"24185": [
"CVE-2004-2701"
],
"24190": [
"CVE-2005-1023"
],
"24191": [
"CVE-2004-2293"
],
"24192": [
"CVE-2004-2295"
],
"24193": [
"CVE-2004-2297"
],
"24194": [
"CVE-2004-2294"
],
"24197": [
"CVE-2004-2508"
],
"24198": [
"CVE-2004-2411"
],
"24199": [
"CVE-2004-2413"
],
"24201": [],
"24202": [
"CVE-2013-2679"
],
"24203": [
"CVE-2013-1360"
],
"24204": [
"CVE-2013-1359"
],
"24212": [],
"24214": [],
"24215": [
"CVE-2004-2716"
],
"24216": [
"CVE-2004-2715"
],
"24217": [
"CVE-2004-2717"
],
"24225": [
"CVE-2004-0613"
],
"24227": [
"CVE-2004-0591"
],
"24228": [],
"24229": [],
"24231": [
"CVE-2004-0617"
],
"24232": [],
"24234": [
"CVE-2004-0620"
],
"24235": [
"CVE-2004-0621"
],
"24236": [
"CVE-2004-0675"
],
"24237": [
"CVE-2004-0665"
],
"24238": [
"CVE-2004-0660"
],
"24239": [
"CVE-2004-0660"
],
"24240": [
"CVE-2004-0660"
],
"24241": [
"CVE-2004-0664"
],
"24244": [
"CVE-2004-0672"
],
"24245": [
"CVE-2004-0672"
],
"24251": [
"CVE-2004-0671"
],
"24252": [
"CVE-2004-0676"
],
"24254": [],
"24255": [
"CVE-2004-2445"
],
"24256": [
"CVE-2004-2443"
],
"24257": [
"CVE-2004-2444"
],
"24260": [
"CVE-2004-0682"
],
"24261": [
"CVE-2004-0681"
],
"24269": [],
"24270": [],
"24357": [],
"24274": [
"CVE-2004-1315"
],
"24279": [
"CVE-2004-0725"
],
"24284": [
"CVE-2004-2518"
],
"24285": [
"CVE-2004-2518"
],
"24286": [
"CVE-2004-2522"
],
"24287": [
"CVE-2004-1441"
],
"24289": [],
"24290": [
"CVE-2004-0660"
],
"24291": [
"CVE-2004-2625"
],
"24292": [],
"24294": [],
"24295": [],
"24356": [],
"24296": [],
"24298": [
"CVE-2004-2561"
],
"24299": [
"CVE-2004-2737"
],
"24300": [
"CVE-2004-2562"
],
"24301": [],
"24302": [
"CVE-2004-2736"
],
"24303": [
"CVE-2004-2551"
],
"24306": [
"CVE-2004-2047"
],
"24307": [],
"24311": [
"CVE-2004-2053"
],
"24313": [
"CVE-2004-2059"
],
"24314": [
"CVE-2004-2059"
],
"24315": [
"CVE-2004-2059"
],
"24316": [
"CVE-2004-2059"
],
"24317": [
"CVE-2004-2060"
],
"24320": [],
"24324": [],
"24329": [
"CVE-2004-2062"
],
"24330": [
"CVE-2004-2063"
],
"24331": [
"CVE-2004-2242"
],
"24332": [],
"24333": [
"CVE-2004-2064"
],
"24334": [
"CVE-2004-2067"
],
"24340": [
"CVE-2004-2514"
],
"24341": [
"CVE-2004-1703"
],
"24347": [],
"24348": [
"CVE-2004-2670"
],
"24349": [],
"24359": [],
"24364": [],
"24365": [
"CVE-2012-6290"
],
"24367": [],
"24368": [],
"24369": [],
"24370": [],
"24371": [],
"24372": [
"CVE-2004-0660"
],
"24373": [],
"24375": [
"CVE-2004-1737"
],
"24377": [
"CVE-2004-1719"
],
"24378": [
"CVE-2004-1719"
],
"24379": [
"CVE-2004-1719"
],
"24380": [
"CVE-2004-1719"
],
"24381": [
"CVE-2004-1720"
],
"24382": [
"CVE-2004-1722"
],
"24383": [
"CVE-2004-1466"
],
"24384": [
"CVE-2004-1724"
],
"24385": [],
"24389": [
"CVE-2004-1735"
],
"24390": [],
"24391": [],
"24392": [
"CVE-2004-1731"
],
"24393": [],
"24397": [],
"24399": [],
"24400": [
"CVE-2004-2425"
],
"24403": [
"CVE-2004-1467"
],
"24401": [],
"24402": [],
"24405": [
"CVE-2004-2702"
],
"24408": [
"CVE-2004-1742"
],
"24410": [
"CVE-2004-1746"
],
"24415": [
"CVE-2004-1640"
],
"24420": [
"CVE-2004-1647"
],
"24422": [
"CVE-2004-1656"
],
"24424": [
"CVE-2004-1657"
],
"24425": [
"CVE-2004-1655"
],
"24432": [
"CVE-2013-1451"
],
"24441": [],
"24508": [],
"24433": [],
"24435": [
"CVE-2013-1471"
],
"24436": [],
"24438": [
"CVE-2013-7387",
"CVE-2013-1412"
],
"24439": [],
"24442": [],
"24443": [],
"24445": [],
"24449": [
"CVE-2013-1120",
"CVE-2013-1114"
],
"24451": [],
"24452": [],
"24453": [],
"24454": [],
"24456": [],
"24457": [],
"24462": [],
"24464": [],
"24465": [
"CVE-2013-1465"
],
"24466": [],
"24510": [],
"24472": [],
"24503": [],
"24475": [
"CVE-2013-2678"
],
"24476": [],
"24477": [],
"24478": [
"CVE-2013-2678"
],
"24480": [],
"24481": [],
"24483": [],
"24484": [],
"24520": [
"CVE-2013-1469"
],
"24509": [],
"24492": [
"CVE-2011-4275",
"CVE-2009-4140"
],
"24496": [],
"24497": [],
"24498": [],
"24499": [],
"24500": [],
"24501": [],
"24504": [
"CVE-2012-6276",
"CVE-2012-5687"
],
"24506": [],
"24507": [],
"24512": [],
"24513": [],
"24514": [],
"24515": [],
"24516": [],
"24517": [],
"24522": [],
"24531": [],
"24530": [],
"24533": [],
"24534": [],
"24535": [],
"24536": [
"CVE-2013-1466"
],
"24537": [],
"24540": [],
"24542": [],
"24543": [],
"24544": [],
"24545": [],
"24546": [],
"24550": [],
"24551": [
"CVE-2013-1453"
],
"24552": [],
"24560": [],
"24561": [
"CVE-2013-1469",
"CVE-2013-1468"
],
"24562": [
"CVE-2013-7375",
"CVE-2013-1807",
"CVE-2013-1806",
"CVE-2013-1805",
"CVE-2013-1804",
"CVE-2013-1803"
],
"24563": [
"CVE-2013-2271"
],
"24564": [],
"24565": [
"CVE-2004-1661"
],
"24566": [
"CVE-2004-1659"
],
"24573": [],
"24574": [],
"24575": [
"CVE-2004-1665"
],
"24576": [],
"24631": [],
"24632": [],
"24633": [],
"24582": [],
"24583": [],
"24585": [],
"24587": [],
"24588": [],
"24589": [],
"24591": [
"CVE-2004-1678"
],
"24601": [],
"24721": [
"CVE-2004-1100"
],
"24603": [],
"24604": [
"CVE-2004-1687"
],
"24611": [],
"24612": [],
"24613": [
"CVE-2004-2143"
],
"24614": [
"CVE-2004-1692"
],
"24615": [
"CVE-2004-1693"
],
"24616": [
"CVE-2004-2161"
],
"24617": [
"CVE-2004-2162"
],
"24625": [
"CVE-2004-1555"
],
"24626": [
"CVE-2004-1555"
],
"24627": [],
"24629": [
"CVE-2013-1668"
],
"24630": [],
"24638": [
"CVE-2004-1554"
],
"24641": [
"CVE-2004-1559"
],
"24642": [
"CVE-2004-1559"
],
"24643": [
"CVE-2004-1559"
],
"24644": [
"CVE-2004-1559"
],
"24645": [
"CVE-2004-1559"
],
"24646": [
"CVE-2004-1559"
],
"24647": [],
"24648": [
"CVE-2004-1562"
],
"24649": [
"CVE-2004-1563"
],
"24650": [
"CVE-2004-1563"
],
"24651": [
"CVE-2004-1564"
],
"24652": [
"CVE-2004-1563"
],
"24655": [],
"24657": [],
"24659": [
"CVE-2004-2511"
],
"24660": [],
"24661": [
"CVE-2004-2511"
],
"24662": [
"CVE-2004-2511"
],
"24663": [],
"24664": [],
"24665": [
"CVE-2004-2512"
],
"24666": [
"CVE-2004-0847"
],
"24667": [],
"24670": [],
"24671": [
"CVE-2004-2202"
],
"24672": [
"CVE-2004-2198"
],
"24673": [
"CVE-2004-2201"
],
"24674": [
"CVE-2004-2201"
],
"24675": [
"CVE-2004-2201"
],
"24676": [],
"24680": [],
"24683": [],
"24685": [
"CVE-2004-1601"
],
"24689": [],
"24690": [
"CVE-2004-1621"
],
"24692": [],
"24697": [
"CVE-2004-1620"
],
"24698": [
"CVE-2004-1622"
],
"24700": [
"CVE-2004-2732"
],
"24702": [],
"24703": [
"CVE-2004-2640"
],
"24922": [
"CVE-2013-2637"
],
"24889": [],
"24717": [
"CVE-2004-1499"
],
"24718": [
"CVE-2004-2246"
],
"24719": [
"CVE-2004-2245"
],
"24921": [],
"24722": [
"CVE-2004-1101"
],
"24723": [
"CVE-2004-1102"
],
"24729": [],
"24731": [
"CVE-2004-2725"
],
"24732": [],
"24734": [],
"24735": [],
"24736": [],
"24737": [],
"24739": [],
"24740": [],
"24742": [],
"24744": [
"CVE-2013-1814"
],
"24748": [],
"24751": [
"CVE-2004-1535"
],
"24752": [],
"24759": [
"CVE-2004-1536"
],
"24762": [
"CVE-2004-1537"
],
"24766": [],
"24768": [
"CVE-2004-1225"
],
"24769": [
"CVE-2004-1227"
],
"24771": [
"CVE-2004-1543"
],
"24772": [
"CVE-2004-1075"
],
"24773": [],
"24779": [
"CVE-2004-1196"
],
"24782": [],
"24783": [
"CVE-2004-1206"
],
"24786": [
"CVE-2013-3431",
"CVE-2013-3430",
"CVE-2013-3429"
],
"24789": [
"CVE-2013-1852"
],
"24790": [],
"24791": [
"CVE-2013-1651",
"CVE-2013-1650",
"CVE-2013-1649",
"CVE-2013-1648",
"CVE-2013-1647",
"CVE-2013-1646",
"CVE-2013-1645"
],
"24792": [
"CVE-2004-1210"
],
"24796": [
"CVE-2004-1212"
],
"24797": [
"CVE-2004-1213"
],
"24798": [
"CVE-2005-0780"
],
"24803": [],
"24806": [
"CVE-2004-1221"
],
"24810": [
"CVE-2004-0067"
],
"24814": [
"CVE-2004-0067"
],
"24816": [
"CVE-2004-0067"
],
"24817": [
"CVE-2004-1147"
],
"24819": [
"CVE-2004-0067"
],
"24820": [
"CVE-2004-0067"
],
"24821": [
"CVE-2004-0067"
],
"24822": [
"CVE-2004-0067"
],
"24823": [],
"24824": [
"CVE-2004-2510"
],
"24825": [
"CVE-2004-2509"
],
"24826": [
"CVE-2004-2509"
],
"24827": [
"CVE-2004-2509"
],
"24829": [
"CVE-2004-0067"
],
"24830": [
"CVE-2004-0067"
],
"24831": [
"CVE-2004-0067"
],
"24832": [
"CVE-2004-0067"
],
"24834": [
"CVE-2004-0067"
],
"24835": [
"CVE-2004-0067"
],
"24836": [],
"24837": [
"CVE-2004-0067"
],
"24838": [
"CVE-2004-1400"
],
"24840": [
"CVE-2004-1401"
],
"24842": [
"CVE-2004-1402"
],
"24844": [
"CVE-2004-1384"
],
"24845": [
"CVE-2004-1384"
],
"24846": [
"CVE-2004-1383"
],
"24847": [
"CVE-2004-1385"
],
"24849": [],
"24850": [],
"24851": [],
"24858": [],
"24859": [],
"24860": [
"CVE-2013-0126"
],
"24861": [],
"24862": [
"CVE-2013-2294"
],
"24864": [],
"24867": [],
"24868": [],
"24869": [],
"24870": [],
"24871": [],
"24873": [],
"24877": [
"CVE-2013-1891"
],
"24879": [],
"24881": [],
"24882": [
"CVE-2013-3522"
],
"24883": [],
"24893": [
"CVE-2013-3721"
],
"24894": [
"CVE-2008-5489",
"CVE-2008-0089"
],
"24898": [
"CVE-2013-2690"
],
"24901": [],
"24906": [
"CVE-2013-2474"
],
"24911": [],
"24913": [
"CVE-2013-2618"
],
"24914": [
"CVE-2013-3529"
],
"24915": [
"CVE-2013-2619"
],
"24916": [],
"24924": [
"CVE-2013-2748"
],
"24926": [],
"24927": [
"CVE-2013-3527"
],
"24928": [],
"24932": [
"CVE-2013-2643",
"CVE-2013-2642",
"CVE-2013-2641"
],
"24934": [
"CVE-2013-3536"
],
"24957": [],
"24969": [
"CVE-2011-4275",
"CVE-2009-4140"
],
"24942": [
"CVE-2013-3050"
],
"27434": [
"CVE-2006-1271"
],
"27435": [
"CVE-2006-1258"
],
"27436": [
"CVE-2006-1326"
],
"24953": [],
"24954": [
"CVE-2013-2498"
],
"24959": [
"CVE-2013-3535"
],
"24960": [
"CVE-2013-3524"
],
"24964": [
"CVE-2013-1509"
],
"24965": [
"CVE-2013-2713",
"CVE-2013-2712"
],
"24967": [],
"25090": [],
"25816": [],
"25817": [
"CVE-2005-1959"
],
"25818": [
"CVE-2005-1955"
],
"24973": [],
"24975": [],
"25089": [
"CVE-2005-0345"
],
"24986": [
"CVE-2004-1406"
],
"24987": [],
"24988": [],
"24989": [],
"24990": [],
"24991": [],
"24992": [],
"24993": [],
"24994": [
"CVE-2004-1405"
],
"25184": [],
"25185": [],
"25186": [],
"25189": [],
"25192": [],
"25193": [],
"29278": [],
"25002": [
"CVE-2013-2594"
],
"25003": [
"CVE-2013-3241",
"CVE-2013-3240",
"CVE-2013-3239",
"CVE-2013-3238"
],
"25014": [],
"25183": [
"CVE-2005-0650"
],
"25024": [],
"25037": [
"CVE-2004-1412"
],
"25038": [
"CVE-2004-1413"
],
"25041": [],
"25042": [],
"25043": [
"CVE-2004-2573"
],
"25044": [
"CVE-2004-2574"
],
"25045": [
"CVE-2004-1415"
],
"25051": [
"CVE-2004-1418"
],
"25052": [
"CVE-2005-0305"
],
"25053": [
"CVE-2005-0305"
],
"25058": [],
"25059": [
"CVE-2005-0307"
],
"25060": [],
"25062": [],
"25064": [
"CVE-2005-0313"
],
"25065": [
"CVE-2005-0313"
],
"25067": [],
"25068": [
"CVE-2005-0320"
],
"25069": [
"CVE-2005-0320"
],
"25071": [],
"25074": [],
"25078": [],
"25084": [
"CVE-2005-0420"
],
"25086": [],
"25087": [
"CVE-2013-3242"
],
"25088": [],
"25093": [],
"25096": [],
"25097": [
"CVE-2005-0443"
],
"25098": [
"CVE-2005-0442"
],
"25099": [
"CVE-2005-0409"
],
"25100": [
"CVE-2005-0409"
],
"25101": [
"CVE-2005-0410"
],
"25102": [
"CVE-2005-0408"
],
"25103": [],
"25104": [
"CVE-2005-0411"
],
"25105": [],
"25108": [],
"25109": [],
"25110": [
"CVE-2005-0452"
],
"25111": [],
"25112": [],
"25113": [],
"25114": [
"CVE-2005-0475"
],
"25115": [
"CVE-2005-0475"
],
"25116": [
"CVE-2005-0475"
],
"25117": [
"CVE-2005-0475"
],
"25118": [
"CVE-2005-0251"
],
"25119": [
"CVE-2005-0251"
],
"25120": [
"CVE-2005-0253"
],
"25121": [
"CVE-2005-0252"
],
"25123": [
"CVE-2005-0479"
],
"25125": [],
"25126": [],
"25127": [
"CVE-2005-0513"
],
"25138": [
"CVE-2013-1603",
"CVE-2013-1602",
"CVE-2013-1601",
"CVE-2013-1600",
"CVE-2013-1599"
],
"25139": [
"CVE-2013-1598",
"CVE-2013-1597",
"CVE-2013-1596",
"CVE-2013-1595",
"CVE-2013-1594"
],
"25142": [],
"25143": [
"CVE-2005-0477"
],
"25145": [],
"25147": [],
"25148": [],
"25149": [],
"25151": [],
"25152": [
"CVE-2005-0543"
],
"25153": [
"CVE-2005-0543"
],
"25154": [
"CVE-2005-0543"
],
"25155": [
"CVE-2005-0543"
],
"25156": [],
"25158": [],
"25159": [],
"25160": [
"CVE-2005-0569"
],
"25161": [],
"25162": [
"CVE-2005-0606"
],
"25168": [],
"25169": [],
"25170": [],
"25172": [],
"25173": [],
"25174": [
"CVE-2005-0670"
],
"25175": [
"CVE-2005-0670"
],
"25176": [],
"25177": [],
"25178": [
"CVE-2005-0629"
],
"25179": [],
"25180": [
"CVE-2005-0632"
],
"25197": [],
"25198": [],
"25199": [
"CVE-2005-0741"
],
"25200": [],
"25201": [
"CVE-2005-0735"
],
"25206": [],
"25208": [
"CVE-2005-0776"
],
"25212": [],
"25213": [
"CVE-2005-0781"
],
"25214": [
"CVE-2005-0781"
],
"25215": [
"CVE-2005-0782"
],
"25216": [
"CVE-2005-0782"
],
"25217": [
"CVE-2005-0795"
],
"25220": [],
"25222": [
"CVE-2005-0796"
],
"25223": [
"CVE-2005-0783"
],
"25224": [
"CVE-2005-0786"
],
"25225": [
"CVE-2005-0791"
],
"25226": [],
"25227": [
"CVE-2005-0862"
],
"25228": [
"CVE-2005-0862"
],
"25229": [
"CVE-2005-0862"
],
"25230": [
"CVE-2005-0818"
],
"25232": [
"CVE-2005-0800"
],
"25233": [
"CVE-2005-0802"
],
"25235": [
"CVE-2005-0805"
],
"25236": [
"CVE-2005-0863"
],
"25237": [
"CVE-2005-0828"
],
"25239": [
"CVE-2005-0857"
],
"25240": [
"CVE-2005-0858"
],
"25241": [
"CVE-2005-0829"
],
"25242": [],
"40397": [],
"25243": [
"CVE-2005-0860"
],
"25244": [
"CVE-2005-0859"
],
"25245": [],
"25247": [],
"25248": [],
"25249": [],
"25250": [],
"25251": [],
"25252": [
"CVE-2005-0853"
],
"25253": [
"CVE-2005-0854"
],
"25254": [
"CVE-2005-0854"
],
"25257": [
"CVE-2005-0842"
],
"25258": [
"CVE-2005-0843"
],
"25260": [
"CVE-2005-0879"
],
"25261": [
"CVE-2005-0879"
],
"25262": [
"CVE-2005-0881"
],
"25263": [
"CVE-2005-0883"
],
"25264": [
"CVE-2005-0883"
],
"25265": [
"CVE-2005-0870"
],
"25266": [
"CVE-2005-0870"
],
"25267": [
"CVE-2005-0886"
],
"25269": [
"CVE-2005-0873"
],
"25270": [
"CVE-2005-0872"
],
"25271": [
"CVE-2005-0887"
],
"25272": [
"CVE-2005-0889"
],
"25273": [
"CVE-2005-0890"
],
"25276": [
"CVE-2005-0896"
],
"25278": [
"CVE-2005-0935"
],
"25279": [
"CVE-2005-0935"
],
"25280": [
"CVE-2005-0936"
],
"25282": [],
"25283": [],
"25284": [],
"25285": [],
"25286": [],
"25292": [
"CVE-2013-2684",
"CVE-2013-2683",
"CVE-2013-2682",
"CVE-2013-2681",
"CVE-2013-2680",
"CVE-2013-2679",
"CVE-2013-2678"
],
"25298": [
"CVE-2013-2945"
],
"25299": [],
"25300": [],
"25301": [],
"25302": [],
"25304": [
"CVE-2012-6495",
"CVE-2012-6081"
],
"25305": [
"CVE-2013-3336"
],
"33406": [
"CVE-2009-3701"
],
"33407": [
"CVE-2009-3701"
],
"33408": [
"CVE-2009-3701"
],
"25308": [
"CVE-2005-0928"
],
"25309": [
"CVE-2005-0928"
],
"25310": [
"CVE-2005-0928"
],
"25311": [
"CVE-2005-0929"
],
"25312": [
"CVE-2005-0929"
],
"25313": [
"CVE-2005-0945"
],
"25314": [
"CVE-2005-0931"
],
"25315": [],
"25316": [],
"25317": [
"CVE-2005-0925"
],
"25318": [
"CVE-2005-0948"
],
"25320": [
"CVE-2005-0962"
],
"25323": [
"CVE-2005-0955"
],
"25324": [
"CVE-2005-1008"
],
"25327": [
"CVE-2005-0980"
],
"25328": [
"CVE-2005-0981"
],
"25330": [
"CVE-2005-0992"
],
"25331": [
"CVE-2005-1006"
],
"25332": [
"CVE-2005-1011"
],
"40396": [],
"25337": [
"CVE-2005-1004"
],
"25338": [
"CVE-2005-1005"
],
"25339": [
"CVE-2005-1000"
],
"25340": [
"CVE-2005-1000"
],
"25341": [
"CVE-2005-1027"
],
"25342": [
"CVE-2005-1000"
],
"25343": [
"CVE-2005-1000"
],
"25344": [
"CVE-2005-1026"
],
"25345": [
"CVE-2005-1026"
],
"25346": [
"CVE-2005-1029"
],
"25347": [
"CVE-2005-1029"
],
"25348": [
"CVE-2005-1030"
],
"25349": [
"CVE-2005-1030"
],
"25350": [],
"25351": [
"CVE-2005-1030"
],
"25352": [
"CVE-2005-1030"
],
"25354": [
"CVE-2005-1095"
],
"25355": [
"CVE-2005-1033"
],
"25356": [
"CVE-2005-1033"
],
"25357": [
"CVE-2005-1033"
],
"25358": [
"CVE-2005-1033"
],
"25360": [
"CVE-2005-0997"
],
"25366": [
"CVE-2005-1049"
],
"25367": [
"CVE-2005-1049"
],
"25368": [],
"25369": [
"CVE-2005-1073"
],
"25370": [
"CVE-2005-1074"
],
"25371": [
"CVE-2005-1075"
],
"25372": [
"CVE-2005-1075"
],
"25373": [
"CVE-2005-1081"
],
"25374": [
"CVE-2005-1082"
],
"25376": [
"CVE-2005-1054"
],
"25377": [
"CVE-2005-1053"
],
"25378": [
"CVE-2005-1053"
],
"25379": [
"CVE-2005-1079"
],
"25380": [
"CVE-2005-1070"
],
"25381": [
"CVE-2005-1076"
],
"25382": [
"CVE-2005-1071"
],
"25390": [
"CVE-2005-1188"
],
"25394": [
"CVE-2005-1130"
],
"25398": [],
"25399": [],
"25400": [],
"25401": [],
"25403": [],
"25404": [],
"25405": [],
"25409": [],
"25410": [],
"25412": [],
"25413": [],
"25414": [],
"25415": [],
"25416": [],
"25417": [],
"25422": [
"CVE-2005-1117"
],
"25423": [
"CVE-2005-1135"
],
"25424": [
"CVE-2005-1161"
],
"25425": [
"CVE-2005-1161"
],
"25426": [
"CVE-2005-1161"
],
"25427": [
"CVE-2005-1162"
],
"25428": [
"CVE-2005-1162"
],
"25430": [],
"25431": [
"CVE-2005-1181"
],
"25432": [
"CVE-2005-1170"
],
"25433": [
"CVE-2005-1171"
],
"25434": [
"CVE-2005-1202"
],
"25435": [
"CVE-2005-1202"
],
"25436": [
"CVE-2005-1203"
],
"25437": [
"CVE-2005-1203"
],
"25438": [
"CVE-2005-1183"
],
"25440": [],
"25441": [],
"25442": [],
"25447": [],
"25449": [
"CVE-2013-2754"
],
"25451": [
"CVE-2005-1196"
],
"25455": [],
"25456": [],
"25457": [
"CVE-2005-1199"
],
"25458": [
"CVE-2005-4670"
],
"25459": [],
"25464": [
"CVE-2005-4671"
],
"25466": [
"CVE-2005-1412"
],
"25467": [
"CVE-2005-1222"
],
"25468": [
"CVE-2005-1233"
],
"25469": [
"CVE-2005-1223"
],
"25473": [
"CVE-2005-1233"
],
"25474": [],
"25475": [],
"25476": [
"CVE-2005-1224"
],
"25477": [
"CVE-2005-1224"
],
"25478": [
"CVE-2005-1224"
],
"25479": [
"CVE-2005-1224"
],
"25480": [
"CVE-2005-1224"
],
"25481": [
"CVE-2005-1224"
],
"25482": [
"CVE-2005-1236"
],
"25483": [
"CVE-2005-1236"
],
"25485": [
"CVE-2005-1236"
],
"25484": [
"CVE-2005-1236"
],
"25488": [],
"25489": [],
"25490": [],
"25491": [],
"25492": [],
"25493": [],
"25494": [],
"25495": [],
"25496": [],
"25498": [],
"25500": [],
"25501": [],
"25502": [],
"25503": [
"CVE-2005-1285"
],
"25504": [],
"25505": [],
"25506": [],
"25507": [],
"25508": [],
"25509": [],
"25510": [],
"40395": [],
"25511": [],
"25512": [],
"25513": [],
"25514": [],
"25515": [],
"25516": [],
"25518": [
"CVE-2013-3294"
],
"25519": [
"CVE-2013-2097"
],
"25520": [],
"25521": [],
"25522": [],
"25523": [],
"25524": [],
"25528": [],
"25529": [
"CVE-2005-1293"
],
"25530": [
"CVE-2005-1329"
],
"25531": [
"CVE-2005-1325"
],
"25532": [],
"25533": [],
"25534": [
"CVE-2005-1308"
],
"25535": [],
"25536": [],
"25537": [],
"25538": [
"CVE-2005-1360"
],
"25539": [],
"25540": [],
"25541": [],
"25542": [],
"25543": [],
"25544": [],
"25545": [],
"25548": [
"CVE-2005-1398"
],
"25549": [
"CVE-2005-1374"
],
"25550": [
"CVE-2005-1374"
],
"25551": [
"CVE-2005-1374"
],
"25552": [
"CVE-2005-1375"
],
"25553": [
"CVE-2005-1375"
],
"25555": [
"CVE-2005-0890"
],
"25556": [
"CVE-2005-0890"
],
"25558": [
"CVE-2005-1378"
],
"25560": [
"CVE-2005-1403"
],
"25564": [
"CVE-2005-1403"
],
"25565": [
"CVE-2005-1403"
],
"25566": [
"CVE-2005-1403"
],
"25567": [],
"25568": [
"CVE-2005-1384"
],
"25569": [
"CVE-2005-1384"
],
"25570": [
"CVE-2005-1479"
],
"25575": [
"CVE-2005-1440"
],
"25576": [
"CVE-2005-1440"
],
"25577": [
"CVE-2005-1440"
],
"25578": [
"CVE-2005-1440"
],
"25579": [
"CVE-2005-1440"
],
"25580": [
"CVE-2005-1440"
],
"25720": [],
"25585": [
"CVE-2005-1417"
],
"25586": [
"CVE-2005-1417"
],
"25587": [
"CVE-2005-1417"
],
"25588": [
"CVE-2005-1417"
],
"25589": [
"CVE-2005-1417"
],
"25590": [],
"25591": [],
"25592": [
"CVE-2005-1611"
],
"25593": [],
"25594": [
"CVE-2005-1492"
],
"25595": [],
"25596": [],
"25599": [],
"25601": [
"CVE-2005-1486"
],
"25602": [
"CVE-2005-1486"
],
"25603": [
"CVE-2005-1487"
],
"25604": [
"CVE-2005-1487"
],
"25605": [],
"25606": [],
"30092": [],
"25821": [],
"25823": [
"CVE-2005-1998"
],
"25824": [],
"25825": [],
"25612": [
"CVE-2005-1498"
],
"25614": [
"CVE-2005-1503"
],
"25615": [],
"25616": [],
"25617": [],
"25618": [],
"25619": [],
"25620": [],
"25622": [
"CVE-2005-1494"
],
"25623": [
"CVE-2005-1506"
],
"25628": [
"CVE-2005-1193"
],
"25630": [
"CVE-2005-1548"
],
"25632": [],
"25634": [
"CVE-2005-1550"
],
"25635": [],
"25637": [
"CVE-2005-1593"
],
"25638": [
"CVE-2005-1594"
],
"25639": [],
"25640": [],
"25641": [
"CVE-2004-2181"
],
"25642": [
"CVE-2005-1610"
],
"25644": [],
"25645": [],
"25649": [],
"25650": [
"CVE-2005-1587"
],
"25651": [
"CVE-2005-1561"
],
"25653": [],
"25654": [
"CVE-2005-1614"
],
"25655": [
"CVE-2005-1615"
],
"25656": [
"CVE-2005-1612"
],
"25657": [
"CVE-2005-1613"
],
"25659": [
"CVE-2005-1619"
],
"25660": [
"CVE-2005-1619"
],
"25661": [
"CVE-2005-1645"
],
"25662": [
"CVE-2005-1620"
],
"25663": [],
"25664": [],
"25665": [],
"25666": [
"CVE-2005-1366"
],
"25667": [],
"25668": [],
"25671": [
"CVE-2005-1637"
],
"25672": [
"CVE-2005-1637"
],
"25673": [
"CVE-2005-1633"
],
"25674": [
"CVE-2005-1633"
],
"25675": [
"CVE-2005-1633"
],
"25676": [
"CVE-2005-1633"
],
"25677": [
"CVE-2005-1633"
],
"25678": [
"CVE-2005-1633"
],
"25679": [
"CVE-2005-1633"
],
"25681": [],
"25682": [],
"25683": [],
"25685": [],
"25686": [
"CVE-2005-1681"
],
"25689": [
"CVE-2005-1715"
],
"25690": [],
"25693": [
"CVE-2005-1752"
],
"25766": [
"CVE-2005-1823"
],
"25700": [],
"25701": [],
"25702": [
"CVE-2005-1754"
],
"25704": [],
"25705": [],
"25715": [],
"25716": [],
"25721": [],
"25723": [],
"25724": [],
"25726": [
"CVE-2013-3531"
],
"25727": [
"CVE-2005-1782"
],
"25728": [
"CVE-2005-1782"
],
"25729": [
"CVE-2005-1782"
],
"25730": [
"CVE-2005-1782"
],
"25731": [
"CVE-2005-1782"
],
"25732": [
"CVE-2005-1782"
],
"25733": [
"CVE-2005-1782"
],
"25734": [
"CVE-2005-1782"
],
"25735": [
"CVE-2005-1782"
],
"25738": [],
"25739": [],
"25740": [
"CVE-2005-1800"
],
"25741": [
"CVE-2005-1817"
],
"25742": [
"CVE-2005-1803"
],
"25743": [
"CVE-2005-1803"
],
"25744": [
"CVE-2005-1803"
],
"25745": [],
"25746": [
"CVE-2005-1803"
],
"25747": [
"CVE-2005-1803"
],
"25748": [
"CVE-2005-1804"
],
"25749": [
"CVE-2005-1804"
],
"25750": [
"CVE-2005-1803"
],
"25751": [
"CVE-2005-1805"
],
"25753": [
"CVE-2005-1788"
],
"25754": [
"CVE-2005-1788"
],
"25756": [],
"25758": [],
"40391": [],
"25759": [
"CVE-2005-1823"
],
"25760": [
"CVE-2005-1823"
],
"25761": [
"CVE-2005-1823"
],
"25762": [
"CVE-2005-1823"
],
"25763": [
"CVE-2005-1823"
],
"25764": [
"CVE-2005-1823"
],
"25765": [
"CVE-2005-1823"
],
"25767": [
"CVE-2005-1822"
],
"25768": [
"CVE-2005-1822"
],
"25769": [
"CVE-2005-1822"
],
"25770": [
"CVE-2005-1822"
],
"25771": [
"CVE-2005-1822"
],
"25772": [
"CVE-2005-1822"
],
"25773": [
"CVE-2005-1822"
],
"25774": [
"CVE-2005-1822"
],
"25819": [],
"33411": [
"CVE-2009-4433"
],
"33412": [
"CVE-2009-4433"
],
"33413": [],
"33416": [],
"33417": [
"CVE-2009-4823"
],
"33418": [
"CVE-2009-4428"
],
"33419": [
"CVE-2009-4435"
],
"33420": [
"CVE-2009-4435"
],
"40390": [],
"33421": [],
"33422": [],
"33424": [
"CVE-2009-4822"
],
"33425": [
"CVE-2013-2118"
],
"25777": [
"CVE-2005-1821"
],
"25778": [],
"25779": [],
"25780": [],
"25781": [],
"25783": [],
"25785": [],
"25786": [],
"25787": [],
"25788": [
"CVE-2005-1870"
],
"25790": [],
"25792": [
"CVE-2005-1881"
],
"25793": [
"CVE-2005-1886"
],
"25794": [
"CVE-2005-1884"
],
"25795": [
"CVE-2005-1967"
],
"25796": [
"CVE-2005-1967"
],
"25797": [
"CVE-2005-1967"
],
"25798": [
"CVE-2005-1967"
],
"25799": [
"CVE-2005-1893"
],
"25800": [
"CVE-2005-1895"
],
"25801": [
"CVE-2005-1894"
],
"25803": [],
"25804": [
"CVE-2005-1943"
],
"25805": [
"CVE-2005-1943"
],
"25806": [
"CVE-2005-1948"
],
"25808": [],
"25810": [],
"25811": [],
"25812": [
"CVE-2013-2573",
"CVE-2013-2572"
],
"25813": [
"CVE-2013-1605",
"CVE-2013-1604"
],
"25815": [
"CVE-2013-2570",
"CVE-2013-2569",
"CVE-2013-2568",
"CVE-2013-2567"
],
"25826": [
"CVE-2005-2044"
],
"25827": [
"CVE-2005-2044"
],
"25828": [
"CVE-2005-2044"
],
"25829": [
"CVE-2005-2044"
],
"25830": [
"CVE-2005-2044"
],
"25831": [
"CVE-2005-2044"
],
"25832": [
"CVE-2005-2044"
],
"25833": [
"CVE-2005-2044"
],
"25834": [
"CVE-2005-2044"
],
"25838": [
"CVE-2005-2030"
],
"25839": [
"CVE-2005-2035"
],
"25840": [
"CVE-2005-1951"
],
"25843": [
"CVE-2005-2009"
],
"25844": [
"CVE-2005-2009"
],
"25845": [
"CVE-2005-2010"
],
"25846": [
"CVE-2005-2021"
],
"25847": [
"CVE-2003-0557"
],
"25848": [],
"25849": [],
"26289": [],
"26290": [],
"26291": [
"CVE-2005-3043"
],
"25853": [
"CVE-2005-2033"
],
"25854": [
"CVE-2005-2011"
],
"25855": [],
"25856": [
"CVE-2005-2012"
],
"25857": [
"CVE-2005-1526"
],
"25858": [
"CVE-2005-2199"
],
"25859": [
"CVE-2005-1524"
],
"25860": [
"CVE-2005-2046"
],
"25861": [
"CVE-2005-2046"
],
"25862": [
"CVE-2005-2046"
],
"25863": [
"CVE-2005-2046"
],
"25864": [
"CVE-2005-2046"
],
"25865": [
"CVE-2005-2046"
],
"25866": [
"CVE-2006-6365"
],
"25867": [
"CVE-2005-2046"
],
"25868": [
"CVE-2005-2048"
],
"25869": [
"CVE-2005-2048"
],
"25870": [
"CVE-2005-2048"
],
"25871": [
"CVE-2005-2048"
],
"25872": [
"CVE-2005-2049"
],
"25873": [
"CVE-2005-2049"
],
"25874": [
"CVE-2005-1250"
],
"25875": [],
"25876": [],
"25877": [],
"25878": [],
"25879": [],
"25880": [],
"25881": [],
"25882": [],
"25884": [],
"25885": [],
"25886": [],
"25887": [],
"25888": [],
"25889": [],
"25890": [],
"25891": [],
"25892": [],
"25893": [],
"25894": [],
"25895": [],
"25897": [
"CVE-2005-2058"
],
"25898": [
"CVE-2005-2058"
],
"25899": [
"CVE-2005-2058"
],
"25900": [
"CVE-2005-2058"
],
"25901": [
"CVE-2005-2058"
],
"25902": [
"CVE-2005-2058"
],
"25903": [
"CVE-2005-2058"
],
"25904": [],
"25905": [
"CVE-2005-2064"
],
"25906": [
"CVE-2005-2064"
],
"25907": [
"CVE-2005-2065"
],
"25908": [],
"25909": [],
"25910": [],
"25913": [
"CVE-2005-2077"
],
"25914": [],
"25915": [],
"25927": [
"CVE-2005-1524"
],
"25918": [],
"25919": [],
"25920": [],
"25922": [
"CVE-2003-0509"
],
"25923": [
"CVE-2003-0509"
],
"25926": [
"CVE-2005-2154"
],
"25924": [
"CVE-2005-2140"
],
"25925": [],
"25928": [
"CVE-2005-2155"
],
"25929": [
"CVE-2005-2155"
],
"25930": [
"CVE-2005-2155"
],
"25931": [
"CVE-2005-2155"
],
"25932": [
"CVE-2005-2155"
],
"25934": [],
"25935": [],
"25937": [],
"25938": [
"CVE-2005-2256"
],
"25939": [],
"25940": [
"CVE-2005-2163"
],
"25941": [
"CVE-2005-2162"
],
"25942": [],
"25945": [],
"25946": [],
"25950": [],
"25951": [],
"25952": [],
"25953": [],
"25954": [],
"25955": [],
"25956": [],
"25957": [],
"25958": [],
"25959": [],
"25960": [
"CVE-2005-2199"
],
"25963": [],
"25964": [],
"25965": [
"CVE-2005-2318"
],
"25968": [],
"25969": [],
"25971": [],
"25973": [],
"25976": [
"CVE-2013-4098",
"CVE-2013-4097",
"CVE-2013-4096"
],
"25977": [
"CVE-2013-4095",
"CVE-2013-4094",
"CVE-2013-4093",
"CVE-2013-4092",
"CVE-2013-4091"
],
"25978": [],
"25981": [],
"25982": [],
"25983": [],
"25984": [],
"25985": [],
"25990": [
"CVE-2005-2326"
],
"25994": [
"CVE-2005-2330"
],
"25995": [],
"25996": [],
"25997": [],
"25998": [
"CVE-2013-5948"
],
"26001": [
"CVE-2005-2276"
],
"26007": [],
"26293": [
"CVE-2005-3052"
],
"26294": [],
"26295": [],
"26296": [],
"26009": [],
"26012": [
"CVE-2013-1081"
],
"26014": [],
"26015": [],
"26016": [
"CVE-2005-2383"
],
"26017": [
"CVE-2005-2455"
],
"26018": [],
"26019": [],
"26020": [],
"26021": [],
"26023": [],
"26025": [],
"26026": [],
"26027": [],
"26028": [],
"26029": [],
"26030": [],
"26031": [],
"26033": [
"CVE-2005-2386"
],
"26034": [
"CVE-2005-2397"
],
"26036": [],
"26037": [
"CVE-2005-2324"
],
"26038": [
"CVE-2005-2324"
],
"26039": [],
"26040": [],
"26041": [],
"26042": [],
"26043": [],
"26045": [
"CVE-2005-2432"
],
"26046": [],
"26047": [],
"26048": [],
"26049": [
"CVE-2005-2441"
],
"26050": [
"CVE-2005-2441"
],
"26051": [
"CVE-2005-2460"
],
"26052": [
"CVE-2005-2461"
],
"26053": [],
"26054": [],
"26055": [],
"26056": [
"CVE-2005-2467"
],
"26057": [
"CVE-2005-2467"
],
"26058": [
"CVE-2005-2467"
],
"26059": [],
"26060": [
"CVE-2005-2560"
],
"26061": [],
"26062": [
"CVE-2005-2466"
],
"26063": [
"CVE-2005-2476"
],
"26064": [],
"26065": [
"CVE-2005-2480"
],
"26066": [
"CVE-2005-2483"
],
"26067": [
"CVE-2005-2488"
],
"26068": [
"CVE-2005-2488"
],
"26069": [],
"26070": [],
"26072": [
"CVE-2005-2486"
],
"26073": [],
"26327": [
"CVE-2005-3200"
],
"26077": [],
"26297": [],
"26298": [
"CVE-2005-3083"
],
"26079": [],
"26080": [
"CVE-2005-2543"
],
"26081": [],
"26082": [],
"26083": [],
"26084": [],
"26085": [],
"26086": [
"CVE-2008-6562"
],
"26087": [],
"26088": [],
"26089": [
"CVE-2005-4880"
],
"26090": [
"CVE-2005-4880"
],
"26091": [
"CVE-2005-4880"
],
"26092": [
"CVE-2005-4880"
],
"26093": [],
"26094": [],
"26095": [],
"26096": [],
"26097": [],
"26098": [
"CVE-2005-2539"
],
"26099": [
"CVE-2005-2539"
],
"26102": [
"CVE-2005-3159"
],
"26103": [],
"26104": [
"CVE-2005-2542"
],
"26105": [],
"26106": [
"CVE-2005-2562"
],
"26107": [
"CVE-2005-2588"
],
"26108": [
"CVE-2005-2588"
],
"26109": [
"CVE-2005-2588"
],
"26111": [],
"26112": [
"CVE-2007-3627"
],
"26113": [
"CVE-2007-3627"
],
"26114": [
"CVE-2007-3627"
],
"26115": [],
"26116": [],
"26117": [
"CVE-2005-2569"
],
"26118": [
"CVE-2005-2569"
],
"26119": [
"CVE-2005-2569"
],
"26120": [
"CVE-2005-2569"
],
"26121": [
"CVE-2005-2569"
],
"26122": [
"CVE-2005-2569"
],
"26124": [],
"26125": [
"CVE-2013-3739"
],
"26126": [],
"26127": [],
"26129": [],
"26132": [],
"26136": [
"CVE-2013-3961"
],
"26140": [
"CVE-2005-2616"
],
"26141": [
"CVE-2005-2616"
],
"26142": [
"CVE-2005-2616"
],
"26143": [
"CVE-2005-2616"
],
"26144": [
"CVE-2005-2587"
],
"26146": [],
"26147": [
"CVE-2005-2580"
],
"26148": [
"CVE-2005-2580"
],
"26149": [
"CVE-2005-2580"
],
"26150": [
"CVE-2005-2580"
],
"26153": [
"CVE-2005-2603"
],
"26154": [],
"26155": [],
"26156": [],
"26157": [],
"26158": [],
"26159": [
"CVE-2005-2637"
],
"26160": [
"CVE-2005-2638"
],
"26161": [
"CVE-2005-2638"
],
"26162": [
"CVE-2005-2633"
],
"26163": [
"CVE-2005-2633"
],
"26164": [
"CVE-2005-2633"
],
"26165": [
"CVE-2005-2633"
],
"26166": [
"CVE-2005-2633"
],
"26169": [
"CVE-2005-2648"
],
"26170": [
"CVE-2005-2649"
],
"26171": [
"CVE-2005-2651"
],
"26172": [
"CVE-2005-2557"
],
"26174": [
"CVE-2013-3691",
"CVE-2013-3687",
"CVE-2013-3686",
"CVE-2013-3541",
"CVE-2013-3540"
],
"26176": [
"CVE-2005-2673"
],
"26177": [
"CVE-2005-2675"
],
"26178": [
"CVE-2005-2675"
],
"26179": [
"CVE-2005-2675"
],
"26180": [
"CVE-2005-2675"
],
"26181": [
"CVE-2005-2674"
],
"26182": [
"CVE-2005-2674"
],
"26183": [],
"26184": [
"CVE-2005-2683"
],
"26186": [],
"26187": [
"CVE-2005-2689"
],
"26188": [
"CVE-2005-2689"
],
"26189": [
"CVE-2005-2690"
],
"26190": [],
"26191": [],
"26192": [],
"26193": [],
"26197": [
"CVE-2005-2721"
],
"26199": [
"CVE-2005-2869"
],
"26200": [
"CVE-2005-2769"
],
"26201": [
"CVE-2005-2775"
],
"26202": [],
"26203": [
"CVE-2005-2777"
],
"26204": [],
"26205": [
"CVE-2005-2788"
],
"26206": [
"CVE-2005-2788"
],
"26207": [
"CVE-2005-2675"
],
"26208": [
"CVE-2005-2782"
],
"26209": [
"CVE-2005-2783"
],
"26211": [
"CVE-2005-2792"
],
"26212": [
"CVE-2005-2813"
],
"26213": [],
"26215": [
"CVE-2005-2814"
],
"26217": [
"CVE-2005-2846"
],
"26223": [],
"26224": [
"CVE-2005-2855"
],
"26225": [
"CVE-2005-2885"
],
"26226": [],
"26228": [],
"26229": [],
"26231": [
"CVE-2005-2892"
],
"26232": [],
"26234": [
"CVE-2005-2896"
],
"26235": [
"CVE-2005-2896"
],
"26236": [
"CVE-2005-2896"
],
"26237": [],
"26240": [],
"26241": [],
"26243": [],
"26244": [
"CVE-2013-4665",
"CVE-2013-4664"
],
"26246": [],
"26247": [],
"40300": [],
"26252": [
"CVE-2005-2952"
],
"26253": [
"CVE-2005-4821"
],
"26254": [
"CVE-2005-4821"
],
"26255": [],
"26256": [
"CVE-2005-2953"
],
"26257": [
"CVE-2005-2954"
],
"26258": [
"CVE-2005-2956"
],
"26259": [
"CVE-2005-2979"
],
"26260": [
"CVE-2005-2877"
],
"26261": [
"CVE-2005-2980"
],
"26262": [],
"26263": [
"CVE-2005-2985"
],
"26264": [
"CVE-2005-2989"
],
"26265": [
"CVE-2005-2989"
],
"26266": [
"CVE-2005-2989"
],
"26267": [
"CVE-2005-2989"
],
"26268": [
"CVE-2005-2989"
],
"26333": [
"CVE-2005-3208"
],
"26334": [
"CVE-2005-3208"
],
"26270": [],
"26272": [
"CVE-2005-3026"
],
"26273": [
"CVE-2005-3019"
],
"26274": [
"CVE-2005-3019"
],
"26275": [
"CVE-2005-3019"
],
"26276": [
"CVE-2005-3019"
],
"26277": [],
"26278": [
"CVE-2005-3020"
],
"26279": [
"CVE-2005-3020"
],
"26280": [
"CVE-2005-3020"
],
"26281": [
"CVE-2005-3020"
],
"26282": [
"CVE-2005-3020"
],
"26283": [
"CVE-2005-3020"
],
"26284": [
"CVE-2005-3004"
],
"26285": [
"CVE-2005-3005"
],
"26286": [],
"26287": [],
"26300": [
"CVE-2005-3127"
],
"26302": [
"CVE-2005-2877"
],
"26303": [
"CVE-2005-3152"
],
"26304": [
"CVE-2005-3152"
],
"26305": [
"CVE-2005-3128"
],
"26307": [
"CVE-2005-3130"
],
"26308": [
"CVE-2005-3131"
],
"26309": [
"CVE-2005-3131"
],
"26310": [
"CVE-2005-3131"
],
"26311": [
"CVE-2005-3131"
],
"26312": [],
"26313": [
"CVE-2005-3133"
],
"26386": [
"CVE-2005-3305"
],
"26387": [
"CVE-2005-3305"
],
"26316": [],
"26319": [],
"26328": [
"CVE-2005-3200"
],
"26324": [
"CVE-2005-4698"
],
"26335": [],
"26337": [
"CVE-2005-3236"
],
"26338": [
"CVE-2005-3236"
],
"26339": [
"CVE-2005-3237"
],
"26343": [
"CVE-2005-4770"
],
"26344": [
"CVE-2005-4694"
],
"26345": [
"CVE-2005-4799"
],
"26346": [
"CVE-2005-3290"
],
"26347": [],
"26348": [
"CVE-2005-4674"
],
"26349": [
"CVE-2005-4675"
],
"26350": [
"CVE-2005-3518"
],
"26351": [
"CVE-2005-3285"
],
"26354": [
"CVE-2005-3522"
],
"26355": [
"CVE-2005-3520"
],
"26356": [
"CVE-2005-3520"
],
"26357": [
"CVE-2005-3520"
],
"26358": [
"CVE-2005-3520"
],
"26359": [
"CVE-2005-3520"
],
"26360": [
"CVE-2005-3520"
],
"26361": [
"CVE-2005-3520"
],
"26362": [
"CVE-2005-3519"
],
"26363": [
"CVE-2005-3519"
],
"26364": [
"CVE-2005-3519"
],
"26365": [
"CVE-2005-3519"
],
"26366": [
"CVE-2013-2227",
"CVE-2013-2226"
],
"26369": [
"CVE-2005-3519"
],
"26370": [
"CVE-2005-3519"
],
"26371": [
"CVE-2005-3519"
],
"26372": [
"CVE-2005-3519"
],
"26373": [
"CVE-2005-3519"
],
"26377": [],
"26378": [
"CVE-2005-3514"
],
"26379": [
"CVE-2005-3514"
],
"26380": [
"CVE-2005-3515"
],
"26381": [
"CVE-2005-3516"
],
"26383": [
"CVE-2005-3308"
],
"26384": [
"CVE-2005-3307"
],
"26385": [],
"26388": [
"CVE-2005-3305"
],
"26389": [
"CVE-2005-3305"
],
"26390": [
"CVE-2005-3363"
],
"26391": [
"CVE-2005-3320"
],
"26392": [
"CVE-2005-3301"
],
"26393": [
"CVE-2005-3301"
],
"26394": [
"CVE-2005-3324"
],
"26395": [
"CVE-2005-3325"
],
"26396": [
"CVE-2005-3326"
],
"26397": [
"CVE-2005-4702"
],
"26398": [
"CVE-2005-3329"
],
"26399": [
"CVE-2005-3332"
],
"26400": [
"CVE-2005-3334"
],
"26401": [],
"26405": [
"CVE-2013-4953"
],
"26406": [
"CVE-2013-5321"
],
"27541": [
"CVE-2006-1579"
],
"27542": [
"CVE-2006-1659"
],
"27543": [
"CVE-2006-1659"
],
"26408": [
"CVE-2007-3519"
],
"26410": [],
"26414": [],
"26415": [
"CVE-2013-3307"
],
"26416": [
"CVE-2013-4952"
],
"26827": [
"CVE-2005-4243"
],
"26423": [],
"26425": [
"CVE-2005-3369"
],
"26426": [],
"26427": [
"CVE-2005-3408"
],
"26428": [
"CVE-2005-3368"
],
"26429": [
"CVE-2005-3315"
],
"26430": [
"CVE-2005-3315"
],
"26431": [
"CVE-2005-3405"
],
"26432": [
"CVE-2005-3404"
],
"26433": [
"CVE-2005-3404"
],
"26434": [],
"26435": [
"CVE-2005-3422"
],
"26436": [
"CVE-2005-3432"
],
"26437": [],
"26438": [
"CVE-2005-3395"
],
"26439": [
"CVE-2005-3411"
],
"26440": [
"CVE-2005-3478"
],
"26441": [
"CVE-2005-3394"
],
"26442": [
"CVE-2005-3388"
],
"26444": [
"CVE-2005-3397"
],
"26445": [],
"26446": [
"CVE-2005-4769"
],
"26447": [
"CVE-2005-3412"
],
"26449": [],
"26453": [],
"26455": [
"CVE-2005-3512"
],
"26456": [],
"26458": [
"CVE-2005-3469"
],
"26459": [
"CVE-2005-3584"
],
"26461": [
"CVE-2005-3473"
],
"26462": [
"CVE-2005-3473"
],
"26463": [
"CVE-2005-3473"
],
"26465": [
"CVE-2005-3507"
],
"26466": [
"CVE-2005-3507"
],
"26467": [],
"26468": [
"CVE-2005-3508"
],
"26469": [
"CVE-2005-3509"
],
"26470": [
"CVE-2005-3509"
],
"26473": [
"CVE-2005-4657"
],
"26474": [
"CVE-2005-4423"
],
"26475": [
"CVE-2005-3559"
],
"26476": [
"CVE-2005-3558"
],
"26477": [
"CVE-2005-3544"
],
"26478": [
"CVE-2005-3547"
],
"26480": [
"CVE-2005-3550"
],
"26481": [
"CVE-2005-3555"
],
"26482": [
"CVE-2005-3555"
],
"26483": [
"CVE-2005-3556"
],
"26484": [
"CVE-2005-3556"
],
"26485": [
"CVE-2005-3556"
],
"26486": [
"CVE-2005-3636"
],
"26487": [
"CVE-2005-3635"
],
"26488": [
"CVE-2005-3634"
],
"26490": [],
"26496": [],
"26499": [],
"26500": [
"CVE-2005-3676"
],
"26501": [
"CVE-2005-3679"
],
"26502": [
"CVE-2005-3639"
],
"26503": [
"CVE-2005-3682"
],
"26504": [
"CVE-2005-3682"
],
"26505": [
"CVE-2005-3571"
],
"26506": [
"CVE-2005-3576"
],
"26507": [
"CVE-2005-3577"
],
"26508": [
"CVE-2005-3578"
],
"26509": [
"CVE-2005-3579"
],
"26510": [
"CVE-2005-4647"
],
"26511": [
"CVE-2005-4646"
],
"26512": [
"CVE-2005-3789"
],
"26513": [
"CVE-2005-3789"
],
"26514": [
"CVE-2005-3790"
],
"26515": [
"CVE-2005-3797"
],
"26516": [
"CVE-2005-3638"
],
"26829": [
"CVE-2005-4243"
],
"26830": [
"CVE-2005-4243"
],
"26521": [],
"27437": [
"CVE-2006-1326"
],
"26527": [],
"26528": [
"CVE-2013-1414"
],
"26530": [
"CVE-2013-2225"
],
"26532": [
"CVE-2005-3727"
],
"26533": [
"CVE-2005-3728"
],
"26534": [
"CVE-2005-3730"
],
"26535": [
"CVE-2005-3695"
],
"26537": [
"CVE-2005-3685"
],
"26538": [],
"26539": [
"CVE-2005-3742"
],
"26541": [
"CVE-2005-3743"
],
"26543": [
"CVE-2005-3746"
],
"26544": [
"CVE-2005-3769"
],
"26545": [
"CVE-2005-3748"
],
"26546": [
"CVE-2005-3770"
],
"26547": [
"CVE-2005-3770"
],
"26549": [
"CVE-2005-4160"
],
"26550": [
"CVE-2005-3893"
],
"26551": [
"CVE-2005-3893"
],
"26552": [
"CVE-2005-3894"
],
"26553": [
"CVE-2013-4950",
"CVE-2013-4949",
"CVE-2013-4948"
],
"26828": [
"CVE-2005-4243"
],
"26559": [
"CVE-2005-3902"
],
"26560": [
"CVE-2005-3849"
],
"26561": [
"CVE-2005-3855"
],
"26562": [
"CVE-2005-3914"
],
"26563": [
"CVE-2005-3914"
],
"26564": [
"CVE-2005-3914"
],
"26565": [
"CVE-2005-3833"
],
"26566": [
"CVE-2005-3834"
],
"26567": [
"CVE-2005-3916"
],
"26568": [],
"26569": [],
"26570": [],
"26571": [
"CVE-2005-3826"
],
"26572": [
"CVE-2005-3954"
],
"26573": [
"CVE-2005-3955"
],
"26574": [
"CVE-2005-3955"
],
"26576": [
"CVE-2005-3816"
],
"26580": [
"CVE-2005-3817"
],
"26581": [
"CVE-2005-3817"
],
"26582": [
"CVE-2005-3817"
],
"26583": [
"CVE-2005-3817"
],
"26584": [
"CVE-2005-3818"
],
"26585": [
"CVE-2005-3818"
],
"26586": [
"CVE-2005-3819"
],
"26587": [
"CVE-2005-3825"
],
"26588": [
"CVE-2005-3815"
],
"26589": [
"CVE-2005-3918"
],
"26590": [
"CVE-2005-3918"
],
"26591": [
"CVE-2005-4167"
],
"26592": [
"CVE-2005-4168"
],
"26593": [
"CVE-2005-4169"
],
"26594": [
"CVE-2005-4170"
],
"26595": [
"CVE-2005-3838"
],
"26596": [
"CVE-2005-3827"
],
"26597": [
"CVE-2005-3919"
],
"26598": [
"CVE-2005-3860"
],
"26599": [
"CVE-2005-3861"
],
"26600": [
"CVE-2005-3859"
],
"26602": [
"CVE-2005-3875"
],
"26603": [
"CVE-2005-3875"
],
"26604": [
"CVE-2005-3884"
],
"26605": [
"CVE-2005-3920"
],
"26606": [
"CVE-2005-3920 "
],
"26607": [
"CVE-2005-4781"
],
"26608": [
"CVE-2005-3844"
],
"26609": [
"CVE-2005-3953"
],
"26610": [
"CVE-2005-3953"
],
"26611": [
"CVE-2005-3953"
],
"26612": [],
"26613": [
"CVE-2005-3879"
],
"26614": [
"CVE-2005-3879"
],
"26615": [
"CVE-2005-3879"
],
"26616": [
"CVE-2005-3879"
],
"26617": [
"CVE-2005-3864"
],
"26618": [
"CVE-2005-3865"
],
"26619": [
"CVE-2005-3868"
],
"26621": [],
"26623": [
"CVE-2013-3729",
"CVE-2013-3728",
"CVE-2013-3727"
],
"26624": [
"CVE-2013-7376",
"CVE-2013-3515",
"CVE-2013-3514"
],
"26625": [
"CVE-2005-3870"
],
"26626": [
"CVE-2005-3872"
],
"26627": [
"CVE-2005-3872"
],
"26628": [
"CVE-2005-3873"
],
"26629": [
"CVE-2005-3874"
],
"26630": [
"CVE-2000-0751"
],
"26631": [
"CVE-2005-3877"
],
"26632": [
"CVE-2005-3877"
],
"26633": [],
"26634": [
"CVE-2005-3924"
],
"26635": [
"CVE-2005-3959"
],
"26636": [],
"26637": [
"CVE-2005-3925"
],
"26638": [
"CVE-2005-3925"
],
"26639": [
"CVE-2005-3927"
],
"26640": [
"CVE-2005-3927"
],
"26641": [
"CVE-2005-3927"
],
"26642": [
"CVE-2005-3927"
],
"26643": [
"CVE-2005-3878"
],
"26644": [],
"26645": [
"CVE-2005-3931"
],
"26646": [
"CVE-2005-3947"
],
"26647": [
"CVE-2005-3846"
],
"26649": [
"CVE-2005-3956"
],
"26650": [
"CVE-2005-3958"
],
"26651": [
"CVE-2005-3911"
],
"26652": [
"CVE-2005-3909"
],
"26653": [
"CVE-2005-3908"
],
"26654": [],
"26655": [],
"26656": [
"CVE-2005-3942"
],
"26657": [
"CVE-2005-3941"
],
"26658": [
"CVE-2005-3940"
],
"26659": [
"CVE-2005-3943"
],
"26660": [
"CVE-2005-3943"
],
"26661": [
"CVE-2005-3944"
],
"26662": [
"CVE-2005-3930"
],
"26663": [],
"26664": [],
"26667": [
"CVE-2005-3935"
],
"26668": [
"CVE-2005-3948"
],
"26669": [
"CVE-2005-3937"
],
"26670": [
"CVE-2005-3937"
],
"26671": [
"CVE-2005-3937"
],
"26672": [
"CVE-2005-3937"
],
"26673": [
"CVE-2005-3938"
],
"26674": [
"CVE-2005-3938"
],
"26675": [
"CVE-2005-3938"
],
"26676": [
"CVE-2005-3938"
],
"26677": [
"CVE-2005-3938"
],
"26678": [
"CVE-2005-3882"
],
"26679": [
"CVE-2005-3939"
],
"26680": [
"CVE-2005-3939"
],
"26681": [
"CVE-2005-3939"
],
"26682": [],
"26683": [
"CVE-2005-3932"
],
"26684": [
"CVE-2005-3933"
],
"26685": [
"CVE-2005-3986"
],
"26686": [
"CVE-2005-3986"
],
"26687": [],
"26688": [
"CVE-2005-3988"
],
"26689": [
"CVE-2005-3963"
],
"26691": [
"CVE-2005-3982"
],
"26692": [
"CVE-2005-3972"
],
"26693": [
"CVE-2005-3980"
],
"26694": [
"CVE-2005-3991"
],
"26695": [
"CVE-2005-3991"
],
"26696": [
"CVE-2005-3991"
],
"26697": [
"CVE-2005-3968"
],
"26698": [
"CVE-2005-3978"
],
"26699": [
"CVE-2005-3978"
],
"26700": [
"CVE-2005-3966"
],
"26701": [
"CVE-2005-4003"
],
"26702": [
"CVE-2005-4003"
],
"26704": [
"CVE-2005-3998"
],
"26705": [
"CVE-2005-4000"
],
"26706": [
"CVE-2005-4005"
],
"26707": [
"CVE-2005-4081"
],
"26713": [
"CVE-2005-4001"
],
"26714": [
"CVE-2005-4001"
],
"26715": [
"CVE-2005-4016"
],
"26716": [
"CVE-2005-4032"
],
"26717": [
"CVE-2005-4035"
],
"26718": [
"CVE-2005-4035"
],
"26719": [
"CVE-2005-4035"
],
"26720": [
"CVE-2005-4018"
],
"26721": [
"CVE-2005-4091"
],
"26722": [
"CVE-2005-4043"
],
"26723": [
"CVE-2005-4019"
],
"26724": [
"CVE-2005-4034"
],
"26725": [
"CVE-2005-4034"
],
"26726": [
"CVE-2005-4034"
],
"26727": [
"CVE-2005-4034"
],
"26728": [],
"26729": [
"CVE-2005-4037"
],
"26730": [
"CVE-2005-4039"
],
"26731": [
"CVE-2005-4049"
],
"26732": [
"CVE-2005-4065"
],
"26734": [],
"26735": [],
"26736": [
"CVE-2013-5633",
"CVE-2013-5632",
"CVE-2013-5631",
"CVE-2013-5630",
"CVE-2013-5628",
"CVE-2013-5627",
"CVE-2013-5625",
"CVE-2013-5624",
"CVE-2013-5623",
"CVE-2013-5622",
"CVE-2013-5621"
],
"27634": [
"CVE-2006-1783"
],
"26742": [
"CVE-2005-4166"
],
"26743": [
"CVE-2005-4047"
],
"26744": [
"CVE-2005-4063"
],
"26745": [
"CVE-2005-4060"
],
"26746": [
"CVE-2005-4064"
],
"26747": [
"CVE-2005-4064"
],
"26748": [],
"26750": [
"CVE-2005-4054"
],
"26751": [
"CVE-2005-4055"
],
"26755": [
"CVE-2005-4139"
],
"26756": [
"CVE-2005-4139"
],
"26757": [
"CVE-2005-4139"
],
"26758": [
"CVE-2005-4136"
],
"26759": [
"CVE-2005-4141"
],
"26760": [
"CVE-2005-4141"
],
"26761": [],
"26763": [
"CVE-2005-4073"
],
"26764": [
"CVE-2005-4071"
],
"26765": [
"CVE-2005-4071"
],
"26766": [
"CVE-2005-4074"
],
"26767": [
"CVE-2005-4075"
],
"26770": [
"CVE-2005-4161"
],
"26771": [
"CVE-2005-4197"
],
"26772": [
"CVE-2005-4177"
],
"26777": [
"CVE-2005-4205"
],
"26778": [
"CVE-2005-4206"
],
"26780": [
"CVE-2005-4196"
],
"26781": [
"CVE-2005-4196"
],
"26782": [
"CVE-2005-4196"
],
"26783": [
"CVE-2005-4195"
],
"26784": [
"CVE-2005-4207"
],
"26785": [
"CVE-2005-4221"
],
"26786": [
"CVE-2005-4229"
],
"26787": [
"CVE-2005-4211"
],
"26788": [
"CVE-2005-4212"
],
"26789": [
"CVE-2005-4234"
],
"26790": [
"CVE-2005-4228"
],
"26791": [
"CVE-2005-4228"
],
"26792": [
"CVE-2005-4228"
],
"26793": [
"CVE-2005-4246"
],
"26794": [
"CVE-2005-4247"
],
"26795": [
"CVE-2005-4240"
],
"26796": [
"CVE-2005-4241"
],
"26797": [
"CVE-2005-4239"
],
"26798": [
"CVE-2005-4238"
],
"26799": [
"CVE-2005-4244"
],
"26800": [
"CVE-2005-4244"
],
"26801": [
"CVE-2005-4245"
],
"27438": [
"CVE-2006-1326"
],
"26804": [],
"26806": [
"CVE-2013-4946",
"CVE-2013-4945"
],
"26807": [
"CVE-2013-4883",
"CVE-2013-4882"
],
"26808": [
"CVE-2005-4250"
],
"26809": [
"CVE-2005-4251"
],
"26810": [
"CVE-2005-4251"
],
"26812": [
"CVE-2005-4233"
],
"26813": [
"CVE-2005-4232"
],
"26814": [
"CVE-2005-4254"
],
"26815": [],
"26817": [
"CVE-2005-4260"
],
"26818": [
"CVE-2005-4262"
],
"26819": [
"CVE-2005-4263"
],
"26820": [
"CVE-2005-4256"
],
"26821": [
"CVE-2005-4259"
],
"26822": [
"CVE-2005-4259"
],
"26823": [
"CVE-2005-4259"
],
"26824": [
"CVE-2005-4255"
],
"26826": [
"CVE-2005-4198"
],
"26831": [
"CVE-2005-4243"
],
"26832": [
"CVE-2005-4243"
],
"26836": [
"CVE-2005-4317"
],
"26837": [
"CVE-2005-4319"
],
"26838": [
"CVE-2005-4288"
],
"26839": [
"CVE-2005-4415"
],
"26840": [
"CVE-2005-4416"
],
"26841": [
"CVE-2005-4287"
],
"26842": [
"CVE-2005-4306"
],
"26843": [
"CVE-2005-4306"
],
"26844": [
"CVE-2005-4311"
],
"26845": [
"CVE-2005-4299"
],
"26846": [
"CVE-2005-4298"
],
"26847": [
"CVE-2005-4289"
],
"26848": [
"CVE-2005-4290"
],
"26849": [
"CVE-2005-4291"
],
"26850": [
"CVE-2005-4314"
],
"26851": [
"CVE-2005-4293"
],
"26852": [
"CVE-2005-4285"
],
"26853": [
"CVE-2005-4302"
],
"26854": [
"CVE-2005-4303"
],
"26855": [
"CVE-2005-4330"
],
"26856": [
"CVE-2005-4331"
],
"26857": [
"CVE-2005-4329"
],
"26858": [
"CVE-2005-4333"
],
"26859": [
"CVE-2005-4333"
],
"26860": [
"CVE-2005-4333"
],
"26861": [
"CVE-2005-4307"
],
"26862": [
"CVE-2005-4307"
],
"26863": [
"CVE-2005-4307"
],
"26864": [
"CVE-2005-4328"
],
"26865": [
"CVE-2005-4327"
],
"26866": [],
"26867": [],
"26868": [],
"26870": [],
"26871": [
"CVE-2005-4432"
],
"26872": [
"CVE-2005-4516"
],
"26873": [
"CVE-2005-4370"
],
"26874": [
"CVE-2005-4371"
],
"26875": [
"CVE-2005-4374"
],
"26876": [
"CVE-2005-4374"
],
"26877": [
"CVE-2005-4375"
],
"26878": [
"CVE-2005-4381"
],
"26879": [
"CVE-2005-4385"
],
"26880": [
"CVE-2005-4365"
],
"26881": [
"CVE-2005-4365"
],
"26882": [
"CVE-2005-4364"
],
"26883": [
"CVE-2005-4399"
],
"26884": [
"CVE-2005-4400"
],
"26885": [
"CVE-2005-4780"
],
"26888": [],
"26890": [],
"26893": [],
"26894": [],
"26895": [
"CVE-2005-4361"
],
"26896": [
"CVE-2005-4390"
],
"26897": [
"CVE-2005-4527"
],
"26898": [],
"26899": [
"CVE-2005-4403"
],
"26900": [
"CVE-2005-4408"
],
"26901": [
"CVE-2005-4408"
],
"26902": [
"CVE-2005-4408"
],
"26903": [
"CVE-2005-4378"
],
"26904": [
"CVE-2005-4380"
],
"26905": [
"CVE-2005-4380"
],
"26906": [
"CVE-2005-4380"
],
"26907": [
"CVE-2005-4380"
],
"26908": [
"CVE-2005-4380"
],
"26909": [],
"26910": [],
"26911": [
"CVE-2005-4363"
],
"26912": [],
"26914": [
"CVE-2005-4510"
],
"26916": [
"CVE-2005-4563"
],
"26917": [
"CVE-2005-4454"
],
"26918": [
"CVE-2005-4573"
],
"26919": [
"CVE-2005-4435"
],
"26920": [
"CVE-2005-4419"
],
"26921": [
"CVE-2005-4462"
],
"26923": [
"CVE-2005-4460"
],
"26924": [
"CVE-2005-4476"
],
"26925": [
"CVE-2005-4477"
],
"26926": [
"CVE-2005-4482"
],
"26927": [
"CVE-2005-4483"
],
"26928": [
"CVE-2005-4484"
],
"26929": [
"CVE-2005-4484"
],
"26930": [
"CVE-2005-4485"
],
"26931": [
"CVE-2005-4485"
],
"26932": [
"CVE-2005-4485"
],
"26933": [
"CVE-2005-4485"
],
"26934": [
"CVE-2005-4485"
],
"26935": [
"CVE-2005-4485"
],
"26936": [
"CVE-2005-4485"
],
"26937": [
"CVE-2005-4488"
],
"26938": [
"CVE-2005-4489"
],
"26939": [
"CVE-2005-4489"
],
"26940": [
"CVE-2005-4490"
],
"26941": [
"CVE-2005-4490"
],
"26942": [
"CVE-2005-4490"
],
"26943": [
"CVE-2005-4490"
],
"26944": [
"CVE-2005-4490"
],
"26945": [
"CVE-2005-4490"
],
"26946": [
"CVE-2005-4490"
],
"26947": [
"CVE-2005-4491"
],
"26948": [
"CVE-2005-4491"
],
"26949": [
"CVE-2005-4491"
],
"26952": [],
"26953": [],
"26954": [],
"26955": [
"CVE-2013-5979"
],
"26956": [],
"26957": [],
"26958": [
"CVE-2013-5099"
],
"26959": [
"CVE-2005-4478"
],
"26960": [
"CVE-2005-4478"
],
"26961": [
"CVE-2005-4478"
],
"26962": [
"CVE-2005-4479"
],
"26963": [
"CVE-2005-4486"
],
"26964": [
"CVE-2005-4486"
],
"26965": [
"CVE-2005-4500"
],
"26968": [
"CVE-2005-4496"
],
"26969": [
"CVE-2005-4497"
],
"26972": [
"CVE-2005-4550"
],
"26973": [
"CVE-2005-4427"
],
"26974": [
"CVE-2005-4427"
],
"26975": [
"CVE-2005-4427"
],
"26976": [
"CVE-2005-4554"
],
"26977": [
"CVE-2005-4554"
],
"26978": [
"CVE-2005-4555"
],
"26979": [
"CVE-2005-4556"
],
"26980": [
"CVE-2005-4556"
],
"26981": [
"CVE-2005-4557"
],
"26982": [
"CVE-2005-4558"
],
"26983": [
"CVE-2005-4558"
],
"26984": [
"CVE-2005-4559"
],
"26986": [
"CVE-2005-4574"
],
"40575": [],
"26987": [
"CVE-2005-4576"
],
"26988": [
"CVE-2005-4588"
],
"26989": [
"CVE-2005-4627"
],
"26990": [],
"26991": [],
"26992": [
"CVE-2005-4596"
],
"26993": [
"CVE-2005-4598"
],
"26994": [
"CVE-2005-4637"
],
"26995": [],
"26998": [
"CVE-2006-0076"
],
"26999": [
"CVE-2006-0075"
],
"27000": [],
"27001": [],
"27002": [
"CVE-2006-0074"
],
"27003": [
"CVE-2006-0088"
],
"27004": [
"CVE-2006-0066"
],
"27633": [],
"27005": [],
"27006": [],
"27439": [
"CVE-2006-1326"
],
"27440": [
"CVE-2006-1326"
],
"27441": [
"CVE-2006-1326"
],
"27442": [
"CVE-2006-1326"
],
"27009": [],
"27011": [],
"27015": [],
"27016": [
"CVE-2006-0136"
],
"27017": [
"CVE-2006-0137"
],
"27018": [
"CVE-2006-0079"
],
"27019": [],
"27020": [],
"27021": [
"CVE-2006-0073"
],
"27022": [],
"27023": [],
"27025": [],
"27027": [],
"27028": [
"CVE-2005-4430"
],
"27029": [
"CVE-2005-3845"
],
"27030": [
"CVE-2005-4429"
],
"27033": [
"CVE-2006-0110"
],
"27034": [
"CVE-2006-0115"
],
"27035": [
"CVE-2006-0115"
],
"27036": [
"CVE-2006-0115"
],
"27037": [
"CVE-2006-0135"
],
"27038": [
"CVE-2006-0103"
],
"27039": [],
"27356": [
"CVE-2006-1121"
],
"27357": [
"CVE-2006-1073"
],
"27358": [
"CVE-2006-1071"
],
"27359": [
"CVE-2006-1070"
],
"27360": [
"CVE-2006-1216"
],
"27042": [],
"27048": [
"CVE-2006-0125"
],
"27052": [
"CVE-2006-0154"
],
"27053": [
"CVE-2006-0160"
],
"27054": [
"CVE-2006-0153"
],
"27058": [
"CVE-2006-0163"
],
"27059": [
"CVE-2006-0198"
],
"27060": [
"CVE-2006-0185"
],
"27061": [
"CVE-2006-0173"
],
"27062": [
"CVE-2006-0174"
],
"27063": [
"CVE-2006-0175"
],
"27064": [
"CVE-2006-0171"
],
"27067": [
"CVE-2006-0167"
],
"27068": [
"CVE-2006-0167"
],
"27070": [
"CVE-2006-0210"
],
"27071": [
"CVE-2006-0194"
],
"27075": [
"CVE-2006-0209"
],
"27076": [
"CVE-2013-2574"
],
"27077": [],
"27078": [
"CVE-2006-0222"
],
"27079": [
"CVE-2006-0211"
],
"27080": [],
"27081": [
"CVE-2006-0217"
],
"27083": [
"CVE-2006-0240"
],
"27084": [
"CVE-2006-0320"
],
"27085": [
"CVE-2006-0361"
],
"27086": [
"CVE-2006-0235"
],
"27087": [
"CVE-2006-0249"
],
"27088": [
"CVE-2006-0251"
],
"27091": [
"CVE-2006-0217"
],
"27092": [
"CVE-2006-0237"
],
"27093": [
"CVE-2006-0315"
],
"27097": [
"CVE-2006-0244"
],
"27098": [
"CVE-2006-0317"
],
"27099": [
"CVE-2006-0318"
],
"27100": [
"CVE-2006-0234"
],
"27102": [
"CVE-2006-0358"
],
"27103": [
"CVE-2006-0358"
],
"27104": [
"CVE-2006-0310"
],
"27105": [
"CVE-2006-0311"
],
"27106": [
"CVE-2006-0312"
],
"27107": [],
"27109": [
"CVE-2006-0366"
],
"27110": [
"CVE-2006-0349"
],
"27111": [
"CVE-2006-0350"
],
"27112": [
"CVE-2006-0345"
],
"27114": [
"CVE-2006-0324"
],
"27115": [
"CVE-2006-0341"
],
"27116": [
"CVE-2006-0413"
],
"27117": [
"CVE-2006-0372"
],
"27118": [],
"27119": [],
"27120": [
"CVE-2006-0407"
],
"27121": [
"CVE-2006-0418"
],
"27122": [
"CVE-2006-0442"
],
"27123": [
"CVE-2006-0409"
],
"27124": [
"CVE-2006-0415"
],
"27125": [
"CVE-2006-0417"
],
"27126": [
"CVE-2006-0443"
],
"27127": [
"CVE-2006-0461"
],
"27128": [],
"27129": [],
"27130": [],
"27134": [],
"27136": [
"CVE-2013-1616"
],
"27137": [
"CVE-2006-0470"
],
"27138": [
"CVE-2006-0462"
],
"27139": [
"CVE-2006-0473"
],
"27141": [],
"27142": [],
"27143": [
"CVE-2005-4334"
],
"27146": [
"CVE-2006-0480"
],
"27147": [
"CVE-2006-0479"
],
"27149": [
"CVE-2006-0524"
],
"27151": [
"CVE-2006-0510"
],
"27153": [
"CVE-2006-0509"
],
"27154": [
"CVE-2006-0502"
],
"27155": [
"CVE-2006-1974"
],
"27156": [
"CVE-2006-0491"
],
"27157": [],
"27158": [
"CVE-2006-0518"
],
"27160": [
"CVE-2006-0532"
],
"27161": [
"CVE-2006-0534"
],
"27162": [],
"27163": [
"CVE-2006-0513"
],
"27164": [
"CVE-2006-0545"
],
"27165": [
"CVE-2005-4461"
],
"27166": [],
"27167": [],
"27169": [
"CVE-2006-0624"
],
"27170": [
"CVE-2006-0651"
],
"27172": [
"CVE-2006-0625"
],
"27173": [
"CVE-2006-0650"
],
"27174": [
"CVE-2006-0669"
],
"27175": [
"CVE-2006-0942"
],
"27176": [],
"27177": [
"CVE-2013-3365",
"CVE-2013-3098"
],
"27361": [
"CVE-2006-1076"
],
"27183": [
"CVE-2006-0660"
],
"27184": [
"CVE-2006-0757"
],
"27185": [
"CVE-2006-0757"
],
"27186": [
"CVE-2006-0758"
],
"27187": [],
"27188": [],
"27189": [],
"27190": [],
"27192": [
"CVE-2006-0713"
],
"27193": [
"CVE-2006-0713"
],
"27194": [
"CVE-2006-0713"
],
"27195": [
"CVE-2006-0713"
],
"27197": [
"CVE-2006-0700"
],
"27198": [
"CVE-2006-0701"
],
"27199": [
"CVE-2006-0703"
],
"27200": [
"CVE-2006-0702"
],
"27201": [
"CVE-2006-0675"
],
"27202": [
"CVE-2006-0774"
],
"27204": [
"CVE-2006-0684"
],
"27205": [
"CVE-2006-0685"
],
"27206": [
"CVE-2005-3544"
],
"27207": [],
"27208": [
"CVE-2006-0676"
],
"27209": [
"CVE-2006-0706"
],
"27213": [
"CVE-2006-0699"
],
"27214": [
"CVE-2006-0719"
],
"27215": [
"CVE-2006-0715"
],
"27216": [
"CVE-2005-3853"
],
"27217": [
"CVE-2006-0755"
],
"27218": [
"CVE-2006-0755"
],
"27219": [
"CVE-2006-0755"
],
"27220": [
"CVE-2006-0755"
],
"27221": [
"CVE-2006-0755"
],
"27222": [
"CVE-2006-0755"
],
"27223": [
"CVE-2006-0755"
],
"27224": [
"CVE-2006-0755"
],
"27225": [
"CVE-2006-0755"
],
"27226": [
"CVE-2006-0721"
],
"27227": [
"CVE-2006-0733"
],
"27228": [
"CVE-2006-0841"
],
"27229": [
"CVE-2006-0841"
],
"27230": [
"CVE-2006-0735"
],
"27236": [],
"27237": [],
"27238": [
"CVE-2006-0791"
],
"27239": [
"CVE-2006-0775"
],
"27240": [],
"27242": [],
"27243": [
"CVE-2006-0783"
],
"27245": [
"CVE-2006-0792"
],
"27247": [
"CVE-2006-0857"
],
"27248": [
"CVE-2006-0832"
],
"27249": [
"CVE-2006-0805"
],
"27250": [
"CVE-2006-0691"
],
"27251": [
"CVE-2006-0673"
],
"27252": [
"CVE-2006-0885"
],
"27254": [
"CVE-2006-0800"
],
"27255": [
"CVE-2006-0801"
],
"27256": [
"CVE-2006-0875"
],
"27259": [
"CVE-2006-0880"
],
"27260": [
"CVE-2006-0879"
],
"27261": [
"CVE-2006-0882"
],
"27262": [
"CVE-2006-0881"
],
"27263": [
"CVE-2006-1033"
],
"27264": [
"CVE-2006-1033"
],
"27265": [
"CVE-2006-1033"
],
"27266": [
"CVE-2006-1033"
],
"27267": [
"CVE-2006-1033"
],
"27268": [
"CVE-2006-1033"
],
"27269": [
"CVE-2006-1033"
],
"27494": [
"CVE-2006-1425"
],
"27495": [
"CVE-2006-1428"
],
"27496": [
"CVE-2006-1428"
],
"27272": [
"CVE-2013-4898"
],
"27274": [
"CVE-2013-5318"
],
"27275": [],
"27276": [],
"27279": [
"CVE-2013-3215",
"CVE-2013-3214",
"CVE-2013-3213",
"CVE-2013-3212"
],
"27281": [],
"27283": [
"CVE-2013-7389"
],
"27284": [
"CVE-2013-4859"
],
"27286": [
"CVE-2013-4865",
"CVE-2013-4864",
"CVE-2013-4863",
"CVE-2013-4862",
"CVE-2013-4861"
],
"27287": [
"CVE-2013-4789"
],
"27288": [
"CVE-2013-5006"
],
"27289": [
"CVE-2013-2581",
"CVE-2013-2580",
"CVE-2013-2579",
"CVE-2013-2578"
],
"27290": [],
"27291": [
"CVE-2013-3803"
],
"27298": [
"CVE-2006-0835"
],
"27299": [
"CVE-2006-0894"
],
"27300": [
"CVE-2006-0894"
],
"27301": [
"CVE-2006-0894"
],
"27302": [
"CVE-2006-0894"
],
"27303": [
"CVE-2006-0920"
],
"27304": [
"CVE-2006-0922"
],
"27305": [
"CVE-2006-0933"
],
"27306": [
"CVE-2006-0927"
],
"27307": [
"CVE-2006-0927"
],
"27308": [
"CVE-2006-0923"
],
"27309": [
"CVE-2006-0923"
],
"27310": [
"CVE-2006-0974"
],
"27311": [
"CVE-2006-0976"
],
"27312": [
"CVE-2006-0936"
],
"27313": [
"CVE-2006-0939"
],
"27314": [
"CVE-2006-0939"
],
"27315": [
"CVE-2013-5317",
"CVE-2013-5316"
],
"27318": [],
"27320": [
"CVE-2006-0946"
],
"27321": [
"CVE-2006-0972"
],
"27322": [
"CVE-2006-1034"
],
"27323": [
"CVE-2006-1034"
],
"27324": [
"CVE-2006-0944"
],
"27327": [
"CVE-2006-0906"
],
"27328": [
"CVE-2006-0906"
],
"27330": [
"CVE-2006-1007"
],
"27331": [
"CVE-2006-1008"
],
"27332": [
"CVE-2006-1008"
],
"27333": [
"CVE-2006-0983"
],
"27336": [
"CVE-2006-0984"
],
"27337": [
"CVE-2006-1045"
],
"27338": [
"CVE-2006-1021"
],
"27339": [
"CVE-2006-1022"
],
"27340": [
"CVE-2006-1013"
],
"27341": [
"CVE-2006-1018"
],
"27342": [
"CVE-2006-1081"
],
"27343": [
"CVE-2006-1040"
],
"27344": [
"CVE-2006-1098"
],
"27345": [
"CVE-2006-1099"
],
"27346": [
"CVE-2006-1132"
],
"27347": [
"CVE-2006-1133"
],
"27348": [
"CVE-2006-1133"
],
"27354": [
"CVE-2006-0877"
],
"27355": [
"CVE-2006-1215"
],
"27362": [
"CVE-2006-1131"
],
"27363": [
"CVE-2006-3053"
],
"27364": [
"CVE-2006-1080"
],
"27557": [],
"27367": [
"CVE-2006-1199"
],
"27368": [
"CVE-2006-1113"
],
"27369": [
"CVE-2006-1114"
],
"27370": [
"CVE-2006-1114"
],
"27371": [
"CVE-2006-1144"
],
"27372": [
"CVE-2006-1144"
],
"27373": [
"CVE-2006-1202"
],
"27374": [
"CVE-2006-1135"
],
"27375": [
"CVE-2006-1135"
],
"27376": [],
"27379": [
"CVE-2006-1157"
],
"27380": [
"CVE-2006-1205"
],
"27381": [
"CVE-2006-1205"
],
"27382": [
"CVE-2006-1205"
],
"27383": [
"CVE-2006-1205"
],
"27384": [
"CVE-2006-1205"
],
"27385": [
"CVE-2006-1205"
],
"27386": [
"CVE-2006-1205"
],
"27387": [
"CVE-2006-1205"
],
"27388": [
"CVE-2006-1205"
],
"27389": [
"CVE-2006-1205"
],
"27390": [
"CVE-2006-1120"
],
"27391": [
"CVE-2006-1120"
],
"27392": [
"CVE-2006-1120"
],
"27393": [
"CVE-2006-1120"
],
"27394": [
"CVE-2006-1120"
],
"27395": [
"CVE-2006-1120"
],
"27396": [],
"27398": [],
"27399": [],
"27402": [
"CVE-2013-4977",
"CVE-2013-4976",
"CVE-2013-4975"
],
"27403": [],
"27405": [],
"27406": [
"CVE-2013-4884"
],
"27408": [],
"27409": [
"CVE-2006-1196"
],
"27410": [
"CVE-2006-1196"
],
"27411": [
"CVE-2006-1196"
],
"27412": [
"CVE-2006-1196"
],
"27413": [
"CVE-2006-1212"
],
"27414": [
"CVE-2006-1230"
],
"27415": [
"CVE-2006-1233"
],
"27416": [
"CVE-2006-1233"
],
"27417": [
"CVE-2006-1233"
],
"27419": [],
"27422": [],
"27423": [
"CVE-2006-1234"
],
"27424": [
"CVE-2006-1232"
],
"27427": [],
"27430": [
"CVE-2013-5121",
"CVE-2013-5120"
],
"27431": [
"CVE-2013-4880",
"CVE-2013-4879",
"CVE-2013-4881"
],
"27991": [],
"27990": [
"CVE-2006-2973"
],
"27443": [
"CVE-2006-1336"
],
"27444": [
"CVE-2006-1324"
],
"27445": [
"CVE-2005-4500"
],
"27446": [
"CVE-2006-1349"
],
"27447": [
"CVE-2006-1349"
],
"27448": [
"CVE-2006-1330"
],
"27449": [
"CVE-2006-1330"
],
"27450": [
"CVE-2006-1323"
],
"27451": [
"CVE-2006-1344"
],
"27454": [
"CVE-2006-1367"
],
"27455": [
"CVE-2006-1372"
],
"27456": [
"CVE-2006-1372"
],
"27457": [
"CVE-2006-1372"
],
"27458": [
"CVE-2006-1377"
],
"27459": [
"CVE-2006-1377"
],
"27462": [
"CVE-2006-1374"
],
"27463": [
"CVE-2006-1384"
],
"27464": [
"CVE-2006-1395"
],
"27465": [
"CVE-2006-1496"
],
"27466": [
"CVE-2006-1497"
],
"27467": [
"CVE-2006-1482"
],
"27468": [
"CVE-2006-1419"
],
"27469": [
"CVE-2006-1413"
],
"27470": [
"CVE-2006-1413"
],
"27471": [
"CVE-2006-1413"
],
"27472": [
"CVE-2006-1413"
],
"27473": [
"CVE-2006-1413"
],
"27475": [
"CVE-2006-1420"
],
"27477": [
"CVE-2006-1334"
],
"27478": [
"CVE-2006-1334"
],
"27479": [
"CVE-2006-1414"
],
"27480": [
"CVE-2006-1417"
],
"27481": [
"CVE-2006-1417"
],
"27482": [
"CVE-2006-1418"
],
"27483": [
"CVE-2006-1426"
],
"27484": [
"CVE-2006-1426"
],
"27485": [
"CVE-2006-1238"
],
"27486": [
"CVE-2006-1407"
],
"27487": [
"CVE-2006-1407"
],
"27488": [
"CVE-2006-1404"
],
"27489": [
"CVE-2006-1431"
],
"27490": [
"CVE-2006-1429"
],
"27491": [
"CVE-2006-1489"
],
"27492": [
"CVE-2006-1487"
],
"27493": [
"CVE-2006-1486"
],
"27497": [
"CVE-2006-1430"
],
"27498": [
"CVE-2006-1430"
],
"27499": [
"CVE-2006-1430"
],
"27500": [
"CVE-2006-1504"
],
"27501": [
"CVE-2006-1504"
],
"27502": [
"CVE-2006-1508"
],
"27503": [
"CVE-2006-1508"
],
"27504": [
"CVE-2006-1508"
],
"27505": [
"CVE-2006-1508"
],
"27506": [
"CVE-2006-1508"
],
"27507": [
"CVE-2006-1556"
],
"27509": [
"CVE-2006-1501"
],
"27510": [
"CVE-2006-1536"
],
"27511": [
"CVE-2006-1536"
],
"27512": [
"CVE-2006-1535"
],
"27513": [
"CVE-2006-1543"
],
"27514": [],
"27515": [],
"27518": [],
"27519": [
"CVE-2013-5312",
"CVE-2013-5311",
"CVE-2008-4157",
"CVE-2008-2335"
],
"27729": [
"CVE-2006-2001"
],
"27521": [],
"27522": [
"CVE-2013-7368",
"CVE-2013-7349",
"CVE-2013-5640"
],
"27533": [
"CVE-2006-1557"
],
"27728": [
"CVE-2005-3302"
],
"27525": [],
"27531": [
"CVE-2013-4241",
"CVE-2013-4240"
],
"27532": [
"CVE-2010-2694"
],
"27534": [
"CVE-2006-1573"
],
"27535": [
"CVE-2006-1572"
],
"27536": [
"CVE-2006-1567"
],
"27537": [
"CVE-2006-1584"
],
"27538": [
"CVE-2006-1569"
],
"27539": [
"CVE-2006-1569"
],
"27540": [
"CVE-2006-1568"
],
"27544": [
"CVE-2006-1659"
],
"27545": [
"CVE-2006-1659"
],
"27546": [
"CVE-2006-1659"
],
"27548": [
"CVE-2006-1595"
],
"27549": [
"CVE-2006-1595"
],
"27550": [
"CVE-2006-1581"
],
"27551": [
"CVE-2006-1582"
],
"27552": [
"CVE-2006-1586"
],
"27558": [
"CVE-2006-1580"
],
"27559": [
"CVE-2006-1580"
],
"27560": [
"CVE-2006-1613"
],
"27561": [
"CVE-2006-1427"
],
"27562": [
"CVE-2006-1427"
],
"27563": [
"CVE-2006-1634"
],
"27567": [],
"27570": [],
"27571": [
"CVE-2006-1661"
],
"27572": [
"CVE-2006-1661"
],
"27573": [
"CVE-2006-1661"
],
"27574": [
"CVE-2006-1590"
],
"27575": [
"CVE-2006-1755"
],
"27576": [
"CVE-2006-1676"
],
"27578": [
"CVE-2006-1679"
],
"27579": [
"CVE-2006-1745"
],
"27580": [
"CVE-2006-1673"
],
"27582": [
"CVE-2006-1699"
],
"27583": [
"CVE-2006-1682"
],
"27584": [
"CVE-2006-1765"
],
"27585": [
"CVE-2006-1713"
],
"27586": [
"CVE-2006-1714"
],
"27587": [
"CVE-2006-1675"
],
"27588": [
"CVE-2006-1675"
],
"27589": [
"CVE-2006-1702"
],
"27590": [
"CVE-2006-1685"
],
"27591": [
"CVE-2006-1701"
],
"27592": [
"CVE-2006-1704"
],
"27593": [
"CVE-2006-1758"
],
"27594": [
"CVE-2006-1697"
],
"27597": [
"CVE-2014-1222"
],
"27598": [],
"27600": [],
"27601": [],
"27602": [
"CVE-2013-5117"
],
"27603": [],
"27605": [],
"27612": [
"CVE-2006-1706"
],
"27613": [
"CVE-2006-1706"
],
"27614": [
"CVE-2006-1706"
],
"27615": [
"CVE-2006-1770"
],
"27616": [
"CVE-2006-1760"
],
"27617": [
"CVE-2006-1760"
],
"27618": [
"CVE-2006-1760"
],
"27619": [
"CVE-2006-1760"
],
"27620": [
"CVE-2006-0015"
],
"27621": [
"CVE-2006-1718"
],
"27622": [],
"27623": [
"CVE-2006-1759"
],
"27624": [
"CVE-2006-1773"
],
"27625": [
"CVE-2006-1767"
],
"27626": [
"CVE-2006-1768"
],
"27628": [
"CVE-2006-1754"
],
"27629": [
"CVE-2006-1683"
],
"27631": [
"CVE-2006-1709"
],
"27632": [
"CVE-2006-1803"
],
"27638": [
"CVE-2006-1800"
],
"27642": [
"CVE-2006-1893"
],
"27643": [
"CVE-2006-1839"
],
"27644": [
"CVE-2006-1801"
],
"27645": [
"CVE-2006-1805"
],
"27646": [
"CVE-2006-1808"
],
"27647": [
"CVE-2006-1918"
],
"27648": [
"CVE-2006-1820"
],
"27649": [
"CVE-2006-1821"
],
"27650": [
"CVE-2006-1822"
],
"27651": [
"CVE-2006-1802"
],
"27652": [],
"27970": [
"CVE-2006-2871"
],
"27655": [],
"27656": [],
"27658": [],
"27659": [
"CVE-2006-1878"
],
"27660": [
"CVE-2006-1781"
],
"27661": [],
"27662": [],
"27663": [
"CVE-2006-1916"
],
"27664": [
"CVE-2006-1913"
],
"27665": [
"CVE-2006-1835"
],
"27666": [],
"27667": [
"CVE-2006-1912"
],
"27669": [
"CVE-2006-1909"
],
"27672": [],
"27673": [
"CVE-2006-1825"
],
"27674": [
"CVE-2006-1954"
],
"27675": [
"CVE-2006-1906"
],
"27676": [
"CVE-2006-1925"
],
"27677": [
"CVE-2006-1852"
],
"27678": [
"CVE-2006-1853"
],
"27679": [
"CVE-2006-1946"
],
"27680": [
"CVE-2006-1946"
],
"27681": [
"CVE-2006-1946"
],
"27682": [
"CVE-2006-1944"
],
"27683": [
"CVE-2006-1944"
],
"27684": [
"CVE-2006-1960"
],
"27685": [
"CVE-2006-1943"
],
"27686": [
"CVE-2006-1943"
],
"27687": [
"CVE-2006-1926"
],
"27688": [
"CVE-2006-1971"
],
"27689": [
"CVE-2006-1950"
],
"27690": [
"CVE-2006-1849"
],
"27691": [
"CVE-2006-1850"
],
"27692": [
"CVE-2006-1947"
],
"27693": [
"CVE-2006-1922"
],
"27694": [
"CVE-2006-1945"
],
"27695": [
"CVE-2006-1965"
],
"27696": [
"CVE-2006-1965"
],
"27697": [
"CVE-2006-1965"
],
"28055": [],
"28057": [],
"28058": [
"CVE-2006-3158"
],
"28061": [
"CVE-2006-3109"
],
"28062": [
"CVE-2006-3109"
],
"28700": [
"CVE-2006-5108"
],
"28053": [
"CVE-2013-5630",
"CVE-2013-5627",
"CVE-2013-5625",
"CVE-2013-5624",
"CVE-2013-5622",
"CVE-2013-5621"
],
"28054": [
"CVE-2013-5673",
"CVE-2013-5672"
],
"27707": [
"CVE-2006-1929"
],
"27709": [],
"27710": [
"CVE-2006-1980"
],
"27975": [
"CVE-2006-2877"
],
"27976": [
"CVE-2006-2877"
],
"27977": [
"CVE-2006-2883"
],
"27978": [
"CVE-2006-2884"
],
"28694": [
"CVE-2006-5104"
],
"27711": [
"CVE-2006-2037"
],
"27712": [],
"27713": [
"CVE-2006-1979"
],
"27717": [
"CVE-2006-2016"
],
"27718": [
"CVE-2006-2016"
],
"27719": [
"CVE-2006-2016"
],
"33404": [
"CVE-2009-4382"
],
"27721": [
"CVE-2006-2016"
],
"27722": [
"CVE-2006-2016"
],
"27724": [
"CVE-2006-1995"
],
"27725": [
"CVE-2006-2067"
],
"27726": [
"CVE-2006-2028"
],
"27731": [
"CVE-2006-2040"
],
"27732": [
"CVE-2006-2040"
],
"27733": [
"CVE-2006-2040"
],
"27734": [
"CVE-2006-2051"
],
"27735": [
"CVE-2006-2048"
],
"27736": [
"CVE-2006-2061"
],
"27737": [
"CVE-2006-2052"
],
"27738": [
"CVE-2006-2079"
],
"27739": [
"CVE-2006-2052"
],
"27740": [],
"27741": [],
"27742": [
"CVE-2006-2070"
],
"27743": [
"CVE-2006-2089"
],
"27750": [],
"27751": [],
"27753": [
"CVE-2013-3586",
"CVE-2013-3585"
],
"27755": [
"CVE-2013-0632"
],
"27756": [],
"27757": [
"CVE-2006-2132"
],
"27761": [
"CVE-2006-2138"
],
"27763": [
"CVE-2006-2121"
],
"27767": [
"CVE-2006-2119"
],
"27768": [
"CVE-2006-2122"
],
"27770": [
"CVE-2006-2127"
],
"27771": [
"CVE-2008-4423",
"CVE-2008-3918"
],
"27855": [
"CVE-2006-2365"
],
"27857": [
"CVE-2006-2360"
],
"27773": [],
"27774": [
"CVE-2013-4775"
],
"27776": [
"CVE-2013-2113"
],
"27777": [
"CVE-2013-4900"
],
"27779": [],
"27780": [
"CVE-2006-2214"
],
"27781": [
"CVE-2006-2214"
],
"27782": [
"CVE-2006-2143"
],
"27783": [
"CVE-2006-2228"
],
"27784": [
"CVE-2006-2116"
],
"27785": [
"CVE-2006-2144"
],
"27786": [],
"27787": [
"CVE-2006-2126"
],
"27788": [
"CVE-2006-2140"
],
"27789": [
"CVE-2006-2140"
],
"27792": [
"CVE-2006-2124"
],
"27793": [
"CVE-2006-2141"
],
"27794": [
"CVE-2006-2109"
],
"27795": [
"CVE-2006-2187"
],
"27796": [
"CVE-2006-2187"
],
"27797": [],
"27798": [
"CVE-2006-2177"
],
"27799": [
"CVE-2006-2174"
],
"27800": [
"CVE-2006-2163"
],
"27803": [
"CVE-2006-2211"
],
"27804": [
"CVE-2006-2210"
],
"27807": [
"CVE-2006-2241"
],
"27808": [
"CVE-2006-2209"
],
"27809": [
"CVE-2006-2208"
],
"27810": [
"CVE-2006-2181"
],
"27811": [
"CVE-2006-2181"
],
"27812": [
"CVE-2006-2176"
],
"27813": [
"CVE-2006-2179"
],
"27814": [
"CVE-2006-2179"
],
"27815": [
"CVE-2006-2178"
],
"27816": [
"CVE-2006-2178"
],
"27817": [
"CVE-2006-2178"
],
"27818": [
"CVE-2006-2217"
],
"27819": [
"CVE-2006-2249"
],
"27821": [
"CVE-2006-2252"
],
"27822": [
"CVE-2006-2269"
],
"27823": [
"CVE-2006-2280"
],
"27824": [
"CVE-2006-2262"
],
"27825": [
"CVE-2006-2264"
],
"27826": [
"CVE-2006-2264"
],
"27827": [
"CVE-2006-2264"
],
"27828": [
"CVE-2006-2265"
],
"27829": [],
"27831": [
"CVE-2006-2255"
],
"27832": [
"CVE-2006-2255"
],
"27833": [
"CVE-2006-2255"
],
"27834": [
"CVE-2006-2255"
],
"27835": [
"CVE-2006-2255"
],
"27836": [
"CVE-2006-2255"
],
"27837": [
"CVE-2006-2339"
],
"27838": [
"CVE-2006-2295"
],
"27839": [
"CVE-2006-2295"
],
"27840": [
"CVE-2006-2294"
],
"27841": [
"CVE-2006-2294"
],
"27842": [
"CVE-2006-2293"
],
"27843": [
"CVE-2006-2336"
],
"27844": [
"CVE-2006-2306"
],
"27845": [
"CVE-2006-2315"
],
"27846": [
"CVE-2006-2300"
],
"27848": [
"CVE-2006-2300"
],
"27849": [
"CVE-2006-2296"
],
"27853": [
"CVE-2006-2046"
],
"27858": [
"CVE-2006-2359"
],
"27859": [
"CVE-2006-2390"
],
"27863": [
"CVE-2006-4450"
],
"27864": [
"CVE-2006-2397"
],
"27865": [
"CVE-2006-2397"
],
"27866": [
"CVE-2006-2397"
],
"27867": [
"CVE-2006-2398"
],
"27868": [
"CVE-2006-2395"
],
"27869": [
"CVE-2006-7005"
],
"27870": [
"CVE-2006-7004"
],
"27871": [],
"27872": [],
"27876": [],
"27878": [
"CVE-2013-3314"
],
"27879": [],
"27880": [
"CVE-2006-2404"
],
"27881": [
"CVE-2006-2396"
],
"27883": [],
"27884": [
"CVE-2006-2423"
],
"27885": [
"CVE-2006-2425"
],
"27886": [],
"27888": [
"CVE-2006-2437"
],
"27889": [
"CVE-2006-2491"
],
"27890": [
"CVE-2006-2473"
],
"27895": [
"CVE-2006-2474"
],
"27896": [
"CVE-2006-2497"
],
"27897": [
"CVE-2006-2497"
],
"27898": [
"CVE-2006-2499"
],
"27899": [
"CVE-2006-2552"
],
"27900": [
"CVE-2006-2608"
],
"27904": [],
"27905": [],
"27907": [],
"27908": [],
"27909": [
"CVE-2006-7042"
],
"27910": [],
"27911": [],
"27912": [],
"27913": [
"CVE-2006-2732"
],
"27916": [
"CVE-2006-2728"
],
"27917": [
"CVE-2006-2635"
],
"27918": [
"CVE-2006-2648"
],
"27919": [
"CVE-2006-2699"
],
"27920": [
"CVE-2006-2689"
],
"27921": [
"CVE-2006-2689"
],
"27922": [
"CVE-2006-2689"
],
"27924": [],
"27926": [
"CVE-2006-2747"
],
"27927": [],
"27928": [],
"27929": [
"CVE-2006-2805"
],
"27932": [
"CVE-2006-2771"
],
"27933": [
"CVE-2006-2817"
],
"27934": [
"CVE-2006-2853"
],
"27994": [
"CVE-2006-3009"
],
"27995": [
"CVE-2006-3009"
],
"27996": [
"CVE-2006-3009"
],
"27997": [
"CVE-2006-3009"
],
"28394": [
"CVE-2006-4240"
],
"27945": [
"CVE-2006-2873"
],
"27946": [],
"27947": [],
"27948": [
"CVE-2006-2842"
],
"27949": [
"CVE-2006-2811"
],
"27950": [
"CVE-2006-2811"
],
"27951": [
"CVE-2006-2811"
],
"27952": [
"CVE-2006-2811"
],
"27953": [
"CVE-2006-2811"
],
"27954": [
"CVE-2006-2811"
],
"27955": [
"CVE-2006-2811"
],
"27956": [
"CVE-2006-2811"
],
"27958": [
"CVE-2006-2821"
],
"27959": [
"CVE-2006-2803"
],
"27960": [
"CVE-2006-2858"
],
"27961": [
"CVE-2006-2865"
],
"27962": [
"CVE-2006-2854"
],
"27963": [
"CVE-2006-2855"
],
"27964": [
"CVE-2006-2867"
],
"27979": [
"CVE-2006-2887"
],
"27980": [],
"27982": [
"CVE-2006-2892"
],
"27985": [
"CVE-2006-2680"
],
"27988": [
"CVE-2006-2922"
],
"27989": [
"CVE-2006-2922"
],
"27998": [
"CVE-2006-3009"
],
"27999": [
"CVE-2006-2986"
],
"28000": [
"CVE-2006-2986"
],
"28002": [
"CVE-2006-2955"
],
"28003": [
"CVE-2006-2955"
],
"28004": [
"CVE-2006-2955"
],
"28006": [],
"28008": [],
"28009": [
"CVE-2006-3061"
],
"28010": [
"CVE-2006-3061"
],
"28011": [
"CVE-2006-3006"
],
"28012": [],
"28013": [
"CVE-2006-3051"
],
"28014": [
"CVE-2006-3050"
],
"28015": [],
"28016": [
"CVE-2006-3069"
],
"28017": [
"CVE-2006-3052"
],
"28018": [],
"28019": [],
"28020": [
"CVE-2006-3036"
],
"28021": [
"CVE-2006-3036"
],
"28022": [],
"28023": [],
"28024": [],
"28025": [
"CVE-2006-3315"
],
"28027": [
"CVE-2006-3042"
],
"28028": [],
"28060": [],
"28059": [
"CVE-2006-3161"
],
"28031": [
"CVE-2006-3189"
],
"28032": [
"CVE-2006-3191"
],
"28033": [
"CVE-2006-3142"
],
"28034": [],
"28035": [
"CVE-2006-3175"
],
"28036": [
"CVE-2006-3175"
],
"28037": [
"CVE-2006-3175"
],
"28038": [],
"28039": [
"CVE-2006-7052"
],
"28040": [
"CVE-2006-7052"
],
"28041": [
"CVE-2006-7052"
],
"28042": [
"CVE-2006-7052"
],
"28043": [
"CVE-2006-7052"
],
"28045": [
"CVE-2006-7052"
],
"28063": [
"CVE-2006-3259"
],
"28064": [],
"28066": [
"CVE-2006-3194"
],
"28067": [
"CVE-2006-3195"
],
"28068": [
"CVE-2006-3366"
],
"28069": [
"CVE-2006-3366"
],
"28070": [
"CVE-2006-3366"
],
"28071": [
"CVE-2006-3366"
],
"28072": [
"CVE-2006-3366"
],
"28073": [
"CVE-2006-3366"
],
"28074": [
"CVE-2006-3366"
],
"28075": [
"CVE-2006-6995"
],
"28076": [
"CVE-2006-3253"
],
"28078": [
"CVE-2006-3259"
],
"28086": [
"CVE-2006-3143"
],
"28088": [
"CVE-2005-4011"
],
"28089": [
"CVE-2006-3254"
],
"28090": [
"CVE-2006-3256"
],
"28091": [
"CVE-2006-3255"
],
"28092": [],
"28093": [
"CVE-2006-3271"
],
"28094": [
"CVE-2006-3271"
],
"28095": [
"CVE-2006-3271"
],
"28096": [
"CVE-2006-3271"
],
"28097": [],
"28098": [
"CVE-2006-6958"
],
"28101": [],
"28102": [
"CVE-2006-3563"
],
"28104": [],
"28105": [],
"28106": [],
"28107": [
"CVE-2006-3337"
],
"28108": [],
"28109": [
"CVE-2006-3299"
],
"28110": [
"CVE-2006-3245"
],
"28111": [
"CVE-2006-3295"
],
"28112": [
"CVE-2006-3296"
],
"28113": [],
"28114": [
"CVE-2006-3343"
],
"28115": [
"CVE-2006-3323"
],
"28116": [],
"28117": [
"CVE-2006-3323"
],
"28119": [
"CVE-2006-3474"
],
"28120": [
"CVE-2006-3474"
],
"28121": [
"CVE-2006-3474"
],
"28122": [
"CVE-2006-3474"
],
"28124": [],
"28125": [
"CVE-2006-3329"
],
"28126": [],
"28129": [],
"28131": [],
"28132": [
"CVE-2006-3358"
],
"28133": [
"CVE-2006-3358"
],
"28134": [
"CVE-2006-3359"
],
"28136": [],
"28137": [
"CVE-2006-3607"
],
"28138": [
"CVE-2006-3607"
],
"28139": [
"CVE-2006-3607"
],
"28140": [
"CVE-2006-3607"
],
"28141": [
"CVE-2006-3395"
],
"28142": [
"CVE-2006-3763"
],
"28143": [
"CVE-2006-3381"
],
"28146": [
"CVE-2006-3385"
],
"28147": [
"CVE-2006-3562"
],
"28148": [
"CVE-2006-3562"
],
"28149": [
"CVE-2006-3562"
],
"28150": [
"CVE-2006-3475"
],
"28151": [
"CVE-2006-3475"
],
"28152": [
"CVE-2006-3475"
],
"28153": [
"CVE-2006-3475"
],
"28154": [
"CVE-2006-3475"
],
"28155": [
"CVE-2006-3475"
],
"28156": [
"CVE-2006-3475"
],
"28157": [
"CVE-2006-3402"
],
"28158": [
"CVE-2006-3405"
],
"28159": [
"CVE-2006-3363"
],
"28161": [
"CVE-2006-3476"
],
"28162": [
"CVE-2006-3374"
],
"28163": [],
"28166": [
"CVE-2006-3577"
],
"28167": [
"CVE-2006-3543"
],
"28168": [],
"28171": [],
"28273": [
"CVE-2006-3990"
],
"28174": [
"CVE-2013-4341"
],
"28175": [
"CVE-2013-4984",
"CVE-2013-4983"
],
"28176": [
"CVE-2006-3484"
],
"28177": [
"CVE-2006-3484"
],
"28178": [
"CVE-2006-3484"
],
"28179": [
"CVE-2006-3484"
],
"28180": [
"CVE-2006-3484"
],
"28184": [],
"28185": [],
"28190": [
"CVE-2006-3556"
],
"28191": [
"CVE-2013-5689",
"CVE-2013-5688"
],
"28192": [
"CVE-2006-3662"
],
"28193": [
"CVE-2006-3518"
],
"28195": [
"CVE-2006-3517"
],
"28199": [],
"28200": [
"CVE-2006-3602"
],
"28201": [
"CVE-2006-3560"
],
"28203": [],
"28204": [
"CVE-2006-2835"
],
"28205": [
"CVE-2006-3603"
],
"28206": [
"CVE-2006-3568"
],
"28208": [
"CVE-2006-3604"
],
"28211": [
"CVE-2006-3616"
],
"28212": [
"CVE-2006-3616"
],
"28214": [
"CVE-2006-3680"
],
"28215": [],
"28216": [
"CVE-2006-3608"
],
"28217": [],
"28219": [
"CVE-2006-3621"
],
"28223": [
"CVE-2006-3689"
],
"28229": [],
"28231": [
"CVE-2006-3692"
],
"28233": [
"CVE-2006-3843"
],
"28236": [],
"28238": [
"CVE-2013-3179"
],
"28239": [
"CVE-2013-5730"
],
"28243": [],
"28247": [
"CVE-2006-3777"
],
"28248": [
"CVE-2006-3776"
],
"28249": [
"CVE-2006-3822"
],
"28250": [
"CVE-2006-3823"
],
"28251": [
"CVE-2006-3955"
],
"28253": [
"CVE-2003-1179"
],
"28255": [
"CVE-2006-3836"
],
"28260": [
"CVE-2006-3850"
],
"28261": [],
"28262": [
"CVE-2006-3886"
],
"28264": [],
"28267": [
"CVE-2006-3884"
],
"28268": [
"CVE-2006-3883"
],
"28269": [
"CVE-2006-3883"
],
"28270": [
"CVE-2006-3883"
],
"28272": [
"CVE-2010-4513"
],
"28274": [
"CVE-2006-3927"
],
"28275": [
"CVE-2006-3926"
],
"28276": [
"CVE-2006-3926"
],
"28278": [],
"28279": [],
"28280": [
"CVE-2006-3909"
],
"28281": [
"CVE-2006-3940"
],
"28282": [
"CVE-2006-3940"
],
"28283": [
"CVE-2006-3929"
],
"28289": [
"CVE-2006-3957"
],
"28291": [],
"28292": [
"CVE-2006-7072"
],
"28294": [
"CVE-2006-3948"
],
"28295": [
"CVE-2006-4992"
],
"28296": [
"CVE-2006-4992"
],
"28297": [
"CVE-2006-4992"
],
"28302": [],
"28303": [
"CVE-2006-3959"
],
"28304": [
"CVE-2006-3960"
],
"28305": [
"CVE-2006-3972"
],
"28306": [
"CVE-2006-3963"
],
"28307": [
"CVE-2006-3963"
],
"28308": [
"CVE-2006-3964"
],
"28309": [],
"28310": [
"CVE-2006-3967"
],
"28311": [
"CVE-2006-4040"
],
"28315": [],
"28316": [],
"28317": [
"CVE-2006-3997"
],
"28318": [
"CVE-2006-3982"
],
"28319": [
"CVE-2006-4008"
],
"28320": [
"CVE-2006-4007"
],
"28321": [
"CVE-2006-4000"
],
"28322": [],
"28323": [],
"28324": [
"CVE-2006-4308"
],
"28326": [
"CVE-2006-4009"
],
"28327": [
"CVE-2006-4010"
],
"28329": [],
"28330": [],
"28339": [],
"28340": [
"CVE-2006-4068"
],
"28342": [
"CVE-2006-4273"
],
"28509": [
"CVE-2006-4751"
],
"28347": [
"CVE-2006-4025"
],
"28349": [],
"28350": [
"CVE-2006-1747"
],
"28351": [
"CVE-2006-1747"
],
"28352": [
"CVE-2006-1747"
],
"28353": [
"CVE-2006-1747"
],
"28354": [
"CVE-2006-1747"
],
"28355": [
"CVE-2006-1747"
],
"28356": [
"CVE-2006-1747"
],
"28359": [
"CVE-2006-4061"
],
"28362": [
"CVE-2006-4122"
],
"28363": [],
"28364": [
"CVE-2006-4161"
],
"28366": [],
"28370": [
"CVE-2006-4156"
],
"28371": [
"CVE-2006-4157"
],
"28372": [],
"28377": [
"CVE-2013-5962"
],
"28378": [
"CVE-2006-4163"
],
"28379": [],
"28382": [
"CVE-2006-4208"
],
"28385": [],
"28388": [
"CVE-2006-4190"
],
"28390": [
"CVE-2006-4230"
],
"28392": [
"CVE-2006-4215"
],
"28393": [],
"28396": [
"CVE-2006-4241"
],
"28399": [],
"40378": [
"CVE-2016-5740"
],
"28402": [],
"28403": [],
"28404": [],
"28406": [
"CVE-2006-4279"
],
"28409": [
"CVE-2013-5091"
],
"28410": [],
"28411": [],
"28412": [
"CVE-2006-4358"
],
"28413": [
"CVE-2006-4293"
],
"28414": [
"CVE-2006-4293"
],
"28415": [
"CVE-2006-4293"
],
"28416": [
"CVE-2006-4322"
],
"28417": [
"CVE-2006-4349"
],
"28418": [
"CVE-2006-4609"
],
"28419": [
"CVE-2006-4357"
],
"28422": [
"CVE-2006-4362"
],
"28423": [
"CVE-2006-4366"
],
"28426": [],
"28428": [
"CVE-2006-4421"
],
"28429": [
"CVE-2006-4449"
],
"28430": [
"CVE-2006-4428"
],
"28431": [
"CVE-2006-4422"
],
"28432": [
"CVE-2006-4423"
],
"28433": [
"CVE-2006-4423"
],
"28434": [
"CVE-2006-4423"
],
"28435": [
"CVE-2006-4423"
],
"28436": [
"CVE-2006-4443"
],
"28437": [
"CVE-2006-4553"
],
"28439": [
"CVE-2006-4454"
],
"28440": [
"CVE-2006-4545"
],
"28441": [
"CVE-2006-4497"
],
"28442": [],
"28443": [
"CVE-2006-4524"
],
"28444": [
"CVE-2006-4591"
],
"28446": [
"CVE-2006-4543"
],
"28447": [],
"28749": [
"CVE-2006-5190"
],
"28750": [
"CVE-2006-5190"
],
"28751": [
"CVE-2006-5190"
],
"28464": [
"CVE-2006-4478"
],
"28465": [
"CVE-2006-4479"
],
"28466": [
"CVE-2006-4540"
],
"28467": [],
"28468": [],
"28452": [
"CVE-2013-5961"
],
"28453": [
"CVE-2006-4477"
],
"28454": [
"CVE-2006-4477"
],
"28455": [
"CVE-2006-4477"
],
"28456": [
"CVE-2006-4477"
],
"28457": [
"CVE-2006-4477"
],
"28458": [
"CVE-2006-4477"
],
"28459": [
"CVE-2006-4477"
],
"28460": [
"CVE-2006-4477"
],
"28461": [
"CVE-2006-4477"
],
"28462": [
"CVE-2006-4477"
],
"28470": [
"CVE-2006-4634"
],
"28471": [],
"28472": [],
"28473": [
"CVE-2006-4599"
],
"28485": [
"CVE-2013-5917"
],
"28486": [],
"28487": [
"CVE-2006-4563"
],
"28488": [
"CVE-2006-4631"
],
"28490": [
"CVE-2006-4593"
],
"28492": [
"CVE-2006-4643"
],
"28493": [
"CVE-2006-4666"
],
"28494": [
"CVE-2006-4668"
],
"28495": [
"CVE-2006-4294"
],
"28496": [
"CVE-2006-4673"
],
"28497": [
"CVE-2006-4708"
],
"28498": [
"CVE-2006-4708"
],
"28499": [
"CVE-2006-4709"
],
"28502": [
"CVE-2006-4747"
],
"28503": [
"CVE-2006-4747"
],
"28505": [],
"29215": [],
"28510": [
"CVE-2006-4754"
],
"28511": [
"CVE-2006-4753"
],
"28514": [
"CVE-2006-4731"
],
"28515": [
"CVE-2006-4884"
],
"28516": [
"CVE-2006-4884"
],
"28517": [
"CVE-2006-4884"
],
"40377": [
"CVE-2016-6854",
"CVE-2016-6853",
"CVE-2016-6851"
],
"28518": [],
"28519": [],
"28520": [],
"28522": [
"CVE-2006-4889"
],
"28523": [
"CVE-2006-4889"
],
"28524": [
"CVE-2006-4889"
],
"28525": [
"CVE-2006-4889"
],
"28526": [
"CVE-2006-4889"
],
"28527": [
"CVE-2006-4889"
],
"28528": [
"CVE-2006-4889"
],
"28529": [
"CVE-2006-4889"
],
"28530": [
"CVE-2006-4889"
],
"28531": [
"CVE-2006-4889"
],
"28532": [
"CVE-2006-4889"
],
"28533": [
"CVE-2006-4889"
],
"28534": [
"CVE-2006-4889"
],
"28535": [
"CVE-2006-4889"
],
"28536": [
"CVE-2006-4889"
],
"28537": [
"CVE-2006-4889"
],
"28538": [
"CVE-2006-4889"
],
"28539": [
"CVE-2006-4889"
],
"28540": [
"CVE-2006-4889"
],
"28541": [
"CVE-2006-4889"
],
"28543": [
"CVE-2006-4771"
],
"28544": [],
"28545": [
"CVE-2006-4794"
],
"28546": [
"CVE-2006-4794"
],
"28547": [
"CVE-2006-4794"
],
"28548": [
"CVE-2006-4794"
],
"28549": [
"CVE-2006-4794"
],
"28551": [
"CVE-2006-4794"
],
"28552": [
"CVE-2006-4794"
],
"28554": [
"CVE-2006-4794"
],
"28555": [
"CVE-2013-5118"
],
"28556": [
"CVE-2006-4794"
],
"28557": [
"CVE-2013-5693",
"CVE-2013-5692"
],
"28558": [],
"28658": [],
"28659": [
"CVE-2006-5060"
],
"28660": [],
"28560": [],
"28562": [
"CVE-2013-6852"
],
"28563": [],
"28564": [],
"38990": [],
"28565": [
"CVE-2006-4825"
],
"28566": [
"CVE-2006-4796"
],
"28567": [
"CVE-2006-4504"
],
"28568": [
"CVE-2006-4505"
],
"28569": [],
"28570": [
"CVE-2006-3636"
],
"28571": [
"CVE-2006-4838"
],
"28572": [
"CVE-2006-4838"
],
"28573": [
"CVE-2006-4836"
],
"28574": [
"CVE-2006-4829"
],
"28575": [],
"28577": [
"CVE-2006-4857"
],
"28580": [],
"28581": [
"CVE-2006-4875"
],
"28582": [
"CVE-2006-4874"
],
"28583": [
"CVE-2006-4874"
],
"28584": [
"CVE-2006-4874"
],
"28585": [
"CVE-2006-4874"
],
"28586": [
"CVE-2006-4876"
],
"28587": [],
"28589": [],
"28590": [
"CVE-2006-4848"
],
"28591": [
"CVE-2006-4877"
],
"28592": [
"CVE-2006-4881"
],
"28593": [],
"28594": [],
"28597": [
"CVE-2006-4872"
],
"28598": [],
"28599": [
"CVE-2006-4894"
],
"28600": [
"CVE-2006-4871"
],
"28601": [
"CVE-2006-4917"
],
"28603": [
"CVE-2006-4915"
],
"28604": [
"CVE-2006-4923"
],
"28605": [
"CVE-2006-4955"
],
"28606": [
"CVE-2006-4952"
],
"28607": [
"CVE-2006-4953"
],
"28608": [
"CVE-2006-4953"
],
"28609": [
"CVE-2006-4954"
],
"28610": [
"CVE-2006-4956"
],
"28611": [
"CVE-2006-5021"
],
"28612": [
"CVE-2006-5021"
],
"28613": [
"CVE-2006-5021"
],
"28614": [
"CVE-2006-5021"
],
"28615": [
"CVE-2006-4973"
],
"28616": [],
"28617": [
"CVE-2006-4985"
],
"28618": [
"CVE-2006-4985"
],
"28619": [
"CVE-2006-4985"
],
"28620": [
"CVE-2006-4985"
],
"28621": [
"CVE-2006-4985"
],
"28622": [
"CVE-2006-4985"
],
"28623": [
"CVE-2006-4985"
],
"28624": [
"CVE-2006-4985"
],
"28625": [
"CVE-2006-4985"
],
"28626": [
"CVE-2006-4985"
],
"28627": [
"CVE-2006-4985"
],
"28628": [
"CVE-2006-4985"
],
"28629": [
"CVE-2006-4985"
],
"28630": [
"CVE-2006-4985"
],
"28631": [
"CVE-2006-4985"
],
"28632": [
"CVE-2006-4985"
],
"28633": [
"CVE-2006-4985"
],
"28634": [
"CVE-2006-4985"
],
"28635": [
"CVE-2006-4985"
],
"28636": [
"CVE-2006-4985"
],
"28637": [
"CVE-2006-4985"
],
"28638": [
"CVE-2006-4985"
],
"28644": [
"CVE-2006-5019"
],
"28645": [
"CVE-2006-5031"
],
"28646": [],
"28647": [
"CVE-2006-5028"
],
"28649": [],
"28695": [
"CVE-2006-5107"
],
"40359": [],
"28696": [
"CVE-2006-5107"
],
"28697": [
"CVE-2006-5107"
],
"28698": [
"CVE-2006-5107"
],
"28699": [
"CVE-2006-5108"
],
"28652": [],
"28653": [
"CVE-2013-5697"
],
"28654": [
"CVE-2013-2586"
],
"28656": [
"CVE-2013-5748"
],
"28661": [],
"28662": [
"CVE-2006-5057"
],
"28663": [
"CVE-2006-5057"
],
"28664": [
"CVE-2006-5056"
],
"28665": [],
"28667": [
"CVE-2006-5064"
],
"28668": [
"CVE-2006-5064"
],
"28669": [
"CVE-2006-5064"
],
"28670": [
"CVE-2006-5066"
],
"28671": [
"CVE-2006-5066"
],
"28672": [
"CVE-2006-5103"
],
"28673": [
"CVE-2006-5920"
],
"28674": [
"CVE-2006-5076"
],
"28675": [
"CVE-2006-5076"
],
"28676": [
"CVE-2006-5076"
],
"28684": [
"CVE-2013-7349",
"CVE-2013-5640",
"CVE-2013-5639"
],
"28685": [
"CVE-2013-5696"
],
"28686": [
"CVE-2006-5089"
],
"28687": [],
"28688": [],
"28689": [],
"28690": [],
"28691": [],
"28692": [
"CVE-2006-5090"
],
"28693": [
"CVE-2006-5090"
],
"28701": [
"CVE-2006-5108"
],
"28702": [
"CVE-2006-5108"
],
"28703": [
"CVE-2006-5108"
],
"28704": [
"CVE-2006-5108"
],
"28729": [],
"28730": [
"CVE-2006-5145"
],
"28727": [],
"28731": [
"CVE-2006-5145"
],
"28732": [
"CVE-2006-5146"
],
"28733": [
"CVE-2006-5146"
],
"28734": [
"CVE-2006-5146"
],
"29275": [],
"29276": [],
"28728": [
"CVE-2006-5141"
],
"28708": [],
"28709": [],
"28711": [
"CVE-2006-5074"
],
"28712": [],
"28714": [
"CVE-2006-5118"
],
"29274": [
"CVE-2013-6275"
],
"28716": [
"CVE-2006-2066"
],
"29279": [
"CVE-2013-6794",
"CVE-2013-6793"
],
"28719": [
"CVE-2006-5096"
],
"28720": [],
"28721": [
"CVE-2006-5120"
],
"28722": [
"CVE-2006-5120"
],
"28723": [],
"28736": [
"CVE-2006-5154"
],
"28737": [
"CVE-2006-5166"
],
"28738": [
"CVE-2006-5164"
],
"28740": [],
"28741": [],
"28742": [
"CVE-2006-4206"
],
"28743": [
"CVE-2006-5190"
],
"28744": [
"CVE-2006-5190"
],
"28745": [
"CVE-2006-5190"
],
"28746": [
"CVE-2006-5190"
],
"28747": [
"CVE-2006-5190"
],
"28748": [
"CVE-2006-5190"
],
"28752": [
"CVE-2006-5190"
],
"28753": [
"CVE-2006-5190"
],
"28754": [
"CVE-2006-5190"
],
"28755": [
"CVE-2006-5190"
],
"28756": [
"CVE-2006-5190"
],
"28757": [
"CVE-2006-5190"
],
"28758": [
"CVE-2006-5190"
],
"28759": [
"CVE-2006-5190"
],
"28761": [
"CVE-2006-5193"
],
"28762": [
"CVE-2006-7231"
],
"28767": [
"CVE-2006-5228"
],
"28768": [
"CVE-2006-5217"
],
"28769": [],
"28770": [
"CVE-2006-5219"
],
"28771": [],
"28772": [
"CVE-2006-5232"
],
"28773": [
"CVE-2006-5251"
],
"28774": [
"CVE-2006-5234"
],
"28776": [
"CVE-2006-5239"
],
"28777": [
"CVE-2006-5262"
],
"28778": [
"CVE-2006-5210"
],
"28779": [],
"28780": [],
"28781": [
"CVE-2006-5250"
],
"28782": [
"CVE-2006-5249"
],
"28783": [],
"28784": [],
"28786": [
"CVE-2006-7146"
],
"28787": [],
"28790": [
"CVE-2006-5294"
],
"28791": [
"CVE-2006-7091"
],
"28792": [
"CVE-2006-6634"
],
"28793": [
"CVE-2006-6634"
],
"28794": [],
"28795": [
"CVE-2006-5411"
],
"28796": [
"CVE-2006-5311"
],
"28797": [
"CVE-2006-6592"
],
"28798": [
"CVE-2006-6592"
],
"28799": [
"CVE-2006-6592"
],
"28800": [
"CVE-2006-6592"
],
"28801": [
"CVE-2006-6592"
],
"28802": [
"CVE-2006-6592"
],
"28803": [],
"28804": [
"CVE-2006-7168"
],
"28807": [],
"28808": [],
"28814": [],
"28815": [],
"28818": [
"CVE-2006-7104"
],
"28819": [
"CVE-2006-5422"
],
"28820": [],
"28821": [
"CVE-2006-7120"
],
"28823": [],
"28824": [
"CVE-2006-5524"
],
"28825": [],
"28826": [
"CVE-2006-5428"
],
"28827": [],
"28828": [
"CVE-2006-5431"
],
"28829": [
"CVE-2006-5450"
],
"28830": [
"CVE-2006-5436"
],
"28831": [
"CVE-2006-5503"
],
"28832": [],
"28833": [
"CVE-2006-5446"
],
"28838": [],
"28839": [
"CVE-2006-5529"
],
"28840": [
"CVE-2006-5528"
],
"28842": [
"CVE-2006-5512"
],
"28843": [
"CVE-2006-5535"
],
"28844": [
"CVE-2006-5535"
],
"28845": [
"CVE-2006-5566"
],
"28846": [
"CVE-2006-5516"
],
"28851": [],
"28854": [],
"28857": [
"CVE-2006-5603"
],
"28858": [
"CVE-2006-5530"
],
"28859": [
"CVE-2006-5530"
],
"28861": [],
"28862": [],
"28863": [
"CVE-2006-5564"
],
"28864": [
"CVE-2006-6416"
],
"28865": [],
"28866": [],
"28867": [
"CVE-2006-5609"
],
"28868": [],
"28869": [
"CVE-2006-5635"
],
"28870": [],
"28871": [
"CVE-2007-2064"
],
"28872": [
"CVE-2007-2065"
],
"28873": [
"CVE-2006-7184"
],
"28874": [
"CVE-2006-7184"
],
"28875": [
"CVE-2006-5716"
],
"28878": [
"CVE-2006-5662"
],
"28879": [
"CVE-2006-5662"
],
"28881": [
"CVE-2006-5643"
],
"28882": [
"CVE-2006-5626"
],
"28883": [],
"28885": [
"CVE-2006-5720"
],
"28886": [],
"28889": [
"CVE-2006-5661"
],
"28890": [
"CVE-2006-5652"
],
"28891": [
"CVE-2006-5712"
],
"28892": [],
"28893": [],
"28896": [],
"28898": [],
"28899": [
"CVE-2006-5838"
],
"28900": [
"CVE-2006-5770"
],
"28901": [
"CVE-2006-5770"
],
"28902": [
"CVE-2006-5770"
],
"28903": [
"CVE-2006-5770"
],
"28904": [
"CVE-2006-5770"
],
"28905": [
"CVE-2006-5770"
],
"28906": [],
"28907": [],
"28908": [],
"28909": [
"CVE-2006-5761"
],
"28910": [],
"28913": [
"CVE-2006-5899"
],
"28914": [
"CVE-2006-5810"
],
"28917": [
"CVE-2006-5830"
],
"28918": [
"CVE-2006-5830"
],
"28919": [
"CVE-2006-5830"
],
"28920": [
"CVE-2006-5830"
],
"28921": [
"CVE-2006-5830"
],
"28922": [
"CVE-2006-5831"
],
"28923": [
"CVE-2006-5829"
],
"28924": [
"CVE-2006-5829"
],
"28925": [
"CVE-2006-5829"
],
"28926": [
"CVE-2006-5829"
],
"28927": [
"CVE-2006-5829"
],
"28928": [
"CVE-2006-5829"
],
"28929": [
"CVE-2006-5829"
],
"28930": [
"CVE-2006-5829"
],
"28931": [
"CVE-2006-5829"
],
"28932": [
"CVE-2006-5829"
],
"28933": [
"CVE-2006-5829"
],
"28934": [
"CVE-2006-5829"
],
"28935": [
"CVE-2006-5832"
],
"28936": [
"CVE-2006-5832"
],
"28937": [
"CVE-2006-5832"
],
"28938": [
"CVE-2006-5924"
],
"28939": [
"CVE-2006-5825"
],
"28940": [],
"28941": [
"CVE-2006-5853"
],
"28942": [
"CVE-2006-5846"
],
"28943": [
"CVE-2006-5847"
],
"28944": [],
"28945": [],
"28946": [],
"28947": [],
"28949": [
"CVE-2006-6923"
],
"28950": [
"CVE-2006-5915"
],
"28951": [
"CVE-2006-5914"
],
"28952": [],
"28953": [
"CVE-2006-6924"
],
"28954": [
"CVE-2006-6925"
],
"28956": [],
"28959": [
"CVE-2013-5978",
"CVE-2013-5977"
],
"28960": [],
"29086": [
"CVE-2006-6095"
],
"28963": [
"CVE-2006-6924"
],
"28964": [
"CVE-2006-6924"
],
"28965": [
"CVE-2006-6924"
],
"28967": [
"CVE-2006-5951"
],
"28970": [],
"28971": [],
"28972": [
"CVE-2013-5743"
],
"28975": [],
"28976": [],
"28977": [],
"28978": [
"CVE-2013-5147"
],
"28979": [],
"28980": [],
"28982": [
"CVE-2006-5883"
],
"28983": [
"CVE-2006-5883"
],
"28985": [],
"28986": [],
"28988": [],
"28989": [
"CVE-2006-5958"
],
"28990": [
"CVE-2006-5958"
],
"28991": [
"CVE-2006-5958"
],
"28992": [
"CVE-2006-5957"
],
"40373": [],
"28993": [
"CVE-2006-5957"
],
"28994": [
"CVE-2006-5957"
],
"28995": [],
"29151": [],
"29152": [
"CVE-2006-6147"
],
"29153": [
"CVE-2006-6147"
],
"29154": [
"CVE-2006-6083"
],
"29155": [
"CVE-2006-6082"
],
"28998": [
"CVE-2006-6581"
],
"28999": [
"CVE-2006-5983"
],
"29000": [
"CVE-2006-5983"
],
"29001": [
"CVE-2006-5983"
],
"29002": [
"CVE-2006-5983"
],
"29003": [
"CVE-2006-5983"
],
"29004": [
"CVE-2006-5983"
],
"29005": [
"CVE-2006-5983"
],
"29006": [
"CVE-2006-5983"
],
"29008": [
"CVE-2006-5946"
],
"29009": [],
"29010": [
"CVE-2006-5936"
],
"29011": [
"CVE-2006-5987"
],
"29012": [
"CVE-2006-7118"
],
"29013": [],
"29014": [
"CVE-2006-5945"
],
"29015": [
"CVE-2006-5945"
],
"29016": [
"CVE-2006-5944"
],
"29017": [
"CVE-2006-6451"
],
"29018": [
"CVE-2006-6451"
],
"29019": [],
"29020": [],
"29021": [],
"29023": [],
"29024": [
"CVE-2006-5943"
],
"29025": [],
"29026": [
"CVE-2006-7170"
],
"29027": [
"CVE-2006-7170"
],
"29028": [
"CVE-2006-6708"
],
"29029": [
"CVE-2006-6709"
],
"29030": [
"CVE-2006-6709"
],
"29031": [
"CVE-2006-6709"
],
"29034": [],
"29037": [
"CVE-2006-6109"
],
"29038": [
"CVE-2006-6109"
],
"29040": [],
"29041": [],
"29042": [
"CVE-2006-6066"
],
"29043": [
"CVE-2006-6066"
],
"29044": [
"CVE-2006-6066"
],
"29046": [],
"29047": [
"CVE-2006-7086"
],
"29048": [
"CVE-2006-6088"
],
"29049": [
"CVE-2006-6020"
],
"29050": [
"CVE-2006-6951"
],
"29051": [],
"41035": [],
"29053": [
"CVE-2006-6932"
],
"29054": [
"CVE-2006-6932"
],
"29058": [
"CVE-2006-6942"
],
"29059": [
"CVE-2006-6942"
],
"29060": [
"CVE-2006-6942"
],
"29061": [
"CVE-2006-6942"
],
"29062": [
"CVE-2006-6943"
],
"29063": [
"CVE-2006-6937"
],
"29064": [
"CVE-2006-6936"
],
"29065": [],
"29150": [],
"29221": [
"CVE-2006-6363"
],
"29222": [
"CVE-2006-6366"
],
"29068": [],
"29071": [
"CVE-2004-1875"
],
"29072": [
"CVE-2006-7133"
],
"29073": [],
"29074": [],
"29075": [
"CVE-2006-6092"
],
"29077": [
"CVE-2006-6067"
],
"29078": [
"CVE-2006-6067"
],
"29079": [
"CVE-2006-6040"
],
"29080": [
"CVE-2006-6021"
],
"29081": [
"CVE-2006-6022"
],
"29085": [
"CVE-2004-1873"
],
"29084": [
"CVE-2006-6111"
],
"29087": [
"CVE-2006-6095"
],
"29088": [
"CVE-2006-6096"
],
"29089": [
"CVE-2006-6094"
],
"29090": [
"CVE-2006-6094"
],
"29091": [
"CVE-2011-4275",
"CVE-2009-4140"
],
"29156": [
"CVE-2006-6082"
],
"29211": [],
"29118": [
"CVE-2006-6208"
],
"29093": [
"CVE-2006-6050"
],
"29094": [
"CVE-2006-6050"
],
"29095": [
"CVE-2006-6035"
],
"40372": [],
"29097": [],
"29098": [
"CVE-2006-6211"
],
"29099": [
"CVE-2006-6211"
],
"29100": [
"CVE-2006-6211"
],
"29101": [
"CVE-2006-6211"
],
"29103": [
"CVE-2006-6152"
],
"29104": [
"CVE-2006-6152"
],
"29105": [
"CVE-2006-6153"
],
"29106": [
"CVE-2006-6153"
],
"29107": [
"CVE-2006-6927"
],
"29108": [
"CVE-2006-6927"
],
"29109": [
"CVE-2006-6927"
],
"29110": [
"CVE-2006-6927"
],
"29111": [
"CVE-2006-6927"
],
"29112": [
"CVE-2006-6927"
],
"29113": [
"CVE-2006-6927"
],
"29114": [
"CVE-2006-6928"
],
"29115": [
"CVE-2006-6928"
],
"29116": [
"CVE-2006-6928"
],
"29117": [
"CVE-2006-6928"
],
"29119": [
"CVE-2006-6208"
],
"29120": [
"CVE-2006-6208"
],
"29121": [
"CVE-2006-6204"
],
"29122": [
"CVE-2006-6204"
],
"29123": [
"CVE-2006-6204"
],
"29124": [
"CVE-2006-6205"
],
"29126": [
"CVE-2006-6080"
],
"29128": [
"CVE-2006-6284"
],
"29131": [],
"29133": [
"CVE-2006-6930"
],
"29134": [
"CVE-2006-6929"
],
"29135": [
"CVE-2006-6929"
],
"29136": [
"CVE-2006-6929"
],
"29137": [
"CVE-2006-6929"
],
"29157": [],
"29158": [],
"29159": [],
"29141": [
"CVE-2006-6768"
],
"29142": [
"CVE-2006-6342"
],
"29143": [
"CVE-2006-6342"
],
"29145": [
"CVE-2006-6185"
],
"29162": [
"CVE-2006-6087"
],
"29217": [
"CVE-2006-6300"
],
"29218": [
"CVE-2006-6356"
],
"29219": [
"CVE-2006-6367"
],
"29220": [
"CVE-2006-6298"
],
"29165": [
"CVE-2006-6158"
],
"29166": [
"CVE-2006-6158"
],
"29992": [
"CVE-2006-5911"
],
"29993": [
"CVE-2006-5911"
],
"29216": [
"CVE-2006-6337"
],
"29173": [],
"29174": [
"CVE-2006-6209"
],
"29175": [
"CVE-2006-6272"
],
"29176": [
"CVE-2006-6210"
],
"29177": [
"CVE-2006-6118"
],
"29178": [
"CVE-2006-6195"
],
"29179": [
"CVE-2006-6195"
],
"29180": [],
"29181": [],
"29182": [
"CVE-2006-6198"
],
"29183": [
"CVE-2006-6198"
],
"29184": [
"CVE-2006-6198"
],
"29185": [
"CVE-2006-6198"
],
"29186": [
"CVE-2006-6198"
],
"29187": [
"CVE-2006-6198"
],
"29188": [
"CVE-2006-6198"
],
"29189": [
"CVE-2006-6243"
],
"29191": [
"CVE-2006-6181"
],
"29192": [
"CVE-2006-6189"
],
"29193": [],
"29195": [
"CVE-2006-6247"
],
"29196": [
"CVE-2006-6247"
],
"29197": [
"CVE-2006-6207"
],
"29198": [
"CVE-2006-6197"
],
"29199": [
"CVE-2006-6197"
],
"40371": [],
"29200": [
"CVE-2006-6197"
],
"29202": [
"CVE-2006-6343"
],
"29203": [],
"29205": [],
"29262": [],
"29207": [
"CVE-2006-6339"
],
"29231": [
"CVE-2006-6414"
],
"29232": [
"CVE-2006-6387"
],
"29233": [
"CVE-2006-6387"
],
"29223": [
"CVE-2006-6364"
],
"29224": [],
"29225": [
"CVE-2006-6389"
],
"29226": [
"CVE-2006-6389"
],
"29227": [
"CVE-2006-6447"
],
"29228": [
"CVE-2006-6447"
],
"29328": [],
"29237": [
"CVE-2006-6523"
],
"29238": [],
"29240": [
"CVE-2006-6536"
],
"29241": [],
"29242": [
"CVE-2006-6521"
],
"29243": [
"CVE-2006-6520"
],
"29244": [
"CVE-2006-6520"
],
"29245": [
"CVE-2006-6520"
],
"29246": [
"CVE-2006-6478"
],
"29247": [
"CVE-2006-6479"
],
"29248": [
"CVE-2006-6479"
],
"29249": [
"CVE-2006-6479"
],
"29250": [
"CVE-2006-6479"
],
"29251": [
"CVE-2006-6479"
],
"29252": [
"CVE-2006-6478"
],
"29253": [
"CVE-2006-6478"
],
"29254": [
"CVE-2006-6517"
],
"29255": [
"CVE-2006-6517"
],
"29258": [],
"29264": [],
"29265": [],
"29266": [
"CVE-2013-6236"
],
"29267": [
"CVE-2006-6518"
],
"29268": [
"CVE-2006-6519"
],
"29269": [
"CVE-2006-6518"
],
"29270": [],
"29271": [],
"29272": [
"CVE-2006-6845"
],
"29280": [],
"29282": [
"CVE-2006-6569"
],
"29283": [
"CVE-2006-6571"
],
"29284": [
"CVE-2006-6625"
],
"29288": [
"CVE-2006-6640"
],
"29289": [],
"29293": [
"CVE-2006-6642"
],
"29294": [
"CVE-2006-6721"
],
"29298": [
"CVE-2006-6733"
],
"29299": [
"CVE-2006-6734"
],
"29300": [
"CVE-2006-6690"
],
"29301": [
"CVE-2006-6697"
],
"29303": [],
"29304": [],
"29292": [],
"29306": [
"CVE-2006-6729"
],
"29308": [
"CVE-2006-6703"
],
"29311": [
"CVE-2006-6746"
],
"29312": [],
"29313": [
"CVE-2006-6746"
],
"29314": [
"CVE-2006-6747"
],
"29994": [
"CVE-2006-5911"
],
"29995": [
"CVE-2006-5911"
],
"29318": [],
"29326": [
"CVE-2013-5694"
],
"30207": [
"CVE-2007-3339"
],
"30203": [
"CVE-2007-3323"
],
"30204": [
"CVE-2007-3324"
],
"29330": [],
"29331": [],
"29332": [],
"29333": [
"CVE-2006-6794"
],
"40370": [],
"29334": [
"CVE-2006-6776"
],
"29335": [
"CVE-2006-6777"
],
"29336": [
"CVE-2006-6791"
],
"29337": [
"CVE-2006-6778"
],
"29338": [
"CVE-2006-6779"
],
"29342": [
"CVE-2006-6788"
],
"29343": [
"CVE-2006-3019"
],
"29344": [
"CVE-2006-3019"
],
"29345": [
"CVE-2006-3019"
],
"29346": [
"CVE-2006-3019"
],
"29347": [
"CVE-2006-3019"
],
"29348": [
"CVE-2006-3019"
],
"29349": [
"CVE-2006-3019"
],
"29350": [
"CVE-2006-3019"
],
"29351": [
"CVE-2006-3019"
],
"29352": [
"CVE-2006-3019"
],
"29375": [],
"29376": [
"CVE-2007-0054"
],
"29354": [],
"29474": [],
"29356": [
"CVE-2006-6808"
],
"29357": [
"CVE-2006-6814"
],
"29358": [
"CVE-2006-6816"
],
"29359": [
"CVE-2006-6816"
],
"29360": [
"CVE-2006-6816"
],
"29361": [
"CVE-2006-6816"
],
"29363": [
"CVE-2006-6824"
],
"29364": [
"CVE-2006-6824"
],
"29365": [
"CVE-2006-6824"
],
"29366": [
"CVE-2006-6824"
],
"29367": [
"CVE-2006-6824"
],
"29368": [
"CVE-2006-6824"
],
"29369": [
"CVE-2006-6824"
],
"29370": [
"CVE-2006-6824"
],
"29372": [
"CVE-2006-6851"
],
"29373": [
"CVE-2006-6861"
],
"29377": [
"CVE-2007-0056"
],
"29378": [
"CVE-2007-0056"
],
"29379": [
"CVE-2007-0056"
],
"29380": [
"CVE-2007-0056"
],
"29381": [
"CVE-2007-0056"
],
"29382": [
"CVE-2007-0056"
],
"29384": [
"CVE-2007-0121"
],
"29385": [
"CVE-2007-0140"
],
"29476": [],
"29389": [],
"29390": [
"CVE-2007-0118"
],
"29391": [
"CVE-2007-0118"
],
"29392": [
"CVE-2007-0118"
],
"29393": [
"CVE-2007-0118"
],
"29394": [
"CVE-2007-0119"
],
"29395": [
"CVE-2007-0119"
],
"29396": [
"CVE-2007-0119"
],
"29397": [
"CVE-2007-0122"
],
"29398": [
"CVE-2007-0142"
],
"29401": [
"CVE-2007-0112"
],
"29404": [
"CVE-2007-0177"
],
"29405": [
"CVE-2007-0179"
],
"29407": [
"CVE-2007-0182"
],
"29408": [
"CVE-2007-0182"
],
"29409": [
"CVE-2007-0182"
],
"29410": [
"CVE-2007-0182"
],
"29411": [
"CVE-2007-0182"
],
"29412": [
"CVE-2007-0182"
],
"29413": [
"CVE-2007-0182"
],
"29414": [
"CVE-2007-0182"
],
"29415": [
"CVE-2007-0182"
],
"40369": [],
"29416": [
"CVE-2007-0182"
],
"29417": [
"CVE-2007-0182"
],
"29418": [
"CVE-2007-0182"
],
"29419": [
"CVE-2007-0182"
],
"29420": [
"CVE-2007-0182"
],
"29421": [
"CVE-2007-0182"
],
"29422": [
"CVE-2007-0182"
],
"29423": [
"CVE-2007-0182"
],
"29424": [
"CVE-2007-0182"
],
"29425": [
"CVE-2007-0182"
],
"29426": [
"CVE-2007-0182"
],
"29427": [
"CVE-2007-0182"
],
"29428": [
"CVE-2007-0182"
],
"29429": [
"CVE-2007-0182"
],
"29430": [
"CVE-2007-0182"
],
"29431": [
"CVE-2007-0182"
],
"29432": [
"CVE-2007-0182"
],
"29433": [
"CVE-2007-0182"
],
"29434": [
"CVE-2007-0182"
],
"29435": [
"CVE-2013-6357"
],
"29437": [
"CVE-2007-0178"
],
"29438": [
"CVE-2007-0190"
],
"29442": [
"CVE-2006-6421"
],
"36794": [],
"29450": [],
"29451": [
"CVE-2007-0316"
],
"29453": [
"CVE-2007-0309"
],
"29456": [
"CVE-2007-0302"
],
"29457": [
"CVE-2007-0302"
],
"29477": [
"CVE-2007-0364"
],
"29478": [
"CVE-2007-0364"
],
"29479": [
"CVE-2007-0364"
],
"29480": [
"CVE-2007-0364"
],
"29481": [
"CVE-2007-0364"
],
"29464": [],
"29466": [],
"29468": [
"CVE-2007-0335"
],
"29469": [
"CVE-2007-0335"
],
"29472": [
"CVE-2006-6487"
],
"29482": [],
"29483": [
"CVE-2007-0364"
],
"29484": [
"CVE-2007-0364"
],
"29485": [
"CVE-2007-0364"
],
"29486": [
"CVE-2007-0364"
],
"29487": [
"CVE-2007-0364"
],
"29488": [
"CVE-2007-0364"
],
"29489": [
"CVE-2007-0364"
],
"29491": [
"CVE-2007-0353"
],
"40368": [],
"29492": [
"CVE-2007-0353"
],
"29497": [],
"29498": [],
"29499": [
"CVE-2007-0399"
],
"29500": [],
"29504": [],
"29505": [],
"29506": [],
"29507": [],
"29508": [],
"30029": [
"CVE-2007-1903"
],
"30031": [],
"30085": [
"CVE-2013-7091"
],
"30035": [
"CVE-2007-1902"
],
"30036": [
"CVE-2007-2714"
],
"30040": [
"CVE-2007-1898"
],
"30041": [
"CVE-2007-2732"
],
"30042": [
"CVE-2007-2732"
],
"30047": [
"CVE-2007-2908"
],
"30048": [],
"30050": [
"CVE-2007-2757"
],
"30051": [
"CVE-2007-2780"
],
"30053": [
"CVE-2007-2805"
],
"30054": [
"CVE-2013-7025"
],
"30055": [],
"30201": [
"CVE-2007-3267"
],
"30156": [],
"30200": [
"CVE-2007-3281"
],
"30015": [
"CVE-2007-0609"
],
"30022": [
"CVE-2007-2632"
],
"30027": [
"CVE-2007-2718"
],
"30028": [
"CVE-2007-2716"
],
"29512": [
"CVE-2013-3528",
"CVE-2013-2749"
],
"29514": [
"CVE-2013-6058"
],
"29515": [],
"29516": [
"CVE-2013-4985"
],
"29517": [
"CVE-2013-6164"
],
"29518": [
"CVE-2013-5220",
"CVE-2013-5219",
"CVE-2013-5218",
"CVE-2013-5039",
"CVE-2013-5038",
"CVE-2013-5037"
],
"29519": [
"CVE-2013-6364"
],
"29521": [],
"29522": [
"CVE-2007-0540"
],
"29525": [],
"29529": [
"CVE-2007-0567"
],
"29530": [
"CVE-2007-0620"
],
"29533": [
"CVE-2007-0575"
],
"29534": [
"CVE-2007-0574"
],
"29537": [
"CVE-2007-0623"
],
"29539": [
"CVE-2007-0635"
],
"29677": [
"CVE-2007-1241"
],
"29678": [
"CVE-2007-1242"
],
"29679": [],
"29680": [
"CVE-2007-1231"
],
"29681": [
"CVE-2007-1158"
],
"29682": [
"CVE-2007-1244"
],
"29684": [],
"29544": [
"CVE-2013-6618"
],
"36816": [],
"29811": [],
"29556": [
"CVE-2007-0649"
],
"29557": [
"CVE-2007-0649"
],
"29559": [
"CVE-2007-0759"
],
"29560": [
"CVE-2007-0758"
],
"29561": [],
"29562": [
"CVE-2007-0821"
],
"29563": [
"CVE-2007-0821"
],
"29564": [
"CVE-2007-0820"
],
"29565": [
"CVE-2007-0820"
],
"29566": [
"CVE-2007-0820"
],
"29567": [
"CVE-2007-0817"
],
"29568": [
"CVE-2007-0836"
],
"29569": [
"CVE-2007-0828"
],
"29570": [
"CVE-2014-1990"
],
"29571": [
"CVE-2007-0849"
],
"29572": [
"CVE-2007-0890"
],
"29574": [
"CVE-2007-0871"
],
"29576": [
"CVE-2007-0885"
],
"29578": [
"CVE-2007-0900"
],
"29579": [
"CVE-2007-0900"
],
"29580": [
"CVE-2007-0900"
],
"29581": [
"CVE-2007-0900"
],
"29582": [
"CVE-2007-0900"
],
"29583": [
"CVE-2007-0900"
],
"29584": [
"CVE-2007-0900"
],
"29585": [
"CVE-2007-0900"
],
"29586": [
"CVE-2007-0900"
],
"29587": [
"CVE-2007-0900"
],
"29588": [
"CVE-2007-0900"
],
"29589": [
"CVE-2007-0900"
],
"29590": [
"CVE-2007-0900"
],
"29591": [
"CVE-2007-0900"
],
"29592": [
"CVE-2007-0900"
],
"29593": [
"CVE-2007-0900"
],
"29596": [],
"29597": [
"CVE-2007-0925"
],
"29598": [
"CVE-2007-1049"
],
"29599": [
"CVE-2007-0982"
],
"29600": [
"CVE-2007-0950"
],
"29601": [
"CVE-2007-0951"
],
"29602": [
"CVE-2007-0970"
],
"29604": [],
"29605": [],
"29606": [],
"29676": [
"CVE-2007-1243"
],
"29608": [
"CVE-2007-1020"
],
"29609": [
"CVE-2007-1024"
],
"29610": [
"CVE-2007-1043"
],
"29611": [
"CVE-2007-1022"
],
"29612": [],
"29615": [
"CVE-2007-1044"
],
"29621": [
"CVE-2007-1050"
],
"29622": [
"CVE-2007-1077"
],
"29623": [
"CVE-2007-1085"
],
"29624": [
"CVE-2007-1020"
],
"29625": [
"CVE-2007-1076"
],
"29626": [
"CVE-2007-1076"
],
"29627": [
"CVE-2007-1141"
],
"29628": [
"CVE-2007-1142"
],
"29629": [
"CVE-2007-1142"
],
"29631": [
"CVE-2007-1159"
],
"29632": [
"CVE-2007-1152"
],
"29633": [],
"29634": [
"CVE-2007-1138"
],
"29635": [
"CVE-2007-1140"
],
"29636": [
"CVE-2007-1148"
],
"29637": [
"CVE-2007-1149"
],
"29638": [
"CVE-2007-1149"
],
"29639": [
"CVE-2007-1151"
],
"29640": [
"CVE-2007-1127"
],
"29641": [
"CVE-2007-1126"
],
"29642": [
"CVE-2007-1124"
],
"29643": [
"CVE-2007-1125"
],
"29644": [
"CVE-2007-1100"
],
"29645": [
"CVE-2007-1110"
],
"29646": [
"CVE-2007-1111"
],
"29647": [
"CVE-2007-1111"
],
"29648": [
"CVE-2007-1111"
],
"29649": [
"CVE-2007-1111"
],
"29650": [
"CVE-2007-1111"
],
"29651": [
"CVE-2007-1111"
],
"29652": [
"CVE-2007-1111"
],
"29653": [
"CVE-2007-1111"
],
"29790": [],
"29658": [
"CVE-2007-1101"
],
"29661": [
"CVE-2007-1240"
],
"29662": [
"CVE-2007-1240"
],
"29663": [
"CVE-2006-7099"
],
"29665": [
"CVE-2007-1232"
],
"29667": [],
"29668": [],
"29669": [],
"29670": [],
"30367": [
"CVE-2007-4079"
],
"30189": [
"CVE-2007-2449"
],
"30190": [
"CVE-2007-3249"
],
"30191": [
"CVE-2007-3101"
],
"29672": [
"CVE-2013-6225"
],
"29673": [
"CVE-2013-6117",
"CVE-2013-3615",
"CVE-2013-3614",
"CVE-2013-3613",
"CVE-2013-3612"
],
"29674": [
"CVE-2014-5007",
"CVE-2013-7390"
],
"29675": [],
"29789": [],
"29694": [],
"29696": [
"CVE-2007-1247"
],
"29697": [
"CVE-2007-1248"
],
"29698": [
"CVE-2007-1248"
],
"29700": [],
"29701": [
"CVE-2007-1277"
],
"29702": [
"CVE-2007-1277"
],
"29703": [
"CVE-2007-1289"
],
"29704": [
"CVE-2007-1291"
],
"29705": [
"CVE-2007-1291"
],
"29709": [
"CVE-2013-5030"
],
"30368": [
"CVE-2007-4079"
],
"30369": [
"CVE-2007-4081"
],
"30370": [
"CVE-2007-4081"
],
"30371": [
"CVE-2007-4084"
],
"29715": [
"CVE-2007-1331"
],
"29722": [
"CVE-2007-1416"
],
"29726": [
"CVE-2007-1422"
],
"29727": [
"CVE-2007-1421"
],
"29728": [
"CVE-2007-1421"
],
"29729": [
"CVE-2007-1421"
],
"29730": [
"CVE-2007-1424"
],
"29731": [
"CVE-2007-1424"
],
"29733": [],
"29736": [
"CVE-2007-1430"
],
"29737": [],
"29742": [
"CVE-2007-1515"
],
"29744": [
"CVE-2007-1514"
],
"29745": [
"CVE-2007-1473"
],
"29747": [
"CVE-2007-1508"
],
"29748": [
"CVE-2007-1509"
],
"29750": [],
"29751": [],
"29754": [
"CVE-2007-1622"
],
"29755": [],
"29756": [
"CVE-2007-1550"
],
"29757": [
"CVE-2007-1550"
],
"29758": [
"CVE-2007-1550"
],
"29759": [
"CVE-2007-1550"
],
"29760": [
"CVE-2007-1550"
],
"29761": [
"CVE-2007-1540"
],
"29762": [
"CVE-2007-1548"
],
"29763": [
"CVE-2007-1604"
],
"29764": [
"CVE-2007-1606"
],
"29765": [
"CVE-2007-1606"
],
"29766": [
"CVE-2007-1606"
],
"29772": [
"CVE-2006-5764"
],
"29773": [
"CVE-2006-5763"
],
"29774": [
"CVE-2006-5763"
],
"29775": [],
"29776": [
"CVE-2007-1714"
],
"29780": [
"CVE-2007-1873"
],
"29782": [
"CVE-2007-3332"
],
"29783": [
"CVE-2007-1678"
],
"29786": [
"CVE-2007-1773"
],
"30105": [
"CVE-2013-7319"
],
"30157": [
"CVE-2007-3130"
],
"30158": [
"CVE-2007-3130"
],
"30107": [],
"30109": [
"CVE-2007-2962"
],
"30111": [
"CVE-2007-3003"
],
"30112": [
"CVE-2007-3000"
],
"30113": [
"CVE-2007-3000"
],
"30114": [
"CVE-2007-3001"
],
"30115": [
"CVE-2007-3001"
],
"30116": [
"CVE-2007-3001"
],
"30118": [
"CVE-2007-3217"
],
"30119": [
"CVE-2007-3217"
],
"30120": [
"CVE-2007-3217"
],
"30121": [
"CVE-2007-3217"
],
"30122": [
"CVE-2007-3217"
],
"30123": [
"CVE-2007-3217"
],
"30124": [
"CVE-2007-3217"
],
"30125": [
"CVE-2007-3217"
],
"30126": [
"CVE-2007-3217"
],
"30127": [
"CVE-2007-3217"
],
"30128": [
"CVE-2007-3217"
],
"30129": [
"CVE-2007-3217"
],
"30131": [
"CVE-2007-3049"
],
"30132": [
"CVE-2007-2991"
],
"30133": [
"CVE-2007-3060"
],
"30134": [
"CVE-2007-3060"
],
"30135": [
"CVE-2007-3060"
],
"30136": [
"CVE-2007-3060"
],
"30137": [
"CVE-2007-3060"
],
"30138": [
"CVE-2007-3055"
],
"30140": [],
"30141": [
"CVE-2007-3080"
],
"30143": [
"CVE-2007-3070"
],
"30145": [],
"30146": [],
"30152": [
"CVE-2007-3063"
],
"30153": [
"CVE-2007-3064"
],
"30159": [
"CVE-2007-3158"
],
"30161": [
"CVE-2007-3134"
],
"30162": [
"CVE-2007-3137"
],
"30165": [],
"30166": [],
"30168": [
"CVE-2007-3196"
],
"30171": [
"CVE-2007-3190"
],
"30172": [
"CVE-2007-3189"
],
"30173": [
"CVE-2007-3191"
],
"30174": [
"CVE-2007-3192"
],
"30175": [
"CVE-2007-3243"
],
"30177": [],
"30205": [
"CVE-2007-3324"
],
"30206": [
"CVE-2007-3339"
],
"30202": [
"CVE-2007-3301"
],
"29794": [],
"29795": [],
"29796": [],
"29797": [
"CVE-2013-6936"
],
"29802": [],
"29805": [
"CVE-2007-1849"
],
"29806": [
"CVE-2007-1845"
],
"29817": [
"CVE-2007-1971"
],
"29821": [
"CVE-2007-1919"
],
"29824": [
"CVE-2007-1905"
],
"29825": [
"CVE-2007-1956"
],
"29827": [
"CVE-2007-1906"
],
"29828": [
"CVE-2007-2011"
],
"29829": [
"CVE-2007-2013"
],
"29830": [
"CVE-2007-2014"
],
"29831": [
"CVE-2007-1364"
],
"29832": [
"CVE-2007-1363"
],
"29833": [
"CVE-2007-1363"
],
"29834": [],
"29838": [
"CVE-2007-1989"
],
"29839": [
"CVE-2007-1989"
],
"29841": [
"CVE-2007-2155"
],
"29842": [
"CVE-2007-2232"
],
"29844": [
"CVE-2007-2233"
],
"29845": [
"CVE-2007-2300"
],
"29846": [
"CVE-2007-2300"
],
"29847": [
"CVE-2007-2300"
],
"29848": [
"CVE-2007-2090"
],
"29849": [
"CVE-2007-1872"
],
"29851": [
"CVE-2007-2061"
],
"29852": [],
"29854": [
"CVE-2007-2310"
],
"29855": [
"CVE-2007-2308"
],
"29861": [],
"29862": [],
"29863": [
"CVE-2007-2064"
],
"29864": [
"CVE-2007-2081"
],
"29865": [
"CVE-2007-2098"
],
"29866": [],
"29868": [],
"29869": [
"CVE-2007-2257"
],
"29870": [
"CVE-2007-2337"
],
"29871": [
"CVE-2007-2337"
],
"29872": [
"CVE-2007-2252"
],
"29874": [
"CVE-2007-2503"
],
"29876": [
"CVE-2007-2256"
],
"29877": [
"CVE-2007-2207"
],
"29878": [],
"29879": [
"CVE-2007-2258"
],
"29880": [
"CVE-2007-2262"
],
"29882": [
"CVE-2007-2247"
],
"29883": [
"CVE-2007-2202"
],
"29885": [],
"29886": [
"CVE-2007-2205"
],
"29887": [
"CVE-2007-2248"
],
"29888": [
"CVE-2007-2248"
],
"29889": [
"CVE-2007-2249"
],
"29890": [
"CVE-2007-2250"
],
"29891": [
"CVE-2007-2338"
],
"29892": [
"CVE-2007-2339"
],
"29893": [
"CVE-2007-2339"
],
"29894": [
"CVE-2007-2339"
],
"29895": [],
"29898": [
"CVE-2007-2268"
],
"29899": [
"CVE-2007-2325"
],
"29902": [],
"29903": [
"CVE-2007-2428"
],
"29904": [
"CVE-2007-2290"
],
"29905": [
"CVE-2007-2290"
],
"29906": [
"CVE-2007-2290"
],
"29907": [
"CVE-2007-2287"
],
"29908": [
"CVE-2007-2474"
],
"29909": [
"CVE-2007-2326"
],
"29910": [
"CVE-2007-2327"
],
"29911": [
"CVE-2007-2330"
],
"29912": [
"CVE-2007-2330"
],
"29913": [],
"29914": [
"CVE-2007-2288"
],
"29915": [
"CVE-2007-2423"
],
"29917": [],
"29918": [],
"29921": [],
"29924": [],
"29927": [
"CVE-2013-7043"
],
"29929": [
"CVE-2007-2420"
],
"29933": [
"CVE-2007-2810"
],
"29935": [],
"29938": [
"CVE-2007-2416"
],
"29941": [
"CVE-2007-2473"
],
"29944": [
"CVE-2007-2628"
],
"29946": [],
"30197": [
"CVE-2007-3127"
],
"30198": [
"CVE-2007-3310"
],
"30199": [
"CVE-2007-3266"
],
"30059": [],
"29953": [],
"29955": [],
"29956": [
"CVE-2007-2532"
],
"29957": [
"CVE-2007-2532"
],
"29958": [
"CVE-2007-2561"
],
"29959": [
"CVE-2013-6023"
],
"29960": [
"CVE-2007-2549"
],
"29961": [
"CVE-2007-2547"
],
"29962": [
"CVE-2007-2524"
],
"29963": [],
"29965": [
"CVE-2007-0605"
],
"29966": [
"CVE-2006-5911"
],
"29967": [
"CVE-2006-5911"
],
"29968": [
"CVE-2006-5911"
],
"29969": [
"CVE-2006-5911"
],
"29970": [
"CVE-2006-5911"
],
"29971": [
"CVE-2006-5911"
],
"29972": [
"CVE-2006-5911"
],
"29973": [
"CVE-2006-5911"
],
"29974": [
"CVE-2006-5911"
],
"29975": [
"CVE-2006-5911"
],
"29976": [
"CVE-2006-5911"
],
"29977": [
"CVE-2006-5911"
],
"29978": [
"CVE-2006-5911"
],
"29979": [
"CVE-2006-5911"
],
"29980": [
"CVE-2006-5911"
],
"29981": [
"CVE-2006-5911"
],
"29982": [
"CVE-2006-5911"
],
"29983": [
"CVE-2006-5911"
],
"29984": [
"CVE-2006-5911"
],
"29985": [
"CVE-2006-5911"
],
"29986": [
"CVE-2006-5911"
],
"29987": [
"CVE-2006-5911"
],
"29988": [
"CVE-2006-5911"
],
"29989": [
"CVE-2006-5911"
],
"29990": [
"CVE-2006-5911"
],
"29991": [
"CVE-2006-5911"
],
"29996": [
"CVE-2006-5911"
],
"29997": [
"CVE-2006-5911"
],
"29998": [
"CVE-2006-5911"
],
"29999": [
"CVE-2006-5911"
],
"30000": [],
"30002": [
"CVE-2013-7187"
],
"30003": [
"CVE-2006-5911"
],
"30004": [
"CVE-2006-5911"
],
"30005": [
"CVE-2006-5911"
],
"30006": [
"CVE-2006-5911"
],
"30012": [
"CVE-2013-6787"
],
"30013": [
"CVE-2013-6341"
],
"30062": [
"CVE-2013-5945"
],
"30063": [],
"30064": [],
"30065": [
"CVE-2007-2806"
],
"30066": [
"CVE-2007-2685"
],
"30068": [
"CVE-2007-2686"
],
"30070": [],
"30071": [
"CVE-2007-2857"
],
"30073": [],
"30075": [
"CVE-2007-2865"
],
"30076": [
"CVE-2007-2887"
],
"30077": [
"CVE-2007-2832"
],
"30079": [],
"30081": [
"CVE-2007-2892"
],
"30082": [
"CVE-2007-2879"
],
"30083": [],
"30084": [],
"30086": [
"CVE-2007-2932"
],
"30087": [],
"30088": [
"CVE-2007-5579"
],
"30095": [
"CVE-2007-0693"
],
"30097": [
"CVE-2007-3170"
],
"30098": [
"CVE-2007-3171"
],
"30099": [
"CVE-2007-0693"
],
"30101": [
"CVE-2007-2959"
],
"30102": [],
"30103": [],
"30213": [
"CVE-2013-7194"
],
"30215": [],
"30283": [
"CVE-2007-3636"
],
"30216": [
"CVE-2007-3339"
],
"30217": [],
"30220": [
"CVE-2007-3346"
],
"30221": [],
"30223": [
"CVE-2007-3354"
],
"30225": [
"CVE-2007-3394"
],
"30226": [
"CVE-2007-3394"
],
"30227": [],
"30230": [
"CVE-2007-2520"
],
"30232": [
"CVE-2007-3182"
],
"30234": [
"CVE-2007-3183"
],
"30235": [],
"30238": [],
"30366": [],
"30246": [],
"30248": [],
"30249": [],
"30250": [
"CVE-2006-6355"
],
"30253": [
"CVE-2007-2801"
],
"30259": [
"CVE-2007-3517"
],
"30260": [
"CVE-2007-3572"
],
"30261": [
"CVE-2007-3555"
],
"30262": [
"CVE-2007-3556"
],
"30263": [
"CVE-2007-3569"
],
"30266": [
"CVE-2007-3593"
],
"30267": [
"CVE-2007-3593"
],
"30268": [
"CVE-2007-3593"
],
"30269": [
"CVE-2007-3593"
],
"30270": [
"CVE-2007-3593"
],
"30271": [
"CVE-2007-3594"
],
"30272": [
"CVE-2007-3594"
],
"30273": [
"CVE-2007-3594"
],
"30274": [
"CVE-2007-3594"
],
"30275": [
"CVE-2007-3594"
],
"30277": [
"CVE-2007-3619"
],
"30282": [
"CVE-2007-3629"
],
"30286": [
"CVE-2007-3714"
],
"30289": [
"CVE-2005-1413"
],
"30290": [],
"30293": [
"CVE-2007-3693"
],
"30294": [
"CVE-2007-3789"
],
"30296": [
"CVE-2007-3013"
],
"30297": [
"CVE-2007-3014"
],
"30298": [
"CVE-2007-3014"
],
"30299": [
"CVE-2007-3017"
],
"30300": [
"CVE-2007-3824"
],
"30301": [
"CVE-2007-3792"
],
"30302": [
"CVE-2007-3792"
],
"30303": [
"CVE-2007-3792"
],
"30383": [
"CVE-2007-4088"
],
"30384": [
"CVE-2007-4088"
],
"30385": [
"CVE-2007-4088"
],
"30386": [
"CVE-2007-4088"
],
"30387": [
"CVE-2007-4089"
],
"30388": [
"CVE-2007-4089"
],
"30389": [
"CVE-2007-4092"
],
"30390": [
"CVE-2007-4095"
],
"30391": [],
"30801": [
"CVE-2007-6001"
],
"30310": [],
"30311": [],
"30312": [
"CVE-2007-3822"
],
"30313": [
"CVE-2007-3838"
],
"30316": [
"CVE-2007-3884"
],
"30317": [
"CVE-2007-3889"
],
"30318": [
"CVE-2007-3888"
],
"30320": [
"CVE-2007-4047"
],
"30321": [
"CVE-2007-4047"
],
"30323": [
"CVE-2007-3963"
],
"30324": [
"CVE-2007-3963"
],
"30978": [
"CVE-2008-0192"
],
"30327": [
"CVE-2007-3989"
],
"30328": [
"CVE-2007-4076"
],
"30329": [
"CVE-2013-7316"
],
"30330": [
"CVE-2007-4075"
],
"30331": [
"CVE-2007-3991"
],
"30332": [
"CVE-2007-3987"
],
"30333": [],
"30382": [
"CVE-2007-4024"
],
"30378": [],
"30379": [],
"30380": [
"CVE-2007-4022"
],
"30803": [],
"30793": [
"CVE-2007-6138"
],
"30794": [],
"30375": [],
"30358": [
"CVE-2013-7136"
],
"30792": [],
"30356": [
"CVE-2013-7274"
],
"30415": [
"CVE-2013-6976"
],
"30357": [],
"30361": [],
"30362": [
"CVE-2013-6976"
],
"30876": [],
"30364": [],
"30365": [],
"30800": [],
"30396": [
"CVE-2013-6884",
"CVE-2013-6881",
"CVE-2013-6882",
"CVE-2013-6883"
],
"30398": [
"CVE-2013-6839"
],
"40521": [],
"30402": [
"CVE-2007-4052"
],
"30403": [
"CVE-2007-4104"
],
"40518": [],
"40519": [],
"30405": [
"CVE-2007-3909"
],
"30408": [
"CVE-2013-5573"
],
"30409": [
"CVE-2013-5676"
],
"31463": [],
"31466": [
"CVE-2008-6555"
],
"31467": [
"CVE-2008-1504"
],
"31468": [],
"30799": [
"CVE-2007-6136"
],
"30873": [
"CVE-2007-6380"
],
"30874": [
"CVE-2007-6380"
],
"30875": [
"CVE-2007-6380"
],
"30423": [
"CVE-2007-4116"
],
"30424": [
"CVE-2007-4119"
],
"30425": [
"CVE-2007-4109"
],
"30426": [
"CVE-2007-4110"
],
"30427": [
"CVE-2007-4106"
],
"30428": [
"CVE-2007-4111"
],
"30429": [
"CVE-2007-4143"
],
"30433": [
"CVE-2007-4115"
],
"30434": [
"CVE-2007-4115"
],
"30435": [
"CVE-2007-4115"
],
"30436": [
"CVE-2007-4101"
],
"30437": [
"CVE-2007-4101"
],
"30438": [
"CVE-2007-4101"
],
"30440": [
"CVE-2007-4146"
],
"30442": [
"CVE-2007-4178"
],
"30443": [],
"30445": [
"CVE-2007-4186"
],
"30446": [
"CVE-2007-4173"
],
"30448": [
"CVE-2007-4210"
],
"30449": [
"CVE-2007-4210"
],
"30450": [
"CVE-2007-4210"
],
"30451": [
"CVE-2007-4208"
],
"30452": [
"CVE-2007-4244"
],
"30453": [
"CVE-2007-4264"
],
"30456": [
"CVE-2007-4235"
],
"30457": [
"CVE-2007-4235"
],
"30810": [
"CVE-2007-6158"
],
"30459": [
"CVE-2007-4235"
],
"30463": [
"CVE-2007-4283"
],
"30900": [],
"30465": [
"CVE-2007-4325"
],
"30466": [
"CVE-2007-4327"
],
"30467": [
"CVE-2007-4327"
],
"30472": [
"CVE-2013-7091"
],
"30475": [
"CVE-2013-6987"
],
"30476": [],
"30478": [],
"30479": [
"CVE-2007-4330"
],
"30480": [
"CVE-2007-4328"
],
"30481": [
"CVE-2007-4329"
],
"30482": [
"CVE-2007-4329"
],
"30483": [
"CVE-2007-4329"
],
"30486": [
"CVE-2007-4341"
],
"30487": [
"CVE-2007-4334"
],
"30488": [
"CVE-2007-4338"
],
"30489": [],
"30492": [
"CVE-2007-4359"
],
"30501": [
"CVE-2007-4384"
],
"30504": [
"CVE-2007-4419"
],
"30505": [
"CVE-2007-4434"
],
"30509": [
"CVE-2007-4457"
],
"30510": [
"CVE-2007-4458"
],
"30511": [
"CVE-2007-4491"
],
"30514": [
"CVE-2007-4479"
],
"30515": [
"CVE-2005-4053"
],
"30516": [
"CVE-2006-1151"
],
"30518": [
"CVE-2007-4522"
],
"30520": [
"CVE-2007-4482"
],
"30525": [
"CVE-2007-4551"
],
"30531": [],
"30533": [
"CVE-2007-4611"
],
"30534": [],
"30539": [
"CVE-2007-4603"
],
"30541": [
"CVE-2007-4634"
],
"30545": [
"CVE-2007-4630"
],
"30547": [],
"30969": [
"CVE-2008-0094"
],
"31030": [
"CVE-2008-4616"
],
"30872": [
"CVE-2014-10038"
],
"30553": [
"CVE-2007-4711"
],
"30554": [
"CVE-2007-4711"
],
"30555": [],
"30556": [
"CVE-2007-4718"
],
"30557": [
"CVE-2007-4717"
],
"30558": [
"CVE-2007-4717"
],
"30559": [
"CVE-2007-4717"
],
"30560": [
"CVE-2007-4719"
],
"31025": [],
"30877": [
"CVE-2007-6321"
],
"30878": [
"CVE-2007-6374"
],
"30879": [
"CVE-2007-6374"
],
"30880": [
"CVE-2007-6375"
],
"30881": [
"CVE-2007-6376"
],
"30563": [
"CVE-2006-7196"
],
"30564": [
"CVE-2007-4762"
],
"30568": [],
"30570": [
"CVE-2007-4896"
],
"30571": [],
"30572": [],
"30573": [],
"30575": [
"CVE-2007-4899"
],
"30576": [
"CVE-2007-4899"
],
"30577": [
"CVE-2007-4892"
],
"32387": [
"CVE-2008-4139"
],
"32415": [
"CVE-2008-5998"
],
"32413": [],
"32412": [
"CVE-2008-5997"
],
"32411": [
"CVE-2008-6406"
],
"32410": [
"CVE-2008-4344"
],
"32389": [
"CVE-2008-4140"
],
"32409": [
"CVE-2008-6034"
],
"32408": [
"CVE-2008-6026"
],
"32407": [
"CVE-2008-6039"
],
"32406": [
"CVE-2008-6045"
],
"32405": [
"CVE-2008-6044"
],
"32404": [
"CVE-2008-3098"
],
"32403": [
"CVE-2008-6038"
],
"32402": [],
"32401": [],
"35491": [],
"32398": [
"CVE-2008-6404"
],
"32397": [
"CVE-2008-6043"
],
"32396": [],
"32395": [
"CVE-2008-7008"
],
"32394": [],
"32392": [],
"32388": [
"CVE-2008-4172"
],
"33984": [],
"30581": [
"CVE-2007-4937"
],
"30583": [
"CVE-2007-4917"
],
"30585": [
"CVE-2007-4930"
],
"30586": [
"CVE-2007-4930"
],
"30587": [
"CVE-2007-4930"
],
"30588": [
"CVE-2007-4925"
],
"30591": [
"CVE-2007-3010"
],
"30594": [
"CVE-2007-4977"
],
"30595": [
"CVE-2007-4976"
],
"30596": [
"CVE-2007-4975"
],
"30597": [
"CVE-2007-5027"
],
"30598": [
"CVE-2007-5010"
],
"30599": [
"CVE-2007-5011"
],
"30601": [
"CVE-2007-5052"
],
"30602": [
"CVE-2007-5105"
],
"30603": [
"CVE-2007-5060"
],
"30606": [
"CVE-2007-5112"
],
"30607": [],
"30608": [
"CVE-2007-5120"
],
"30609": [
"CVE-2007-5120"
],
"30610": [
"CVE-2007-5120"
],
"30611": [
"CVE-2007-5120"
],
"30612": [
"CVE-2007-5120"
],
"30613": [
"CVE-2007-5120"
],
"30614": [
"CVE-2007-5092"
],
"30615": [
"CVE-2007-5127"
],
"30616": [
"CVE-2007-5127"
],
"30617": [
"CVE-2007-4874"
],
"30618": [
"CVE-2007-4874"
],
"30621": [
"CVE-2007-5142"
],
"30623": [
"CVE-2007-5222"
],
"30624": [
"CVE-2007-5181"
],
"30625": [
"CVE-2007-5180"
],
"30626": [
"CVE-2007-5180"
],
"30629": [
"CVE-2008-6875"
],
"30632": [
"CVE-2007-5218"
],
"30633": [
"CVE-2007-5235"
],
"30634": [
"CVE-2006-3173"
],
"30637": [
"CVE-2007-5229"
],
"30638": [],
"30968": [
"CVE-2008-0094"
],
"30639": [
"CVE-2007-5253"
],
"30640": [],
"30641": [
"CVE-2007-5290"
],
"30642": [
"CVE-2007-5290"
],
"30647": [],
"30649": [
"CVE-2007-5370"
],
"30651": [
"CVE-2007-5410"
],
"30653": [
"CVE-2007-5386"
],
"30654": [
"CVE-2007-5426"
],
"30655": [
"CVE-2007-5427"
],
"30656": [
"CVE-2007-5417"
],
"30657": [
"CVE-2007-5428"
],
"30658": [
"CVE-2007-5440"
],
"30659": [
"CVE-2007-5429"
],
"30660": [
"CVE-2007-5430"
],
"30661": [
"CVE-2007-5113"
],
"30662": [
"CVE-2007-5430"
],
"30663": [
"CVE-2007-4486"
],
"30664": [
"CVE-2007-5430"
],
"30665": [
"CVE-2013-7282"
],
"30667": [
"CVE-2014-0621"
],
"30668": [
"CVE-2014-0620"
],
"30669": [],
"30865": [
"CVE-2014-10037"
],
"30795": [],
"30796": [],
"31530": [],
"31531": [
"CVE-2008-1607"
],
"30674": [
"CVE-2007-5478"
],
"30675": [
"CVE-2007-5480"
],
"30676": [
"CVE-2007-5480"
],
"30682": [
"CVE-2007-5694"
],
"30683": [
"CVE-2007-5693"
],
"30684": [
"CVE-2007-5692"
],
"30685": [
"CVE-2007-5692"
],
"30686": [
"CVE-2007-5692"
],
"30804": [
"CVE-2007-6141"
],
"30689": [
"CVE-2014-10032"
],
"31027": [
"CVE-2008-0334"
],
"31028": [
"CVE-2008-0286"
],
"31029": [
"CVE-2008-7216"
],
"30691": [
"CVE-2007-5190"
],
"30693": [
"CVE-2007-5647"
],
"30694": [
"CVE-2007-5649"
],
"30695": [
"CVE-2007-5648"
],
"30696": [
"CVE-2007-5625"
],
"30697": [
"CVE-2007-5650"
],
"30698": [],
"30699": [
"CVE-2007-5677"
],
"30700": [
"CVE-2007-5679"
],
"30701": [
"CVE-2007-5706"
],
"30703": [
"CVE-2007-5733"
],
"30704": [
"CVE-2007-5739"
],
"30705": [
"CVE-2007-5737"
],
"30706": [],
"30707": [],
"30708": [
"CVE-2007-6032"
],
"30712": [
"CVE-2007-5688"
],
"30715": [
"CVE-2007-5710"
],
"30716": [
"CVE-2007-5725"
],
"30717": [
"CVE-2007-5724"
],
"30718": [
"CVE-2007-4862"
],
"30719": [
"CVE-2007-4863"
],
"30806": [
"CVE-2007-6135"
],
"30807": [
"CVE-2007-6163"
],
"30808": [],
"30723": [
"CVE-2013-6924"
],
"30725": [
"CVE-2013-6924"
],
"30726": [
"CVE-2013-6922"
],
"30727": [
"CVE-2013-6923"
],
"30731": [
"CVE-2007-5802"
],
"30732": [
"CVE-2007-5816"
],
"30733": [
"CVE-2007-5589"
],
"30734": [
"CVE-2007-5952"
],
"30735": [
"CVE-2007-5915"
],
"30737": [
"CVE-2007-5567"
],
"30738": [
"CVE-2007-5951"
],
"30739": [
"CVE-2007-5954"
],
"30741": [
"CVE-2007-5890"
],
"30743": [
"CVE-2007-5776"
],
"30745": [
"CVE-2007-5918"
],
"30746": [
"CVE-2007-5923"
],
"30747": [],
"30748": [
"CVE-2007-5978"
],
"30750": [],
"30751": [
"CVE-2007-3694"
],
"30754": [
"CVE-2007-5983"
],
"30757": [
"CVE-2007-5982"
],
"30758": [
"CVE-2007-5982"
],
"30759": [
"CVE-2007-5993"
],
"30762": [],
"30764": [
"CVE-2007-5817"
],
"30770": [
"CVE-2007-6056"
],
"30774": [
"CVE-2007-6055"
],
"30775": [
"CVE-2007-6091"
],
"30777": [
"CVE-2007-6037"
],
"30778": [],
"30975": [
"CVE-2008-0146"
],
"30976": [],
"30977": [
"CVE-2008-0192"
],
"30786": [],
"30790": [
"CVE-2014-1619"
],
"30811": [
"CVE-2007-6157"
],
"30813": [
"CVE-2007-6162"
],
"30815": [
"CVE-2007-6160"
],
"30817": [
"CVE-2007-6173"
],
"30818": [
"CVE-2007-6110"
],
"30820": [
"CVE-2007-6191"
],
"30821": [
"CVE-2007-6191"
],
"30822": [
"CVE-2007-6198"
],
"30823": [
"CVE-2007-6266"
],
"30824": [
"CVE-2007-6266"
],
"30826": [
"CVE-2007-6218"
],
"30827": [
"CVE-2007-6218"
],
"30828": [
"CVE-2007-6218"
],
"30829": [
"CVE-2007-6218"
],
"30830": [
"CVE-2007-6218"
],
"30831": [
"CVE-2007-6218"
],
"30836": [
"CVE-2007-6275"
],
"30841": [
"CVE-2007-6268"
],
"30842": [
"CVE-2007-6269"
],
"30843": [
"CVE-2007-6270"
],
"30844": [
"CVE-2007-6270"
],
"30845": [
"CVE-2007-6271"
],
"30846": [
"CVE-2007-6297"
],
"30847": [
"CVE-2007-6297"
],
"30848": [
"CVE-2007-6272"
],
"30849": [
"CVE-2007-6272"
],
"30851": [],
"30852": [],
"30853": [
"CVE-2007-6301"
],
"30854": [
"CVE-2007-6307"
],
"30855": [],
"30857": [
"CVE-2007-6309"
],
"30858": [
"CVE-2007-6309"
],
"30859": [],
"30860": [],
"30861": [
"CVE-2007-6380"
],
"30862": [
"CVE-2007-6380"
],
"30863": [
"CVE-2007-6380"
],
"30864": [
"CVE-2007-6380"
],
"30884": [],
"30886": [
"CVE-2007-6467"
],
"30887": [
"CVE-2007-6471"
],
"30888": [
"CVE-2007-6470"
],
"30889": [],
"30890": [],
"30891": [],
"30892": [],
"30893": [],
"30899": [
"CVE-2007-6455"
],
"30909": [],
"30910": [],
"30911": [
"CVE-2014-10010",
"CVE-2014-10001"
],
"30912": [],
"30913": [
"CVE-2014-10015",
"CVE-2014-10014"
],
"30914": [
"CVE-2013-7204"
],
"30916": [
"CVE-2013-7137"
],
"30917": [
"CVE-2013-7139"
],
"30918": [
"CVE-2007-6539"
],
"30919": [
"CVE-2007-6515"
],
"30921": [
"CVE-2007-6538"
],
"30923": [],
"30924": [
"CVE-2007-6574"
],
"30925": [
"CVE-2007-6574"
],
"30926": [
"CVE-2007-6574"
],
"30927": [],
"30929": [
"CVE-2007-6559"
],
"30930": [
"CVE-2007-6559"
],
"30931": [
"CVE-2007-6560"
],
"30932": [
"CVE-2007-6560"
],
"30937": [
"CVE-2007-6564"
],
"30938": [],
"30940": [
"CVE-2007-6597"
],
"30941": [
"CVE-2007-6597"
],
"30945": [
"CVE-2007-6633"
],
"30946": [
"CVE-2013-6872"
],
"30947": [
"CVE-2007-6634"
],
"30948": [
"CVE-2007-6608"
],
"30949": [
"CVE-2007-6608"
],
"30950": [],
"30951": [
"CVE-2007-6608"
],
"30952": [],
"30953": [],
"30954": [],
"30955": [],
"30957": [
"CVE-2007-6670"
],
"30958": [
"CVE-2007-6669"
],
"30959": [
"CVE-2007-6673"
],
"30960": [],
"30961": [],
"30962": [
"CVE-2007-6641"
],
"30963": [
"CVE-2007-6671"
],
"30964": [
"CVE-2007-6646"
],
"30965": [
"CVE-2007-6646"
],
"30966": [
"CVE-2007-6646"
],
"30967": [
"CVE-2007-6646"
],
"30979": [
"CVE-2008-0193"
],
"30980": [
"CVE-2008-0190"
],
"30981": [
"CVE-2008-0207"
],
"30982": [],
"30983": [],
"30984": [],
"31083": [
"CVE-2008-0559"
],
"30987": [],
"30988": [],
"30992": [],
"30993": [],
"30994": [
"CVE-2008-0266"
],
"30995": [
"CVE-2008-0268"
],
"30996": [
"CVE-2008-0267"
],
"30997": [
"CVE-2008-0267"
],
"31000": [
"CVE-2008-0184"
],
"31001": [
"CVE-2008-0218"
],
"31003": [
"CVE-2008-1134"
],
"31004": [
"CVE-2008-0239"
],
"31005": [
"CVE-2008-0239"
],
"31006": [
"CVE-2008-0240"
],
"31007": [
"CVE-2008-0239"
],
"31008": [],
"31009": [
"CVE-2008-0281"
],
"31011": [
"CVE-2008-0289"
],
"31082": [
"CVE-2008-0178"
],
"31015": [],
"31017": [],
"31020": [
"CVE-2008-0123"
],
"31022": [
"CVE-2008-0258"
],
"31034": [
"CVE-2008-0383"
],
"31035": [],
"31037": [
"CVE-2008-0433"
],
"31038": [
"CVE-2008-0432"
],
"31041": [],
"31042": [
"CVE-2008-0436"
],
"31043": [
"CVE-2008-7165"
],
"31044": [
"CVE-2008-0400"
],
"31045": [],
"31048": [
"CVE-2008-0451"
],
"31049": [
"CVE-2008-0439"
],
"31055": [],
"31058": [
"CVE-2008-0744"
],
"31059": [],
"31061": [
"CVE-2008-0540"
],
"31062": [
"CVE-2008-0540"
],
"31063": [
"CVE-2007-6696"
],
"31064": [
"CVE-2007-6696"
],
"31065": [
"CVE-2008-0539"
],
"31066": [
"CVE-2008-7213"
],
"31067": [
"CVE-2008-0489"
],
"31068": [],
"31069": [
"CVE-2008-0552"
],
"31070": [
"CVE-2008-0487"
],
"31071": [
"CVE-2008-0488"
],
"31073": [
"CVE-2008-4727"
],
"31074": [
"CVE-2008-0497"
],
"31075": [
"CVE-2008-0496"
],
"31077": [],
"31079": [
"CVE-2008-0574"
],
"31080": [
"CVE-2008-4611"
],
"31081": [
"CVE-2007-6700"
],
"31084": [],
"31085": [],
"31086": [],
"31087": [
"CVE-2014-10018"
],
"31088": [],
"31091": [
"CVE-2008-0688"
],
"31092": [
"CVE-2008-0691"
],
"31093": [
"CVE-2008-0685"
],
"31094": [
"CVE-2008-0684"
],
"31096": [],
"31097": [
"CVE-2008-0700"
],
"31098": [
"CVE-2008-0650"
],
"31099": [
"CVE-2008-0651"
],
"31101": [],
"31103": [
"CVE-2008-0605"
],
"31104": [
"CVE-2008-0605"
],
"31107": [
"CVE-2008-0645"
],
"31108": [
"CVE-2008-0645"
],
"31109": [
"CVE-2008-0645"
],
"31110": [
"CVE-2008-0645"
],
"31111": [],
"31112": [
"CVE-2008-7036"
],
"31115": [
"CVE-2008-0723"
],
"31116": [
"CVE-2008-0722"
],
"31117": [
"CVE-2008-5692"
],
"31120": [
"CVE-2008-7242"
],
"31121": [],
"31124": [
"CVE-2008-0749"
],
"31125": [
"CVE-2008-0743"
],
"31126": [
"CVE-2008-0751"
],
"31129": [
"CVE-2008-0636"
],
"31131": [],
"31134": [
"CVE-2008-0753"
],
"31135": [],
"31137": [],
"31140": [
"CVE-2014-10002",
"CVE-2008-0685"
],
"31141": [],
"31142": [
"CVE-2014-10020"
],
"31143": [],
"31144": [],
"31145": [],
"31146": [],
"31147": [],
"31154": [
"CVE-2008-0733"
],
"31155": [],
"31156": [
"CVE-2008-0785"
],
"31157": [
"CVE-2008-0783"
],
"31158": [
"CVE-2008-0783"
],
"31159": [
"CVE-2008-0785"
],
"31160": [
"CVE-2008-0785"
],
"31161": [
"CVE-2008-0785"
],
"31162": [
"CVE-2008-0815"
],
"31164": [],
"31258": [],
"31335": [
"CVE-2008-1228"
],
"40357": [],
"31700": [],
"31701": [
"CVE-2008-1985"
],
"31173": [],
"31174": [
"CVE-2014-0793"
],
"31175": [
"CVE-2014-0794"
],
"31180": [
"CVE-2013-7248",
"CVE-2013-7247"
],
"31183": [
"CVE-2014-1683"
],
"31272": [],
"31273": [],
"31274": [],
"31269": [
"CVE-2008-0980"
],
"31270": [
"CVE-2008-0982"
],
"31265": [
"CVE-2008-0980"
],
"31266": [
"CVE-2008-0980"
],
"31267": [
"CVE-2008-0980"
],
"31268": [
"CVE-2008-0980"
],
"31189": [
"CVE-2008-0026"
],
"31191": [
"CVE-2008-7030"
],
"31192": [],
"31193": [],
"31194": [
"CVE-2008-0850"
],
"31195": [
"CVE-2008-0850"
],
"31196": [
"CVE-2008-0851"
],
"31197": [
"CVE-2008-0851"
],
"31198": [
"CVE-2008-0851"
],
"31199": [
"CVE-2008-0850"
],
"31200": [
"CVE-2008-0850"
],
"31201": [],
"31202": [
"CVE-2008-0819"
],
"31206": [],
"31207": [],
"31208": [
"CVE-2008-0816"
],
"31209": [],
"31210": [],
"31211": [],
"31212": [],
"31213": [
"CVE-2008-0854"
],
"31214": [],
"31215": [
"CVE-2008-0817"
],
"31216": [
"CVE-2008-0810"
],
"31217": [
"CVE-2008-0812"
],
"32241": [
"CVE-2008-3682"
],
"32242": [
"CVE-2008-5946"
],
"32243": [
"CVE-2008-5945"
],
"32244": [
"CVE-2008-5947"
],
"32245": [
"CVE-2008-5944"
],
"32246": [
"CVE-2008-5943"
],
"32247": [
"CVE-2008-5943"
],
"31221": [],
"31224": [
"CVE-2008-0846"
],
"31225": [
"CVE-2008-7222"
],
"31226": [
"CVE-2008-0853"
],
"31227": [
"CVE-2008-7040"
],
"31228": [],
"31229": [
"CVE-2008-5584"
],
"31230": [
"CVE-2008-0845"
],
"31233": [
"CVE-2008-5674"
],
"31234": [
"CVE-2008-5674"
],
"31235": [
"CVE-2008-0877"
],
"31236": [
"CVE-2008-0877"
],
"31237": [
"CVE-2008-0877"
],
"31238": [
"CVE-2008-0877"
],
"31239": [
"CVE-2008-5283"
],
"31240": [
"CVE-2008-0872"
],
"31241": [],
"31242": [
"CVE-2008-0855"
],
"31243": [],
"31244": [],
"31245": [],
"31246": [],
"31247": [],
"31248": [],
"31249": [],
"31250": [],
"31251": [],
"31252": [
"CVE-2008-0879"
],
"31256": [],
"31331": [],
"31332": [],
"31528": [],
"31261": [],
"31262": [
"CVE-2014-10000"
],
"31263": [],
"31275": [
"CVE-2008-0943"
],
"31276": [
"CVE-2008-0943"
],
"31277": [
"CVE-2008-0943"
],
"31278": [
"CVE-2008-0942"
],
"31280": [],
"31281": [],
"31282": [
"CVE-2008-0937"
],
"31283": [
"CVE-2004-2000"
],
"31284": [
"CVE-2008-0936"
],
"31286": [],
"31287": [
"CVE-2008-7226"
],
"31288": [],
"31289": [],
"31290": [],
"31291": [],
"31292": [],
"31293": [],
"31294": [
"CVE-2008-1050"
],
"31295": [],
"31296": [
"CVE-2008-7033"
],
"31297": [],
"31299": [
"CVE-2008-1045"
],
"31303": [],
"31304": [],
"31313": [
"CVE-2008-1181"
],
"31314": [
"CVE-2008-1174"
],
"31315": [
"CVE-2008-1129"
],
"31317": [
"CVE-2008-2044"
],
"31318": [
"CVE-2008-1178"
],
"31319": [
"CVE-2008-4803"
],
"31320": [
"CVE-2008-1128"
],
"31321": [],
"31322": [
"CVE-2008-1314"
],
"31324": [
"CVE-2008-1170"
],
"31325": [
"CVE-2008-1170"
],
"31326": [],
"31328": [
"CVE-2008-1173"
],
"31329": [
"CVE-2014-1610"
],
"31337": [
"CVE-2008-1225"
],
"31339": [],
"31341": [
"CVE-2008-1370"
],
"31344": [
"CVE-2008-1219"
],
"31529": [],
"31350": [],
"31351": [
"CVE-2008-1220"
],
"31352": [
"CVE-2008-1273"
],
"31353": [
"CVE-2008-1273"
],
"31354": [
"CVE-2008-1273"
],
"31355": [
"CVE-2008-1273"
],
"31356": [
"CVE-2008-1304"
],
"31357": [
"CVE-2008-1304"
],
"31358": [
"CVE-2008-7152"
],
"31365": [
"CVE-2008-1300"
],
"31366": [
"CVE-2008-1301"
],
"31367": [],
"31368": [],
"31369": [
"CVE-2008-1326"
],
"31370": [
"CVE-2008-1327"
],
"31371": [
"CVE-2008-7133"
],
"31372": [
"CVE-2008-7133"
],
"31373": [
"CVE-2008-7133"
],
"31374": [
"CVE-2008-7133"
],
"31375": [
"CVE-2008-1371"
],
"31377": [
"CVE-2008-1298"
],
"31379": [
"CVE-2008-1296"
],
"31380": [
"CVE-2008-1296"
],
"31382": [],
"31383": [
"CVE-2008-1308"
],
"31384": [
"CVE-2008-1315"
],
"31387": [
"CVE-2008-1325"
],
"31388": [
"CVE-2008-1324"
],
"31389": [
"CVE-2008-7134"
],
"31390": [
"CVE-2008-7134"
],
"31391": [
"CVE-2008-7134"
],
"31392": [],
"31393": [
"CVE-2008-1355"
],
"31697": [
"CVE-2008-1974"
],
"31400": [],
"31401": [],
"31402": [
"CVE-2008-1348"
],
"31404": [
"CVE-2008-1354"
],
"31406": [
"CVE-2008-1413"
],
"31408": [
"CVE-2008-1479"
],
"31410": [],
"31411": [
"CVE-2008-1470"
],
"31413": [
"CVE-2008-1463"
],
"31414": [
"CVE-2008-0125"
],
"31415": [],
"31416": [
"CVE-2008-1481"
],
"31418": [],
"31419": [
"CVE-2014-10023"
],
"31420": [],
"31421": [],
"31423": [],
"31424": [],
"31425": [
"CVE-2013-7055",
"CVE-2013-7054",
"CVE-2013-7053",
"CVE-2013-7052",
"CVE-2013-7051"
],
"31426": [],
"31427": [
"CVE-2014-1665"
],
"31430": [],
"31431": [
"CVE-2014-1836"
],
"31435": [],
"31436": [],
"31438": [
"CVE-2007-4592"
],
"31439": [
"CVE-2008-7142"
],
"31441": [],
"31442": [],
"31443": [
"CVE-2008-1458"
],
"31445": [
"CVE-2008-1606"
],
"31446": [
"CVE-2008-1606"
],
"31447": [],
"31448": [
"CVE-2008-1540"
],
"31449": [
"CVE-2008-1466"
],
"31450": [
"CVE-2008-1466"
],
"31451": [
"CVE-2008-1466"
],
"31452": [
"CVE-2008-1466"
],
"31453": [
"CVE-2008-1466"
],
"31454": [
"CVE-2008-1466"
],
"31455": [
"CVE-2008-1466"
],
"31456": [
"CVE-2008-1466"
],
"31457": [
"CVE-2008-1466"
],
"31458": [],
"31459": [],
"31469": [
"CVE-2008-1511"
],
"31470": [
"CVE-2008-1511"
],
"31471": [
"CVE-2008-1500"
],
"31472": [
"CVE-2008-1499"
],
"31475": [
"CVE-2008-1510"
],
"31476": [
"CVE-2008-1508"
],
"31480": [
"CVE-2008-6543"
],
"31481": [
"CVE-2008-6543"
],
"31482": [
"CVE-2008-6543"
],
"31483": [
"CVE-2008-6543"
],
"31484": [
"CVE-2008-6543"
],
"31485": [
"CVE-2008-6543"
],
"31486": [
"CVE-2008-6543"
],
"31487": [
"CVE-2008-6543"
],
"31488": [
"CVE-2008-6543"
],
"31489": [
"CVE-2008-6543"
],
"31490": [
"CVE-2008-6543"
],
"31491": [
"CVE-2008-6543"
],
"31492": [
"CVE-2008-6543"
],
"31493": [
"CVE-2008-6543"
],
"31494": [
"CVE-2008-6543"
],
"31495": [
"CVE-2008-6543"
],
"31496": [
"CVE-2008-6543"
],
"31497": [
"CVE-2008-6543"
],
"31498": [
"CVE-2008-6543"
],
"31499": [
"CVE-2008-6543"
],
"31500": [
"CVE-2008-6543"
],
"31501": [
"CVE-2008-6543"
],
"31502": [
"CVE-2008-6543"
],
"31503": [
"CVE-2008-6543"
],
"31504": [
"CVE-2008-6543"
],
"31505": [
"CVE-2008-6543"
],
"31506": [
"CVE-2008-6543"
],
"31507": [
"CVE-2008-6543"
],
"31508": [
"CVE-2008-6543"
],
"31509": [
"CVE-2008-6543"
],
"31510": [
"CVE-2008-6543"
],
"31511": [
"CVE-2008-6543"
],
"31512": [
"CVE-2008-6543"
],
"31513": [
"CVE-2008-6543"
],
"31514": [
"CVE-2008-6543"
],
"31515": [
"CVE-2014-10033"
],
"31516": [],
"31517": [
"CVE-2013-2639"
],
"31520": [
"CVE-2014-1401"
],
"31521": [
"CVE-2014-1459"
],
"31525": [],
"31527": [
"CVE-2014-0329"
],
"31535": [
"CVE-2008-1565"
],
"31537": [
"CVE-2008-1795"
],
"31538": [
"CVE-2008-1795"
],
"31539": [
"CVE-2008-7145"
],
"31541": [
"CVE-2008-6565"
],
"31543": [
"CVE-2008-1621"
],
"31544": [
"CVE-2008-1621"
],
"31545": [
"CVE-2008-1621"
],
"31546": [
"CVE-2008-1560"
],
"31547": [
"CVE-2008-1560"
],
"31985": [],
"31549": [],
"31555": [
"CVE-2008-6544"
],
"40770": [],
"40353": [],
"31564": [
"CVE-2008-6562"
],
"31565": [
"CVE-2008-7140"
],
"31566": [
"CVE-2008-7140"
],
"31567": [
"CVE-2008-7141"
],
"31568": [],
"31569": [],
"31570": [],
"31571": [
"CVE-2014-1889"
],
"32215": [
"CVE-2008-4435"
],
"32216": [
"CVE-2008-4435"
],
"31573": [],
"31578": [
"CVE-2014-1204"
],
"31579": [
"CVE-2014-1843",
"CVE-2014-1842",
"CVE-2014-1841"
],
"31580": [
"CVE-2005-4879"
],
"31581": [
"CVE-2008-6491"
],
"31582": [
"CVE-2008-1641"
],
"31584": [
"CVE-2008-6522"
],
"31587": [
"CVE-2008-6196"
],
"31588": [
"CVE-2008-6196"
],
"31589": [
"CVE-2008-6196"
],
"31590": [
"CVE-2008-1800"
],
"31595": [
"CVE-2008-4777"
],
"31596": [
"CVE-2008-6211"
],
"31597": [
"CVE-2008-6211"
],
"31598": [
"CVE-2008-6211"
],
"31599": [
"CVE-2008-6211"
],
"31600": [
"CVE-2008-6211"
],
"31601": [
"CVE-2008-6211"
],
"31602": [
"CVE-2008-6211"
],
"31603": [
"CVE-2008-6478"
],
"31604": [
"CVE-2008-6479"
],
"31605": [
"CVE-2008-1787"
],
"31606": [
"CVE-2008-6550"
],
"31608": [
"CVE-2008-1757"
],
"31609": [
"CVE-2008-1873"
],
"31610": [
"CVE-2008-6206"
],
"31611": [
"CVE-2008-6206"
],
"31614": [],
"31616": [
"CVE-2008-6545"
],
"31617": [],
"31618": [],
"31621": [],
"31622": [
"CVE-2008-6205"
],
"31623": [],
"31625": [],
"31626": [],
"31628": [
"CVE-2008-6200"
],
"31631": [
"CVE-2008-1733"
],
"31633": [],
"31636": [
"CVE-2008-1844"
],
"31637": [
"CVE-2008-1843"
],
"31640": [
"CVE-2008-4765"
],
"31641": [],
"31644": [
"CVE-2008-1969"
],
"31645": [
"CVE-2008-1969"
],
"31646": [
"CVE-2008-1969"
],
"31647": [
"CVE-2014-1219"
],
"31648": [
"CVE-2008-1968"
],
"31649": [
"CVE-2008-1968"
],
"31650": [
"CVE-2008-1967"
],
"31651": [
"CVE-2008-1917"
],
"31652": [
"CVE-2008-1917"
],
"31653": [
"CVE-2008-1917"
],
"31654": [
"CVE-2008-1893"
],
"31655": [
"CVE-2008-4911"
],
"31658": [
"CVE-2008-1955"
],
"31659": [
"CVE-2008-6212"
],
"31660": [
"CVE-2008-2037"
],
"31661": [
"CVE-2008-2037"
],
"31662": [
"CVE-2008-2037"
],
"31663": [
"CVE-2008-2037"
],
"31664": [
"CVE-2008-2037"
],
"31665": [
"CVE-2008-2037"
],
"31666": [
"CVE-2008-6203"
],
"31668": [
"CVE-2008-4768"
],
"31669": [
"CVE-2008-1956"
],
"31670": [
"CVE-2008-4769"
],
"31671": [
"CVE-2008-6585"
],
"31672": [
"CVE-2008-6586"
],
"31673": [],
"31674": [],
"31676": [],
"31677": [
"CVE-2008-1983"
],
"31678": [],
"31679": [
"CVE-2007-0820"
],
"31714": [
"CVE-2008-2219"
],
"31681": [
"CVE-2008-2094"
],
"31682": [
"CVE-2008-1385"
],
"31686": [],
"31690": [],
"31691": [],
"31692": [],
"31693": [],
"31702": [
"CVE-2008-4767"
],
"31703": [
"CVE-2008-1986"
],
"31704": [
"CVE-2008-6596"
],
"31705": [
"CVE-2008-6597"
],
"31708": [
"CVE-2010-2918"
],
"31709": [
"CVE-2008-2082"
],
"31716": [
"CVE-2010-5063"
],
"31717": [
"CVE-2008-2187"
],
"31719": [],
"31720": [],
"31721": [
"CVE-2008-2188"
],
"31722": [
"CVE-2008-2188"
],
"31723": [
"CVE-2008-2118"
],
"31724": [
"CVE-2008-2117"
],
"31725": [
"CVE-2008-6615"
],
"31726": [
"CVE-2008-6616"
],
"31727": [
"CVE-2008-2186"
],
"31729": [
"CVE-2008-6617"
],
"31730": [
"CVE-2008-6655"
],
"31731": [
"CVE-2008-6655"
],
"31732": [
"CVE-2008-6655"
],
"31733": [],
"32240": [],
"31734": [],
"31735": [],
"31738": [
"CVE-2014-1206"
],
"31739": [],
"31740": [
"CVE-2008-2196"
],
"31741": [
"CVE-2008-2202"
],
"31742": [
"CVE-2008-2202"
],
"31743": [
"CVE-2008-2202"
],
"31744": [],
"31745": [
"CVE-2008-6640"
],
"31746": [
"CVE-2008-6640"
],
"31747": [
"CVE-2008-2130"
],
"31749": [],
"31750": [
"CVE-2008-2110"
],
"31751": [
"CVE-2008-5211"
],
"31752": [
"CVE-2008-2227"
],
"31753": [
"CVE-2008-2126"
],
"31754": [
"CVE-2008-2123"
],
"31755": [
"CVE-2008-2123"
],
"31760": [],
"31764": [],
"31765": [],
"31768": [],
"31771": [
"CVE-2008-2070"
],
"31772": [
"CVE-2008-2070"
],
"31773": [
"CVE-2008-2070"
],
"31774": [
"CVE-2008-6631"
],
"31775": [],
"31776": [],
"31777": [],
"31778": [
"CVE-2008-2449"
],
"31779": [
"CVE-2008-2449"
],
"31780": [
"CVE-2008-2264"
],
"31781": [],
"31782": [],
"31783": [
"CVE-2008-2284"
],
"31784": [],
"31787": [],
"31790": [],
"31792": [
"CVE-2014-10009",
"CVE-2014-10008"
],
"31793": [],
"31794": [],
"31795": [],
"31797": [
"CVE-2008-2334"
],
"31798": [
"CVE-2008-2334"
],
"31799": [
"CVE-2008-2334"
],
"31800": [
"CVE-2008-2339"
],
"31801": [
"CVE-2008-2412"
],
"31802": [
"CVE-2008-2413"
],
"31803": [
"CVE-2008-2414"
],
"31804": [
"CVE-2008-2415"
],
"31805": [],
"31806": [
"CVE-2008-2350"
],
"31807": [
"CVE-2008-2478"
],
"31808": [
"CVE-2008-2398"
],
"31809": [
"CVE-2008-2458"
],
"31810": [
"CVE-2008-2422"
],
"31811": [],
"31812": [],
"31813": [],
"31816": [
"CVE-2008-2421"
],
"31821": [
"CVE-2008-6437"
],
"31822": [
"CVE-2008-6437"
],
"31823": [
"CVE-2008-6435"
],
"31824": [
"CVE-2008-6435"
],
"31825": [
"CVE-2008-6431"
],
"31826": [
"CVE-2008-6431"
],
"31827": [
"CVE-2008-6431"
],
"31829": [
"CVE-2008-6572"
],
"31830": [
"CVE-2008-6439"
],
"32045": [
"CVE-2008-6924"
],
"31833": [
"CVE-2014-2090",
"CVE-2014-2089",
"CVE-2014-2088"
],
"31834": [
"CVE-2014-1854"
],
"31835": [
"CVE-2008-6637"
],
"31836": [
"CVE-2008-2510"
],
"31837": [
"CVE-2008-2781"
],
"31838": [
"CVE-2008-2783"
],
"31839": [
"CVE-2008-2783"
],
"31840": [
"CVE-2008-2783"
],
"31841": [
"CVE-2008-6620"
],
"31842": [
"CVE-2008-2491"
],
"31843": [
"CVE-2008-2509"
],
"31844": [
"CVE-2008-2479"
],
"31845": [
"CVE-2008-2479"
],
"31846": [
"CVE-2008-6618"
],
"31847": [
"CVE-2008-6618"
],
"31848": [
"CVE-2008-6618"
],
"31849": [
"CVE-2008-6619"
],
"31850": [
"CVE-2008-2493"
],
"31851": [
"CVE-2008-2492"
],
"31852": [
"CVE-2008-2492"
],
"31854": [],
"31855": [
"CVE-2008-2508"
],
"31857": [],
"31858": [
"CVE-2008-2507"
],
"31859": [],
"31860": [],
"31861": [
"CVE-2008-5222"
],
"31865": [
"CVE-2008-6644"
],
"31866": [
"CVE-2008-6418"
],
"31867": [],
"31868": [],
"31869": [],
"31870": [],
"31871": [],
"31874": [],
"31880": [],
"31881": [],
"31882": [],
"31883": [],
"31888": [],
"31891": [],
"31892": [
"CVE-2008-5264"
],
"31893": [],
"31894": [
"CVE-2014-1677"
],
"31896": [],
"31898": [
"CVE-2014-10001"
],
"31900": [],
"31902": [],
"31904": [
"CVE-2008-2995"
],
"31905": [
"CVE-2008-2995"
],
"31906": [
"CVE-2008-2994"
],
"31907": [
"CVE-2008-2994"
],
"31908": [
"CVE-2008-6736"
],
"31910": [
"CVE-2008-2744"
],
"31916": [
"CVE-2014-4613"
],
"31929": [],
"31933": [
"CVE-2008-2787"
],
"31938": [],
"31939": [],
"31943": [],
"32214": [
"CVE-2014-1903"
],
"31944": [],
"31945": [
"CVE-2008-2871"
],
"31946": [],
"31947": [],
"31948": [],
"31949": [
"CVE-2008-3186"
],
"31950": [
"CVE-2008-3186"
],
"31951": [
"CVE-2008-3186"
],
"31952": [
"CVE-2008-3186"
],
"31953": [
"CVE-2008-3186"
],
"31954": [
"CVE-2008-2987"
],
"31955": [
"CVE-2008-2987"
],
"31956": [
"CVE-2008-2987"
],
"31960": [],
"31961": [
"CVE-2014-10003",
"CVE-2014-10002"
],
"31962": [],
"31967": [],
"32135": [
"CVE-2008-3448"
],
"32046": [
"CVE-2008-3161"
],
"32047": [],
"31970": [],
"31971": [],
"32094": [],
"31975": [
"CVE-2008-5164"
],
"31976": [
"CVE-2008-5164"
],
"31977": [
"CVE-2008-5163"
],
"31978": [
"CVE-2008-5163"
],
"31982": [
"CVE-2013-6043",
"CVE-2013-6042",
"CVE-2013-6041"
],
"32134": [],
"31983": [
"CVE-2014-9304",
"CVE-2014-9181"
],
"31986": [
"CVE-2014-1908",
"CVE-2014-1907",
"CVE-2014-1906",
"CVE-2014-1905"
],
"31989": [],
"31990": [
"CVE-2013-6231"
],
"31992": [
"CVE-2013-5877"
],
"31993": [
"CVE-2014-0372"
],
"31994": [
"CVE-2014-0379"
],
"31995": [
"CVE-2013-5795"
],
"32001": [
"CVE-2008-3034"
],
"32002": [
"CVE-2008-3034"
],
"32003": [
"CVE-2008-3033"
],
"32004": [
"CVE-2007-3653"
],
"32005": [
"CVE-2007-3653"
],
"32131": [],
"32010": [],
"32011": [
"CVE-2008-3163"
],
"32013": [
"CVE-2008-6837"
],
"32014": [
"CVE-2008-6838"
],
"32015": [
"CVE-2008-3151"
],
"32016": [
"CVE-2008-3164"
],
"32017": [
"CVE-2008-3184"
],
"32020": [
"CVE-2008-3201"
],
"32021": [
"CVE-2008-3202"
],
"32022": [
"CVE-2008-6839"
],
"32023": [
"CVE-2008-6839"
],
"32024": [
"CVE-2008-6840"
],
"32025": [
"CVE-2008-6840"
],
"32026": [
"CVE-2008-6840"
],
"32027": [
"CVE-2008-6840"
],
"32028": [
"CVE-2008-6840"
],
"32029": [
"CVE-2008-6840"
],
"32030": [
"CVE-2008-6840"
],
"32031": [
"CVE-2008-6840"
],
"32032": [
"CVE-2008-6840"
],
"32033": [
"CVE-2008-6840"
],
"32034": [
"CVE-2008-6840"
],
"32035": [
"CVE-2008-6840"
],
"32036": [
"CVE-2008-6840"
],
"32037": [
"CVE-2014-10035",
"CVE-2014-10034"
],
"32038": [
"CVE-2013-6232"
],
"32039": [
"CVE-2013-6233"
],
"32040": [
"CVE-2013-6234"
],
"32283": [
"CVE-2008-4744"
],
"32284": [
"CVE-2008-3774"
],
"32051": [
"CVE-2008-3206"
],
"32053": [
"CVE-2008-3233"
],
"32057": [],
"32058": [
"CVE-2008-7087"
],
"32059": [
"CVE-2008-3260"
],
"32060": [
"CVE-2008-3260"
],
"32061": [
"CVE-2008-3260"
],
"32062": [
"CVE-2008-3260"
],
"32063": [
"CVE-2008-3260"
],
"32064": [
"CVE-2008-3260"
],
"32065": [
"CVE-2008-3260"
],
"32066": [
"CVE-2008-3260"
],
"32067": [
"CVE-2008-3260"
],
"32068": [
"CVE-2008-3260"
],
"32069": [
"CVE-2008-3260"
],
"32070": [
"CVE-2008-3260"
],
"32071": [
"CVE-2008-3261"
],
"32075": [
"CVE-2014-2317",
"CVE-2014-1945"
],
"32076": [
"CVE-2014-1944"
],
"32077": [],
"32078": [],
"32079": [
"CVE-2008-3313"
],
"32080": [
"CVE-2008-3313"
],
"32081": [
"CVE-2008-3312"
],
"32082": [
"CVE-2008-3388"
],
"32083": [
"CVE-2008-3388"
],
"32085": [],
"32087": [
"CVE-2008-3380"
],
"32088": [
"CVE-2008-3347"
],
"32089": [
"CVE-2008-3343"
],
"32090": [
"CVE-2007-3198"
],
"32091": [],
"32092": [
"CVE-2008-3311"
],
"32093": [
"CVE-2008-6443"
],
"32096": [
"CVE-2008-3345"
],
"32097": [
"CVE-2008-3296"
],
"32098": [
"CVE-2008-3295"
],
"32099": [
"CVE-2008-3354"
],
"32100": [
"CVE-2008-3354"
],
"32101": [
"CVE-2008-3299"
],
"32102": [
"CVE-2008-3300"
],
"32106": [
"CVE-2008-3315"
],
"32107": [
"CVE-2008-3315"
],
"32108": [
"CVE-2008-3315"
],
"32109": [
"CVE-2008-3315"
],
"32111": [
"CVE-2008-3310"
],
"32113": [
"CVE-2008-3370"
],
"32114": [
"CVE-2008-3351"
],
"32115": [],
"32116": [
"CVE-2008-3575"
],
"32117": [],
"32118": [],
"32119": [
"CVE-2008-3391"
],
"32120": [
"CVE-2008-3391"
],
"32121": [
"CVE-2008-3375"
],
"32122": [
"CVE-2008-3100"
],
"32123": [],
"32126": [
"CVE-2008-3483"
],
"32128": [
"CVE-2008-3404"
],
"32130": [],
"32139": [
"CVE-2008-3566"
],
"32140": [
"CVE-2008-3513"
],
"32141": [
"CVE-2008-3587"
],
"32142": [
"CVE-2008-3573"
],
"32143": [
"CVE-2008-3582"
],
"32144": [
"CVE-2008-3565"
],
"32145": [
"CVE-2008-3565"
],
"32146": [
"CVE-2008-3565"
],
"32147": [
"CVE-2008-3565"
],
"32148": [
"CVE-2008-3565"
],
"32149": [
"CVE-2008-3565"
],
"32150": [
"CVE-2008-3568"
],
"32151": [
"CVE-2008-3495"
],
"32157": [],
"32161": [],
"32162": [
"CVE-2014-2044"
],
"32168": [
"CVE-2008-3574"
],
"32169": [
"CVE-2008-3510"
],
"32170": [
"CVE-2008-3511"
],
"32171": [
"CVE-2008-3511"
],
"32172": [
"CVE-2008-3511"
],
"32173": [
"CVE-2008-3511"
],
"32174": [
"CVE-2008-3511"
],
"32175": [
"CVE-2008-3511"
],
"32176": [
"CVE-2008-3511"
],
"32177": [
"CVE-2008-3511"
],
"32178": [
"CVE-2008-3511"
],
"32179": [
"CVE-2008-3561"
],
"32180": [
"CVE-2008-3562"
],
"32181": [
"CVE-2008-3556"
],
"32182": [
"CVE-2008-6516"
],
"32183": [
"CVE-2008-6516"
],
"32184": [
"CVE-2008-3559"
],
"32185": [
"CVE-2008-3559"
],
"32186": [],
"32187": [],
"32188": [],
"32190": [
"CVE-2008-3560"
],
"32191": [
"CVE-2008-3512"
],
"32196": [
"CVE-2008-4432"
],
"32198": [
"CVE-2008-3668"
],
"32199": [
"CVE-2008-3668"
],
"32200": [
"CVE-2008-3668"
],
"32201": [
"CVE-2008-3668"
],
"32202": [
"CVE-2008-3668"
],
"32203": [
"CVE-2008-3668"
],
"32204": [],
"32282": [],
"32207": [],
"32211": [],
"32212": [
"CVE-2014-2043"
],
"32213": [
"CVE-2014-1222"
],
"32217": [],
"32218": [
"CVE-2008-4424"
],
"32219": [
"CVE-2008-3700"
],
"32220": [
"CVE-2008-3700"
],
"32221": [
"CVE-2008-3701"
],
"32226": [
"CVE-2008-4439"
],
"32227": [
"CVE-2008-4438"
],
"32230": [
"CVE-2008-3679"
],
"32231": [
"CVE-2008-6066"
],
"32232": [
"CVE-2008-6066"
],
"32233": [
"CVE-2008-6066"
],
"32234": [
"CVE-2008-6066"
],
"32235": [
"CVE-2008-6066"
],
"32236": [
"CVE-2008-6066"
],
"32237": [],
"32238": [],
"32239": [],
"32249": [],
"32250": [],
"32251": [
"CVE-2008-3723"
],
"32252": [
"CVE-2008-3712"
],
"32253": [
"CVE-2008-3712"
],
"32254": [
"CVE-2008-3715"
],
"32255": [
"CVE-2008-3722"
],
"32257": [],
"32258": [
"CVE-2008-3714"
],
"32259": [
"CVE-2008-3770"
],
"33409": [],
"32285": [
"CVE-2008-3773"
],
"32263": [],
"32264": [
"CVE-2008-3770"
],
"32265": [
"CVE-2008-3770"
],
"32266": [
"CVE-2008-3770"
],
"32267": [
"CVE-2008-3770"
],
"32268": [
"CVE-2008-3770"
],
"32269": [
"CVE-2008-3770"
],
"32270": [
"CVE-2008-3770"
],
"32271": [
"CVE-2008-6517"
],
"32272": [
"CVE-2008-3917"
],
"32368": [
"CVE-2014-2588",
"CVE-2014-2587",
"CVE-2014-2586"
],
"32274": [],
"32275": [],
"32278": [],
"32279": [
"CVE-2008-3758"
],
"32280": [
"CVE-2008-3752"
],
"32281": [
"CVE-2008-3754"
],
"32287": [
"CVE-2008-4741"
],
"32288": [
"CVE-2008-4742"
],
"32290": [
"CVE-2008-3850"
],
"32291": [
"CVE-2008-3786"
],
"32293": [
"CVE-2008-7059"
],
"32295": [],
"32296": [
"CVE-2008-4053"
],
"32297": [
"CVE-2008-4051"
],
"32298": [],
"32299": [
"CVE-2008-4056"
],
"32300": [],
"32302": [],
"32306": [],
"32307": [
"CVE-2008-3101"
],
"32308": [],
"32309": [
"CVE-2008-3942"
],
"32312": [
"CVE-2008-3941"
],
"32313": [
"CVE-2008-3937"
],
"32314": [
"CVE-2008-3937"
],
"32315": [
"CVE-2008-3937"
],
"32316": [
"CVE-2008-4046"
],
"32317": [],
"32318": [
"CVE-2008-3664"
],
"32319": [],
"32320": [
"CVE-2008-3664"
],
"32321": [
"CVE-2008-3664"
],
"32322": [
"CVE-2008-3664"
],
"32323": [
"CVE-2008-3664"
],
"32324": [
"CVE-2008-3664"
],
"32325": [
"CVE-2008-3664"
],
"32326": [
"CVE-2008-3664"
],
"32327": [
"CVE-2008-3664"
],
"32330": [],
"32331": [],
"32334": [
"CVE-2008-6396"
],
"32337": [
"CVE-2008-6764"
],
"32338": [
"CVE-2008-6979"
],
"32340": [],
"32342": [
"CVE-2008-4459"
],
"32346": [
"CVE-2008-4458"
],
"32347": [
"CVE-2008-6970"
],
"32351": [],
"32352": [],
"32353": [
"CVE-2008-3824"
],
"32354": [
"CVE-2008-3823"
],
"32355": [
"CVE-2008-7120"
],
"32360": [
"CVE-2008-4179"
],
"32361": [
"CVE-2008-4179"
],
"32364": [
"CVE-2008-4174"
],
"32365": [
"CVE-2008-4349"
],
"32366": [],
"32369": [],
"32374": [],
"32375": [
"CVE-2014-2017",
"CVE-2014-2016"
],
"32383": [
"CVE-2008-4096"
],
"32385": [],
"32418": [
"CVE-2008-4328"
],
"32419": [],
"32421": [
"CVE-2008-4120"
],
"32422": [],
"32423": [
"CVE-2008-4320"
],
"32424": [
"CVE-2008-4320"
],
"32425": [
"CVE-2008-4320"
],
"32427": [],
"32430": [
"CVE-2008-4737"
],
"32431": [
"CVE-2008-4672"
],
"32432": [
"CVE-2008-4670"
],
"32433": [],
"32434": [
"CVE-2008-4669"
],
"32437": [],
"32441": [],
"32443": [
"CVE-2008-7017"
],
"32444": [
"CVE-2008-4671"
],
"32447": [
"CVE-2008-6103"
],
"32448": [
"CVE-2008-6094"
],
"32449": [
"CVE-2008-4447"
],
"32450": [
"CVE-2008-6097"
],
"32453": [
"CVE-2008-6164"
],
"32455": [
"CVE-2008-4532"
],
"32459": [
"CVE-2008-4393"
],
"32461": [
"CVE-2008-4525"
],
"32462": [],
"32463": [
"CVE-2008-4499"
],
"32464": [
"CVE-2008-4499"
],
"32467": [
"CVE-2008-4694"
],
"32468": [],
"32473": [],
"32474": [],
"32479": [
"CVE-2008-6660"
],
"32520": [],
"32563": [
"CVE-2008-4895"
],
"32485": [
"CVE-2008-5707"
],
"32486": [],
"32487": [
"CVE-2008-4648"
],
"32488": [
"CVE-2008-4649"
],
"32490": [],
"32492": [
"CVE-2008-4601"
],
"32494": [
"CVE-2008-6799"
],
"32495": [
"CVE-2008-4651"
],
"32496": [
"CVE-2008-4651"
],
"32497": [
"CVE-2008-6779"
],
"32498": [
"CVE-2008-6803"
],
"32499": [
"CVE-2008-6802"
],
"32500": [
"CVE-2008-6075"
],
"32502": [],
"32503": [],
"32504": [],
"32505": [],
"32506": [],
"32507": [],
"32508": [],
"32509": [],
"32510": [],
"32511": [],
"32516": [
"CVE-2014-2531"
],
"32521": [
"CVE-2008-6807"
],
"32523": [
"CVE-2008-7269"
],
"32524": [
"CVE-2008-7267"
],
"32525": [
"CVE-2008-6174"
],
"32526": [
"CVE-2008-6173"
],
"32527": [
"CVE-2008-4761"
],
"32528": [
"CVE-2008-4751"
],
"32531": [
"CVE-2008-4775"
],
"32532": [],
"32533": [],
"32535": [],
"32536": [
"CVE-2007-6080"
],
"32537": [
"CVE-2008-4782"
],
"32538": [
"CVE-2008-5039"
],
"32539": [
"CVE-2008-4787"
],
"32540": [],
"32541": [
"CVE-2008-5064"
],
"32542": [
"CVE-2008-5037"
],
"32543": [
"CVE-2008-5067"
],
"32544": [
"CVE-2008-5068"
],
"32545": [
"CVE-2014-1982"
],
"32546": [
"CVE-2013-6719",
"CVE-2013-6720"
],
"32547": [
"CVE-2008-6217"
],
"32549": [],
"32553": [
"CVE-2008-6266"
],
"32554": [],
"32556": [
"CVE-2014-2879"
],
"32557": [],
"32558": [],
"32559": [],
"32560": [],
"32561": [],
"32562": [],
"32566": [
"CVE-2008-4931"
],
"32567": [
"CVE-2008-6297"
],
"32569": [],
"32570": [],
"32571": [],
"32574": [],
"32575": [
"CVE-2008-6912"
],
"32576": [],
"32577": [
"CVE-2008-5057"
],
"32579": [
"CVE-2008-5115"
],
"32580": [],
"32588": [
"CVE-2008-5126"
],
"32589": [],
"32592": [],
"32593": [],
"32594": [],
"32595": [
"CVE-2008-6306"
],
"32597": [
"CVE-2008-5307"
],
"32598": [],
"32600": [
"CVE-2006-3151"
],
"32601": [],
"32602": [],
"32603": [
"CVE-2008-5978"
],
"32604": [],
"32605": [],
"32606": [],
"32607": [
"CVE-2008-6278"
],
"32608": [
"CVE-2008-6279"
],
"32609": [
"CVE-2008-6887"
],
"32610": [
"CVE-2008-6888"
],
"32611": [
"CVE-2008-6500"
],
"32612": [
"CVE-2008-6325"
],
"32613": [
"CVE-2008-6325"
],
"32614": [
"CVE-2008-6325"
],
"32615": [
"CVE-2008-6325"
],
"32616": [
"CVE-2008-6325"
],
"32617": [
"CVE-2008-6325"
],
"32619": [],
"32620": [],
"32622": [
"CVE-2014-2674"
],
"32623": [
"CVE-2014-0644"
],
"32624": [
"CVE-2008-5977"
],
"32625": [
"CVE-2008-5976"
],
"32626": [
"CVE-2008-6890"
],
"32627": [
"CVE-2008-6891"
],
"32628": [
"CVE-2008-6891"
],
"32629": [
"CVE-2008-6891"
],
"32630": [
"CVE-2008-6847"
],
"32631": [
"CVE-2008-5330"
],
"32632": [
"CVE-2008-6843"
],
"32633": [
"CVE-2008-6392"
],
"32634": [
"CVE-2008-6386"
],
"32635": [
"CVE-2008-6391",
"CVE-2008-6376"
],
"32636": [
"CVE-2008-5970"
],
"32637": [
"CVE-2008-5971"
],
"32638": [],
"32639": [
"CVE-2008-6495"
],
"32640": [
"CVE-2008-6515"
],
"32641": [
"CVE-2008-6385"
],
"32642": [
"CVE-2008-5955"
],
"32644": [],
"32645": [
"CVE-2008-5305"
],
"32646": [
"CVE-2008-5304"
],
"32647": [
"CVE-2008-6503"
],
"32648": [
"CVE-2008-6503"
],
"32649": [
"CVE-2008-5569"
],
"32650": [
"CVE-2008-5569"
],
"32651": [
"CVE-2008-5569"
],
"32652": [
"CVE-2008-5569"
],
"32653": [
"CVE-2008-5571"
],
"32655": [
"CVE-2008-6366",
"CVE-2008-6365"
],
"32656": [
"CVE-2008-3058"
],
"32658": [
"CVE-2008-5923"
],
"32660": [
"CVE-2014-2847"
],
"32662": [],
"32663": [
"CVE-2008-5891"
],
"32664": [],
"32665": [],
"32666": [],
"32668": [],
"32669": [
"CVE-2008-6609"
],
"32670": [
"CVE-2014-2880"
],
"32671": [
"CVE-2008-6019"
],
"32672": [
"CVE-2008-6880"
],
"32676": [],
"32677": [
"CVE-2009-0496"
],
"32678": [
"CVE-2009-0496"
],
"32679": [
"CVE-2009-0496"
],
"32680": [
"CVE-2009-0497"
],
"32683": [],
"32685": [
"CVE-2008-6757"
],
"32687": [],
"32689": [],
"32698": [],
"32701": [
"CVE-2014-2340"
],
"32703": [],
"32708": [
"CVE-2009-0699"
],
"32709": [
"CVE-2009-0700"
],
"32710": [
"CVE-2009-0700"
],
"32713": [],
"32714": [],
"32716": [],
"32718": [],
"32721": [],
"32724": [
"CVE-2009-0326"
],
"32727": [],
"32728": [],
"32729": [
"CVE-2009-0431"
],
"32730": [
"CVE-2009-0430"
],
"32731": [
"CVE-2009-0429"
],
"32732": [],
"32733": [],
"32734": [],
"32735": [
"CVE-2009-0339"
],
"32736": [
"CVE-2009-0338"
],
"32741": [
"CVE-2009-0026"
],
"32742": [
"CVE-2009-0026"
],
"32746": [
"CVE-2009-0260"
],
"32747": [
"CVE-2009-0302",
"CVE-2005-3304"
],
"32748": [
"CVE-2009-0285"
],
"32750": [
"CVE-2009-0283"
],
"32756": [],
"32757": [],
"32758": [],
"32759": [
"CVE-2009-0291"
],
"32760": [
"CVE-2009-0300",
"CVE-2006-2636"
],
"32765": [],
"32766": [
"CVE-2009-0347"
],
"32767": [],
"32768": [],
"32770": [],
"32773": [],
"32777": [],
"32779": [],
"32782": [
"CVE-2009-0573"
],
"32783": [
"CVE-2009-0573"
],
"32784": [
"CVE-2009-0455"
],
"32785": [],
"33129": [
"CVE-2014-3792"
],
"33198": [
"CVE-2009-2780"
],
"32790": [
"CVE-2014-2996",
"CVE-2014-2579"
],
"32792": [
"CVE-2014-2540"
],
"32797": [
"CVE-2009-0741"
],
"32802": [],
"32803": [
"CVE-2008-6104"
],
"32804": [],
"32806": [],
"32807": [
"CVE-2009-0730"
],
"32808": [
"CVE-2009-0541"
],
"32809": [
"CVE-2009-0541"
],
"32810": [
"CVE-2009-0541"
],
"32814": [
"CVE-2014-10001"
],
"32816": [],
"32818": [],
"32819": [],
"32821": [],
"32823": [
"CVE-2006-6771"
],
"32827": [],
"32828": [],
"32830": [
"CVE-2014-2341"
],
"32831": [],
"32833": [
"CVE-2009-0814"
],
"32835": [],
"32840": [],
"32841": [],
"32842": [],
"32843": [
"CVE-2009-0825"
],
"32844": [
"CVE-2009-4888"
],
"32846": [],
"32852": [
"CVE-2009-1204"
],
"32853": [
"CVE-2009-1204"
],
"32854": [
"CVE-2009-1204"
],
"32887": [],
"32858": [],
"32859": [],
"32861": [],
"32862": [
"CVE-2009-1218"
],
"32863": [
"CVE-2009-1729"
],
"32864": [
"CVE-2009-1729"
],
"32866": [],
"32867": [
"CVE-2014-2598"
],
"32868": [
"CVE-2014-2995",
"CVE-2014-2559"
],
"32869": [],
"32870": [
"CVE-2006-3682"
],
"32871": [
"CVE-2009-1070"
],
"32872": [],
"32873": [],
"32874": [
"CVE-2008-6476"
],
"32875": [],
"32880": [
"CVE-2009-1225"
],
"32882": [],
"32883": [],
"32886": [
"CVE-2014-3138"
],
"32888": [],
"32889": [],
"32894": [
"CVE-2009-1288"
],
"32895": [
"CVE-2009-1288"
],
"32896": [
"CVE-2009-1290"
],
"32897": [
"CVE-2009-1287"
],
"32898": [],
"32903": [],
"32907": [],
"32908": [
"CVE-2009-1334"
],
"32909": [
"CVE-2009-1294"
],
"32910": [],
"32911": [],
"32912": [],
"32913": [],
"32914": [],
"32924": [
"CVE-2009-1458"
],
"32927": [
"CVE-2009-0307"
],
"32928": [
"CVE-2009-1456"
],
"32930": [],
"32932": [
"CVE-2009-4934"
],
"32933": [
"CVE-2009-4926"
],
"32934": [
"CVE-2009-4926"
],
"32935": [
"CVE-2009-4926"
],
"32936": [
"CVE-2009-4926"
],
"32937": [
"CVE-2009-4926"
],
"32940": [
"CVE-2009-1357"
],
"32941": [],
"32943": [
"CVE-2014-10019"
],
"32948": [],
"32950": [],
"32952": [],
"32953": [],
"32958": [
"CVE-2009-1620"
],
"32960": [],
"32963": [
"CVE-2009-1616"
],
"32966": [],
"32968": [
"CVE-2009-1468"
],
"32969": [
"CVE-2009-1467"
],
"32973": [
"CVE-2014-2976"
],
"32976": [],
"34148": [],
"32983": [
"CVE-2014-3757"
],
"32985": [
"CVE-2009-1467"
],
"32986": [
"CVE-2009-1469"
],
"32988": [
"CVE-2009-2571"
],
"32989": [
"CVE-2009-2569"
],
"32990": [
"CVE-2010-4107"
],
"32991": [
"CVE-2009-1907"
],
"32992": [],
"32993": [],
"32999": [],
"33057": [
"CVE-2009-2302"
],
"33000": [],
"33001": [
"CVE-2009-1786"
],
"33002": [
"CVE-2009-1593"
],
"33003": [],
"33004": [
"CVE-2014-2383"
],
"33005": [
"CVE-2014-2846"
],
"33006": [],
"33008": [],
"33009": [],
"33011": [
"CVE-2009-1842"
],
"33013": [
"CVE-2009-1845"
],
"33014": [],
"33019": [
"CVE-2014-2347"
],
"33021": [],
"33022": [
"CVE-2009-1938"
],
"33026": [],
"33030": [],
"33038": [
"CVE-2009-2107"
],
"33048": [
"CVE-2009-2216"
],
"33052": [],
"33060": [],
"33061": [
"CVE-2011-4909"
],
"33065": [
"CVE-2009-2360"
],
"33068": [
"CVE-2009-2438"
],
"33070": [],
"33072": [],
"33075": [
"CVE-2014-3871",
"CVE-2006-3823"
],
"33076": [
"CVE-2014-8949",
"CVE-2014-8948",
"CVE-2014-3849",
"CVE-2014-3848",
"CVE-2014-3842"
],
"33085": [
"CVE-2009-2551"
],
"33087": [],
"33090": [],
"33091": [],
"33347": [
"CVE-2009-3566"
],
"33578": [],
"33097": [
"CVE-2009-4690"
],
"33098": [
"CVE-2009-4690"
],
"33102": [],
"33106": [
"CVE-2009-2882"
],
"33107": [
"CVE-2009-2882"
],
"33108": [
"CVE-2009-2882"
],
"33109": [
"CVE-2009-2882"
],
"33110": [
"CVE-2009-2893"
],
"33111": [
"CVE-2009-3220"
],
"33112": [
"CVE-2009-2772"
],
"33113": [
"CVE-2009-2772"
],
"33114": [],
"33115": [
"CVE-2009-3226"
],
"33116": [
"CVE-2009-3225"
],
"33117": [
"CVE-2009-3225"
],
"33119": [
"CVE-2009-3513"
],
"33120": [
"CVE-2009-3513"
],
"33121": [
"CVE-2009-3513"
],
"33122": [],
"33125": [],
"33126": [],
"33127": [],
"40080": [],
"40081": [],
"40082": [],
"33197": [
"CVE-2009-2780"
],
"33130": [
"CVE-2009-3152"
],
"33131": [
"CVE-2009-2783"
],
"33132": [
"CVE-2009-2790"
],
"33136": [
"CVE-2014-9727"
],
"33340": [
"CVE-2009-4172"
],
"33138": [],
"33144": [
"CVE-2009-2595"
],
"33146": [
"CVE-2009-2579"
],
"33147": [
"CVE-2009-4989"
],
"33149": [],
"33346": [
"CVE-2009-3565"
],
"33152": [],
"33153": [],
"33154": [
"CVE-2007-1231"
],
"33155": [
"CVE-2009-4547"
],
"33156": [],
"33157": [
"CVE-2009-4547"
],
"33158": [
"CVE-2009-4547"
],
"33159": [],
"33160": [],
"33166": [
"CVE-2009-2915"
],
"33167": [
"CVE-2009-1872"
],
"33168": [
"CVE-2009-1872"
],
"33169": [
"CVE-2009-1872"
],
"33170": [
"CVE-2009-1872"
],
"33171": [],
"33178": [
"CVE-2009-2704"
],
"33254": [
"CVE-2009-3469"
],
"40346": [
"CVE-2016-4264"
],
"33180": [
"CVE-2009-1879"
],
"33181": [
"CVE-2009-2705"
],
"33186": [
"CVE-2009-3186"
],
"33187": [
"CVE-2009-3186"
],
"33188": [
"CVE-2009-3186"
],
"33189": [],
"33190": [],
"33191": [],
"33195": [],
"33199": [
"CVE-2009-2780"
],
"33200": [
"CVE-2009-2780"
],
"33201": [
"CVE-2009-2780"
],
"33202": [
"CVE-2009-2780"
],
"33204": [
"CVE-2008-7000"
],
"33206": [],
"33208": [],
"33209": [
"CVE-2009-3068"
],
"33214": [
"CVE-2009-4470"
],
"33217": [],
"33218": [],
"33219": [
"CVE-2009-2937"
],
"33226": [
"CVE-2009-3647"
],
"33227": [],
"33231": [],
"33232": [],
"33236": [
"CVE-2009-3436"
],
"33237": [
"CVE-2009-3491"
],
"33238": [
"CVE-2009-3438"
],
"33239": [],
"33240": [
"CVE-2009-3495"
],
"33241": [
"CVE-2009-3496"
],
"33242": [],
"33345": [
"CVE-2009-4174"
],
"33343": [
"CVE-2009-4250"
],
"33344": [
"CVE-2009-4173"
],
"33709": [],
"33247": [],
"33248": [],
"33249": [
"CVE-2014-3246"
],
"33250": [
"CVE-2014-3247"
],
"33252": [
"CVE-2014-3225"
],
"33256": [],
"33262": [
"CVE-2009-4192"
],
"33266": [],
"33267": [
"CVE-2009-3592"
],
"33268": [
"CVE-2009-4743"
],
"33590": [
"CVE-2010-0801"
],
"33342": [
"CVE-2009-4249"
],
"33281": [
"CVE-2009-2733"
],
"33282": [
"CVE-2009-4745"
],
"33284": [],
"33317": [
"CVE-2014-5383"
],
"33286": [
"CVE-2009-4521"
],
"33287": [
"CVE-2009-4522"
],
"33288": [
"CVE-2009-4523"
],
"33290": [
"CVE-2009-4554"
],
"33291": [
"CVE-2009-4554"
],
"33292": [
"CVE-2009-3730"
],
"33293": [
"CVE-2009-3730"
],
"33294": [
"CVE-2009-3747"
],
"33295": [
"CVE-2009-3789"
],
"33296": [
"CVE-2009-3789"
],
"33297": [
"CVE-2009-3789"
],
"33298": [
"CVE-2009-3789"
],
"33299": [
"CVE-2009-3789"
],
"33300": [
"CVE-2009-3789"
],
"33301": [
"CVE-2009-3789"
],
"33302": [
"CVE-2009-3789"
],
"33303": [
"CVE-2009-3789"
],
"33304": [
"CVE-2009-3789"
],
"33305": [
"CVE-2009-3789"
],
"33307": [
"CVE-2009-3804"
],
"33308": [
"CVE-2009-3625"
],
"33309": [
"CVE-2009-3833"
],
"33320": [
"CVE-2009-3911"
],
"33327": [
"CVE-2014-2084"
],
"33341": [
"CVE-2009-4175"
],
"33330": [
"CVE-2014-3740"
],
"33334": [
"CVE-2014-3806"
],
"33353": [
"CVE-2014-2046"
],
"33354": [
"CVE-2009-4047"
],
"33355": [
"CVE-2009-4047"
],
"33356": [
"CVE-2009-4047"
],
"33357": [
"CVE-2009-4047"
],
"33358": [
"CVE-2009-4047"
],
"33359": [
"CVE-2009-4047"
],
"33361": [
"CVE-2009-4218"
],
"33362": [
"CVE-2009-4060"
],
"33365": [],
"40345": [],
"33366": [],
"33367": [],
"33368": [],
"33370": [
"CVE-2014-3120"
],
"33371": [
"CVE-2009-4168"
],
"33372": [],
"33373": [],
"33374": [
"CVE-2009-4032"
],
"33375": [
"CVE-2009-4120"
],
"33376": [
"CVE-2009-4216"
],
"33377": [
"CVE-2009-4112"
],
"33378": [],
"33380": [
"CVE-2009-4253"
],
"33381": [
"CVE-2009-4360"
],
"33382": [
"CVE-2009-4359"
],
"33383": [
"CVE-2009-4154"
],
"33385": [
"CVE-2009-4780"
],
"33389": [
"CVE-2014-2987"
],
"33390": [],
"33391": [],
"33392": [],
"33393": [],
"33394": [],
"33396": [
"CVE-2009-4601"
],
"33400": [],
"33435": [],
"33436": [
"CVE-2009-3702"
],
"33437": [
"CVE-2009-3702"
],
"33438": [
"CVE-2009-4814"
],
"33439": [
"CVE-2009-4813"
],
"33440": [
"CVE-2009-4679"
],
"33441": [],
"33442": [
"CVE-2009-4458"
],
"33443": [
"CVE-2009-4458"
],
"33445": [
"CVE-2009-4446"
],
"33446": [],
"33447": [],
"33448": [],
"33449": [],
"33450": [],
"33451": [],
"33452": [],
"33455": [],
"33456": [],
"33457": [],
"33458": [],
"33459": [],
"33460": [],
"33461": [],
"33462": [],
"33463": [],
"33464": [],
"33465": [],
"33466": [],
"33467": [],
"33468": [],
"33469": [
"CVE-2009-4497"
],
"33470": [],
"33473": [],
"33474": [],
"33475": [],
"33478": [],
"33482": [],
"33484": [],
"33485": [
"CVE-2010-0321"
],
"33486": [],
"33487": [
"CVE-2010-1361"
],
"33488": [],
"33493": [
"CVE-2014-3840"
],
"33494": [],
"33582": [],
"33505": [
"CVE-2010-0319"
],
"33507": [],
"33509": [],
"33510": [],
"33511": [
"CVE-2010-0712"
],
"33514": [
"CVE-2014-3962"
],
"33646": [],
"33518": [
"CVE-2014-4162"
],
"33520": [],
"33574": [],
"33575": [
"CVE-2010-0468"
],
"33526": [],
"33528": [],
"33529": [
"CVE-2010-0374"
],
"33530": [
"CVE-2010-2006"
],
"33534": [],
"33636": [],
"33637": [
"CVE-2009-4650"
],
"33638": [
"CVE-2009-4651"
],
"33639": [],
"33634": [],
"33541": [
"CVE-2010-2005"
],
"33542": [
"CVE-2010-2005"
],
"33543": [
"CVE-2010-2005"
],
"33544": [
"CVE-2010-2005"
],
"33545": [
"CVE-2010-1111"
],
"33546": [
"CVE-2010-1111"
],
"33547": [],
"33550": [],
"33551": [],
"33555": [
"CVE-2014-3974",
"CVE-2014-3975"
],
"33557": [
"CVE-2014-3415",
"CVE-2014-3414"
],
"33558": [],
"33561": [],
"33564": [
"CVE-2009-4612"
],
"40752": [],
"33566": [],
"33586": [],
"33595": [],
"33596": [],
"33597": [],
"33602": [
"CVE-2010-0614"
],
"33603": [
"CVE-2010-0368"
],
"33605": [],
"33606": [],
"33613": [
"CVE-2014-3961"
],
"33617": [],
"33618": [],
"33619": [],
"33621": [],
"33624": [],
"33626": [],
"33627": [],
"33628": [],
"33629": [],
"33630": [],
"33631": [],
"33632": [],
"33633": [
"CVE-2014-3878"
],
"33644": [
"CVE-2010-0695"
],
"33641": [],
"33643": [],
"33647": [],
"33649": [
"CVE-2010-0675"
],
"33650": [],
"33651": [],
"33652": [],
"33654": [],
"33655": [],
"33656": [
"CVE-2010-1078"
],
"33657": [
"CVE-2010-0706"
],
"33658": [],
"40343": [],
"33659": [],
"33660": [],
"33661": [],
"33665": [],
"33675": [
"CVE-2010-0714"
],
"33676": [],
"33678": [
"CVE-2010-2130"
],
"33673": [
"CVE-2010-1372"
],
"33674": [],
"33679": [
"CVE-2010-1095"
],
"33680": [],
"33681": [],
"33683": [],
"33684": [],
"33685": [],
"33687": [],
"33688": [],
"33691": [],
"33706": [],
"33704": [],
"33697": [
"CVE-2014-4033"
],
"33699": [
"CVE-2014-4307",
"CVE-2014-4306"
],
"33700": [
"CVE-2014-2575"
],
"33702": [
"CVE-2014-4034"
],
"33714": [
"CVE-2014-4166"
],
"33715": [],
"33716": [],
"33717": [],
"33718": [],
"33720": [],
"33721": [],
"33722": [],
"33723": [],
"33724": [],
"33726": [],
"33727": [],
"33728": [],
"33730": [],
"33731": [],
"33732": [],
"33734": [],
"33736": [],
"33760": [],
"33761": [
"CVE-2010-1054"
],
"33740": [
"CVE-2013-5757",
"CVE-2013-5756"
],
"33743": [],
"33759": [],
"33748": [],
"33749": [],
"33751": [],
"33753": [],
"33754": [],
"40351": [],
"33756": [],
"33757": [],
"33758": [],
"33762": [],
"33763": [],
"33764": [
"CVE-2010-2275"
],
"33765": [
"CVE-2010-2273"
],
"33766": [],
"33787": [
"CVE-2010-1856"
],
"33769": [
"CVE-2010-1003"
],
"33771": [],
"33772": [],
"33773": [],
"33776": [],
"33777": [],
"33779": [],
"33781": [
"CVE-2010-1337"
],
"33782": [],
"33784": [],
"33785": [],
"33788": [],
"33792": [
"CVE-2014-3778"
],
"33793": [],
"33794": [
"CVE-2009-2907"
],
"33795": [],
"33796": [],
"33797": [
"CVE-2010-1340"
],
"33803": [
"CVE-2014-4155",
"CVE-2014-4154",
"CVE-2014-4019",
"CVE-2014-4018"
],
"34141": [
"CVE-2010-2436"
],
"33976": [
"CVE-2010-1997"
],
"33809": [
"CVE-2014-4644"
],
"33812": [
"CVE-2010-2679"
],
"33813": [],
"33814": [
"CVE-2010-1453"
],
"33815": [],
"33818": [
"CVE-2014-3119"
],
"33820": [],
"33821": [],
"33822": [
"CVE-2014-4645"
],
"33853": [],
"33825": [],
"33827": [],
"33830": [
"CVE-2014-4718"
],
"33832": [
"CVE-2009-4511"
],
"33833": [],
"33834": [],
"33835": [],
"33840": [],
"33857": [],
"33997": [],
"33998": [
"CVE-2010-5048"
],
"33846": [
"CVE-2014-4194"
],
"33851": [
"CVE-2014-4663"
],
"33854": [],
"33881": [],
"33856": [],
"33858": [],
"34146": [],
"34147": [],
"33866": [
"CVE-2014-4716"
],
"33867": [],
"34142": [],
"33870": [
"CVE-2010-1872"
],
"33874": [],
"33875": [],
"33882": [],
"33883": [],
"33884": [
"CVE-2010-1724"
],
"33885": [
"CVE-2010-1724"
],
"33887": [],
"33888": [],
"33889": [],
"33894": [
"CVE-2014-4650"
],
"33896": [
"CVE-2014-4717"
],
"33897": [
"CVE-2014-2399"
],
"33906": [],
"33908": [],
"33909": [],
"33960": [],
"33967": [],
"33969": [
"CVE-2010-1918"
],
"33970": [],
"33913": [],
"33914": [],
"33915": [],
"33916": [],
"33917": [
"CVE-2010-1741"
],
"33918": [],
"33919": [],
"33921": [],
"33922": [],
"33923": [],
"33925": [
"CVE-2010-5046"
],
"33953": [],
"33959": [
"CVE-2010-1905"
],
"33954": [
"CVE-2014-3857"
],
"33933": [],
"33934": [],
"33958": [],
"33957": [
"CVE-2010-1112"
],
"33937": [],
"33939": [],
"33942": [
"CVE-2014-0894",
"CVE-2014-0871",
"CVE-2014-0870",
"CVE-2014-0869",
"CVE-2014-0868",
"CVE-2014-0867",
"CVE-2014-0866",
"CVE-2014-0865",
"CVE-2014-0864"
],
"33945": [
"CVE-2010-1859"
],
"33946": [],
"33947": [],
"33948": [],
"33950": [],
"34103": [],
"33972": [
"CVE-2010-2003"
],
"33975": [],
"33978": [
"CVE-2010-1994"
],
"33979": [],
"33982": [],
"33983": [
"CVE-2014-4912"
],
"33985": [],
"33986": [],
"33987": [],
"33992": [],
"33993": [],
"33994": [],
"33995": [],
"33996": [],
"33999": [],
"34000": [],
"34003": [
"CVE-2010-2034"
],
"34004": [
"CVE-2010-2036"
],
"34005": [
"CVE-2010-2037"
],
"34006": [
"CVE-2010-2035"
],
"34007": [
"CVE-2014-3992",
"CVE-2014-3991"
],
"34008": [
"CVE-2010-2033"
],
"34011": [
"CVE-2010-2040"
],
"34012": [
"CVE-2010-2032"
],
"34014": [
"CVE-2010-1923"
],
"34015": [],
"34016": [
"CVE-2010-2126"
],
"34017": [
"CVE-2010-2126"
],
"34021": [],
"34022": [],
"34023": [],
"34024": [],
"34030": [
"CVE-2014-3418"
],
"34025": [],
"34029": [],
"34031": [
"CVE-2010-2038"
],
"34032": [],
"34034": [
"CVE-2010-2142"
],
"34035": [],
"34062": [
"CVE-2014-4965",
"CVE-2014-4964",
"CVE-2014-4963",
"CVE-2014-4962"
],
"34038": [],
"34189": [
"CVE-2014-5194",
"CVE-2014-5193",
"CVE-2014-5192",
"CVE-2014-5082"
],
"34040": [
"CVE-2010-5051"
],
"34041": [
"CVE-2010-5052"
],
"34042": [],
"34043": [],
"34044": [],
"34045": [],
"34052": [],
"34053": [],
"34054": [],
"34055": [],
"40716": [],
"34057": [],
"34067": [],
"34068": [],
"34070": [],
"34071": [],
"34072": [],
"34073": [
"CVE-2010-2153"
],
"34136": [],
"34086": [
"CVE-2014-5350"
],
"34087": [
"CVE-2014-4960"
],
"34153": [
"CVE-2010-5015"
],
"34138": [
"CVE-2010-4971"
],
"34077": [],
"34078": [],
"34079": [],
"34080": [],
"34081": [],
"34082": [],
"34083": [],
"34084": [],
"34085": [],
"40718": [],
"34089": [],
"34091": [],
"34092": [],
"34095": [],
"34096": [
"CVE-2010-5024"
],
"34097": [
"CVE-2010-5025"
],
"34155": [],
"34157": [],
"34116": [
"CVE-2010-0367"
],
"34117": [
"CVE-2010-0367"
],
"34118": [
"CVE-2010-0371"
],
"34119": [
"CVE-2010-0366"
],
"34120": [
"CVE-2010-0366"
],
"34121": [
"CVE-2010-0365"
],
"34341": [],
"34342": [],
"34100": [
"CVE-2014-5100"
],
"40296": [],
"34140": [
"CVE-2010-2437"
],
"34113": [],
"34105": [
"CVE-2014-5201"
],
"34106": [],
"34107": [],
"34108": [],
"34109": [],
"34110": [],
"34111": [],
"34339": [],
"34124": [],
"34130": [
"CVE-2014-9095"
],
"34127": [
"CVE-2010-2340"
],
"34128": [],
"34161": [
"CVE-2014-9098",
"CVE-2014-9097"
],
"34149": [],
"34159": [],
"34163": [],
"34165": [
"CVE-2014-3738"
],
"34166": [],
"34168": [
"CVE-2014-9096"
],
"34169": [
"CVE-2014-3544"
],
"34170": [
"CVE-2014-4710"
],
"34173": [
"CVE-2014-5115"
],
"34175": [],
"34176": [],
"34177": [],
"34179": [
"CVE-2010-2433"
],
"34180": [],
"34181": [],
"34183": [
"CVE-2010-2463"
],
"34185": [],
"34187": [
"CVE-2014-2225"
],
"34190": [
"CVE-2014-9101"
],
"34194": [],
"34195": [],
"34196": [],
"34197": [],
"34198": [],
"34204": [],
"34205": [],
"34206": [],
"34207": [],
"34209": [],
"34210": [],
"34211": [],
"34212": [],
"34213": [
"CVE-2010-2616"
],
"34214": [
"CVE-2010-2617"
],
"34215": [],
"34216": [],
"34217": [],
"34218": [],
"34219": [
"CVE-2010-4979"
],
"34220": [
"CVE-2010-4978"
],
"34221": [],
"34222": [],
"34223": [
"CVE-2010-2626"
],
"34224": [],
"34225": [
"CVE-2010-1327"
],
"34226": [],
"34229": [],
"34231": [],
"34232": [],
"34234": [],
"34235": [],
"34236": [],
"34237": [],
"34238": [
"CVE-2014-5087",
"CVE-2014-5086",
"CVE-2014-5085",
"CVE-2014-5084",
"CVE-2014-5083",
"CVE-2014-5082",
"CVE-2014-5081"
],
"34239": [
"CVE-2014-5094",
"CVE-2014-5093",
"CVE-2014-5092",
"CVE-2014-5091",
"CVE-2014-5090",
"CVE-2014-5089",
"CVE-2014-5088"
],
"34240": [],
"34241": [],
"34336": [
"CVE-2014-5347",
"CVE-2014-5346",
"CVE-2014-5345"
],
"34337": [],
"34338": [],
"34243": [],
"34245": [
"CVE-2014-4170"
],
"34246": [],
"34250": [
"CVE-2010-4977"
],
"34252": [],
"34253": [
"CVE-2010-2669"
],
"34254": [],
"34255": [],
"34256": [],
"34257": [],
"34258": [
"CVE-2010-2844"
],
"34259": [],
"34260": [],
"34263": [],
"34264": [],
"34265": [
"CVE-2010-5002"
],
"34266": [],
"34268": [],
"34273": [],
"34275": [
"CVE-2014-5276",
"CVE-2014-5275"
],
"34277": [],
"34527": [],
"34280": [],
"34282": [],
"34283": [],
"34284": [
"CVE-2010-2856"
],
"34285": [],
"34286": [
"CVE-2010-2858"
],
"34287": [],
"34288": [],
"34289": [],
"34290": [],
"34291": [],
"34292": [],
"34293": [],
"34294": [],
"34295": [],
"34296": [],
"34298": [],
"34299": [],
"34300": [],
"34302": [],
"34303": [],
"34305": [],
"34308": [
"CVE-2014-3978"
],
"34315": [],
"34317": [],
"34318": [],
"34319": [],
"34321": [],
"34322": [],
"34323": [],
"34324": [],
"34499": [
"CVE-2009-4548"
],
"34343": [],
"34344": [],
"34345": [],
"34347": [],
"34349": [],
"34350": [],
"34351": [],
"34352": [],
"34353": [],
"34354": [],
"34357": [],
"34361": [
"CVE-2014-5246"
],
"34365": [],
"34366": [
"CVE-2009-3856"
],
"34367": [
"CVE-2009-4039"
],
"34370": [],
"34373": [],
"34374": [
"CVE-2010-4949"
],
"34376": [
"CVE-2009-3901"
],
"34377": [],
"34378": [],
"34379": [],
"34380": [
"CVE-2009-4464"
],
"34381": [],
"34466": [],
"34383": [],
"34384": [],
"34386": [],
"34387": [],
"34388": [],
"34389": [
"CVE-2009-4939"
],
"34391": [],
"34392": [],
"34393": [],
"34396": [],
"34397": [],
"34497": [
"CVE-2009-4548"
],
"34498": [
"CVE-2009-4548"
],
"34400": [],
"34401": [],
"34402": [],
"34405": [],
"34408": [
"CVE-2014-5335"
],
"34409": [
"CVE-2014-3996"
],
"34410": [],
"34411": [],
"34412": [
"CVE-2010-4963"
],
"34413": [
"CVE-2010-3023"
],
"34414": [
"CVE-2010-3023"
],
"34415": [],
"34416": [],
"34417": [],
"34418": [],
"34419": [
"CVE-2014-5464"
],
"34420": [
"CVE-2014-2081"
],
"34526": [],
"34424": [],
"34429": [
"CVE-2010-4922"
],
"34430": [],
"34432": [],
"34433": [],
"34456": [
"CVE-2009-3059"
],
"34436": [
"CVE-2014-5465"
],
"34438": [],
"34440": [],
"34441": [],
"34443": [
"CVE-2009-3320"
],
"34444": [
"CVE-2009-3311"
],
"34445": [
"CVE-2009-3260"
],
"34446": [
"CVE-2009-3256"
],
"34447": [
"CVE-2014-2223"
],
"34449": [
"CVE-2014-5377"
],
"34450": [],
"34451": [
"CVE-2014-5519"
],
"34452": [
"CVE-2014-5521",
"CVE-2014-5520"
],
"34453": [
"CVE-2009-3493"
],
"34454": [
"CVE-2009-3493"
],
"34455": [
"CVE-2009-3252"
],
"34459": [
"CVE-2009-3803"
],
"34464": [],
"34467": [],
"34468": [],
"34469": [],
"34470": [
"CVE-2009-3057"
],
"34471": [
"CVE-2009-3057"
],
"34472": [],
"34473": [
"CVE-2009-3066"
],
"34474": [
"CVE-2009-3066"
],
"34475": [
"CVE-2010-4938"
],
"34476": [],
"34477": [],
"34479": [],
"34481": [],
"34482": [
"CVE-2009-4858"
],
"34483": [
"CVE-2009-4869"
],
"34484": [],
"34485": [],
"34486": [],
"34487": [
"CVE-2009-4544"
],
"34492": [],
"34493": [
"CVE-2009-4724"
],
"34494": [
"CVE-2009-4548"
],
"34495": [
"CVE-2009-4548"
],
"34496": [
"CVE-2009-4548"
],
"34501": [
"CVE-2009-4868"
],
"34503": [],
"34504": [
"CVE-2010-2544"
],
"34508": [],
"34511": [
"CVE-2015-1579",
"CVE-2014-9734"
],
"34513": [
"CVE-2014-5469"
],
"34514": [
"CVE-2014-5460"
],
"34518": [
"CVE-2014-5007",
"CVE-2014-5006",
"CVE-2014-5005",
"CVE-2013-7390"
],
"34519": [
"CVE-2014-6043",
"CVE-2014-6037"
],
"34524": [
"CVE-2014-7153"
],
"34525": [
"CVE-2014-6070"
],
"34637": [],
"34684": [],
"34531": [],
"34533": [
"CVE-2010-4882"
],
"34534": [],
"34535": [],
"34536": [],
"34538": [],
"34539": [],
"34541": [],
"34543": [
"CVE-2010-3003"
],
"34544": [
"CVE-2010-3003"
],
"34545": [
"CVE-2010-3003"
],
"34546": [
"CVE-2010-3003"
],
"34547": [
"CVE-2010-3003"
],
"34548": [
"CVE-2009-3360"
],
"34549": [
"CVE-2009-3360"
],
"34550": [
"CVE-2009-3360"
],
"34551": [],
"34552": [
"CVE-2014-5140"
],
"34553": [],
"34555": [
"CVE-2014-10001"
],
"34604": [],
"34558": [],
"34559": [],
"34560": [],
"34561": [],
"34562": [],
"34563": [
"CVE-2010-4877"
],
"34564": [
"CVE-2010-4899"
],
"34565": [
"CVE-2010-3070"
],
"34578": [],
"34581": [],
"34571": [],
"34572": [],
"34580": [
"CVE-2014-6050",
"CVE-2014-6049",
"CVE-2014-6048",
"CVE-2014-6047",
"CVE-2014-6046",
"CVE-2014-6045"
],
"34579": [],
"34924": [
"CVE-2014-4872",
"CVE-2014-4873",
"CVE-2014-4874"
],
"34582": [],
"34583": [],
"34584": [],
"34585": [],
"34586": [
"CVE-2014-2009",
"CVE-2014-2008"
],
"34587": [],
"34589": [],
"34593": [],
"34596": [],
"34597": [
"CVE-2009-3355"
],
"34598": [
"CVE-2009-3362"
],
"34599": [],
"34600": [
"CVE-2009-3359"
],
"34601": [
"CVE-2009-3359"
],
"34605": [
"CVE-2010-3077"
],
"34606": [],
"34607": [],
"34608": [],
"34609": [
"CVE-2010-4901"
],
"34610": [
"CVE-2010-4906"
],
"34611": [
"CVE-2010-4907"
],
"34805": [],
"34806": [
"CVE-2009-2440"
],
"34807": [],
"34808": [],
"34614": [],
"34683": [],
"34616": [
"CVE-2009-2930"
],
"34617": [],
"34618": [
"CVE-2009-4991"
],
"34619": [
"CVE-2010-4909"
],
"34620": [
"CVE-2010-4909"
],
"34751": [],
"34624": [],
"34625": [],
"34626": [],
"34627": [],
"34628": [],
"34629": [],
"34630": [],
"34631": [],
"34632": [
"CVE-2009-3162"
],
"34633": [],
"34634": [
"CVE-2009-4864"
],
"34635": [],
"34636": [],
"34639": [],
"34640": [
"CVE-2010-3462"
],
"34641": [],
"34642": [],
"34643": [
"CVE-2009-4983"
],
"34644": [
"CVE-2009-4983"
],
"34645": [
"CVE-2009-4983"
],
"34646": [],
"34649": [
"CVE-2010-3489"
],
"34650": [],
"34651": [],
"34652": [],
"34653": [],
"34655": [],
"34656": [
"CVE-2009-3153"
],
"34657": [
"CVE-2009-3153"
],
"34658": [
"CVE-2009-3153"
],
"34659": [
"CVE-2009-3153"
],
"34660": [
"CVE-2009-3153"
],
"34661": [
"CVE-2009-3153"
],
"34662": [
"CVE-2009-3153"
],
"34663": [
"CVE-2009-3153"
],
"34664": [],
"34666": [],
"34672": [
"CVE-2014-4865"
],
"34673": [],
"34674": [
"CVE-2009-4717"
],
"34675": [
"CVE-2009-4717"
],
"34676": [
"CVE-2009-4717"
],
"34677": [
"CVE-2009-4717"
],
"34678": [
"CVE-2009-4717"
],
"34679": [
"CVE-2009-4717"
],
"34680": [],
"34681": [
"CVE-2014-5460"
],
"34682": [],
"34687": [
"CVE-2009-2776"
],
"34688": [],
"34689": [],
"34690": [
"CVE-2010-4930"
],
"34692": [],
"34693": [],
"34694": [],
"34699": [],
"34700": [],
"34701": [],
"34702": [],
"34703": [],
"34704": [],
"34705": [],
"34706": [],
"34707": [],
"34708": [],
"34709": [
"CVE-2009-4685"
],
"34710": [
"CVE-2009-4688"
],
"34711": [
"CVE-2009-4689"
],
"34712": [
"CVE-2009-3599"
],
"34713": [
"CVE-2009-3593"
],
"34714": [
"CVE-2009-3593"
],
"34715": [
"CVE-2009-4686"
],
"34803": [
"CVE-2009-2441"
],
"34804": [
"CVE-2009-2437"
],
"34717": [],
"34718": [
"CVE-2014-6409",
"CVE-2014-6607"
],
"34824": [],
"34825": [],
"34826": [
"CVE-2010-4792"
],
"34721": [
"CVE-2014-6420"
],
"34722": [
"CVE-2014-6030"
],
"34730": [
"CVE-2009-2587"
],
"34731": [
"CVE-2009-2587"
],
"34732": [
"CVE-2009-2587"
],
"34733": [
"CVE-2009-2587"
],
"34734": [
"CVE-2009-2587"
],
"34735": [
"CVE-2009-2587"
],
"34736": [
"CVE-2009-2586"
],
"34737": [
"CVE-2009-4684"
],
"34738": [
"CVE-2009-3858"
],
"34740": [
"CVE-2009-3512"
],
"34741": [
"CVE-2009-3512"
],
"34742": [
"CVE-2009-3512"
],
"34743": [],
"34744": [
"CVE-2009-3539"
],
"34745": [
"CVE-2009-3539"
],
"34746": [],
"34747": [
"CVE-2009-3542"
],
"40338": [],
"34748": [
"CVE-2009-4691"
],
"34749": [
"CVE-2009-3509"
],
"34753": [],
"34754": [],
"34755": [],
"34758": [],
"34759": [],
"34760": [
"CVE-2014-6619"
],
"34761": [
"CVE-2014-5258"
],
"34762": [
"CVE-2014-6312"
],
"34763": [
"CVE-2014-6308"
],
"34764": [
"CVE-2014-8307",
"CVE-2014-8306",
"CVE-2014-8305"
],
"34769": [],
"34770": [
"CVE-2009-2888"
],
"34771": [
"CVE-2009-2889"
],
"34772": [
"CVE-2009-3222"
],
"34773": [
"CVE-2010-3695"
],
"34774": [
"CVE-2009-2588"
],
"34775": [
"CVE-2009-2588"
],
"34776": [
"CVE-2009-2588"
],
"34779": [],
"34783": [
"CVE-2009-3601"
],
"34784": [],
"34785": [
"CVE-2010-4821"
],
"34786": [],
"34787": [
"CVE-2010-4883"
],
"34788": [
"CVE-2010-5278"
],
"34789": [
"CVE-2010-4863"
],
"34790": [],
"34791": [
"CVE-2009-4751"
],
"34792": [
"CVE-2009-4752"
],
"34793": [
"CVE-2009-4750"
],
"34794": [],
"34795": [],
"34797": [
"CVE-2010-3201"
],
"34782": [],
"34781": [
"CVE-2014-6242"
],
"34798": [],
"34816": [],
"34800": [
"CVE-2014-7201",
"CVE-2014-7200"
],
"34809": [
"CVE-2009-2428"
],
"34810": [
"CVE-2009-2428"
],
"34811": [
"CVE-2009-2442"
],
"34812": [],
"34813": [],
"34814": [],
"34820": [
"CVE-2010-4864"
],
"34817": [],
"34818": [
"CVE-2014-7190"
],
"34975": [],
"34976": [
"CVE-2010-4875"
],
"34977": [],
"34827": [],
"34828": [],
"34833": [],
"34834": [
"CVE-2010-3581"
],
"34837": [
"CVE-2010-5286"
],
"34839": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"34840": [],
"34841": [],
"34842": [
"CVE-2010-3841"
],
"34843": [
"CVE-2010-3841"
],
"34845": [
"CVE-2009-4857"
],
"34847": [
"CVE-2009-4856"
],
"34849": [
"CVE-2010-1106"
],
"34850": [],
"34851": [
"CVE-2014-8295"
],
"34852": [
"CVE-2014-7226"
],
"34854": [],
"34858": [],
"34861": [
"CVE-2014-6389"
],
"34863": [
"CVE-2014-5308"
],
"34864": [
"CVE-2014-4312",
"CVE-2014-4311"
],
"34865": [
"CVE-2014-5300"
],
"34871": [
"CVE-2009-3598"
],
"34873": [
"CVE-2009-3123"
],
"34874": [
"CVE-2009-2114"
],
"34875": [
"CVE-2009-3124"
],
"34876": [
"CVE-2009-3184"
],
"34877": [
"CVE-2009-3189"
],
"34878": [
"CVE-2009-3187"
],
"34882": [],
"34883": [
"CVE-2010-4152"
],
"34884": [
"CVE-2009-3194"
],
"34885": [
"CVE-2009-3195"
],
"34886": [
"CVE-2009-3195"
],
"34887": [
"CVE-2009-3196"
],
"34888": [
"CVE-2009-3202"
],
"34890": [],
"34891": [],
"34892": [],
"34893": [
"CVE-2009-2884"
],
"34894": [
"CVE-2009-2885"
],
"34895": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"34922": [
"CVE-2014-7969"
],
"35023": [],
"35024": [],
"34902": [
"CVE-2009-2890"
],
"34903": [
"CVE-2009-2891"
],
"34904": [
"CVE-2009-2965"
],
"34905": [
"CVE-2010-4867"
],
"34906": [
"CVE-2010-4868"
],
"34907": [
"CVE-2010-4120"
],
"34908": [
"CVE-2010-4120"
],
"34909": [
"CVE-2010-4120"
],
"34910": [
"CVE-2010-4120"
],
"34911": [
"CVE-2010-4120"
],
"34912": [
"CVE-2010-4120"
],
"34913": [
"CVE-2010-4120"
],
"34914": [
"CVE-2010-4120"
],
"34915": [
"CVE-2010-4120"
],
"34916": [
"CVE-2010-4120"
],
"34917": [
"CVE-2010-4120"
],
"34918": [],
"34919": [
"CVE-2009-2116"
],
"34920": [],
"34928": [],
"34929": [
"CVE-2014-7280"
],
"34930": [
"CVE-2009-2163"
],
"34933": [],
"34934": [],
"34935": [],
"34936": [],
"34937": [],
"34939": [],
"34940": [
"CVE-2009-2600"
],
"34941": [
"CVE-2009-2289"
],
"34942": [],
"34944": [],
"34946": [
"CVE-2010-3977"
],
"34947": [],
"34948": [],
"34951": [
"CVE-2010-4186"
],
"34955": [],
"34956": [],
"34957": [],
"35022": [],
"34958": [],
"34959": [
"CVE-2014-8577"
],
"34981": [],
"34965": [],
"34968": [
"CVE-2014-10000"
],
"34969": [
"CVE-2014-7281"
],
"34970": [],
"34971": [],
"34972": [],
"34973": [],
"34974": [],
"34994": [],
"34995": [],
"34984": [
"CVE-2014-3704"
],
"34988": [
"CVE-2010-4836"
],
"34989": [
"CVE-2010-4873"
],
"34990": [],
"34996": [],
"34992": [
"CVE-2014-3704"
],
"34993": [
"CVE-2014-3704"
],
"35004": [],
"35008": [],
"35012": [],
"35015": [],
"35016": [
"CVE-2010-4784"
],
"35017": [
"CVE-2010-4783"
],
"35025": [],
"35026": [],
"35027": [],
"35028": [],
"35031": [
"CVE-2010-3266"
],
"35035": [
"CVE-2010-4367"
],
"35036": [],
"35037": [],
"35038": [],
"35039": [],
"35041": [],
"35042": [],
"35043": [],
"35044": [],
"35045": [
"CVE-2010-4514"
],
"35046": [
"CVE-2013-7057"
],
"35047": [],
"35048": [],
"35049": [],
"35050": [],
"35052": [
"CVE-2014-8770"
],
"35566": [],
"35056": [
"CVE-2013-3304"
],
"35057": [
"CVE-2014-8739"
],
"35127": [
"CVE-2014-8555"
],
"35060": [
"CVE-2010-4503"
],
"35063": [
"CVE-2010-4513"
],
"35064": [
"CVE-2010-4513"
],
"35065": [],
"35066": [
"CVE-2010-4747"
],
"35067": [
"CVE-2010-4518"
],
"35072": [],
"35073": [
"CVE-2014-8586"
],
"35075": [
"CVE-2014-8657",
"CVE-2014-8655",
"CVE-2014-8653",
"CVE-2014-8654",
"CVE-2014-8656"
],
"35076": [
"CVE-2014-2647"
],
"35079": [
"CVE-2014-9000"
],
"35080": [
"CVE-2014-9001"
],
"40333": [],
"35082": [],
"35083": [],
"35084": [],
"35085": [],
"35087": [],
"35088": [],
"35089": [],
"35090": [],
"35091": [],
"35093": [],
"35094": [],
"35096": [],
"35097": [],
"35098": [
"CVE-2014-7176"
],
"35099": [
"CVE-2014-7177",
"CVE-2014-7176"
],
"35100": [
"CVE-2014-7178"
],
"35102": [
"CVE-2014-2023"
],
"35214": [
"CVE-2014-8728"
],
"35209": [
"CVE-2014-7868",
"CVE-2014-7866"
],
"35106": [],
"35107": [],
"35108": [],
"35109": [],
"35110": [],
"35111": [],
"35113": [
"CVE-2015-1587"
],
"35114": [],
"35116": [
"CVE-2010-4111"
],
"35117": [],
"35118": [],
"35120": [
"CVE-2010-4275"
],
"35121": [],
"35122": [],
"35123": [
"CVE-2010-4619"
],
"35124": [],
"35125": [],
"35126": [],
"35128": [],
"35129": [
"CVE-2014-8953"
],
"35131": [],
"35133": [],
"35134": [],
"35135": [],
"35136": [],
"35137": [],
"35138": [],
"35212": [
"CVE-2014-8607",
"CVE-2014-8606",
"CVE-2014-8605",
"CVE-2014-8604",
"CVE-2014-8603"
],
"35140": [
"CVE-2010-5096"
],
"35141": [
"CVE-2010-5096"
],
"35142": [],
"35143": [],
"35145": [],
"35146": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-3671",
"CVE-2014-3659"
],
"35149": [
"CVE-2010-4276"
],
"35150": [
"CVE-2014-3704"
],
"35155": [],
"35156": [
"CVE-2010-4693"
],
"35157": [
"CVE-2010-4693"
],
"35159": [
"CVE-2014-8775",
"CVE-2014-8774",
"CVE-2014-8773"
],
"35160": [],
"35165": [],
"35167": [
"CVE-2011-0005"
],
"35168": [],
"35169": [],
"35172": [],
"35181": [
"CVE-2014-3439",
"CVE-2014-3438",
"CVE-2014-3437"
],
"35185": [],
"35186": [],
"35187": [],
"35191": [],
"35193": [
"CVE-2014-9005",
"CVE-2014-9004"
],
"35197": [],
"35198": [
"CVE-2014-8954"
],
"35210": [
"CVE-2014-8499",
"CVE-2014-8498"
],
"35203": [],
"35204": [
"CVE-2014-10013"
],
"35206": [
"CVE-2014-8596"
],
"35313": [
"CVE-2014-9178"
],
"35208": [],
"35292": [],
"35291": [],
"35295": [],
"35296": [],
"35297": [
"CVE-2011-4280"
],
"35298": [],
"35221": [
"CVE-2014-9115"
],
"35218": [
"CVE-2014-9179"
],
"35219": [
"CVE-2014-9237"
],
"35220": [],
"35222": [
"CVE-2014-8727"
],
"35223": [
"CVE-2014-8997"
],
"35224": [
"CVE-2014-9241",
"CVE-2014-9240"
],
"35227": [],
"35228": [],
"35231": [],
"35233": [],
"35237": [
"CVE-2014-8681"
],
"35238": [
"CVE-2014-8682"
],
"35239": [
"CVE-2011-0645"
],
"35245": [],
"35246": [],
"35248": [
"CVE-2014-10001"
],
"35293": [],
"35288": [],
"35289": [],
"35290": [],
"35251": [],
"35253": [],
"35254": [
"CVE-2011-0773"
],
"35255": [],
"35256": [
"CVE-2011-0678"
],
"35257": [],
"35258": [],
"35259": [
"CVE-2011-0772"
],
"35260": [
"CVE-2011-0772"
],
"35261": [
"CVE-2011-0740"
],
"35262": [],
"35263": [],
"35264": [],
"35265": [],
"35266": [],
"35272": [
"CVE-2014-8493"
],
"35271": [
"CVE-2014-8995"
],
"35285": [],
"35286": [],
"35287": [],
"35274": [
"CVE-2014-8469"
],
"35275": [
"CVE-2014-9237"
],
"35276": [
"CVE-2014-8493"
],
"35277": [
"CVE-2014-9243",
"CVE-2014-9242"
],
"35278": [
"CVE-2014-9236",
"CVE-2014-9235"
],
"35294": [],
"35300": [],
"35301": [
"CVE-2014-9344"
],
"35303": [
"CVE-2014-8801"
],
"35305": [],
"35306": [],
"35307": [],
"35309": [],
"35310": [],
"35311": [],
"35312": [],
"35567": [],
"35568": [],
"35315": [],
"35319": [],
"35320": [],
"35381": [
"CVE-2014-8429"
],
"35323": [],
"35324": [
"CVE-2014-8877"
],
"35325": [],
"35327": [],
"35328": [],
"35329": [],
"35330": [
"CVE-2010-3272"
],
"35331": [
"CVE-2010-3274"
],
"35332": [],
"35333": [],
"35334": [],
"35335": [],
"35336": [
"CVE-2011-1062"
],
"35337": [
"CVE-2011-1062"
],
"35338": [
"CVE-2011-1062"
],
"35340": [
"CVE-2014-9175"
],
"35341": [],
"35343": [],
"35344": [
"CVE-2014-9348"
],
"35346": [
"CVE-2014-8799"
],
"35347": [],
"35348": [],
"35349": [],
"35350": [],
"35351": [],
"35353": [],
"35357": [
"CVE-2014-8387"
],
"35360": [
"CVE-2011-1060"
],
"35362": [],
"35365": [
"CVE-2014-9347"
],
"35367": [],
"35371": [
"CVE-2014-9173"
],
"35372": [
"CVE-2014-8425",
"CVE-2014-8424",
"CVE-2014-8423"
],
"35373": [],
"35374": [
"CVE-2011-1106"
],
"35375": [],
"35376": [],
"35378": [
"CVE-2014-9119"
],
"35383": [],
"35384": [],
"35385": [],
"35387": [],
"35391": [],
"35392": [],
"35393": [],
"35394": [],
"35396": [],
"35397": [],
"35400": [],
"35401": [],
"35402": [],
"35405": [],
"35406": [],
"35407": [],
"35408": [],
"35409": [],
"35410": [],
"35411": [
"CVE-2011-1427"
],
"35412": [
"CVE-2011-1427"
],
"35416": [],
"35417": [],
"35418": [],
"35419": [],
"35424": [
"CVE-2014-9567"
],
"36125": [
"CVE-2015-1517"
],
"35428": [],
"35429": [],
"35430": [],
"35431": [],
"35435": [],
"35436": [
"CVE-2011-5267"
],
"35438": [],
"35439": [
"CVE-2014-8800"
],
"35442": [
"CVE-2014-9303",
"CVE-2014-8868"
],
"35443": [
"CVE-2014-6235"
],
"35444": [],
"35447": [
"CVE-2014-9173"
],
"35451": [],
"35452": [],
"35453": [],
"35454": [],
"35455": [],
"35456": [],
"35457": [],
"35459": [
"CVE-2014-9305"
],
"35460": [],
"35564": [],
"35565": [],
"35462": [
"CVE-2014-9144",
"CVE-2014-9143",
"CVE-2014-9142"
],
"35463": [
"CVE-2014-9345"
],
"35467": [
"CVE-2011-0745"
],
"35469": [],
"35470": [],
"35473": [
"CVE-2014-9215"
],
"35475": [],
"35476": [],
"35477": [],
"35479": [],
"35480": [],
"35481": [],
"35482": [],
"35490": [],
"35492": [],
"35493": [],
"35518": [
"CVE-2014-5462"
],
"35496": [],
"35497": [],
"35498": [],
"35499": [],
"35500": [],
"35672": [
"CVE-2011-1609"
],
"35673": [],
"35674": [],
"35675": [],
"35676": [],
"35505": [
"CVE-2014-8810"
],
"35506": [],
"35508": [],
"35510": [
"CVE-2014-9528"
],
"35511": [],
"40817": [],
"35559": [],
"35514": [],
"35515": [],
"35516": [],
"35557": [],
"35520": [],
"35521": [],
"35522": [],
"35523": [
"CVE-2011-1671"
],
"35524": [],
"35525": [],
"35526": [],
"35528": [
"CVE-2014-9258"
],
"35529": [],
"35533": [],
"35548": [
"CVE-2011-1670"
],
"35535": [],
"35561": [],
"35562": [],
"35541": [],
"35556": [],
"35543": [
"CVE-2014-10021"
],
"35547": [
"CVE-2011-1557"
],
"35550": [],
"35551": [
"CVE-2014-9522"
],
"35555": [
"CVE-2011-1668"
],
"35569": [],
"35571": [],
"35572": [
"CVE-2011-1723"
],
"35574": [],
"35575": [],
"35576": [],
"35577": [],
"35578": [
"CVE-2014-4644"
],
"35579": [
"CVE-2014-9254"
],
"35582": [
"CVE-2014-1155",
"CVE-2011-3713",
"CVE-2014-9580"
],
"35583": [
"CVE-2014-1470"
],
"35584": [
"CVE-2014-9445",
"CVE-2014-1137"
],
"35585": [
"CVE-2014-9582",
"CVE-2014-9581",
"CVE-2014-1137"
],
"35588": [],
"35591": [
"CVE-2014-9440"
],
"35593": [
"CVE-2014-9436"
],
"35594": [
"CVE-2014-9412",
"CVE-2014-5216"
],
"35596": [],
"35598": [],
"35599": [],
"35601": [],
"35602": [],
"35603": [],
"35604": [],
"35605": [
"CVE-2014-2239"
],
"35607": [],
"35608": [],
"35610": [],
"35611": [],
"35615": [],
"35616": [],
"35617": [],
"35618": [],
"35619": [],
"35621": [],
"35623": [],
"35624": [],
"35625": [
"CVE-2014-9457"
],
"35626": [
"CVE-2014-9439"
],
"35629": [],
"35630": [],
"35631": [],
"35632": [],
"35633": [],
"35634": [],
"35635": [],
"35636": [],
"35643": [],
"35659": [
"CVE-2014-9516"
],
"35645": [],
"35647": [],
"35648": [],
"35649": [],
"35650": [],
"35651": [],
"35657": [],
"35655": [],
"35662": [],
"35664": [],
"35658": [],
"35663": [],
"35653": [],
"35665": [],
"35666": [],
"35667": [],
"35668": [],
"35670": [
"CVE-2014-9435",
"CVE-2014-9434"
],
"35677": [],
"35678": [],
"35679": [
"CVE-2015-1057"
],
"35680": [],
"35682": [],
"35683": [],
"35684": [],
"35699": [],
"35700": [],
"35697": [],
"35698": [],
"35691": [
"CVE-2015-1054"
],
"35713": [],
"35701": [],
"35702": [],
"35704": [],
"35705": [],
"35706": [],
"35707": [],
"35708": [],
"35709": [],
"35710": [
"CVE-2015-1059",
"CVE-2015-1058",
"CVE-2015-1060"
],
"35715": [],
"35716": [],
"35717": [],
"35718": [],
"35719": [],
"35720": [
"CVE-2014-9464"
],
"35721": [
"CVE-2015-0554"
],
"35722": [
"CVE-2015-0919"
],
"35723": [],
"35724": [],
"35726": [],
"35727": [],
"35728": [],
"35730": [
"CVE-2014-9308"
],
"35733": [],
"35734": [],
"35736": [],
"35737": [],
"35739": [],
"35743": [],
"35745": [],
"35747": [
"CVE-2015-1028"
],
"35758": [],
"35750": [
"CVE-2015-1028"
],
"35751": [
"CVE-2015-1028"
],
"35752": [],
"35754": [],
"35755": [],
"35756": [],
"35757": [],
"35759": [],
"35760": [],
"35761": [
"CVE-2011-1838"
],
"35767": [
"CVE-2015-1424",
"CVE-2015-1423",
"CVE-2015-1422"
],
"35998": [],
"35786": [
"CVE-2015-1482",
"CVE-2015-1481",
"CVE-2015-1368"
],
"35770": [
"CVE-2014-8272"
],
"35775": [],
"35781": [
"CVE-2011-0966"
],
"35782": [],
"35783": [],
"35787": [],
"35788": [],
"35789": [],
"35791": [],
"35803": [],
"35796": [],
"35797": [],
"35798": [],
"35802": [],
"35807": [],
"35808": [],
"35814": [],
"35815": [],
"35816": [],
"35819": [],
"35823": [
"CVE-2014-8802"
],
"35824": [],
"35985": [
"CVE-2011-5071"
],
"35986": [
"CVE-2011-5071"
],
"35984": [],
"35826": [],
"35829": [],
"35830": [],
"35831": [],
"35832": [],
"35833": [],
"35834": [],
"35835": [],
"35837": [],
"35838": [],
"35839": [],
"35840": [],
"35996": [
"CVE-2015-2068",
"CVE-2015-2067"
],
"35846": [
"CVE-2015-1376",
"CVE-2015-1375",
"CVE-2015-1366",
"CVE-2015-1365"
],
"35851": [],
"35852": [],
"35853": [],
"35854": [],
"35857": [
"CVE-2015-1364"
],
"35858": [],
"35860": [],
"35861": [],
"35862": [],
"35863": [],
"35865": [],
"35866": [],
"35867": [],
"35871": [],
"35872": [],
"35874": [],
"35875": [],
"35877": [],
"35878": [
"CVE-2015-1476"
],
"35879": [
"CVE-2014-9473"
],
"35882": [],
"35883": [],
"35884": [],
"35890": [
"CVE-2015-1479"
],
"35891": [],
"35893": [],
"35894": [],
"35896": [],
"35899": [],
"35900": [],
"35980": [
"CVE-2014-9331"
],
"35904": [
"CVE-2015-1480"
],
"35906": [],
"35908": [],
"35910": [],
"35911": [
"CVE-2015-1478",
"CVE-2015-1477"
],
"36313": [],
"35982": [
"CVE-2014-7883"
],
"35988": [
"CVE-2011-5071"
],
"35989": [],
"35990": [],
"35991": [
"CVE-2015-1471"
],
"35914": [
"CVE-2015-1374",
"CVE-2015-1373",
"CVE-2015-1372",
"CVE-2015-1371"
],
"35915": [
"CVE-2014-9226",
"CVE-2014-9225",
"CVE-2014-9224",
"CVE-2014-7289"
],
"35916": [
"CVE-2014-9312"
],
"35922": [],
"35923": [],
"35926": [],
"35927": [],
"35929": [],
"35930": [],
"35931": [],
"35933": [
"CVE-2012-4891",
"CVE-2012-4889"
],
"35940": [],
"35941": [
"CVE-2011-3642"
],
"35942": [],
"35943": [
"CVE-2011-2743"
],
"35944": [
"CVE-2011-2743"
],
"35945": [
"CVE-2011-2744"
],
"35946": [
"CVE-2011-2780"
],
"35947": [
"CVE-2011-2745"
],
"35950": [
"CVE-2015-1400"
],
"35954": [],
"35955": [],
"35956": [],
"35958": [],
"35959": [],
"35960": [],
"35987": [
"CVE-2011-5071"
],
"35966": [],
"35967": [],
"35968": [],
"35969": [],
"35971": [],
"35972": [
"CVE-2015-1428"
],
"35973": [],
"35974": [
"CVE-2011-4336"
],
"35975": [],
"35976": [],
"35977": [],
"35978": [],
"35979": [],
"36040": [],
"36000": [
"CVE-2011-2403"
],
"36001": [],
"36002": [
"CVE-2015-0107",
"CVE-2015-0104"
],
"36003": [],
"36005": [],
"36008": [],
"36009": [],
"36010": [],
"36011": [],
"36012": [],
"36015": [],
"36017": [],
"36018": [],
"36019": [],
"36041": [
"CVE-2015-1467"
],
"36023": [
"CVE-2015-1518"
],
"36059": [
"CVE-2014-8690"
],
"36026": [
"CVE-2015-1577"
],
"36027": [
"CVE-2015-1576"
],
"36028": [],
"36029": [
"CVE-2015-1575"
],
"36031": [],
"36058": [
"CVE-2015-2065",
"CVE-2014-9097"
],
"36032": [],
"36033": [],
"36034": [],
"36035": [],
"36036": [],
"36038": [],
"39386": [],
"36042": [],
"36043": [
"CVE-2014-9308"
],
"36044": [],
"36046": [],
"36047": [],
"36048": [],
"36050": [],
"36051": [],
"36054": [
"CVE-2015-2090"
],
"36055": [],
"36057": [
"CVE-2014-6137"
],
"36061": [
"CVE-2015-2196"
],
"36063": [],
"36064": [],
"36065": [],
"36066": [],
"36067": [],
"36068": [
"CVE-2011-2938"
],
"36072": [],
"36073": [],
"36074": [],
"36076": [],
"36077": [],
"36079": [],
"36080": [],
"36081": [],
"36082": [],
"36083": [],
"36084": [],
"36085": [],
"36086": [
"CVE-2015-2218",
"CVE-2015-2199"
],
"36087": [
"CVE-2015-1494"
],
"36089": [
"CVE-2015-2071",
"CVE-2015-2070"
],
"36090": [],
"36091": [
"CVE-2011-3390"
],
"36093": [],
"36094": [],
"36095": [],
"36096": [],
"36097": [],
"36098": [],
"36099": [],
"36102": [],
"36103": [],
"36105": [],
"36106": [],
"36107": [],
"36108": [],
"36109": [],
"36110": [],
"36112": [
"CVE-2014-9262"
],
"36113": [],
"36114": [],
"36116": [],
"36117": [],
"36121": [
"CVE-2011-3979"
],
"36122": [],
"36123": [],
"36126": [],
"36127": [],
"36129": [],
"36131": [],
"36132": [],
"36133": [],
"36134": [],
"36135": [],
"36136": [],
"36137": [],
"36138": [],
"36139": [],
"36140": [],
"36141": [],
"36142": [],
"36144": [],
"36146": [],
"36147": [],
"36148": [],
"36149": [],
"36150": [],
"36151": [],
"36154": [
"CVE-2015-2198"
],
"36155": [],
"36156": [
"CVE-2015-2102"
],
"36157": [
"CVE-2013-5572"
],
"36159": [
"CVE-2015-2184",
"CVE-2015-2183",
"CVE-2015-2182",
"CVE-2010-5322"
],
"36160": [
"CVE-2015-2147",
"CVE-2015-2145",
"CVE-2015-2143",
"CVE-2015-2142",
"CVE-2004-1519"
],
"36161": [
"CVE-2015-2084"
],
"36162": [
"CVE-2011-3010"
],
"36163": [
"CVE-2011-3010"
],
"36164": [],
"36165": [
"CVE-2011-3579"
],
"36166": [],
"36167": [],
"36168": [],
"36171": [],
"36172": [],
"36173": [],
"36175": [],
"36176": [],
"36177": [],
"36178": [
"CVE-2011-3850"
],
"36179": [],
"36180": [
"CVE-2011-3855"
],
"36181": [
"CVE-2011-3856"
],
"36182": [
"CVE-2011-3852"
],
"36183": [
"CVE-2011-3860"
],
"36184": [
"CVE-2011-3861"
],
"36185": [
"CVE-2011-3858"
],
"36186": [
"CVE-2011-3862"
],
"36187": [
"CVE-2011-3865"
],
"36191": [
"CVE-2011-3863"
],
"36192": [],
"36193": [],
"36194": [],
"36195": [
"CVE-2011-3859"
],
"36196": [
"CVE-2011-5169"
],
"36197": [],
"36200": [
"CVE-2011-3340"
],
"36201": [
"CVE-2011-4561"
],
"36202": [
"CVE-2014-8687"
],
"36203": [
"CVE-2011-4670"
],
"36204": [
"CVE-2011-4670"
],
"36208": [
"CVE-2011-4559"
],
"36262": [
"CVE-2014-9566"
],
"36244": [],
"36245": [],
"36213": [
"CVE-2011-4564"
],
"36214": [],
"36215": [],
"36216": [],
"36220": [],
"36221": [],
"36222": [],
"36223": [],
"36224": [],
"36225": [
"CVE-2011-4335"
],
"36226": [
"CVE-2011-4958"
],
"36227": [],
"36228": [],
"36230": [],
"36231": [],
"36232": [
"CVE-2014-9463"
],
"36233": [],
"36236": [],
"36237": [],
"36240": [],
"36241": [],
"36242": [
"CVE-2015-2216"
],
"36243": [],
"36248": [],
"36249": [],
"36251": [
"CVE-2015-2208"
],
"36252": [
"CVE-2011-1513"
],
"36253": [],
"36254": [],
"36255": [],
"36259": [],
"36265": [],
"36269": [],
"36270": [],
"36272": [],
"36273": [],
"36275": [],
"36277": [],
"36278": [],
"36282": [],
"36283": [
"CVE-2011-4090"
],
"36280": [
"CVE-2011-4340"
],
"36281": [
"CVE-2011-4341"
],
"36284": [],
"36286": [
"CVE-2011-4716"
],
"36287": [],
"36289": [],
"36290": [],
"36292": [],
"36293": [
"CVE-2011-4431"
],
"36295": [],
"36297": [],
"36298": [],
"36299": [],
"36301": [
"CVE-2014-9260"
],
"36302": [],
"36303": [
"CVE-2015-2564"
],
"36305": [
"CVE-2015-1875"
],
"36306": [
"CVE-2015-2237"
],
"36307": [
"CVE-2011-4709"
],
"36308": [],
"36314": [],
"36315": [],
"36316": [
"CVE-2011-5105"
],
"36317": [
"CVE-2011-5106"
],
"36320": [
"CVE-2014-9261"
],
"36321": [
"CVE-2015-2680",
"CVE-2015-2679",
"CVE-2015-2678"
],
"36322": [],
"36323": [
"CVE-2011-5107"
],
"36324": [
"CVE-2011-4618"
],
"36325": [
"CVE-2011-4926"
],
"36326": [
"CVE-2011-5182"
],
"36328": [],
"36329": [],
"36330": [
"CVE-2011-4814"
],
"36331": [
"CVE-2011-4802"
],
"36332": [
"CVE-2011-4802"
],
"36333": [
"CVE-2011-4802"
],
"36338": [
"CVE-2011-5181"
],
"36339": [
"CVE-2011-5265"
],
"36340": [],
"36341": [
"CVE-2011-4544"
],
"40008": [],
"36342": [
"CVE-2011-4544"
],
"36343": [
"CVE-2011-4544"
],
"36344": [
"CVE-2011-4544"
],
"36345": [
"CVE-2011-4545"
],
"36346": [
"CVE-2011-4567"
],
"36347": [
"CVE-2011-4541"
],
"36348": [],
"36349": [
"CVE-2011-5108"
],
"36350": [
"CVE-2011-5111"
],
"36351": [
"CVE-2011-5111"
],
"36353": [
"CVE-2011-5184"
],
"36354": [
"CVE-2011-5184"
],
"36355": [
"CVE-2011-5184"
],
"36356": [
"CVE-2011-5184"
],
"36357": [
"CVE-2011-5184"
],
"36358": [
"CVE-2015-2701"
],
"36362": [
"CVE-2011-5177"
],
"36363": [
"CVE-2011-5179"
],
"36364": [],
"36365": [],
"36366": [],
"36367": [],
"36368": [
"CVE-2015-2275"
],
"36369": [
"CVE-2015-2841"
],
"36371": [],
"36372": [],
"36373": [],
"36374": [],
"36375": [
"CVE-2011-4714"
],
"36379": [
"CVE-2011-5258"
],
"36380": [
"CVE-2011-5258"
],
"36381": [
"CVE-2011-5259"
],
"36382": [
"CVE-2011-5180"
],
"36383": [],
"36384": [
"CVE-2011-4833"
],
"36385": [],
"36386": [],
"36406": [
"CVE-2011-4918"
],
"36481": [
"CVE-2011-5207"
],
"36407": [
"CVE-2011-4918"
],
"36408": [
"CVE-2011-4595"
],
"36410": [],
"36413": [
"CVE-2015-2292"
],
"36401": [
"CVE-2011-4540"
],
"36402": [],
"36414": [
"CVE-2015-2791",
"CVE-2015-2315",
"CVE-2015-2314"
],
"36482": [],
"36483": [
"CVE-2012-5346"
],
"36484": [
"CVE-2012-5099"
],
"36485": [
"CVE-2012-5295"
],
"36486": [
"CVE-2012-5294"
],
"36418": [
"CVE-2015-2269"
],
"36419": [],
"36423": [
"CVE-2015-2746"
],
"36432": [],
"36434": [],
"36435": [],
"36436": [
"CVE-2015-0514"
],
"36439": [
"CVE-2015-2562"
],
"36440": [
"CVE-2015-0516"
],
"36441": [
"CVE-2015-2682"
],
"36442": [
"CVE-2015-2838"
],
"36444": [],
"36445": [],
"36446": [],
"36447": [
"CVE-2011-5041"
],
"36448": [
"CVE-2011-5213"
],
"36449": [
"CVE-2011-5213"
],
"36450": [
"CVE-2011-5214"
],
"36451": [
"CVE-2011-5214"
],
"40870": [],
"36453": [
"CVE-2011-5214"
],
"36454": [
"CVE-2011-5214"
],
"36456": [],
"36457": [],
"36458": [],
"36459": [],
"36460": [
"CVE-2011-5222"
],
"36461": [],
"36462": [],
"36463": [
"CVE-2014-5144"
],
"36464": [],
"36466": [
"CVE-2014-9014",
"CVE-2014-9013"
],
"36468": [
"CVE-2011-5045"
],
"36469": [],
"36470": [
"CVE-2011-4551"
],
"36471": [],
"36472": [],
"36473": [
"CVE-2011-5050"
],
"36474": [],
"36478": [],
"36506": [
"CVE-2015-2295"
],
"36487": [],
"36488": [
"CVE-2011-5193"
],
"36489": [
"CVE-2011-5019"
],
"36490": [
"CVE-2014-9014",
"CVE-2014-9013"
],
"36492": [
"CVE-2011-5209"
],
"36493": [
"CVE-2011-5252"
],
"36494": [
"CVE-2012-5343"
],
"36495": [
"CVE-2011-5022"
],
"36496": [
"CVE-2011-5023"
],
"36497": [
"CVE-2012-5104"
],
"36498": [
"CVE-2011-5025"
],
"36499": [
"CVE-2012-5341"
],
"36508": [
"CVE-2012-5102"
],
"36509": [
"CVE-2012-5105"
],
"36510": [
"CVE-2012-5105"
],
"36512": [],
"36515": [],
"36520": [
"CVE-2015-2780"
],
"36521": [
"CVE-2012-5292"
],
"36522": [
"CVE-2012-5292"
],
"36523": [
"CVE-2012-5292"
],
"36524": [
"CVE-2012-6644"
],
"36525": [
"CVE-2012-6644"
],
"36526": [
"CVE-2012-6644"
],
"36527": [
"CVE-2012-6644"
],
"36528": [
"CVE-2012-6644"
],
"36529": [
"CVE-2012-6644"
],
"36530": [
"CVE-2012-6644"
],
"36531": [
"CVE-2012-6643"
],
"36532": [
"CVE-2012-6643"
],
"36534": [
"CVE-2012-6529"
],
"36535": [
"CVE-2012-6529"
],
"36536": [
"CVE-2012-6529"
],
"36538": [],
"36539": [
"CVE-2012-6040"
],
"36540": [
"CVE-2012-6499"
],
"36541": [
"CVE-2012-6043"
],
"36543": [
"CVE-2012-0988"
],
"36544": [],
"36547": [
"CVE-2012-0389"
],
"36548": [],
"36549": [],
"36550": [],
"36551": [],
"36552": [],
"36553": [],
"36554": [
"CVE-2015-1579",
"CVE-2014-9734"
],
"36559": [],
"36560": [],
"36561": [
"CVE-2015-2798"
],
"36565": [
"CVE-2012-6528"
],
"36566": [
"CVE-2012-0900"
],
"36567": [],
"36568": [],
"36569": [
"CVE-2012-0899"
],
"36572": [],
"36573": [],
"36574": [
"CVE-2012-6526"
],
"36575": [],
"36576": [],
"36580": [
"CVE-2015-2223"
],
"36581": [
"CVE-2014-9148",
"CVE-2014-9147",
"CVE-2014-9146",
"CVE-2014-9145",
"CVE-2014-1222"
],
"36582": [
"CVE-2012-0989"
],
"36583": [],
"36584": [],
"36585": [
"CVE-2012-5313"
],
"36586": [],
"36588": [
"CVE-2012-0933"
],
"36589": [],
"36590": [
"CVE-2012-5312"
],
"36591": [],
"36592": [
"CVE-2011-4823"
],
"36593": [],
"36594": [],
"36595": [],
"36596": [],
"36597": [],
"36598": [
"CVE-2011-4804"
],
"36599": [],
"36600": [],
"36601": [],
"36620": [
"CVE-2012-0901"
],
"36609": [
"CVE-2014-7910",
"CVE-2014-7227",
"CVE-2014-7196",
"CVE-2014-7169",
"CVE-2014-62771",
"CVE-2014-6271",
"CVE-2014-5288",
"CVE-2014-5287",
"CVE-2014-3671",
"CVE-2014-3659"
],
"36610": [],
"36611": [],
"36612": [],
"36613": [
"CVE-2015-2824"
],
"36614": [
"CVE-2015-2825"
],
"36615": [
"CVE-2015-2826"
],
"36616": [],
"36617": [],
"36618": [],
"36619": [
"CVE-2015-2166"
],
"36621": [],
"36623": [],
"36624": [],
"36625": [
"CVE-2012-0973"
],
"36626": [
"CVE-2012-0974"
],
"36627": [
"CVE-2012-0990"
],
"36628": [
"CVE-2012-5224"
],
"36629": [],
"36630": [],
"36631": [
"CVE-2012-5229"
],
"36632": [
"CVE-2012-5225"
],
"36634": [],
"36635": [],
"36638": [],
"36639": [],
"36640": [],
"36641": [],
"36642": [],
"36643": [
"CVE-2012-1022"
],
"36644": [
"CVE-2012-1021"
],
"36645": [
"CVE-2012-1023"
],
"36646": [],
"36647": [
"CVE-2012-0932"
],
"36648": [
"CVE-2012-0991"
],
"36649": [
"CVE-2012-0991"
],
"36650": [
"CVE-2012-0991"
],
"36651": [
"CVE-2012-0992"
],
"36654": [
"CVE-2012-0834"
],
"36655": [],
"36656": [],
"36657": [],
"36658": [
"CVE-2012-1069"
],
"36659": [
"CVE-2012-1018"
],
"36660": [
"CVE-2012-1027"
],
"36661": [],
"36664": [],
"36665": [
"CVE-2012-1028"
],
"36666": [
"CVE-2012-1049"
],
"36667": [
"CVE-2012-1049"
],
"36668": [
"CVE-2012-1048"
],
"36671": [],
"36674": [
"CVE-2014-9311"
],
"36675": [],
"36676": [],
"36677": [],
"36678": [
"CVE-2015-0779"
],
"36683": [
"CVE-2012-1225"
],
"36684": [],
"36685": [
"CVE-2012-0865"
],
"36686": [
"CVE-2012-0865"
],
"36687": [
"CVE-2012-0865"
],
"36688": [
"CVE-2011-4403"
],
"36689": [
"CVE-2000-0920"
],
"36691": [],
"36693": [],
"36694": [],
"36695": [
"CVE-2012-1213"
],
"36696": [
"CVE-2012-1200"
],
"36697": [
"CVE-2012-1200"
],
"36698": [
"CVE-2012-1200"
],
"36699": [
"CVE-2012-1200"
],
"36702": [
"CVE-2012-1199"
],
"36703": [
"CVE-2012-1199"
],
"36704": [
"CVE-2012-1199"
],
"36705": [
"CVE-2012-1199"
],
"36706": [
"CVE-2012-1199"
],
"36707": [
"CVE-2012-1199"
],
"36708": [
"CVE-2012-1199"
],
"36709": [
"CVE-2012-1199"
],
"36710": [
"CVE-2012-1199"
],
"36711": [
"CVE-2012-1199"
],
"36712": [
"CVE-2012-1199"
],
"36713": [
"CVE-2012-1199"
],
"36714": [
"CVE-2012-1199"
],
"36715": [
"CVE-2012-1199"
],
"36716": [
"CVE-2012-1199"
],
"36717": [
"CVE-2012-1199"
],
"36718": [
"CVE-2012-1199"
],
"36719": [
"CVE-2012-1199"
],
"36720": [
"CVE-2012-1199"
],
"36721": [
"CVE-2012-1199"
],
"36722": [
"CVE-2012-1199"
],
"36723": [
"CVE-2012-1199"
],
"36724": [
"CVE-2012-1199"
],
"36725": [
"CVE-2012-1199"
],
"36726": [
"CVE-2012-1199"
],
"36727": [
"CVE-2012-1199"
],
"36728": [
"CVE-2012-1199"
],
"36729": [
"CVE-2012-1199"
],
"36730": [
"CVE-2012-1199"
],
"36731": [
"CVE-2012-1199"
],
"36732": [
"CVE-2012-1199"
],
"36733": [],
"36735": [],
"36736": [],
"36738": [],
"36761": [],
"36752": [
"CVE-2012-1199"
],
"36753": [
"CVE-2012-1199"
],
"36754": [
"CVE-2012-1199"
],
"36751": [],
"36755": [
"CVE-2012-1199"
],
"36757": [
"CVE-2012-1199"
],
"36758": [
"CVE-2012-1199"
],
"36759": [
"CVE-2012-1199"
],
"36760": [
"CVE-2012-1198"
],
"36762": [],
"36763": [],
"36764": [],
"36765": [
"CVE-2012-1211"
],
"36766": [
"CVE-2012-1210"
],
"36768": [],
"36769": [
"CVE-2012-1217"
],
"36770": [
"CVE-2012-1217"
],
"36771": [
"CVE-2012-1217"
],
"36772": [],
"36774": [],
"36807": [
"CVE-2015-2845",
"CVE-2015-2844",
"CVE-2015-2843",
"CVE-2015-2842"
],
"36777": [],
"36784": [
"CVE-2012-0996"
],
"36785": [
"CVE-2012-0996"
],
"36786": [
"CVE-2012-0997"
],
"36787": [],
"36790": [
"CVE-2012-1029"
],
"36791": [],
"36792": [],
"36793": [],
"36795": [],
"36796": [],
"36797": [],
"36798": [],
"36800": [],
"36801": [],
"36802": [
"CVE-2015-3314"
],
"36804": [],
"36805": [
"CVE-2015-3313"
],
"36815": [
"CVE-2014-5370"
],
"36848": [
"CVE-2012-5321"
],
"36849": [],
"36850": [],
"36851": [
"CVE-2012-0869"
],
"36852": [],
"36818": [],
"36821": [],
"36823": [],
"36824": [],
"36830": [
"CVE-2012-1294"
],
"36834": [],
"36835": [],
"36844": [
"CVE-2015-3440"
],
"36842": [
"CVE-2014-1695"
],
"36994": [
"CVE-2009-5114"
],
"36853": [
"CVE-2012-0873"
],
"36854": [
"CVE-2012-0873"
],
"36856": [],
"36860": [
"CVE-2015-3302",
"CVE-2015-3301",
"CVE-2015-3300",
"CVE-2015-3986"
],
"36861": [],
"36862": [],
"36863": [],
"36865": [
"CVE-2012-5322"
],
"36867": [],
"36870": [
"CVE-2012-1224"
],
"36873": [
"CVE-2012-1226"
],
"36874": [
"CVE-2012-1001"
],
"36875": [
"CVE-2012-1001"
],
"36876": [
"CVE-2012-4928"
],
"36878": [],
"36882": [
"CVE-2012-1784"
],
"36883": [
"CVE-2012-1787"
],
"36885": [],
"36886": [
"CVE-2012-1782"
],
"36888": [
"CVE-2012-1039"
],
"36889": [
"CVE-2012-1039"
],
"36890": [
"CVE-2012-1039"
],
"36891": [
"CVE-2012-1039"
],
"36892": [],
"36893": [
"CVE-2012-1188"
],
"36894": [
"CVE-2012-1188"
],
"36895": [
"CVE-2012-4998"
],
"36897": [],
"36898": [
"CVE-2012-1110"
],
"36899": [
"CVE-2012-1110"
],
"36900": [
"CVE-2012-1110"
],
"36914": [],
"36916": [],
"36917": [
"CVE-2012-1617"
],
"36910": [
"CVE-2012-1112"
],
"36911": [],
"36912": [],
"36913": [
"CVE-2012-1116"
],
"36904": [],
"36973": [
"CVE-2012-4873"
],
"36922": [],
"36907": [],
"36965": [],
"36967": [],
"36968": [],
"36970": [],
"36971": [],
"36924": [],
"36925": [],
"36926": [],
"36927": [],
"36929": [],
"36930": [],
"36934": [],
"36935": [],
"36936": [],
"36937": [],
"36938": [],
"36939": [],
"36940": [
"CVE-2015-2248"
],
"36941": [
"CVE-2014-0910"
],
"36942": [],
"36943": [],
"36944": [
"CVE-2012-1556"
],
"36946": [
"CVE-2012-6520"
],
"36947": [
"CVE-2012-2099"
],
"36948": [
"CVE-2012-2099"
],
"36949": [
"CVE-2015-3141"
],
"36950": [
"CVE-2015-3140"
],
"36951": [
"CVE-2015-3140"
],
"36952": [],
"36953": [
"CVE-2015-3140"
],
"36954": [],
"36958": [],
"36959": [],
"36960": [],
"36961": [],
"36963": [],
"36974": [],
"36975": [],
"36976": [
"CVE-2009-5112"
],
"36977": [
"CVE-2012-1778"
],
"36978": [],
"36979": [],
"37186": [],
"37006": [],
"36986": [],
"36987": [
"CVE-2013-5223"
],
"36988": [
"CVE-2013-5223"
],
"36989": [],
"36990": [],
"36991": [],
"36992": [],
"36993": [],
"36997": [],
"36999": [
"CVE-2012-1469"
],
"37000": [
"CVE-2012-1469"
],
"37001": [
"CVE-2012-1468"
],
"37002": [
"CVE-2012-1467"
],
"37003": [],
"37004": [],
"37008": [],
"37009": [
"CVE-2012-1592"
],
"37010": [],
"37011": [],
"37012": [
"CVE-2012-1603"
],
"37013": [
"CVE-2012-1604"
],
"37015": [],
"37016": [
"CVE-2012-5913"
],
"37017": [],
"37018": [
"CVE-2012-5909"
],
"37019": [
"CVE-2012-5908"
],
"37021": [
"CVE-2012-5907"
],
"37022": [
"CVE-2012-1470"
],
"37023": [],
"37024": [
"CVE-2012-1597"
],
"37025": [],
"37026": [],
"37027": [
"CVE-2012-5903"
],
"37028": [],
"37029": [
"CVE-2012-4889"
],
"37030": [
"CVE-2012-4889"
],
"37031": [
"CVE-2012-4889"
],
"37032": [
"CVE-2012-4889"
],
"37033": [],
"37034": [
"CVE-2012-4878"
],
"37035": [
"CVE-2012-4877"
],
"37038": [
"CVE-2012-1664"
],
"37039": [
"CVE-2012-1664"
],
"37040": [
"CVE-2012-1664"
],
"37041": [
"CVE-2012-1664"
],
"37042": [
"CVE-2012-1664"
],
"37043": [
"CVE-2012-1664"
],
"37044": [
"CVE-2012-1664"
],
"37045": [
"CVE-2012-1664"
],
"37046": [
"CVE-2012-1664"
],
"37047": [
"CVE-2012-1665"
],
"37048": [
"CVE-2012-1665"
],
"37050": [],
"37054": [
"CVE-2015-3337"
],
"37055": [],
"37057": [],
"37058": [],
"37059": [],
"37062": [
"CVE-2012-4686"
],
"37063": [],
"37067": [
"CVE-2015-4018"
],
"37070": [],
"37071": [],
"37072": [],
"37073": [],
"37074": [
"CVE-2015-4039",
"CVE-2015-4038"
],
"37152": [],
"37075": [
"CVE-2012-1835"
],
"37076": [
"CVE-2012-1835"
],
"37077": [
"CVE-2012-1835"
],
"37078": [
"CVE-2012-1835"
],
"37079": [],
"37080": [
"CVE-2015-3325"
],
"37082": [],
"37083": [],
"37084": [
"CVE-2012-2104"
],
"37085": [],
"37086": [],
"37087": [
"CVE-2012-2234"
],
"37090": [],
"37091": [
"CVE-2012-4745"
],
"37092": [
"CVE-2012-0984"
],
"37093": [
"CVE-2012-0984"
],
"37094": [
"CVE-2012-2270"
],
"37095": [],
"37096": [],
"37253": [
"CVE-2015-5065"
],
"37254": [],
"37255": [],
"37100": [],
"37101": [
"CVE-2011-5099"
],
"37102": [],
"37103": [],
"37104": [
"CVE-2012-6513"
],
"37105": [],
"37106": [],
"37107": [
"CVE-2015-4063",
"CVE-2015-4062"
],
"37108": [
"CVE-2015-4065",
"CVE-2015-4064"
],
"37109": [
"CVE-2015-4066"
],
"37110": [
"CVE-2015-1833"
],
"37111": [],
"37112": [
"CVE-2015-4127"
],
"37113": [],
"37114": [
"CVE-2014-0999",
"CVE-2014-8391"
],
"37115": [],
"37116": [],
"37117": [],
"37118": [],
"37119": [
"CVE-2012-4060"
],
"37120": [
"CVE-2012-4055"
],
"37121": [],
"37122": [],
"37123": [],
"37125": [
"CVE-2012-4251"
],
"37126": [
"CVE-2012-4253"
],
"37127": [
"CVE-2012-4251"
],
"37128": [
"CVE-2012-4251"
],
"37129": [
"CVE-2012-4253"
],
"37130": [
"CVE-2012-4254"
],
"37131": [
"CVE-2012-4252"
],
"37132": [
"CVE-2015-4084"
],
"37133": [
"CVE-2012-4251"
],
"37134": [],
"37135": [],
"37136": [
"CVE-2012-4282"
],
"37137": [
"CVE-2012-1990"
],
"37138": [
"CVE-2012-6045"
],
"37139": [],
"37140": [
"CVE-2012-6046"
],
"37142": [
"CVE-2012-1506"
],
"37143": [
"CVE-2012-1507"
],
"37144": [
"CVE-2012-1507"
],
"37145": [
"CVE-2012-1507"
],
"37146": [
"CVE-2012-2274"
],
"37147": [
"CVE-2012-2918"
],
"37148": [
"CVE-2012-2919"
],
"37151": [],
"37154": [],
"37155": [
"CVE-2012-2371"
],
"37161": [],
"37162": [],
"37166": [],
"37172": [
"CVE-2015-1389"
],
"37174": [],
"37176": [],
"37177": [],
"37178": [],
"37179": [],
"37180": [],
"37185": [],
"37182": [],
"37189": [],
"37190": [],
"37191": [
"CVE-2012-2913"
],
"37192": [
"CVE-2012-2913"
],
"37193": [],
"37194": [],
"37195": [
"CVE-2012-6622"
],
"37196": [],
"37200": [
"CVE-2015-4465",
"CVE-2015-4153"
],
"37201": [],
"37202": [
"CVE-2012-2917"
],
"37203": [
"CVE-2012-6624"
],
"37204": [],
"37205": [
"CVE-2012-2904"
],
"37206": [
"CVE-2012-2910"
],
"37207": [
"CVE-2012-2910"
],
"37208": [
"CVE-2012-2911"
],
"37209": [],
"37213": [],
"37214": [],
"37252": [],
"37216": [
"CVE-2012-2914"
],
"37217": [
"CVE-2012-2906"
],
"37219": [],
"37220": [],
"37221": [],
"37222": [],
"37223": [],
"37224": [
"CVE-2012-2941"
],
"37225": [],
"37226": [],
"37350": [],
"37351": [],
"37352": [],
"37353": [
"CVE-2012-3577"
],
"37248": [
"CVE-2015-4137"
],
"37237": [],
"37238": [],
"37240": [],
"37241": [],
"37243": [],
"37244": [],
"37245": [],
"37266": [
"CVE-2015-4659"
],
"37250": [
"CVE-2015-2125"
],
"39479": [],
"37298": [],
"37301": [
"CVE-2015-2803"
],
"37302": [],
"37304": [
"CVE-2015-5079"
],
"37305": [
"CVE-2007-6587"
],
"37307": [],
"37308": [],
"37309": [],
"37310": [],
"37311": [
"CVE-2012-2436"
],
"37312": [
"CVE-2012-2452"
],
"37313": [
"CVE-2012-2452"
],
"37314": [],
"37315": [],
"37257": [
"CVE-2015-4677"
],
"37258": [],
"37259": [
"CVE-2015-4119",
"CVE-2015-4118"
],
"37260": [
"CVE-2015-3898",
"CVE-2015-3897"
],
"37261": [
"CVE-2015-2805"
],
"37263": [],
"37264": [
"CVE-2015-4010"
],
"37270": [],
"37271": [
"CVE-2015-4420"
],
"37272": [
"CVE-2015-7347",
"CVE-2015-7346"
],
"37274": [
"CVE-2015-4414"
],
"37275": [
"CVE-2015-4455"
],
"37283": [],
"37316": [],
"37354": [],
"37290": [
"CVE-2015-4658"
],
"37329": [],
"37330": [],
"37331": [],
"37296": [
"CVE-2015-3624"
],
"37317": [],
"37318": [],
"37319": [
"CVE-2007-3071"
],
"37320": [],
"37321": [],
"37322": [
"CVE-2015-5150",
"CVE-2015-5149"
],
"37323": [],
"37325": [
"CVE-2015-5148"
],
"37328": [],
"37355": [],
"37356": [],
"37357": [],
"37337": [],
"37338": [],
"37339": [],
"37340": [],
"37341": [],
"37342": [],
"37816": [
"CVE-2014-8008",
"CVE-2014-6271"
],
"37815": [],
"39249": [
"CVE-2014-5101"
],
"37440": [
"CVE-2015-5452",
"CVE-2011-2165"
],
"37360": [
"CVE-2015-5066",
"CVE-2015-3221"
],
"37361": [],
"37363": [
"CVE-2015-3933"
],
"37364": [],
"37369": [
"CVE-2015-4117"
],
"37370": [
"CVE-2012-3578"
],
"37371": [],
"37372": [
"CVE-2012-2959"
],
"37373": [],
"37374": [],
"37375": [],
"37376": [],
"37377": [],
"37378": [],
"37379": [],
"37380": [],
"37381": [],
"37382": [],
"37383": [],
"37387": [
"CVE-2015-4633"
],
"37388": [
"CVE-2015-4632"
],
"37389": [
"CVE-2015-4631",
"CVE-2015-4630"
],
"37394": [
"CVE-2015-3443"
],
"37395": [
"CVE-2015-2169"
],
"37397": [],
"37398": [],
"37399": [],
"37403": [],
"37404": [
"CVE-2012-2698"
],
"37406": [],
"37407": [],
"37408": [],
"37409": [],
"37410": [],
"37411": [],
"37412": [],
"37413": [],
"37414": [],
"37415": [],
"37416": [],
"37417": [],
"37418": [],
"37419": [],
"37420": [],
"37565": [
"CVE-2012-2237"
],
"37497": [],
"37423": [
"CVE-2015-4553"
],
"37424": [],
"37425": [],
"37430": [],
"37431": [],
"37432": [],
"37433": [],
"37434": [],
"37435": [
"CVE-2012-3232"
],
"37436": [],
"37437": [],
"37438": [],
"37439": [
"CVE-2015-5354",
"CVE-2015-5353"
],
"37441": [],
"37442": [],
"37443": [],
"37444": [],
"37445": [],
"37446": [
"CVE-2015-3934"
],
"37447": [
"CVE-2015-4460"
],
"37449": [
"CVE-2015-4685",
"CVE-2015-4684",
"CVE-2015-4683",
"CVE-2015-4682",
"CVE-2015-4681"
],
"37450": [],
"37451": [],
"37452": [],
"37453": [],
"37454": [],
"37499": [],
"37457": [
"CVE-2012-4000"
],
"37459": [],
"37460": [],
"37461": [],
"37464": [],
"37466": [],
"37467": [],
"37468": [],
"37469": [],
"37470": [
"CVE-2012-3414"
],
"37472": [],
"40676": [],
"37474": [],
"37498": [
"CVE-2012-3805"
],
"37476": [],
"37479": [],
"37481": [],
"37482": [],
"37483": [],
"37484": [],
"37485": [],
"37486": [],
"37488": [
"CVE-2012-4032"
],
"37489": [],
"37563": [],
"37492": [],
"37534": [
"CVE-2015-4616",
"CVE-2015-4614"
],
"37494": [],
"37500": [],
"37501": [],
"37502": [],
"37503": [],
"37504": [],
"37505": [],
"37506": [],
"37507": [],
"37508": [],
"37509": [],
"37511": [],
"37514": [],
"37515": [
"CVE-2015-6518",
"CVE-2015-6517"
],
"37516": [],
"37519": [],
"37520": [],
"37521": [
"CVE-2012-1915"
],
"37522": [
"CVE-2012-2570"
],
"37524": [],
"37527": [
"CVE-2015-2280"
],
"37528": [
"CVE-2015-1561",
"CVE-2015-1560"
],
"37621": [
"CVE-2015-2863",
"CVE-2015-2862"
],
"37530": [
"CVE-2015-5468"
],
"37531": [],
"37532": [
"CVE-2015-2279"
],
"37533": [
"CVE-2015-5520"
],
"37537": [],
"37540": [],
"37541": [],
"37544": [],
"37547": [
"CVE-2012-3848"
],
"37548": [
"CVE-2012-2627"
],
"37549": [
"CVE-2012-2626"
],
"37550": [],
"37551": [],
"37552": [
"CVE-2012-3351"
],
"37553": [],
"37554": [],
"37555": [],
"37556": [],
"37557": [],
"37559": [],
"37560": [],
"37567": [],
"37569": [],
"37570": [],
"37571": [],
"37572": [],
"37573": [],
"37575": [],
"37577": [],
"37578": [
"CVE-2012-3872"
],
"37579": [
"CVE-2012-3872"
],
"37580": [
"CVE-2012-3872"
],
"37581": [
"CVE-2012-4070"
],
"37582": [],
"37583": [],
"37584": [
"CVE-2012-4237"
],
"37585": [
"CVE-2012-4237"
],
"37586": [],
"37587": [],
"37588": [],
"37589": [],
"37590": [
"CVE-2012-3952"
],
"37591": [],
"37592": [
"CVE-2015-6512"
],
"37594": [
"CVE-2015-6519"
],
"37595": [],
"37596": [
"CVE-2015-5530",
"CVE-2015-5529"
],
"37601": [
"CVE-2015-5471"
],
"37602": [
"CVE-2015-5595",
"CVE-2015-5594",
"CVE-2015-5591"
],
"37603": [],
"37604": [
"CVE-2014-8677",
"CVE-2014-8676",
"CVE-2014-8675",
"CVE-2014-8674",
"CVE-2014-8673"
],
"37622": [],
"37609": [
"CVE-2015-4425"
],
"37610": [
"CVE-2015-6516"
],
"37613": [
"CVE-2012-3953"
],
"37614": [
"CVE-2012-4034"
],
"37615": [
"CVE-2012-4035"
],
"37616": [
"CVE-2012-4036"
],
"37617": [],
"37620": [],
"37623": [],
"37624": [],
"37625": [],
"37626": [],
"37629": [],
"37630": [],
"37632": [
"CVE-2012-4236"
],
"37633": [],
"37634": [],
"37635": [],
"37636": [],
"37637": [],
"37638": [],
"37641": [],
"37642": [],
"37643": [
"CVE-2012-0744"
],
"37644": [],
"37645": [],
"37646": [],
"37648": [],
"37649": [],
"37650": [],
"37651": [],
"37652": [],
"37653": [],
"37654": [],
"37656": [],
"37659": [
"CVE-2015-5399"
],
"37662": [],
"37666": [
"CVE-2015-4075",
"CVE-2015-4074",
"CVE-2015-4073",
"CVE-2015-4072",
"CVE-2015-4071"
],
"37672": [],
"37674": [],
"37675": [],
"37676": [],
"37677": [],
"37678": [],
"37679": [],
"37680": [],
"37681": [],
"37682": [],
"37683": [
"CVE-2012-4234"
],
"37684": [
"CVE-2012-2517"
],
"37686": [
"CVE-2015-2878"
],
"37687": [],
"37689": [],
"37690": [
"CVE-2012-3551"
],
"37691": [],
"37693": [],
"37694": [],
"37695": [],
"37696": [],
"37697": [],
"37698": [
"CVE-2012-3233"
],
"37700": [],
"37826": [],
"37751": [],
"37752": [],
"37705": [],
"37707": [
"CVE-2015-5533"
],
"37708": [
"CVE-2015-4669",
"CVE-2015-4668",
"CVE-2015-4667",
"CVE-2015-4666",
"CVE-2015-4665",
"CVE-2015-4664"
],
"37709": [],
"37712": [],
"37713": [],
"37714": [],
"37715": [],
"37720": [],
"37725": [],
"37726": [],
"37734": [],
"37735": [],
"37753": [],
"37738": [
"CVE-2015-2321"
],
"37824": [
"CVE-2015-6522"
],
"37744": [],
"37750": [],
"37754": [],
"37948": [],
"37950": [
"CVE-2012-4231"
],
"37757": [],
"37761": [],
"37765": [
"CVE-2015-5161"
],
"37767": [],
"37769": [],
"37770": [],
"37773": [],
"37774": [],
"37778": [],
"37779": [
"CVE-2012-4336"
],
"37781": [],
"37782": [],
"37784": [],
"37785": [],
"37786": [
"CVE-2008-6720",
"CVE-2008-0565"
],
"37787": [
"CVE-2012-4768"
],
"37789": [],
"37790": [],
"37791": [],
"37940": [
"CVE-2012-5342"
],
"37941": [
"CVE-2012-5342"
],
"37942": [
"CVE-2012-5342"
],
"37943": [
"CVE-2011-4640"
],
"37944": [],
"37945": [],
"37946": [],
"37801": [],
"37802": [],
"37804": [],
"37805": [],
"37806": [],
"37807": [],
"37809": [],
"37811": [],
"37817": [],
"37818": [],
"37819": [],
"37820": [],
"37821": [],
"37822": [],
"37827": [],
"37828": [],
"37829": [
"CVE-2012-4242"
],
"37830": [],
"37938": [
"CVE-2012-4989"
],
"37939": [],
"38066": [
"CVE-2012-6312"
],
"38067": [],
"37833": [],
"37835": [],
"37836": [],
"37837": [],
"37838": [],
"37885": [],
"37886": [],
"37887": [],
"37888": [],
"37891": [
"CVE-2015-5437"
],
"37892": [],
"37894": [],
"37896": [],
"37899": [],
"37901": [],
"37902": [],
"37903": [],
"37904": [],
"37906": [],
"37907": [
"CVE-2015-6805"
],
"37926": [
"CVE-2014-9613"
],
"37927": [
"CVE-2014-9612"
],
"37928": [
"CVE-2014-9605"
],
"37929": [
"CVE-2014-9610"
],
"37930": [],
"37931": [
"CVE-2014-9611"
],
"37932": [
"CVE-2014-9619"
],
"37933": [
"CVE-2014-9618"
],
"37934": [],
"37935": [],
"37936": [],
"37955": [
"CVE-2015-6655"
],
"37956": [],
"37959": [],
"37960": [],
"37961": [],
"37962": [],
"37963": [],
"37965": [],
"37968": [],
"37970": [],
"37971": [],
"37973": [],
"37974": [],
"37977": [
"CVE-2015-1397"
],
"37978": [],
"37979": [],
"37982": [],
"37983": [],
"37989": [
"CVE-2015-6810"
],
"37991": [],
"37992": [],
"37993": [],
"37994": [],
"37995": [
"CVE-2012-4939"
],
"37998": [],
"37999": [],
"38000": [
"CVE-2015-6568",
"CVE-2015-6567"
],
"38002": [],
"38004": [],
"38006": [],
"38007": [],
"38008": [],
"38009": [],
"38010": [
"CVE-2012-4951"
],
"38011": [
"CVE-2012-5367"
],
"38012": [],
"38015": [
"CVE-2012-2437"
],
"38016": [
"CVE-2012-4949"
],
"38017": [],
"38018": [],
"38019": [],
"38022": [],
"38023": [],
"38024": [
"CVE-2012-5851"
],
"38025": [],
"38026": [],
"38027": [],
"38029": [],
"38030": [
"CVE-2012-3448"
],
"38034": [
"CVE-2015-6811"
],
"38037": [],
"38039": [],
"38040": [],
"38041": [],
"38042": [
"CVE-2012-5701"
],
"38043": [
"CVE-2012-5702"
],
"38044": [],
"38045": [],
"38046": [],
"38047": [],
"38048": [],
"38050": [],
"38051": [
"CVE-2015-6809"
],
"38056": [],
"38057": [],
"38060": [],
"38061": [],
"38062": [
"CVE-2012-4982"
],
"38063": [],
"38064": [],
"38068": [],
"38071": [],
"38073": [],
"38074": [
"CVE-2015-6545"
],
"38086": [
"CVE-2015-6965"
],
"38076": [],
"38077": [],
"38078": [
"CVE-2012-6608"
],
"38099": [],
"38080": [],
"38081": [],
"38090": [],
"38091": [],
"38101": [],
"38102": [],
"38103": [],
"38097": [],
"38098": [
"CVE-2015-6945",
"CVE-2015-6944"
],
"38105": [],
"38110": [],
"38111": [
"CVE-2012-6313"
],
"38112": [],
"38113": [],
"38114": [
"CVE-2012-5878"
],
"38115": [
"CVE-2012-4932"
],
"38118": [
"CVE-2015-3623"
],
"38119": [
"CVE-2015-6827"
],
"38127": [],
"38128": [
"CVE-2015-6912",
"CVE-2015-6911"
],
"38129": [],
"38130": [],
"38131": [],
"38133": [],
"38134": [],
"38135": [],
"38139": [],
"38140": [],
"38141": [],
"38142": [],
"38143": [],
"38144": [],
"38148": [],
"38204": [
"CVE-2012-5190"
],
"38152": [],
"38153": [
"CVE-2012-6448"
],
"38154": [],
"38155": [],
"38156": [],
"38157": [],
"38158": [],
"38159": [],
"38160": [],
"38161": [],
"38162": [],
"38163": [],
"38166": [],
"38167": [],
"38168": [],
"38169": [
"CVE-2013-0161"
],
"38171": [],
"38178": [],
"38173": [
"CVE-2015-7387"
],
"38174": [],
"38176": [],
"38182": [],
"38183": [],
"38184": [],
"38187": [
"CVE-2015-7235"
],
"38188": [],
"38189": [],
"38190": [
"CVE-2015-7707"
],
"38191": [
"CVE-2015-6972"
],
"38192": [
"CVE-2015-6973"
],
"38197": [],
"38207": [
"CVE-2012-6430"
],
"38209": [],
"38210": [],
"38256": [
"CVE-2015-3203"
],
"38258": [],
"38213": [
"CVE-2015-6962"
],
"38223": [],
"38224": [],
"38228": [],
"38229": [],
"38231": [],
"38234": [
"CVE-2013-1402"
],
"38235": [
"CVE-2013-1410"
],
"38236": [
"CVE-2013-0807"
],
"38237": [],
"38238": [],
"38241": [],
"38245": [],
"38246": [],
"38251": [
"CVE-2013-1463"
],
"38255": [],
"38261": [
"CVE-2015-7241"
],
"38290": [],
"38291": [],
"38292": [
"CVE-2015-7382",
"CVE-2015-7381",
"CVE-2015-6009",
"CVE-2015-6008"
],
"38294": [],
"38295": [],
"38296": [
"CVE-2013-1409"
],
"38297": [
"CVE-2013-1408"
],
"38300": [
"CVE-2013-1464"
],
"38301": [],
"38304": [
"CVE-2015-4148"
],
"38309": [],
"38311": [],
"40882": [],
"38314": [
"CVE-2013-0291"
],
"38315": [],
"38316": [
"CVE-2015-8038",
"CVE-2015-8037"
],
"38318": [],
"38320": [],
"38321": [
"CVE-2015-5075"
],
"38322": [],
"38323": [
"CVE-2015-5074"
],
"38324": [
"CVE-2013-1636"
],
"38326": [],
"38327": [],
"38328": [],
"38329": [
"CVE-2012-6550"
],
"38331": [
"CVE-2013-1765"
],
"38332": [
"CVE-2013-2289"
],
"38333": [],
"38334": [
"CVE-2012-5337"
],
"38335": [],
"38338": [
"CVE-2015-7904",
"CVE-2015-7903",
"CVE-2015-7902",
"CVE-2015-7901",
"CVE-2015-7900",
"CVE-2015-6494",
"CVE-2015-6493"
],
"38339": [],
"38342": [],
"38343": [],
"38345": [
"CVE-2016-1713",
"CVE-2015-6000"
],
"38350": [],
"38351": [
"CVE-2015-6922",
"CVE-2015-6589"
],
"38354": [],
"38355": [
"CVE-2013-2287"
],
"38358": [],
"38359": [],
"38363": [],
"38366": [],
"38367": [],
"38369": [
"CVE-2015-6970"
],
"38372": [],
"38373": [
"CVE-2013-2501"
],
"38374": [],
"38375": [],
"38376": [
"CVE-2013-2714"
],
"38377": [
"CVE-2013-2503"
],
"38379": [],
"38380": [],
"38383": [
"CVE-2015-5531"
],
"38385": [],
"38386": [],
"38391": [],
"38393": [],
"38395": [],
"38537": [],
"38400": [],
"38406": [],
"38407": [],
"38408": [],
"38409": [],
"38410": [],
"38411": [
"CVE-2015-7293"
],
"38413": [],
"38414": [],
"40407": [],
"38415": [
"CVE-2013-0125"
],
"38416": [
"CVE-2013-2750"
],
"38417": [
"CVE-2013-2559"
],
"38418": [
"CVE-2013-2267"
],
"38424": [
"CVE-2015-5285"
],
"38425": [
"CVE-2013-0135"
],
"38426": [
"CVE-2013-0135"
],
"38427": [
"CVE-2013-0135"
],
"38428": [
"CVE-2013-0135"
],
"38429": [
"CVE-2013-0135"
],
"38430": [
"CVE-2013-0135"
],
"38431": [
"CVE-2013-0135"
],
"38432": [
"CVE-2013-0135"
],
"38433": [
"CVE-2013-0135"
],
"38434": [
"CVE-2013-0135"
],
"38435": [
"CVE-2013-0135"
],
"38436": [
"CVE-2013-1938"
],
"38438": [],
"38439": [
"CVE-2013-3526"
],
"38440": [
"CVE-2013-1937"
],
"38441": [
"CVE-2013-3530"
],
"38443": [],
"38445": [],
"38446": [],
"38448": [
"CVE-2015-4040"
],
"38449": [],
"38450": [],
"38455": [
"CVE-2015-6018"
],
"38476": [
"CVE-2013-3538"
],
"38477": [
"CVE-2013-3537"
],
"38458": [
"CVE-2013-3532"
],
"38459": [
"CVE-2013-3525"
],
"38460": [
"CVE-2013-1942"
],
"38461": [
"CVE-2013-2649"
],
"38462": [
"CVE-2013-2649"
],
"38463": [],
"38470": [],
"38471": [],
"38478": [],
"38479": [
"CVE-2013-2504"
],
"38480": [],
"38482": [],
"38484": [],
"38487": [],
"38488": [
"CVE-2014-2962"
],
"38491": [],
"38494": [
"CVE-2013-2009"
],
"38496": [],
"38497": [],
"38499": [],
"38506": [
"CVE-2013-3320"
],
"38507": [
"CVE-2013-3320"
],
"38508": [],
"38509": [],
"38510": [],
"38511": [],
"38514": [],
"38515": [],
"38516": [],
"38517": [
"CVE-2013-2107"
],
"38518": [
"CVE-2013-3082"
],
"38519": [
"CVE-2013-3081"
],
"38520": [
"CVE-2013-2108"
],
"38523": [],
"38524": [],
"38525": [],
"38527": [
"CVE-2015-7714"
],
"38528": [
"CVE-2015-7715"
],
"38572": [],
"38534": [],
"38645": [],
"38543": [],
"38544": [],
"38545": [
"CVE-2013-2623"
],
"38546": [
"CVE-2013-2621"
],
"38547": [],
"38548": [
"CVE-2013-2624"
],
"38550": [
"CVE-2013-0143"
],
"38551": [
"CVE-2015-5603"
],
"38553": [],
"38560": [],
"38561": [],
"38562": [
"CVE-2013-3574"
],
"38563": [
"CVE-2013-3575"
],
"38565": [],
"38567": [],
"38568": [],
"38569": [],
"38570": [],
"38571": [],
"38573": [
"CVE-2015-5161"
],
"38574": [],
"38575": [],
"38577": [],
"38578": [],
"38579": [],
"38581": [
"CVE-2015-5534"
],
"38585": [
"CVE-2013-3684"
],
"38588": [],
"38590": [],
"38592": [],
"38593": [],
"38594": [],
"38596": [
"CVE-2013-3639"
],
"38598": [],
"38602": [],
"38604": [],
"38605": [],
"38606": [],
"38607": [],
"38608": [
"CVE-2013-4692"
],
"38630": [],
"38621": [
"CVE-2013-4692"
],
"38624": [],
"38625": [
"CVE-2013-4117"
],
"38628": [],
"38629": [
"CVE-2015-7808"
],
"38642": [
"CVE-2013-5314"
],
"38635": [],
"38638": [
"CVE-2013-4951"
],
"38639": [
"CVE-2013-5020"
],
"38640": [
"CVE-2015-1793"
],
"38641": [
"CVE-2014-6593"
],
"38643": [
"CVE-2013-4954"
],
"38646": [],
"38648": [],
"38649": [],
"38651": [],
"38652": [],
"38653": [],
"38654": [
"CVE-2013-4620"
],
"38655": [],
"38656": [],
"38657": [
"CVE-2017-16836"
],
"38661": [],
"38664": [],
"38665": [],
"38684": [],
"38673": [],
"38674": [],
"38675": [
"CVE-2013-4759"
],
"38676": [
"CVE-2013-4625"
],
"38677": [],
"38678": [],
"38679": [],
"38682": [
"CVE-2013-4624"
],
"38683": [
"CVE-2013-4624"
],
"38688": [],
"38689": [
"CVE-2013-2653"
],
"38691": [
"CVE-2013-5028"
],
"38693": [],
"38695": [],
"38696": [],
"38697": [],
"38698": [],
"38699": [],
"38706": [],
"38707": [
"CVE-2015-5999"
],
"38709": [],
"38712": [],
"38727": [],
"38728": [],
"38729": [],
"38737": [
"CVE-2013-4900"
],
"38738": [
"CVE-2013-4200"
],
"38739": [
"CVE-2013-3597"
],
"38740": [
"CVE-2013-4727"
],
"38744": [],
"38745": [
"CVE-2013-4888"
],
"38746": [
"CVE-2013-4889"
],
"38748": [],
"38749": [],
"38750": [],
"38753": [],
"38754": [],
"38755": [],
"38756": [],
"38757": [],
"38762": [],
"38765": [
"CVE-2015-7984"
],
"38767": [],
"38768": [],
"38769": [],
"38770": [],
"38773": [
"CVE-2015-8703",
"CVE-2015-7252",
"CVE-2015-7251",
"CVE-2015-7250",
"CVE-2015-7249",
"CVE-2015-7248"
],
"38781": [
"CVE-2013-5967"
],
"38803": [],
"38782": [],
"38776": [],
"38777": [],
"38780": [],
"38783": [],
"38784": [],
"38785": [
"CVE-2013-6129"
],
"38786": [],
"38790": [
"CVE-2015-7808"
],
"38799": [],
"38800": [],
"38801": [],
"38806": [
"CVE-2013-1742"
],
"38807": [
"CVE-2013-1743"
],
"38808": [],
"38811": [],
"38814": [],
"38816": [],
"38819": [],
"38820": [],
"38822": [],
"38831": [],
"38828": [],
"38830": [],
"38833": [],
"38840": [],
"38841": [],
"38842": [
"CVE-2013-6873"
],
"38843": [],
"38836": [
"CVE-2015-8368"
],
"38837": [],
"38844": [
"CVE-2013-6797"
],
"38848": [],
"38852": [],
"38853": [],
"38855": [],
"38856": [],
"38861": [
"CVE-2015-8351"
],
"38862": [
"CVE-2013-6985"
],
"38863": [],
"38864": [],
"38865": [],
"39563": [],
"38867": [],
"38868": [],
"38869": [],
"38870": [],
"38872": [],
"38873": [
"CVE-2013-7097"
],
"38874": [],
"38875": [],
"38876": [
"CVE-2013-7193"
],
"38877": [
"CVE-2013-7193"
],
"38879": [],
"38880": [],
"38881": [],
"38882": [
"CVE-2013-7108"
],
"38883": [
"CVE-2013-7192"
],
"38884": [
"CVE-2013-7192"
],
"38885": [
"CVE-2013-7189"
],
"38886": [
"CVE-2013-7189"
],
"38887": [
"CVE-2013-7189"
],
"38888": [
"CVE-2013-7189"
],
"38889": [
"CVE-2013-7190"
],
"38890": [
"CVE-2013-7190"
],
"38891": [
"CVE-2013-7190"
],
"38892": [
"CVE-2013-7190"
],
"38895": [],
"38896": [],
"38897": [],
"38898": [],
"38899": [],
"38901": [],
"38902": [],
"38906": [],
"38907": [],
"38908": [
"CVE-2013-2627"
],
"38913": [],
"38914": [],
"38915": [],
"38919": [
"CVE-2013-7209"
],
"40437": [
"CVE-2016-5312"
],
"38920": [],
"38921": [],
"38922": [],
"38924": [
"CVE-2013-7233"
],
"38927": [],
"38928": [],
"38929": [],
"38935": [
"CVE-2013-7278"
],
"38936": [
"CVE-2013-7240"
],
"38938": [],
"38941": [],
"38942": [],
"38943": [],
"38944": [
"CVE-2014-1636"
],
"38945": [
"CVE-2014-1636"
],
"38946": [
"CVE-2014-1636"
],
"38947": [
"CVE-2014-1636"
],
"38948": [
"CVE-2014-1636"
],
"38949": [
"CVE-2014-1636"
],
"38950": [
"CVE-2014-1636"
],
"38951": [
"CVE-2014-1636"
],
"38952": [
"CVE-2014-1636"
],
"38953": [
"CVE-2014-1636"
],
"38954": [
"CVE-2014-1636"
],
"38955": [
"CVE-2014-1636"
],
"38956": [
"CVE-2014-1637"
],
"38957": [
"CVE-2014-1915"
],
"38958": [
"CVE-2014-1915"
],
"38965": [],
"38966": [],
"39096": [
"CVE-2014-1597"
],
"39098": [],
"39057": [
"CVE-2014-1671"
],
"38971": [],
"38975": [
"CVE-2015-8358"
],
"38976": [
"CVE-2015-8357"
],
"38977": [
"CVE-2015-8562"
],
"38981": [],
"38984": [],
"38985": [],
"38986": [],
"38987": [],
"38988": [],
"38989": [],
"38991": [],
"39011": [
"CVE-2014-1618"
],
"39012": [
"CVE-2014-1618"
],
"39013": [],
"39014": [],
"39015": [
"CVE-2013-6017"
],
"39016": [],
"39017": [
"CVE-2015-8352"
],
"39028": [
"CVE-2013-7219"
],
"39029": [],
"39030": [],
"39031": [],
"39032": [],
"39033": [
"CVE-2015-8566",
"CVE-2015-8562"
],
"39034": [],
"39099": [],
"39038": [],
"39058": [],
"39059": [],
"39060": [],
"39062": [],
"39063": [],
"39064": [],
"39065": [
"CVE-2014-1631"
],
"39066": [
"CVE-2014-1631",
"CVE-2014-1632"
],
"39068": [],
"39069": [],
"39078": [],
"39079": [
"CVE-2013-6229"
],
"39080": [
"CVE-2013-6229"
],
"39081": [
"CVE-2013-6229"
],
"39083": [],
"39084": [],
"39085": [],
"39086": [],
"39087": [],
"39088": [
"CVE-2014-1214"
],
"39090": [],
"39093": [],
"39094": [],
"39100": [],
"39101": [],
"39106": [
"CVE-2014-2069"
],
"39107": [
"CVE-2014-2091"
],
"39108": [
"CVE-2014-2211"
],
"39109": [],
"39110": [],
"39111": [],
"39113": [],
"39116": [
"CVE-2014-2339"
],
"39117": [
"CVE-2013-5954"
],
"39118": [],
"39124": [],
"39126": [],
"39127": [],
"39128": [],
"39129": [],
"39130": [],
"39131": [],
"39133": [],
"39135": [],
"39136": [
"CVE-2013-7346"
],
"39137": [],
"39139": [
"CVE-2013-7196"
],
"39140": [],
"39141": [],
"39142": [
"CVE-2014-0358"
],
"39143": [
"CVE-2014-0358"
],
"39145": [
"CVE-2014-0358"
],
"39146": [],
"39150": [],
"42552": [],
"42553": [],
"42563": [],
"39153": [],
"39156": [],
"39157": [],
"39167": [],
"39168": [],
"39170": [
"CVE-2015-8399",
"CVE-2015-8398"
],
"39171": [],
"39172": [],
"39173": [
"CVE-2014-2934"
],
"39174": [
"CVE-2014-2934"
],
"39176": [
"CVE-2014-2989"
],
"39178": [],
"39179": [],
"39184": [],
"39187": [
"CVE-2014-3749"
],
"39188": [
"CVE-2014-3935"
],
"39189": [],
"39190": [],
"39191": [],
"39192": [
"CVE-2015-2049"
],
"39193": [
"CVE-2013-7285"
],
"39197": [
"CVE-2014-3210"
],
"39198": [
"CVE-2014-3866"
],
"39199": [
"CVE-2014-3854"
],
"39200": [
"CVE-2014-3934"
],
"39202": [],
"39206": [
"CVE-2014-2303"
],
"39210": [],
"39211": [],
"39212": [
"CVE-2014-4030"
],
"39213": [
"CVE-2014-4163"
],
"39223": [
"CVE-2014-3868"
],
"39231": [
"CVE-2015-8261"
],
"39234": [],
"39235": [],
"39236": [],
"39237": [],
"39238": [
"CVE-2014-4852"
],
"39239": [
"CVE-2014-4741"
],
"39240": [
"CVE-2014-4944"
],
"39241": [],
"39243": [],
"39245": [
"CVE-2015-8770"
],
"39246": [
"CVE-2015-8356"
],
"39250": [
"CVE-2014-9094"
],
"39251": [
"CVE-2014-4937"
],
"39252": [
"CVE-2014-4938"
],
"39253": [
"CVE-2014-4939"
],
"39254": [],
"39255": [],
"39256": [
"CVE-2014-4940"
],
"39257": [
"CVE-2014-4940"
],
"39261": [],
"39262": [],
"39263": [],
"39266": [
"CVE-2015-8284",
"CVE-2015-8283",
"CVE-2015-8282"
],
"39267": [
"CVE-2014-4736"
],
"39268": [
"CVE-2014-2227"
],
"39269": [
"CVE-2014-5189"
],
"39270": [
"CVE-2014-9099"
],
"39271": [],
"39272": [],
"39273": [],
"39279": [],
"39280": [
"CVE-2014-5180"
],
"39281": [],
"39282": [
"CVE-2014-8375"
],
"39283": [
"CVE-2014-5200"
],
"39287": [
"CVE-2014-5368"
],
"39288": [
"CVE-2014-3997"
],
"39289": [
"CVE-2014-5097"
],
"39290": [],
"39291": [],
"39294": [],
"39296": [],
"39297": [],
"39298": [],
"39299": [],
"39300": [],
"39301": [],
"39302": [],
"39303": [],
"39304": [],
"39306": [],
"39309": [],
"39313": [],
"39317": [],
"39319": [],
"39320": [],
"39441": [
"CVE-2017-10000"
],
"39332": [],
"39333": [],
"39334": [
"CVE-2014-3427"
],
"39335": [],
"39339": [],
"39341": [],
"39342": [],
"39343": [
"CVE-2014-5104"
],
"39344": [
"CVE-2014-5104"
],
"39345": [
"CVE-2014-5104"
],
"39346": [
"CVE-2014-5104"
],
"39347": [
"CVE-2014-5109"
],
"39348": [
"CVE-2014-5111"
],
"39349": [
"CVE-2014-5111"
],
"39350": [
"CVE-2014-5111"
],
"39351": [
"CVE-2014-5111"
],
"39352": [
"CVE-2014-5112"
],
"39354": [],
"39355": [],
"39356": [],
"39382": [
"CVE-2015-7986"
],
"39384": [],
"39385": [],
"39387": [],
"39391": [],
"39394": [],
"39399": [],
"39402": [
"CVE-2015-4593",
"CVE-2015-4594",
"CVE-2015-4592",
"CVE-2015-4591"
],
"39404": [],
"39405": [
"CVE-2016-2534"
],
"39407": [
"CVE-2014-2045"
],
"39408": [
"CVE-2016-0862",
"CVE-2016-0861"
],
"39409": [
"CVE-2015-7247",
"CVE-2015-7246",
"CVE-2015-7245"
],
"39410": [],
"39411": [],
"39412": [
"CVE-2016-1525",
"CVE-2016-1524"
],
"39413": [],
"39414": [],
"39415": [],
"39416": [],
"39418": [],
"39419": [],
"39420": [],
"39421": [],
"39422": [],
"39423": [],
"39427": [
"CVE-2010-0122"
],
"39435": [
"CVE-2016-0956"
],
"39436": [
"CVE-2015-7572",
"CVE-2015-7571",
"CVE-2015-7570",
"CVE-2015-7569",
"CVE-2015-7568",
"CVE-2015-7567"
],
"39448": [],
"39449": [],
"39450": [],
"39451": [],
"39453": [],
"39456": [],
"39459": [],
"39458": [],
"39468": [],
"39469": [],
"39473": [],
"39474": [],
"39477": [],
"39478": [],
"39481": [
"CVE-2016-1915",
"CVE-2016-1914"
],
"39485": [],
"39486": [
"CVE-2016-4004"
],
"39488": [],
"39489": [],
"39495": [
"CVE-2005-2428"
],
"39497": [],
"39498": [],
"39500": [
"CVE-2015-6541"
],
"39501": [],
"39506": [],
"39507": [],
"39513": [],
"39521": [],
"39524": [
"CVE-2016-2539"
],
"39526": [],
"39534": [],
"39536": [],
"39547": [],
"39548": [],
"39552": [],
"39553": [],
"39558": [],
"39559": [
"CVE-2015-7564",
"CVE-2015-7563",
"CVE-2015-7562"
],
"39564": [],
"39626": [],
"39572": [],
"39573": [
"CVE-2016-0793"
],
"39575": [],
"39576": [],
"39577": [],
"39580": [],
"39581": [],
"39582": [],
"39583": [],
"39584": [],
"39586": [],
"39587": [],
"39588": [],
"39589": [],
"39590": [],
"39591": [],
"39592": [],
"39593": [],
"39597": [],
"39621": [],
"39622": [],
"39623": [],
"39637": [],
"39641": [],
"39642": [
"CVE-2016-0784"
],
"39646": [],
"40046": [
"CVE-2016-4337"
],
"39659": [],
"39664": [],
"39667": [],
"39668": [],
"39672": [],
"39676": [],
"39677": [],
"39678": [],
"39679": [],
"39968": [],
"39682": [],
"39683": [
"CVE-2015-8256"
],
"39687": [
"CVE-2016-1596",
"CVE-2016-1595",
"CVE-2016-1594",
"CVE-2016-1593"
],
"39688": [],
"39691": [
"CVE-2016-0492",
"CVE-2016-0491"
],
"39695": [],
"39696": [],
"39697": [],
"39701": [
"CVE-2015-9266"
],
"39704": [],
"39705": [],
"39707": [],
"39709": [],
"39710": [
"CVE-2016-3694"
],
"39711": [],
"39714": [],
"39715": [
"CVE-2016-2203"
],
"39716": [],
"39720": [],
"39721": [],
"39725": [],
"39726": [],
"39730": [],
"39737": [],
"39738": [
"CVE-2016-0891"
],
"39739": [
"CVE-2015-9222"
],
"39744": [],
"39745": [],
"39746": [],
"39751": [],
"39752": [],
"39759": [],
"39760": [
"CVE-2016-2784"
],
"39761": [],
"39762": [
"CVE-2015-6024",
"CVE-2015-6023"
],
"39765": [],
"39766": [],
"39777": [
"CVE-2015-2794"
],
"39780": [],
"39781": [],
"39784": [],
"39798": [],
"39806": [],
"39807": [],
"39808": [],
"39883": [],
"39813": [
"CVE-2016-4793"
],
"39816": [
"CVE-2016-4313"
],
"39817": [],
"39821": [
"CVE-2016-4808",
"CVE-2016-4807",
"CVE-2016-4806"
],
"39822": [
"CVE-2016-2296"
],
"39837": [
"CVE-2016-2389"
],
"39838": [
"CVE-2016-4010"
],
"39840": [
"CVE-2016-2386"
],
"39841": [
"CVE-2016-2388"
],
"39848": [],
"39849": [],
"39850": [],
"39855": [],
"39856": [],
"39864": [],
"40059": [],
"39868": [],
"39870": [],
"39871": [],
"40464": [
"CVE-2016-6435"
],
"39872": [],
"39876": [],
"39965": [],
"39879": [],
"39880": [
"CVE-2016-3670"
],
"39881": [],
"40463": [
"CVE-2016-6433"
],
"39884": [],
"39886": [],
"39887": [
"CVE-2014-6278"
],
"39889": [],
"39890": [],
"39891": [],
"39892": [],
"39893": [],
"39894": [],
"39895": [],
"39896": [],
"39897": [],
"39898": [],
"39899": [],
"39904": [
"CVE-2016-1337",
"CVE-2016-1336",
"CVE-2016-1328",
"CVE-2015-6402",
"CVE-2015-6401"
],
"39905": [],
"39909": [],
"40047": [],
"39911": [],
"39912": [],
"39913": [],
"39931": [],
"39932": [],
"39934": [],
"39935": [],
"39936": [],
"39937": [],
"39946": [],
"39948": [],
"39949": [],
"39950": [],
"39951": [],
"39952": [],
"39953": [],
"39955": [],
"39956": [],
"39957": [],
"39962": [],
"39963": [],
"39964": [],
"39969": [],
"39970": [],
"39971": [],
"39972": [],
"39974": [],
"39976": [],
"39977": [],
"39978": [],
"39981": [],
"39982": [],
"39983": [
"CVE-2016-4309"
],
"39987": [],
"39988": [],
"39989": [],
"39995": [
"CVE-2016-3974"
],
"39996": [
"CVE-2016-3976"
],
"39997": [],
"39998": [],
"40111": [],
"40006": [],
"40009": [],
"40010": [],
"40011": [],
"40012": [],
"40013": [],
"40015": [],
"40016": [],
"40332": [],
"40019": [],
"40021": [],
"40022": [],
"40024": [],
"40027": [],
"40028": [],
"40030": [],
"40041": [
"CVE-2016-5304",
"CVE-2016-3653",
"CVE-2016-3652"
],
"40042": [],
"40044": [],
"40045": [],
"40092": [],
"40093": [],
"40050": [],
"40051": [],
"40055": [],
"40057": [],
"40058": [],
"40060": [],
"40062": [],
"40063": [],
"40065": [],
"40068": [],
"40070": [],
"40076": [],
"40077": [],
"40078": [],
"40106": [],
"40109": [
"CVE-2016-4469"
],
"40112": [],
"40114": [
"CVE-2014-2021"
],
"40115": [
"CVE-2014-2022"
],
"40193": [],
"40171": [
"CVE-2015-8257"
],
"40126": [],
"40127": [],
"40129": [
"CVE-2016-6186"
],
"40133": [],
"40134": [],
"40135": [],
"40137": [],
"40140": [],
"40149": [],
"40150": [],
"40153": [],
"40154": [
"CVE-2016-6175"
],
"40156": [],
"40157": [],
"40158": [],
"40159": [],
"40160": [],
"40161": [
"CVE-2016-1610",
"CVE-2016-1611",
"CVE-2016-1609",
"CVE-2016-1608",
"CVE-2016-1607"
],
"40163": [],
"40165": [],
"40166": [],
"40174": [],
"40180": [
"CVE-2016-5840"
],
"40185": [
"CVE-2016-5734"
],
"40189": [],
"40190": [],
"40191": [],
"40202": [],
"40204": [],
"40205": [],
"40206": [],
"40207": [],
"40209": [],
"40210": [],
"40211": [],
"40212": [],
"40213": [],
"40214": [],
"40215": [],
"40216": [],
"40218": [],
"40220": [],
"40221": [],
"40225": [
"CVE-2016-6483"
],
"40227": [],
"40228": [],
"40229": [
"CVE-2016-6603",
"CVE-2016-6602",
"CVE-2016-6601",
"CVE-2016-6600"
],
"40231": [],
"40281": [],
"40236": [
"CVE-2016-4340"
],
"40262": [],
"40237": [],
"40239": [
"CVE-2016-4312",
"CVE-2016-4311"
],
"40240": [
"CVE-2016-4314"
],
"40241": [
"CVE-2016-4316"
],
"40242": [
"CVE-2016-4315"
],
"40247": [],
"40248": [],
"40249": [],
"40250": [],
"40251": [],
"40252": [],
"40254": [],
"40260": [],
"40261": [],
"40263": [],
"40264": [],
"40265": [],
"40266": [],
"40267": [],
"40269": [],
"40272": [],
"40273": [],
"40274": [],
"40276": [
"CVE-2016-6909"
],
"40277": [],
"40278": [],
"40282": [],
"40283": [],
"40284": [],
"40285": [
"CVE-2005-4664"
],
"40286": [],
"40288": [
"CVE-2016-6897",
"CVE-2016-6896"
],
"40290": [],
"40292": [],
"40293": [],
"40295": [],
"40312": [],
"40324": [],
"40325": [],
"40326": [],
"40327": [],
"40328": [],
"40454": [],
"40462": [],
"40467": [],
"40468": [],
"40469": [],
"40470": [],
"40475": [],
"40479": [],
"40480": [],
"40481": [],
"40486": [],
"40487": [],
"40492": [],
"40493": [],
"40495": [],
"40496": [],
"40500": [],
"40501": [],
"40505": [],
"40506": [],
"40511": [],
"40512": [],
"40516": [],
"40513": [],
"40517": [],
"40526": [],
"40527": [],
"40529": [],
"40530": [],
"40531": [],
"40532": [],
"40534": [],
"43567": [
"CVE-2018-5479"
],
"43569": [],
"43900": [],
"43590": [
"CVE-2017-17976"
],
"43591": [
"CVE-2017-17999"
],
"43592": [
"CVE-2017-3528"
],
"43593": [],
"43594": [
"CVE-2017-10366"
],
"43595": [
"CVE-2018-5688",
"CVE-2018-5688"
],
"43600": [],
"43667": [],
"43676": [
"CVE-2018-5705"
],
"43678": [],
"43682": [],
"43683": [
"CVE-2018-5715"
],
"43733": [
"CVE-2017-10004"
],
"43777": [],
"45337": [],
"43789": [],
"43790": [],
"43791": [],
"43788": [],
"43792": [],
"43793": [],
"43794": [],
"43795": [],
"43796": [],
"43797": [],
"43798": [],
"43800": [],
"43801": [],
"43802": [],
"43803": [],
"43804": [],
"43805": [],
"43806": [],
"43807": [
"CVE-2004-1835"
],
"43808": [
"CVE-2004-1870",
"CVE-2004-1871"
],
"43809": [
"CVE-2004-1923",
"CVE-2004-1924",
"CVE-2004-1925",
"CVE-2004-1926",
"CVE-2004-1927",
"CVE-2004-1928"
],
"43810": [],
"43811": [
"CVE-2004-1965"
],
"43812": [
"CVE-2004-2364"
],
"43813": [],
"43814": [
"CVE-2005-1672",
"CVE-2005-1673",
"CVE-2005-1674"
],
"43815": [
"CVE-2004-2566"
],
"43818": [
"CVE-2004-1420",
"CVE-2004-1421",
"CVE-2004-1422"
],
"43819": [
"CVE-2004-1423"
],
"43820": [],
"43821": [
"CVE-2005-0270",
"CVE-2005-0271",
"CVE-2005-0272"
],
"43822": [
"CVE-2005-0273",
"CVE-2005-0274"
],
"43823": [
"CVE-2005-1200",
"CVE-2005-1201"
],
"43824": [
"CVE-2005-1597",
"CVE-2005-1598"
],
"43825": [
"CVE-2005-1642"
],
"43827": [
"CVE-2005-2112",
"CVE-2005-2113"
],
"43828": [],
"43829": [
"CVE-2005-1921"
],
"43830": [
"CVE-2005-2095"
],
"43831": [
"CVE-2005-2414"
],
"43832": [
"CVE-2006-0806"
],
"43833": [
"CVE-2006-0823"
],
"43834": [
"CVE-2006-0869"
],
"43835": [
"CVE-2006-0871",
"CVE-2006-1794"
],
"43836": [
"CVE-2006-1032"
],
"43837": [
"CVE-2006-1127",
"CVE-2006-1128"
],
"43838": [
"CVE-2006-0887",
"CVE-2006-2826"
],
"43839": [
"CVE-2006-4019"
],
"43840": [
"CVE-2006-4525"
],
"43841": [
"CVE-2006-4844"
],
"43842": [
"CVE-2006-4904"
],
"43843": [],
"43844": [],
"43845": [],
"43846": [],
"43848": [
"CVE-2017-10273"
],
"43849": [
"CVE-2017-15374"
],
"43850": [],
"43852": [
"CVE-2018-5954"
],
"43853": [
"CVE-2017-16921"
],
"43855": [],
"43858": [],
"43860": [
"CVE-2018-5985"
],
"43861": [
"CVE-2018-5977"
],
"43862": [
"CVE-2018-5976"
],
"43863": [
"CVE-2018-5986"
],
"43864": [
"CVE-2018-5979"
],
"43865": [
"CVE-2018-5978"
],
"43866": [
"CVE-2018-5984"
],
"43867": [
"CVE-2018-5969"
],
"43868": [
"CVE-2018-5972"
],
"43869": [
"CVE-2018-5988"
],
"43870": [
"CVE-2018-5973"
],
"43872": [],
"43873": [
"CVE-2017-9248"
],
"43874": [
"CVE-2017-11357",
"CVE-2017-11317"
],
"43883": [
"CVE-2016-6599",
"CVE-2016-6598"
],
"43884": [],
"43885": [
"CVE-2015-3001",
"CVE-2015-3000",
"CVE-2015-2999",
"CVE-2015-2998",
"CVE-2015-2997",
"CVE-2015-2996",
"CVE-2015-2995",
"CVE-2015-2994",
"CVE-2015-2993"
],
"43886": [
"CVE-2014-2922",
"CVE-2014-2921"
],
"43888": [
"CVE-2014-1603"
],
"43889": [
"CVE-2014-0334"
],
"43892": [
"CVE-2014-7862"
],
"43893": [
"CVE-2014-6039",
"CVE-2014-6038"
],
"43894": [
"CVE-2014-7864",
"CVE-2014-7863"
],
"43895": [
"CVE-2014-5446",
"CVE-2014-5445"
],
"43896": [
"CVE-2014-7868",
"CVE-2014-7866",
"CVE-2014-6036",
"CVE-2014-6035",
"CVE-2014-6034"
],
"43898": [
"CVE-2018-5720"
],
"40542": [],
"40543": [],
"40544": [],
"40545": [],
"40546": [],
"40547": [],
"40552": [],
"40553": [],
"40554": [],
"40555": [],
"40557": [],
"40558": [],
"40559": [],
"40566": [],
"40569": [],
"40571": [],
"40576": [],
"40584": [],
"40590": [
"CVE-2016-3473"
],
"40591": [],
"40594": [],
"40595": [
"CVE-2016-7998"
],
"40596": [
"CVE-2016-7982"
],
"40597": [
"CVE-2016-7980"
],
"40612": [],
"40614": [],
"40620": [],
"40626": [],
"40628": [],
"40629": [],
"40631": [],
"40642": [],
"40644": [],
"40645": [],
"40641": [],
"40646": [],
"40640": [],
"40637": [
"CVE-2016-8869",
"CVE-2016-8870"
],
"40650": [],
"40671": [],
"40682": [
"CVE-2016-8580"
],
"40683": [
"CVE-2016-8581"
],
"40684": [
"CVE-2016-8582"
],
"40690": [],
"40692": [],
"40698": [],
"40700": [],
"40701": [],
"40705": [],
"40706": [],
"40707": [],
"40708": [],
"40719": [],
"40723": [],
"40724": [],
"40725": [],
"40732": [],
"40733": [],
"40742": [
"CVE-2016-7851"
],
"40746": [],
"40749": [],
"40750": [],
"40751": [
"CVE-2016-6195"
],
"40753": [],
"40755": [],
"40756": [],
"40771": [],
"40772": [],
"40782": [],
"40783": [],
"40776": [],
"40791": [],
"40794": [],
"40795": [],
"40799": [],
"40800": [],
"40801": [],
"40802": [],
"40803": [],
"40804": [],
"40809": [],
"40816": [],
"40826": [],
"40895": [],
"40837": [],
"40842": [
"CVE-2016-7065"
],
"40850": [],
"40851": [],
"40852": [],
"40853": [],
"40856": [],
"40877": [],
"40887": [
"CVE-2013-5528"
],
"40889": [
"CVE-2016-6277"
],
"40898": [],
"40901": [],
"40904": [],
"40908": [],
"40912": [],
"40932": [],
"40934": [],
"40939": [],
"40940": [],
"40941": [],
"40942": [],
"43882": [
"CVE-2015-6589"
],
"40961": [
"CVE-2016-0736"
],
"40966": [],
"40968": [
"CVE-2016-10033"
],
"40970": [
"CVE-2016-10033"
],
"40969": [
"CVE-2016-10045",
"CVE-2016-10033"
],
"40971": [],
"40972": [
"CVE-2016-10074"
],
"40973": [],
"40974": [
"CVE-2016-10033"
],
"40976": [],
"40977": [],
"40978": [],
"40979": [
"CVE-2016-10034"
],
"40982": [
"CVE-2016-7454"
],
"40983": [
"CVE-2017-5633"
],
"40986": [
"CVE-2016-10074",
"CVE-2016-10045",
"CVE-2016-10034",
"CVE-2016-10033"
],
"40989": [
"CVE-2016-6283"
],
"40997": [
"CVE-2014-8380"
],
"40998": [],
"40999": [],
"41027": [],
"41001": [],
"41002": [],
"41004": [],
"41005": [
"CVE-2014-7235"
],
"41006": [],
"41007": [],
"41009": [],
"41010": [],
"41011": [],
"41014": [],
"41017": [],
"41023": [],
"41024": [],
"41028": [],
"41029": [],
"41032": [],
"41033": [],
"41034": [],
"41036": [],
"41037": [],
"41038": [],
"41040": [],
"41043": [],
"41044": [],
"41045": [],
"41046": [],
"41047": [],
"41048": [],
"41049": [],
"41050": [],
"41051": [],
"41052": [],
"41053": [],
"41054": [],
"41055": [],
"41056": [],
"41060": [],
"41058": [],
"41059": [],
"41061": [],
"41062": [],
"41063": [],
"41064": [],
"41065": [],
"41066": [],
"41067": [],
"41068": [],
"41070": [],
"41071": [],
"41074": [],
"41075": [],
"41077": [],
"41078": [],
"41080": [],
"41081": [],
"41082": [],
"41083": [],
"41084": [],
"41086": [],
"41087": [],
"41091": [],
"41092": [],
"41093": [],
"41094": [],
"41095": [],
"41096": [],
"41097": [],
"41098": [],
"41099": [],
"41100": [],
"41101": [],
"41102": [],
"41103": [],
"41104": [],
"41105": [],
"41106": [],
"41107": [],
"41108": [],
"41109": [],
"41110": [],
"41111": [],
"41112": [],
"41113": [],
"41114": [],
"41117": [],
"41116": [],
"41118": [],
"41119": [],
"41120": [],
"41121": [],
"41122": [],
"41123": [],
"41124": [],
"41125": [],
"41126": [],
"41127": [],
"41131": [],
"41132": [],
"41133": [],
"41134": [],
"41135": [],
"41136": [],
"41137": [],
"41138": [],
"41139": [],
"41140": [],
"41141": [
"CVE-2017-5473"
],
"41143": [
"CVE-2017-5594"
],
"41147": [],
"41150": [],
"41155": [],
"41156": [
"CVE-2012-1563"
],
"41157": [
"CVE-2016-9838"
],
"41159": [],
"41166": [],
"41167": [],
"41168": [],
"41169": [],
"41170": [],
"41172": [],
"41175": [],
"41177": [],
"41178": [],
"41179": [
"CVE-2016-10043"
],
"41180": [],
"41181": [],
"41182": [],
"41184": [],
"41185": [
"CVE-2017-5630"
],
"41186": [],
"41187": [],
"41188": [],
"41189": [],
"41190": [],
"41191": [],
"41193": [],
"41194": [],
"41195": [],
"41197": [],
"41198": [],
"41199": [],
"41200": [],
"41205": [
"CVE-2017-5521"
],
"41201": [],
"41202": [],
"41203": [],
"41204": [],
"41208": [],
"41209": [],
"41210": [],
"41223": [],
"41224": [],
"41231": [],
"41225": [],
"41226": [],
"41230": [],
"41228": [],
"41229": [],
"41235": [],
"41238": [],
"41239": [],
"41241": [],
"41242": [],
"41243": [],
"41244": [],
"41245": [],
"41246": [],
"41247": [],
"41249": [],
"41250": [],
"41251": [],
"41252": [],
"41253": [],
"41254": [],
"41255": [],
"41256": [],
"41266": [],
"41267": [],
"41258": [],
"41259": [],
"41260": [],
"41261": [],
"41262": [],
"41263": [],
"41264": [],
"41268": [],
"41269": [],
"41270": [],
"41271": [],
"41272": [],
"41279": [],
"41280": [],
"41283": [],
"41284": [],
"41285": [],
"41286": [],
"41287": [],
"41288": [],
"41290": [],
"41291": [],
"41292": [],
"41293": [],
"41294": [],
"41295": [],
"41296": [],
"41300": [],
"41301": [],
"41302": [],
"41303": [],
"41304": [],
"41305": [],
"41306": [],
"41299": [],
"41307": [],
"41308": [],
"41309": [],
"41310": [],
"41311": [],
"41312": [],
"41328": [],
"41313": [],
"41314": [],
"41315": [],
"41316": [],
"41317": [],
"41318": [],
"41319": [],
"41322": [],
"41323": [],
"41324": [],
"41325": [],
"41326": [],
"41327": [],
"41329": [],
"41330": [],
"41331": [],
"41332": [],
"41333": [],
"41334": [],
"41335": [],
"41336": [],
"41337": [],
"41338": [],
"41339": [],
"41340": [],
"41341": [],
"41342": [],
"41343": [],
"41344": [],
"41345": [],
"41346": [],
"41347": [],
"41359": [],
"41360": [
"CVE-2017-5174",
"CVE-2017-5173"
],
"41361": [
"CVE-2016-9316",
"CVE-2016-9315",
"CVE-2016-9314",
"CVE-2016-9269"
],
"41362": [],
"41368": [],
"41371": [],
"41372": [],
"41373": [],
"41374": [],
"41376": [],
"41377": [
"CVE-2017-5344"
],
"41378": [],
"41379": [],
"41380": [],
"41382": [],
"41383": [],
"41384": [],
"41385": [],
"41386": [],
"41387": [],
"41388": [],
"41389": [],
"41390": [],
"41391": [],
"41392": [],
"41393": [],
"41394": [
"CVE-2017-6077"
],
"41395": [
"CVE-2017-5496"
],
"41396": [],
"41399": [],
"41400": [],
"41401": [],
"41402": [
"CVE-2015-5995"
],
"41595": [],
"41404": [],
"41405": [],
"41406": [],
"41407": [],
"41408": [],
"41409": [],
"41410": [],
"41411": [],
"41412": [],
"41413": [
"CVE-2016-9553"
],
"41414": [
"CVE-2016-9554"
],
"41415": [
"CVE-2016-9683"
],
"41416": [
"CVE-2016-9684"
],
"41424": [
"CVE-2016-8580"
],
"41427": [],
"41428": [],
"41429": [],
"41430": [],
"41431": [],
"41432": [],
"41433": [],
"41437": [],
"41438": [
"CVE-2017-6098",
"CVE-2017-6097",
"CVE-2017-6096",
"CVE-2017-6095"
],
"41440": [],
"41441": [],
"41442": [],
"41444": [],
"41445": [],
"41446": [],
"41447": [],
"41448": [],
"41449": [
"CVE-2017-2363"
],
"41450": [],
"41451": [
"CVE-2017-2371"
],
"41452": [],
"41453": [
"CVE-2017-2365"
],
"41455": [],
"41456": [],
"41459": [
"CVE-2017-6334"
],
"41460": [],
"41461": [],
"41462": [],
"41463": [],
"41464": [],
"41465": [],
"41466": [],
"41470": [],
"41472": [
"CVE-2017-6334",
"CVE-2017-6366"
],
"41478": [
"CVE-2017-6411"
],
"41492": [],
"41482": [
"CVE-2016-8527",
"CVE-2016-8526"
],
"41483": [],
"41484": [],
"41485": [],
"41486": [],
"41487": [],
"41488": [],
"41489": [],
"41490": [],
"41491": [],
"41493": [],
"41494": [],
"41495": [],
"41496": [],
"41497": [
"CVE-2017-5487"
],
"41499": [],
"41500": [],
"41501": [],
"41502": [
"CVE-2017-6443"
],
"41504": [],
"41505": [],
"41506": [],
"41507": [],
"41508": [],
"41512": [],
"41513": [],
"41514": [],
"41515": [],
"41516": [],
"41517": [],
"41518": [],
"41519": [],
"41520": [],
"41521": [],
"41522": [],
"41523": [],
"41524": [],
"41525": [],
"41526": [],
"41527": [],
"41528": [],
"41529": [],
"41530": [],
"41531": [],
"41532": [],
"41533": [],
"41534": [],
"41535": [],
"41536": [],
"41539": [],
"41540": [
"CVE-2017-10020",
"CVE-2017-6104"
],
"41541": [
"CVE-2017-7178"
],
"41543": [],
"41544": [],
"41546": [],
"41548": [],
"41549": [],
"41550": [],
"41551": [],
"41552": [],
"41553": [],
"41554": [],
"41556": [],
"41557": [],
"41558": [],
"41559": [],
"41560": [],
"41561": [],
"41562": [],
"41563": [],
"41564": [],
"41566": [],
"41567": [],
"41568": [],
"41569": [],
"41570": [
"CVE-2017-5638"
],
"41571": [
"CVE-2017-6547"
],
"41572": [
"CVE-2017-6549"
],
"41573": [
"CVE-2017-6548"
],
"41574": [
"CVE-2017-6803"
],
"42393": [],
"42392": [],
"41577": [
"CVE-2017-6550"
],
"41579": [],
"41578": [
"CVE-2017-6529",
"CVE-2017-6528",
"CVE-2017-6527",
"CVE-2017-6526"
],
"41580": [],
"41582": [],
"41583": [],
"41584": [],
"41585": [],
"41593": [],
"41586": [],
"41587": [],
"41588": [],
"41589": [],
"41590": [],
"41591": [],
"41594": [
"CVE-2017-6823"
],
"41599": [],
"41600": [],
"41602": [],
"41603": [],
"41604": [],
"41616": [],
"41617": [],
"41618": [
"CVE-2016-8855"
],
"43357": [],
"43358": [],
"43361": [],
"43362": [
"CVE-2017-17672"
],
"43363": [
"CVE-2017-17411"
],
"43364": [
"CVE-2017-17739",
"CVE-2017-17738",
"CVE-2017-17737"
],
"43365": [],
"43377": [
"CVE-2017-17759"
],
"43378": [
"CVE-2017-17752"
],
"43379": [
"CVE-2017-17721"
],
"43393": [
"CVE-2017-17875"
],
"43394": [
"CVE-2017-17876"
],
"43395": [],
"43396": [],
"43398": [],
"43399": [],
"43400": [],
"43402": [],
"43404": [],
"43405": [],
"43409": [
"CVE-2018-5211"
],
"43414": [
"CVE-2017-17215"
],
"43420": [
"CVE-2018-3811",
"CVE-2018-3810"
],
"43422": [
"CVE-2017-14960"
],
"43431": [
"CVE-2017-17098",
"CVE-2017-17097"
],
"43436": [
"CVE-2008-6985"
],
"43437": [],
"43438": [],
"43847": [],
"43440": [],
"43441": [],
"43442": [],
"43443": [],
"43444": [],
"43445": [],
"43447": [
"CVE-2017-7997"
],
"43455": [
"CVE-2017-9554"
],
"43457": [],
"43459": [],
"43460": [
"CVE-2017-16887",
"CVE-2017-16886",
"CVE-2017-16885"
],
"43461": [],
"43462": [
"CVE-2017-10004"
],
"43475": [],
"43477": [
"CVE-2017-17970"
],
"43479": [
"CVE-2018-5315"
],
"43484": [],
"43485": [],
"43486": [],
"43487": [],
"43488": [
"CVE-2018-5263"
],
"43495": [
"CVE-2016-2388",
"CVE-2016-2386",
"CVE-2016-1910"
],
"43496": [],
"43535": [
"CVE-2018-5370"
],
"43543": [],
"43560": [
"CVE-2014-4688"
],
"41622": [
"CVE-2017-10020"
],
"41625": [
"CVE-2015-8258"
],
"41626": [
"CVE-2015-8255"
],
"41627": [],
"41628": [],
"41632": [],
"41633": [
"CVE-2017-6896"
],
"41634": [],
"41636": [],
"43350": [],
"43351": [],
"43901": [],
"43907": [],
"43908": [],
"43909": [],
"43911": [
"CVE-2017-5264"
],
"43912": [
"CVE-2018-6007"
],
"43913": [
"CVE-2018-6008"
],
"43914": [
"CVE-2018-6363"
],
"43915": [
"CVE-2018-6365"
],
"43916": [
"CVE-2017-17612"
],
"43917": [
"CVE-2018-6364"
],
"43918": [
"CVE-2018-6367"
],
"43919": [],
"43922": [
"CVE-2017-16570"
],
"43928": [
"CVE-2017-16716"
],
"43931": [
"CVE-2018-6397"
],
"43932": [
"CVE-2018-6398"
],
"43933": [
"CVE-2018-6395"
],
"43934": [
"CVE-2016-5063"
],
"43940": [
"CVE-2018-6577"
],
"43949": [
"CVE-2018-6576"
],
"43941": [],
"43942": [],
"43943": [],
"43947": [],
"43948": [
"CVE-2018-6578"
],
"43950": [
"CVE-2018-6579"
],
"43957": [
"CVE-2018-6575"
],
"43958": [
"CVE-2018-6580"
],
"43959": [
"CVE-2018-6581"
],
"43960": [
"CVE-2018-2636"
],
"43961": [],
"43963": [
"CVE-2017-14521"
],
"43964": [
"CVE-2017-14523"
],
"43965": [],
"43966": [],
"43967": [
"CVE-2018-6180"
],
"43974": [
"CVE-2018-6605"
],
"43975": [
"CVE-2018-6604"
],
"43976": [
"CVE-2018-6582"
],
"43977": [
"CVE-2018-6610"
],
"43978": [
"CVE-2018-6609"
],
"43980": [],
"43981": [
"CVE-2018-6190"
],
"45564": [],
"43994": [],
"43995": [],
"44008": [],
"44016": [
"CVE-2018-6845"
],
"44017": [],
"44018": [],
"44019": [],
"44020": [],
"44021": [],
"44028": [
"CVE-2018-6889"
],
"44029": [
"CVE-2018-6888"
],
"44030": [],
"44033": [
"CVE-2018-6940"
],
"44034": [
"CVE-2018-6941"
],
"44036": [],
"44037": [],
"44038": [],
"44039": [
"CVE-2018-1213",
"CVE-2018-1204",
"CVE-2018-1203",
"CVE-2018-1202",
"CVE-2018-1201",
"CVE-2018-1189",
"CVE-2018-1188",
"CVE-2018-1187",
"CVE-2018-1186"
],
"44041": [
"CVE-2016-3542"
],
"44043": [
"CVE-2018-6388"
],
"44044": [
"CVE-2018-5955"
],
"44050": [
"CVE-2017-16935"
],
"44051": [
"CVE-2017-16934"
],
"44054": [
"CVE-2017-15647"
],
"44056": [
"CVE-2017-15579",
"CVE-2017-15578"
],
"44058": [
"CVE-2017-15236"
],
"44059": [
"CVE-2017-15235"
],
"44060": [
"CVE-2017-13068"
],
"44061": [
"CVE-2017-14335"
],
"44062": [
"CVE-2017-3898"
],
"44065": [
"CVE-2017-12854"
],
"44070": [
"CVE-2017-11502"
],
"44071": [
"CVE-2017-11471",
"CVE-2017-11470",
"CVE-2017-11469"
],
"44072": [
"CVE-2017-11456"
],
"44074": [],
"44098": [
"CVE-2016-6272"
],
"44100": [],
"44101": [],
"44102": [],
"44104": [
"CVE-2017-16356"
],
"44105": [
"CVE-2018-5982"
],
"44106": [
"CVE-2018-5993"
],
"44107": [
"CVE-2018-5990"
],
"44108": [
"CVE-2018-6584"
],
"44109": [
"CVE-2018-6373"
],
"44110": [
"CVE-2018-6004"
],
"44111": [
"CVE-2018-5991"
],
"44112": [
"CVE-2018-5981"
],
"44113": [
"CVE-2018-6396"
],
"44114": [
"CVE-2018-6394"
],
"44115": [
"CVE-2018-6372"
],
"44116": [
"CVE-2018-5970"
],
"44117": [
"CVE-2018-6368"
],
"44118": [
"CVE-2018-5983"
],
"44119": [
"CVE-2018-6006"
],
"44120": [
"CVE-2018-5994"
],
"44121": [
"CVE-2018-6585"
],
"44122": [
"CVE-2018-5971"
],
"44123": [
"CVE-2018-6370"
],
"44124": [
"CVE-2018-6024"
],
"44125": [
"CVE-2018-6005"
],
"44126": [
"CVE-2018-5974"
],
"44127": [
"CVE-2018-5975"
],
"44128": [
"CVE-2018-5980"
],
"44129": [
"CVE-2018-5992"
],
"44130": [
"CVE-2018-6583"
],
"44131": [
"CVE-2018-5987"
],
"44132": [
"CVE-2018-5989"
],
"44133": [
"CVE-2018-7180"
],
"44134": [
"CVE-2018-7177"
],
"44135": [
"CVE-2018-7179"
],
"44136": [
"CVE-2018-7178"
],
"44137": [
"CVE-2018-7176"
],
"44138": [],
"44140": [],
"44141": [
"CVE-2017-10046"
],
"44144": [
"CVE-2018-7198"
],
"41641": [],
"41642": [],
"41644": [],
"41662": [
"CVE-2017-6206"
],
"41663": [],
"41665": [],
"41671": [],
"41673": [],
"41674": [],
"41676": [
"CVE-2014-3829",
"CVE-2014-3828"
],
"41677": [
"CVE-2015-1187"
],
"41787": [],
"41788": [],
"41789": [],
"41685": [
"CVE-2014-8598",
"CVE-2014-7146"
],
"41686": [
"CVE-2012-0261"
],
"41687": [
"CVE-2012-0262"
],
"41688": [
"CVE-2016-1004",
"CVE-2016-1003"
],
"41691": [
"CVE-2015-2994"
],
"41692": [
"CVE-2016-1209"
],
"41697": [
"CVE-2015-1592"
],
"41698": [
"CVE-2015-1172"
],
"41714": [
"CVE-2012-6664"
],
"42804": [
"CVE-2017-14843"
],
"42058": [],
"42547": [
"CVE-2017-8770"
],
"42545": [],
"42453": [
"CVE-2017-9767"
],
"42621": [],
"42640": [],
"42544": [
"CVE-2017-9650"
],
"41899": [],
"41716": [],
"41717": [],
"41724": [],
"41725": [],
"41726": [],
"41727": [],
"41728": [],
"41729": [],
"41730": [],
"41731": [],
"41732": [],
"41733": [],
"41735": [],
"41736": [],
"41746": [
"CVE-2017-6087"
],
"41747": [
"CVE-2017-6088"
],
"41748": [
"CVE-2017-5869"
],
"41749": [],
"41758": [],
"41774": [],
"41779": [
"CVE-2017-5607"
],
"41780": [],
"41816": [],
"41817": [],
"41818": [],
"41819": [],
"41820": [],
"41821": [
"CVE-2017-7398"
],
"41822": [],
"41828": [
"CVE-2017-2641"
],
"41824": [
"CVE-2017-7447",
"CVE-2017-7446"
],
"41829": [
"CVE-2017-7462",
"CVE-2017-7461"
],
"41830": [
"CVE-2017-7571"
],
"41831": [],
"41832": [],
"41833": [],
"41834": [],
"41835": [],
"41836": [],
"41837": [],
"41838": [],
"41839": [],
"41840": [
"CVE-2017-6190"
],
"41841": [],
"41842": [
"CVE-2017-6361",
"CVE-2017-6360",
"CVE-2017-6359"
],
"42085": [],
"41844": [],
"41845": [],
"41846": [],
"42089": [],
"42090": [],
"42091": [
"CVE-2017-1092"
],
"41849": [],
"41855": [
"CVE-2009-3960"
],
"41856": [],
"41858": [],
"41859": [],
"41857": [],
"41860": [],
"41862": [],
"41863": [
"CVE-2017-7588"
],
"41864": [],
"41865": [
"CVE-2017-2480"
],
"41866": [
"CVE-2017-2479"
],
"41876": [],
"41877": [],
"41881": [],
"41882": [],
"41884": [],
"41885": [
"CVE-2017-7725"
],
"41890": [
"CVE-2017-7615"
],
"41900": [],
"41918": [],
"41919": [],
"41920": [],
"41921": [],
"41922": [],
"41925": [
"CVE-2017-3548"
],
"41926": [
"CVE-2017-3549"
],
"41927": [
"CVE-2017-5799",
"CVE-2017-5798"
],
"41928": [
"CVE-2017-7221"
],
"41930": [],
"41936": [],
"41939": [],
"41940": [],
"41943": [],
"41944": [],
"41946": [],
"41947": [],
"41948": [],
"41950": [],
"41953": [
"CVE-2017-7981"
],
"41958": [],
"41960": [],
"41961": [],
"41962": [
"CVE-2016-10033"
],
"41963": [
"CVE-2017-8295"
],
"41966": [],
"41967": [
"CVE-2017-6086"
],
"41976": [],
"41979": [],
"41985": [
"CVE-2017-7312"
],
"41986": [
"CVE-2017-7314"
],
"41988": [],
"41989": [],
"41990": [],
"41997": [
"CVE-2017-8912"
],
"41998": [],
"42003": [],
"42004": [
"CVE-2017-8928"
],
"42005": [
"CVE-2017-8382"
],
"42012": [
"CVE-2017-6412"
],
"42013": [
"CVE-2017-6340",
"CVE-2017-6339",
"CVE-2017-6338"
],
"42028": [
"CVE-2017-7952"
],
"42029": [
"CVE-2017-7953"
],
"42082": [],
"42033": [
"CVE-2017-8917"
],
"42034": [
"CVE-2017-3546"
],
"42035": [],
"42036": [
"CVE-2016-6256"
],
"42037": [],
"42038": [],
"42039": [],
"42042": [
"CVE-2017-5631",
"CVE-2017-5631#"
],
"42043": [
"CVE-2017-7620"
],
"42044": [
"CVE-2017-9101"
],
"42062": [
"CVE-2016-9834"
],
"42064": [
"CVE-2017-2504"
],
"42065": [],
"42066": [
"CVE-2017-2508"
],
"42067": [
"CVE-2017-2510"
],
"42068": [
"CVE-2017-2515"
],
"42069": [],
"42074": [
"CVE-2017-7852"
],
"42075": [],
"42093": [],
"42094": [],
"42095": [],
"42096": [],
"42097": [],
"42098": [],
"42101": [],
"42105": [
"CVE-2017-2528"
],
"42106": [],
"42107": [],
"42111": [
"CVE-2016-6566"
],
"42113": [],
"42114": [],
"42117": [
"CVE-2017-9415"
],
"42118": [
"CVE-2017-9413"
],
"42120": [
"CVE-2017-9414"
],
"42127": [],
"42129": [],
"42130": [
"CVE-2017-8841",
"CVE-2017-8840",
"CVE-2017-8839",
"CVE-2017-8838",
"CVE-2017-8837",
"CVE-2017-8836",
"CVE-2017-8835"
],
"42131": [],
"42132": [],
"42133": [],
"42143": [
"CVE-2017-9516"
],
"42149": [],
"42150": [],
"42151": [],
"42153": [],
"42154": [],
"42156": [],
"42164": [],
"42166": [
"CVE-2017-9418"
],
"42167": [],
"42172": [
"CVE-2017-9603"
],
"42173": [
"CVE-2017-9429"
],
"42178": [],
"42184": [
"CVE-2017-9602"
],
"42185": [],
"42187": [],
"42192": [],
"42193": [
"CVE-2017-9730"
],
"42194": [],
"42195": [],
"42196": [],
"42197": [],
"42205": [],
"42221": [
"CVE-2016-10074",
"CVE-2016-10045",
"CVE-2016-10034",
"CVE-2016-10033"
],
"42252": [],
"42262": [
"CVE-2016-7508"
],
"42263": [],
"42268": [],
"42269": [
"CVE-2017-9813",
"CVE-2017-9812",
"CVE-2017-9811",
"CVE-2017-9810"
],
"42284": [],
"42293": [],
"42290": [
"CVE-2017-9833"
],
"42291": [
"CVE-2017-9834"
],
"42520": [
"CVE-2017-12971",
"CVE-2017-12970",
"CVE-2017-12965"
],
"42306": [
"CVE-2017-6971"
],
"42307": [],
"42308": [],
"42309": [],
"42311": [],
"42312": [],
"42313": [
"CVE-2017-11165"
],
"42314": [
"CVE-2017-7175",
"CVE-2017-6972"
],
"42317": [],
"42320": [],
"42321": [],
"42322": [],
"42323": [],
"42324": [
"CVE-2017-9791"
],
"42326": [],
"42330": [],
"42332": [
"CVE-2017-6182"
],
"42333": [
"CVE-2017-6320"
],
"42335": [
"CVE-2017-11356",
"CVE-2017-11355"
],
"42340": [
"CVE-2017-10246"
],
"42342": [
"CVE-2016-9682"
],
"42343": [],
"42345": [
"CVE-2017-6316"
],
"42344": [],
"42346": [
"CVE-2017-6316"
],
"42347": [],
"42348": [],
"42351": [],
"42352": [],
"42353": [],
"42358": [
"CVE-2017-11346"
],
"42359": [],
"42371": [],
"42372": [],
"42378": [
"CVE-2017-7037"
],
"42379": [],
"42380": [],
"42383": [],
"42381": [],
"42543": [
"CVE-2017-9640"
],
"42387": [],
"42388": [
"CVE-2017-3133",
"CVE-2017-3132",
"CVE-2017-3131"
],
"42401": [
"CVE-2016-9349"
],
"42402": [
"CVE-2016-9351",
"CVE-2016-9349"
],
"42403": [],
"42404": [],
"42408": [
"CVE-2017-11494"
],
"42410": [],
"42412": [],
"42413": [],
"42414": [],
"42415": [],
"42416": [],
"42417": [],
"42419": [],
"42420": [],
"42421": [],
"42635": [],
"42423": [],
"42427": [
"CVE-2017-11320"
],
"42431": [],
"42434": [
"CVE-2017-11155",
"CVE-2017-11154",
"CVE-2017-11153",
"CVE-2017-11152",
"CVE-2017-11151"
],
"42436": [],
"42437": [],
"42438": [],
"42439": [],
"42440": [],
"42441": [],
"42442": [],
"42443": [],
"42444": [
"CVE-2015-9098"
],
"42446": [],
"42447": [],
"42448": [],
"42449": [],
"42450": [],
"42452": [],
"42458": [],
"42457": [],
"42461": [],
"42462": [],
"42463": [],
"42482": [],
"42487": [],
"42488": [],
"42489": [],
"42490": [],
"42491": [],
"42519": [
"CVE-2017-6327"
],
"42492": [],
"42493": [],
"42494": [],
"42496": [],
"42497": [],
"42499": [],
"42500": [],
"42501": [],
"42502": [],
"42504": [],
"42505": [],
"42517": [
"CVE-2017-9979",
"CVE-2017-9978"
],
"42506": [],
"42507": [],
"42508": [],
"42509": [],
"42510": [],
"42511": [],
"42513": [],
"42514": [],
"42515": [],
"42516": [],
"42524": [],
"42525": [],
"42526": [],
"42527": [],
"42528": [],
"42529": [],
"42530": [],
"42531": [],
"42532": [],
"42533": [],
"42534": [],
"42535": [
"CVE-2017-12984"
],
"42561": [],
"42562": [],
"42564": [],
"42566": [],
"42569": [],
"42570": [],
"42571": [],
"42572": [],
"42573": [],
"42574": [],
"42575": [],
"42577": [],
"42578": [],
"42579": [],
"42580": [],
"42581": [
"CVE-2017-12943"
],
"42582": [],
"42583": [],
"42584": [],
"42585": [],
"42588": [],
"42589": [],
"42590": [],
"42591": [
"CVE-2017-6558"
],
"42592": [],
"42595": [],
"42596": [
"CVE-2016-10001"
],
"42597": [
"CVE-2016-10001"
],
"42598": [
"CVE-2016-10001"
],
"42603": [],
"42606": [],
"42607": [],
"42608": [
"CVE-2017-13713"
],
"42610": [
"CVE-2017-13754"
],
"42613": [
"CVE-2017-6328"
],
"42615": [],
"42616": [],
"42617": [],
"42618": [
"CVE-2017-14126"
],
"42619": [],
"42620": [],
"42622": [],
"42623": [],
"42628": [],
"42629": [],
"42631": [],
"42632": [],
"42633": [
"CVE-2017-14219"
],
"42634": [],
"42636": [],
"42637": [],
"42638": [],
"42639": [],
"42641": [],
"42642": [],
"42643": [],
"42644": [],
"42645": [],
"42648": [],
"42649": [
"CVE-2017-14147"
],
"42651": [],
"42653": [],
"42654": [],
"42655": [],
"42656": [],
"42657": [],
"42658": [],
"42659": [],
"42660": [
"CVE-2017-14396"
],
"42661": [],
"42662": [],
"42663": [],
"42667": [],
"42668": [],
"42669": [],
"42670": [],
"42671": [],
"42672": [],
"42673": [],
"42674": [],
"42675": [],
"42677": [],
"42676": [],
"42678": [],
"42679": [],
"42680": [],
"42681": [],
"42682": [],
"42684": [],
"42685": [],
"42686": [],
"42687": [],
"42688": [],
"42689": [],
"42690": [],
"42699": [
"CVE-2014-0780"
],
"42705": [],
"42706": [
"CVE-2011-3487"
],
"42707": [
"CVE-2011-3487"
],
"42713": [],
"42714": [],
"42715": [],
"42716": [],
"42717": [],
"42727": [],
"42728": [],
"42729": [],
"42730": [],
"42731": [],
"42732": [
"CVE-2017-11435"
],
"42733": [],
"42734": [],
"42736": [],
"42737": [],
"42738": [],
"42739": [
"CVE-2017-14243"
],
"42740": [
"CVE-2017-14244"
],
"42745": [
"CVE-2017-9798"
],
"42751": [],
"42752": [],
"42754": [
"CVE-2017-12930"
],
"42755": [
"CVE-2017-12929"
],
"42761": [
"CVE-2017-14618"
],
"42768": [],
"42769": [],
"42770": [],
"42771": [],
"42772": [
"CVE-2017-14703"
],
"42773": [
"CVE-2017-14704"
],
"42774": [],
"42775": [],
"42776": [],
"42785": [],
"42786": [],
"42788": [],
"42789": [],
"42792": [],
"42794": [
"CVE-2017-14507"
],
"42795": [
"CVE-2017-14838"
],
"42796": [
"CVE-2017-14840"
],
"42797": [
"CVE-2017-14839"
],
"42798": [
"CVE-2017-14842"
],
"42799": [
"CVE-2017-14841"
],
"42800": [
"CVE-2017-14845"
],
"42801": [
"CVE-2017-14844"
],
"42802": [
"CVE-2017-14846"
],
"42884": [],
"42805": [
"CVE-2017-14847"
],
"42889": [
"CVE-2017-14083"
],
"42892": [
"CVE-2017-14086"
],
"42893": [
"CVE-2017-14085"
],
"42894": [],
"42895": [
"CVE-2017-14087"
],
"42916": [],
"42919": [],
"42922": [
"CVE-2017-14738"
],
"42923": [
"CVE-2017-14620"
],
"42924": [
"CVE-2017-14848"
],
"42925": [],
"42926": [],
"42927": [
"CVE-2017-15956"
],
"42931": [],
"42933": [],
"42934": [
"CVE-2017-6090"
],
"42935": [
"CVE-2017-6089"
],
"42939": [
"CVE-2017-14757"
],
"42940": [
"CVE-2017-14758"
],
"42947": [],
"42950": [
"CVE-2017-14717",
"CVE-2017-14712"
],
"42953": [
"CVE-2017-12615"
],
"42954": [],
"42956": [],
"42959": [
"CVE-2017-12479"
],
"42961": [
"CVE-2017-15084"
],
"42966": [
"CVE-2017-12617"
],
"42967": [],
"42968": [],
"43013": [],
"42971": [
"CVE-2017-11394"
],
"42972": [],
"42975": [],
"44274": [
"CVE-2018-7890"
],
"42978": [
"CVE-2017-15284"
],
"42979": [],
"42980": [],
"42981": [],
"42982": [],
"42983": [],
"42985": [],
"42986": [
"CVE-2017-15287"
],
"42987": [
"CVE-2017-14619"
],
"42988": [
"CVE-2017-14956"
],
"42989": [
"CVE-2017-15646",
"CVE-2017-15645",
"CVE-2017-15644"
],
"42991": [
"CVE-2017-15359"
],
"42993": [],
"43002": [
"CVE-2017-15276"
],
"43003": [
"CVE-2017-15012"
],
"43004": [
"CVE-2017-15013"
],
"43005": [
"CVE-2017-15014"
],
"43009": [
"CVE-2017-12629"
],
"43011": [],
"43012": [],
"43015": [],
"43023": [
"CVE-2017-15291"
],
"43018": [
"CVE-2017-13129"
],
"43019": [
"CVE-2017-14680"
],
"43021": [
"CVE-2017-14955"
],
"43022": [
"CVE-2017-13772"
],
"43024": [
"CVE-2017-15687"
],
"43027": [],
"43028": [
"CVE-2017-14143"
],
"43034": [],
"43035": [],
"43036": [],
"43037": [],
"43038": [],
"43039": [],
"43040": [],
"43041": [],
"43042": [],
"43043": [],
"43044": [],
"43045": [
"CVE-2017-15639"
],
"43046": [],
"43047": [],
"43048": [],
"43049": [],
"43050": [],
"43051": [],
"43052": [],
"43053": [
"CVE-2017-15879"
],
"43054": [
"CVE-2017-15878"
],
"43056": [
"CVE-2017-5223"
],
"43062": [
"CVE-2017-15081"
],
"43063": [
"CVE-2017-15727"
],
"43064": [
"CVE-2017-15730"
],
"43065": [],
"43066": [
"CVE-2017-15993"
],
"43067": [
"CVE-2017-15992"
],
"43068": [
"CVE-2017-15991"
],
"43069": [
"CVE-2017-15990"
],
"43070": [
"CVE-2017-15989"
],
"43071": [
"CVE-2017-15988"
],
"43072": [
"CVE-2017-15987"
],
"43073": [
"CVE-2017-15986"
],
"43074": [
"CVE-2017-15985"
],
"43075": [
"CVE-2017-15984"
],
"43076": [
"CVE-2017-15983"
],
"43077": [
"CVE-2017-15982"
],
"43078": [
"CVE-2017-15981"
],
"43079": [
"CVE-2017-15980"
],
"43080": [
"CVE-2017-15979"
],
"43081": [
"CVE-2017-15978"
],
"43082": [
"CVE-2017-15977"
],
"43083": [
"CVE-2017-15976"
],
"43084": [
"CVE-2017-15975"
],
"43085": [
"CVE-2017-15974"
],
"43086": [
"CVE-2017-15973"
],
"43087": [
"CVE-2017-15972"
],
"43088": [
"CVE-2017-15971"
],
"43089": [
"CVE-2017-15970"
],
"43090": [
"CVE-2017-15969"
],
"43091": [
"CVE-2017-15968"
],
"43092": [
"CVE-2017-15967"
],
"43093": [
"CVE-2017-15966"
],
"43094": [
"CVE-2017-15965"
],
"43095": [
"CVE-2017-15964"
],
"43096": [
"CVE-2017-15963"
],
"43097": [
"CVE-2017-15962"
],
"43098": [
"CVE-2017-15961"
],
"43099": [
"CVE-2017-15960"
],
"43100": [
"CVE-2017-15959"
],
"43101": [
"CVE-2017-15958"
],
"43102": [
"CVE-2017-15957"
],
"43103": [
"CVE-2017-10309"
],
"43106": [
"CVE-2017-16244"
],
"43108": [],
"43110": [],
"43113": [],
"43114": [
"CVE-2017-3548"
],
"43117": [
"CVE-2017-16562"
],
"43122": [
"CVE-2017-16567"
],
"43123": [
"CVE-2017-16568"
],
"43128": [],
"43129": [
"CVE-2017-16543",
"CVE-2017-16542"
],
"43136": [
"CVE-2017-16780"
],
"43137": [
"CVE-2017-16781"
],
"43138": [
"CVE-2017-16524"
],
"43140": [
"CVE-2017-16807"
],
"43155": [
"CVE-2017-15806"
],
"43158": [
"CVE-2017-16819"
],
"43177": [
"CVE-2017-16962"
],
"43188": [
"CVE-2017-16953"
],
"43190": [],
"43196": [
"CVE-2017-17058"
],
"43203": [],
"43205": [
"CVE-2017-16884"
],
"43206": [
"CVE-2017-17055"
],
"43210": [
"CVE-2017-11319"
],
"43211": [
"CVE-2017-17110"
],
"43212": [
"CVE-2017-17111"
],
"43213": [],
"43214": [],
"43215": [],
"43227": [],
"43228": [],
"43232": [],
"43235": [
"CVE-2017-17594"
],
"43237": [
"CVE-2017-17593"
],
"43238": [
"CVE-2017-17592"
],
"43239": [
"CVE-2017-17591"
],
"43240": [
"CVE-2017-17589"
],
"43241": [
"CVE-2017-17590"
],
"43242": [
"CVE-2017-17583"
],
"43243": [
"CVE-2017-17581"
],
"43244": [
"CVE-2017-17586"
],
"43245": [
"CVE-2017-17585"
],
"43246": [
"CVE-2017-17584"
],
"43249": [
"CVE-2017-17580"
],
"43250": [
"CVE-2017-17587"
],
"43251": [
"CVE-2017-17588"
],
"43252": [
"CVE-2017-17582"
],
"43253": [
"CVE-2017-17575"
],
"43254": [
"CVE-2017-17576"
],
"43255": [
"CVE-2017-17579"
],
"43256": [
"CVE-2017-17573"
],
"43257": [
"CVE-2017-17578"
],
"43258": [
"CVE-2017-17574"
],
"43259": [
"CVE-2017-17572"
],
"43260": [
"CVE-2017-17577"
],
"43261": [
"CVE-2017-17570"
],
"43262": [
"CVE-2017-17571"
],
"43263": [
"CVE-2017-17602"
],
"43264": [
"CVE-2017-17599"
],
"43265": [
"CVE-2017-17598"
],
"43266": [
"CVE-2017-17600"
],
"43267": [
"CVE-2017-17595"
],
"43268": [
"CVE-2017-17597"
],
"43269": [
"CVE-2017-17601"
],
"43270": [
"CVE-2017-17609"
],
"43271": [
"CVE-2017-17608"
],
"43272": [
"CVE-2017-17607"
],
"43273": [
"CVE-2017-17606"
],
"43282": [
"CVE-2017-17630"
],
"43274": [
"CVE-2017-17605"
],
"43275": [
"CVE-2017-17596"
],
"43276": [
"CVE-2017-17611"
],
"43281": [
"CVE-2017-17614"
],
"43277": [
"CVE-2017-17610"
],
"43280": [
"CVE-2017-17615"
],
"43278": [
"CVE-2017-17648"
],
"43279": [
"CVE-2017-17616"
],
"43283": [
"CVE-2017-17613"
],
"43284": [
"CVE-2017-17612"
],
"43285": [
"CVE-2017-17617"
],
"43286": [
"CVE-2017-17618"
],
"43287": [
"CVE-2017-17629"
],
"43288": [
"CVE-2017-17619"
],
"43289": [
"CVE-2017-17620"
],
"43290": [
"CVE-2017-17621"
],
"43291": [
"CVE-2017-17622"
],
"43292": [
"CVE-2017-17623"
],
"43293": [
"CVE-2017-17624"
],
"43294": [
"CVE-2017-17625"
],
"43295": [
"CVE-2017-17626"
],
"43296": [
"CVE-2017-17627"
],
"43297": [
"CVE-2017-17628"
],
"43299": [
"CVE-2017-17631"
],
"43300": [
"CVE-2017-17632"
],
"43301": [
"CVE-2017-17633"
],
"43302": [
"CVE-2017-17634"
],
"43304": [
"CVE-2017-17603"
],
"43305": [
"CVE-2017-17604"
],
"43306": [
"CVE-2017-17635"
],
"43307": [
"CVE-2017-17636"
],
"43308": [
"CVE-2017-17637"
],
"43309": [
"CVE-2017-17638"
],
"43310": [
"CVE-2017-17639"
],
"43311": [
"CVE-2017-17640"
],
"43312": [
"CVE-2017-17641"
],
"43314": [
"CVE-2017-17642"
],
"43315": [
"CVE-2017-17874"
],
"43316": [
"CVE-2017-17873"
],
"43323": [
"CVE-2017-17870"
],
"43324": [
"CVE-2017-16949"
],
"43329": [
"CVE-2017-17871"
],
"43330": [
"CVE-2017-17872"
],
"43332": [
"CVE-2017-16787"
],
"43333": [
"CVE-2017-17649"
],
"43334": [
"CVE-2017-17651"
],
"43335": [
"CVE-2017-17643"
],
"43336": [
"CVE-2017-17645"
],
"43337": [
"CVE-2017-10682"
],
"43340": [
"CVE-2017-14016"
],
"43343": [],
"43346": [],
"43347": [],
"43348": [],
"43349": [],
"44158": [
"CVE-2018-7313"
],
"44159": [
"CVE-2018-7317"
],
"44160": [
"CVE-2018-7314"
],
"44161": [
"CVE-2018-7315"
],
"44162": [
"CVE-2018-7312"
],
"44163": [
"CVE-2018-7318"
],
"44164": [
"CVE-2018-7316"
],
"44165": [
"CVE-2018-7319"
],
"44166": [
"CVE-2018-6230",
"CVE-2018-6229",
"CVE-2018-6228",
"CVE-2018-6227",
"CVE-2018-6226",
"CVE-2018-6225",
"CVE-2018-6224",
"CVE-2018-6223",
"CVE-2018-6222",
"CVE-2018-6221",
"CVE-2018-6220",
"CVE-2018-6219"
],
"45605": [],
"44186": [],
"44276": [],
"44191": [
"CVE-2018-7477"
],
"44192": [
"CVE-2018-7448"
],
"44194": [
"CVE-2017-18195"
],
"44216": [
"CVE-2018-6193"
],
"44219": [
"CVE-2018-6936"
],
"44220": [
"CVE-2018-7739"
],
"44223": [
"CVE-2018-7490",
"CVE-2018-7490"
],
"44241": [],
"44250": [],
"44252": [],
"44256": [
"CVE-2018-7216"
],
"44261": [],
"44262": [
"CVE-2018-7739"
],
"44272": [
"CVE-2017-15367"
],
"44277": [
"CVE-2018-7474"
],
"44278": [
"CVE-2017-16720"
],
"44281": [],
"44285": [
"CVE-2018-7707",
"CVE-2018-7706",
"CVE-2018-7705",
"CVE-2018-7704",
"CVE-2018-7703",
"CVE-2018-7702",
"CVE-2018-7701"
],
"44286": [
"CVE-2018-7538"
],
"44288": [
"CVE-2018-7543"
],
"44289": [
"CVE-2017-8046"
],
"44295": [],
"44317": [
"CVE-2018-9010"
],
"44318": [
"CVE-2017-10004"
],
"44320": [
"CVE-2018-8772"
],
"44324": [
"CVE-2018-0114"
],
"44328": [],
"44346": [],
"44335": [],
"44336": [],
"44339": [],
"44340": [
"CVE-2018-7422"
],
"44343": [
"CVE-2018-8947"
],
"44350": [
"CVE-2018-7171"
],
"44351": [
"CVE-2018-7203"
],
"44352": [
"CVE-2018-0878"
],
"44353": [],
"44354": [
"CVE-2018-8903"
],
"44355": [
"CVE-2014-3704"
],
"44358": [
"CVE-2017-8917"
],
"44360": [
"CVE-2018-8979"
],
"44361": [
"CVE-2018-7300"
],
"44362": [
"CVE-2018-9092"
],
"44366": [
"CVE-2018-9034"
],
"44367": [
"CVE-2018-9035"
],
"44368": [
"CVE-2018-7297"
],
"44369": [
"CVE-2018-9107"
],
"44370": [
"CVE-2018-9106"
],
"44371": [
"CVE-2018-8719"
],
"44373": [],
"44374": [],
"44377": [],
"44378": [
"CVE-2018-9032"
],
"44381": [],
"44379": [
"CVE-2016-1713"
],
"44380": [],
"44383": [
"CVE-2018-8908"
],
"44384": [
"CVE-2018-8732"
],
"44385": [
"CVE-2018-8817"
],
"44386": [],
"44387": [],
"44388": [
"CVE-2018-5708"
],
"44390": [],
"44391": [
"CVE-2018-8811"
],
"44392": [
"CVE-2018-8815"
],
"44393": [],
"44399": [],
"44400": [],
"44401": [
"CVE-2018-9183"
],
"44403": [
"CVE-2018-6849"
],
"44405": [
"CVE-2018-7653"
],
"44406": [
"CVE-2018-7736"
],
"44407": [
"CVE-2018-7737"
],
"44408": [
"CVE-2018-9173"
],
"44409": [
"CVE-2018-8729"
],
"44413": [
"CVE-2018-9248"
],
"44414": [
"CVE-2018-9126"
],
"44416": [
"CVE-2018-7746"
],
"44612": [
"CVE-2018-9155"
],
"44417": [
"CVE-2018-9118"
],
"44418": [
"CVE-2018-8814"
],
"44419": [
"CVE-2018-7745"
],
"44420": [],
"44421": [
"CVE-2018-8813"
],
"44424": [
"CVE-2018-9238"
],
"44425": [],
"44429": [
"CVE-2018-9843"
],
"44430": [],
"44431": [],
"44432": [],
"44433": [],
"44434": [
"CVE-2018-9235"
],
"44435": [],
"44436": [
"CVE-2018-9237",
"CVE-2018-9236"
],
"44437": [
"CVE-2018-8729"
],
"44439": [
"CVE-2018-9926"
],
"44440": [],
"44441": [
"CVE-2018-1217"
],
"44443": [
"CVE-2018-9172"
],
"44444": [
"CVE-2018-9844"
],
"44447": [
"CVE-2018-10063"
],
"44448": [
"CVE-2018-7600"
],
"44450": [
"CVE-2018-10070"
],
"44449": [
"CVE-2018-7600"
],
"44454": [
"CVE-2018-8057"
],
"44469": [
"CVE-2016-7786",
"CVE-2016-7786"
],
"44471": [
"CVE-2018-10068"
],
"44534": [
"CVE-2018-10258"
],
"44483": [],
"44484": [],
"44486": [
"CVE-2018-9857"
],
"44487": [
"CVE-2018-8831"
],
"44488": [
"CVE-2018-8880"
],
"44489": [
"CVE-2018-7747"
],
"44492": [],
"44493": [
"CVE-2018-10079",
"CVE-2018-10078",
"CVE-2018-10077"
],
"44495": [
"CVE-2018-8770",
"CVE-2018-8056"
],
"44496": [
"CVE-2018-10188"
],
"44497": [
"CVE-2018-10201"
],
"44498": [
"CVE-2017-12635"
],
"44501": [
"CVE-2018-9205"
],
"44502": [
"CVE-2018-10109"
],
"44503": [
"CVE-2018-10310"
],
"44504": [
"CVE-2018-10312"
],
"44511": [
"CVE-2018-9137"
],
"44512": [
"CVE-2018-9038"
],
"44513": [
"CVE-2017-14322"
],
"44515": [
"CVE-2018-9245",
"CVE-2018-10286",
"CVE-2018-10285"
],
"44520": [],
"44542": [
"CVE-2018-7602"
],
"44531": [
"CVE-2018-8716"
],
"44535": [
"CVE-2018-10255"
],
"44536": [
"CVE-2018-10257"
],
"44537": [
"CVE-2018-10256"
],
"44538": [
"CVE-2018-10259"
],
"44539": [
"CVE-2018-10260"
],
"44543": [
"CVE-2016-10036"
],
"44544": [],
"44545": [
"CVE-2018-9160"
],
"44546": [
"CVE-2018-10366"
],
"44547": [
"CVE-2018-10365"
],
"44548": [],
"44550": [],
"44551": [
"CVE-2018-10321"
],
"44557": [
"CVE-2018-7602"
],
"44559": [
"CVE-2018-10504"
],
"44560": [
"CVE-2018-8736",
"CVE-2018-8735",
"CVE-2018-8734",
"CVE-2018-8733"
],
"44563": [
"CVE-2018-10309"
],
"44567": [
"CVE-2018-9302"
],
"44580": [
"CVE-cve 2017-1"
],
"44583": [
"CVE-2013-2251"
],
"44585": [
"CVE-2018-10371"
],
"44587": [
"CVE-2015-1503"
],
"44589": [
"CVE-2018-10757"
],
"44595": [],
"44606": [
"CVE-2018-6023"
],
"44607": [
"CVE-2018-10832"
],
"44608": [
"CVE-2018-10580"
],
"44613": [
"CVE-2018-10314"
],
"44617": [
"CVE-2018-10313"
],
"44618": [
"CVE-2018-10311"
],
"44622": [],
"44623": [
"CVE-2018-5430"
],
"44624": [],
"44625": [
"CVE-2018-7465"
],
"44626": [
"CVE-2016-2279"
],
"44627": [],
"44685": [],
"44628": [],
"44631": [
"CVE-2018-6563"
],
"44632": [],
"44634": [
"CVE-2018-1247"
],
"44636": [],
"44637": [
"CVE-2018-11094"
],
"44639": [],
"44640": [
"CVE-2016-5809"
],
"44645": [],
"44646": [],
"44647": [],
"44651": [],
"44650": [],
"44655": [],
"44657": [
"CVE-2018-8898"
],
"44661": [],
"44660": [],
"44662": [],
"44663": [],
"44664": [],
"44668": [],
"44666": [
"CVE-2018-9163"
],
"44667": [
"CVE-2015- 5698"
],
"44671": [],
"44672": [],
"44675": [],
"44676": [],
"44678": [
"CVE-2013-0663"
],
"44679": [],
"44681": [],
"44682": [],
"44683": [],
"44684": [],
"44686": [],
"44687": [
"CVE-2014-2908"
],
"44689": [],
"44692": [],
"44691": [
"CVE-2018-11339"
],
"44698": [],
"44699": [],
"44700": [],
"44701": [],
"44702": [],
"44703": [],
"46066": [],
"46067": [
"CVE-2018-20448"
],
"44706": [],
"44707": [],
"44708": [],
"44709": [],
"44710": [],
"44711": [],
"44712": [],
"44714": [],
"44716": [],
"44715": [],
"44719": [],
"44718": [],
"44720": [],
"44722": [],
"44725": [],
"44726": [],
"44727": [],
"44728": [],
"44729": [],
"44730": [],
"44732": [],
"44733": [],
"44734": [],
"44753": [],
"44754": [],
"44755": [
"CVE-2018-11415"
],
"44757": [
"CVE-2017-10033"
],
"44752": [
"CVE-2018-2791"
],
"44736": [],
"44737": [],
"44739": [],
"44746": [],
"45569": [],
"45336": [
"CVE-2018-14497"
],
"44748": [],
"44749": [
"CVE-2014-3110"
],
"44751": [],
"44761": [],
"44762": [],
"44763": [
"CVE-2018-11445",
"CVE-2018-11442"
],
"44764": [
"CVE-2018-11443"
],
"44765": [
"CVE-2018-11444"
],
"44766": [],
"44767": [],
"44769": [],
"44770": [],
"44771": [],
"44772": [],
"44773": [],
"44774": [],
"44775": [
"CVE-2018-11332"
],
"44777": [],
"44778": [],
"45607": [],
"45606": [],
"44781": [],
"44782": [
"CVE-2018-11403"
],
"44783": [
"CVE-2018-11404"
],
"44785": [],
"44786": [],
"44788": [],
"44789": [],
"44790": [
"CVE-2018-11512"
],
"44792": [],
"44793": [
"CVE-2018-11535"
],
"44794": [
"CVE-2018-11523"
],
"44795": [
"CVE-2018-11532"
],
"44799": [],
"44800": [],
"44801": [
"CVE-2018-11538"
],
"44803": [
"CVE-2018-11522"
],
"44804": [
"CVE-2018-6411",
"CVE-2018-6410",
"CVE-2018-6409"
],
"44805": [
"CVE-2018-10094"
],
"44809": [],
"44813": [],
"44814": [],
"44815": [],
"44816": [],
"44823": [],
"44824": [],
"44825": [
"CVE-2018-11670"
],
"44826": [
"CVE-2018-11671"
],
"44827": [
"CVE-2018-11586"
],
"44831": [
"CVE-2018-11628"
],
"44833": [
"CVE-2018-11715"
],
"44837": [
"CVE-2018-11564"
],
"44839": [
"CVE-2018-11581"
],
"44843": [
"CVE-2018-8718"
],
"44949": [],
"44943": [
"CVE-2018-12636"
],
"44945": [],
"44851": [],
"44853": [],
"44854": [],
"44855": [
"CVE-2018-10118"
],
"44864": [
"CVE-2018-10088"
],
"44865": [
"CVE-2018-11409"
],
"44866": [
"CVE-2018-12055"
],
"44867": [
"CVE-2018-10969"
],
"44868": [],
"44869": [],
"44870": [
"CVE-2018-12053"
],
"44871": [],
"44872": [],
"44873": [
"CVE-2018-12052"
],
"44874": [
"CVE-2018-12054"
],
"44877": [],
"44879": [],
"44881": [
"CVE-2018-5756",
"CVE-2018-5755",
"CVE-2018-5754",
"CVE-2018-5753",
"CVE-2018-5752",
"CVE-2018-5751",
"CVE-2017-17062"
],
"44882": [
"CVE-2018-12111"
],
"44883": [],
"44884": [],
"44951": [],
"44887": [
"CVE-2018-12114"
],
"44891": [],
"44893": [
"CVE-2018-12254"
],
"44895": [
"CVE-2018-12095"
],
"44897": [
"CVE-2018-12094"
],
"44901": [],
"44902": [],
"44905": [],
"44907": [],
"44910": [
"CVE-2018-12525",
"CVE-2018-12524",
"CVE-2018-12523",
"CVE-2018-12522"
],
"44911": [],
"44912": [],
"44913": [
"CVE-2017-12636"
],
"44916": [
"CVE-2018-10956"
],
"44917": [],
"44918": [
"CVE-2018-12602"
],
"44919": [
"CVE-2018-12603"
],
"44922": [
"CVE-2018-12604"
],
"44924": [
"CVE-2018-12613"
],
"44926": [],
"44928": [
"CVE-2018-12613"
],
"44982": [
"CVE-2018-13109"
],
"44931": [
"CVE-2018-11525"
],
"44932": [],
"44933": [],
"44935": [
"CVE-2018-12705"
],
"44936": [],
"44937": [],
"44938": [
"CVE-2018-13032"
],
"44939": [],
"44940": [
"CVE-2018-11526"
],
"44952": [
"CVE-2018-12739"
],
"44953": [
"CVE-2018-12912"
],
"44954": [],
"44955": [],
"44956": [
"CVE-2018-0296"
],
"44957": [],
"44959": [
"CVE-2018-6961"
],
"44960": [],
"44964": [],
"44973": [
"CVE-2018-12520"
],
"46489": [
"CVE-2019-7385"
],
"44975": [],
"44976": [
"CVE-2018-10000"
],
"44977": [
"CVE-2018-12908"
],
"44978": [
"CVE-2018-12519"
],
"45014": [
"CVE-2018-12981",
"CVE-2018-12980",
"CVE-2018-12979"
],
"44981": [],
"44986": [
"CVE-2018-8738"
],
"44988": [],
"46488": [
"CVE-2019-9082"
],
"44996": [],
"44997": [],
"44998": [
"CVE-2017-3248"
],
"44999": [],
"45002": [],
"45003": [
"CVE-2018-13849"
],
"45161": [],
"45007": [],
"45065": [],
"45030": [
"CVE-2018-14064"
],
"45178": [
"CVE-2018-14888"
],
"45015": [
"CVE-2018-0710",
"CVE-2018-0709",
"CVE-2018-0708",
"CVE-2018-0707",
"CVE-2018-0706"
],
"45016": [
"CVE-2018-13981",
"CVE-2018-13980"
],
"45021": [
"CVE-2018-15137"
],
"45022": [
"CVE-2018-13989"
],
"45027": [
"CVE-2018-12463"
],
"45031": [],
"45034": [],
"45035": [],
"45036": [],
"45037": [],
"45038": [],
"45046": [
"CVE-2018-13784"
],
"45047": [
"CVE-2018-13784"
],
"45049": [],
"45053": [
"CVE-2018-11124"
],
"45054": [],
"45056": [
"CVE-2018-13832"
],
"45055": [],
"45057": [
"CVE-2018-14392"
],
"45062": [
"CVE-2018-14418"
],
"45063": [
"CVE-2018-13862"
],
"45083": [
"CVE-2018-12465",
"CVE-2018-12464"
],
"45068": [],
"45160": [
"CVE-2018-14493"
],
"45070": [],
"45073": [],
"45076": [
"CVE-2018-10618"
],
"45078": [
"CVE-2015-5996"
],
"45209": [],
"45084": [],
"45088": [
"CVE-2018-13859"
],
"45090": [],
"45094": [
"CVE-2018-14328"
],
"45338": [
"CVE-2018-15917"
],
"45340": [
"CVE-2018-15918"
],
"45341": [
"CVE-2014-0030"
],
"45342": [
"CVE-2018-16059"
],
"45097": [
"CVE-2018-14417"
],
"45103": [
"CVE-2018-14728"
],
"45105": [
"CVE-2018-14335"
],
"45108": [
"CVE-2018-14716"
],
"45109": [],
"45127": [
"CVE-2018-14029"
],
"45128": [],
"45129": [],
"45131": [],
"45133": [
"CVE-2018-13416"
],
"45169": [
"CVE-2017-15580"
],
"45167": [],
"45135": [],
"45136": [
"CVE-2018-8096"
],
"45143": [
"CVE-2018-14869"
],
"45145": [
"CVE-2018-13417"
],
"45146": [
"CVE-2018-13415"
],
"45148": [],
"45150": [
"CVE-2018-14840"
],
"45152": [
"CVE-2018-7669"
],
"45153": [
"CVE-2018-12090"
],
"45154": [],
"45155": [],
"45577": [
"CVE-2018-12596"
],
"45158": [
"CVE-2019-8982"
],
"45266": [],
"45164": [],
"45240": [
"CVE-2018-15534"
],
"45172": [],
"45173": [],
"45177": [
"CVE-2016-3411"
],
"45179": [],
"45190": [
"CVE-2018-1563",
"CVE-2018-1513"
],
"45195": [
"CVE-2018-14912"
],
"45196": [
"CVE-2017-10000"
],
"45198": [
"CVE-2017-10000"
],
"45200": [
"CVE-2018-11511",
"CVE-2018-11510",
"CVE-2018-11509"
],
"45202": [
"CVE-2018-15142",
"CVE-2018-15141",
"CVE-2018-15140"
],
"45201": [],
"45206": [],
"45208": [
"CVE-2018-14059",
"CVE-2018-14058",
"CVE-2018-14057"
],
"45212": [
"CVE-2018-11510"
],
"45221": [],
"45224": [
"CVE-2018-11502"
],
"45225": [
"CVE-2018-10752"
],
"45228": [],
"45230": [],
"45231": [],
"45232": [],
"45234": [],
"45236": [],
"45237": [],
"45242": [
"CVE-2018-15533"
],
"45247": [],
"45248": [],
"45252": [],
"45253": [],
"45254": [
"CVE-2018-15608"
],
"45255": [],
"45256": [
"CVE-2018-15740"
],
"45258": [
"CVE-2018-15845"
],
"45264": [
"CVE-2018-15884"
],
"45267": [],
"45270": [],
"45271": [
"CVE-2018-15536",
"CVE-2018-15535"
],
"45274": [
"CVE-2018-15877"
],
"45680": [
"CVE-2018-18924"
],
"45284": [
"CVE-2017-10004"
],
"45286": [],
"45296": [
"CVE-2018-15745"
],
"45303": [
"CVE-2018-16133"
],
"45305": [],
"45306": [
"CVE-2018-12710"
],
"45307": [],
"45309": [
"CVE-2018-16134"
],
"45310": [],
"45314": [
"CVE-2018-15844"
],
"45319": [
"CVE-2018-16252"
],
"45322": [],
"45323": [],
"45343": [],
"45326": [],
"45327": [],
"45328": [],
"45330": [],
"45344": [],
"45347": [],
"45348": [
"CVE-2018-0715"
],
"45351": [],
"45361": [],
"45375": [],
"45384": [
"CVE-2018-12634"
],
"45385": [
"CVE-2018-16836"
],
"45386": [
"CVE-2018-10763"
],
"45387": [
"CVE-2018-10814"
],
"45392": [
"CVE-2018-1756"
],
"45393": [
"CVE-2018-15596"
],
"45394": [
"CVE-2018-16946"
],
"45396": [
"CVE-2018-1306"
],
"45400": [
"CVE-2018-1322",
"CVE-2018-1321"
],
"45409": [
"CVE-2018-10575",
"CVE-2018-10576",
"CVE-2018-10577"
],
"45411": [],
"45422": [],
"45423": [
"CVE-2018-17254"
],
"45434": [
"CVE-2018-10020"
],
"45437": [
"CVE-2018-16736"
],
"45438": [
"CVE-2018-16283"
],
"45439": [
"CVE-2018-16299"
],
"45440": [
"CVE-2018-16288"
],
"45445": [
"CVE-2018-17255"
],
"45446": [],
"45447": [
"CVE-2018-14592"
],
"45448": [
"CVE-2018-17173"
],
"45449": [
"CVE-2018-17128"
],
"45451": [],
"45452": [],
"45454": [],
"45456": [],
"45460": [],
"45461": [],
"45462": [],
"45463": [
"CVE-2018-17391"
],
"45464": [
"CVE-2018-17379"
],
"45465": [
"CVE-2018-17375"
],
"45466": [
"CVE-2018-17378"
],
"45468": [
"CVE-2018-17377"
],
"45469": [
"CVE-2018-17382"
],
"45470": [
"CVE-2018-17385"
],
"45471": [],
"45472": [],
"45473": [
"CVE-2018-17384"
],
"45474": [
"CVE-2018-17383"
],
"45475": [
"CVE-2018-17376"
],
"45476": [
"CVE-2018-17397"
],
"45477": [
"CVE-2018-17380"
],
"45478": [
"CVE-2018-17394"
],
"45487": [],
"45490": [],
"45491": [],
"46487": [],
"45498": [],
"45499": [],
"45500": [
"CVE-2018-16659"
],
"45506": [],
"45507": [],
"45508": [],
"45509": [],
"45510": [],
"45511": [],
"45512": [],
"45513": [],
"45514": [
"CVE-2018-17832"
],
"45515": [],
"45518": [
"CVE-2018-17428"
],
"45519": [],
"45521": [],
"45523": [],
"45524": [],
"45525": [
"CVE-2018-17593",
"CVE-2018-17591",
"CVE-2018-17590",
"CVE-2018-17588",
"CVE-2018-17587"
],
"45526": [
"CVE-2018-17310",
"CVE-2018-17313"
],
"45530": [],
"45532": [],
"45533": [
"CVE-2018-17443",
"CVE-2018-17442",
"CVE-2018-17441",
"CVE-2018-17440"
],
"45534": [],
"45535": [],
"45536": [],
"45537": [],
"45539": [],
"45542": [],
"45580": [],
"45581": [],
"45582": [],
"45584": [
"CVE-2018-9206"
],
"45586": [
"CVE-2016-8366"
],
"45588": [],
"45589": [],
"45590": [
"CVE-2016-8380",
"CVE-2016-8371"
],
"45591": [],
"45592": [],
"45593": [],
"45594": [
"CVE-2018-17784"
],
"45595": [
"CVE-2014-10029"
],
"45596": [],
"45597": [],
"45599": [],
"45600": [],
"45601": [],
"45602": [],
"45603": [],
"45604": [],
"45610": [
"CVE-2018-18324",
"CVE-2018-18323",
"CVE-2018-18322"
],
"45612": [],
"45613": [],
"45614": [],
"45615": [],
"45616": [],
"45617": [],
"45618": [],
"45619": [],
"45620": [],
"45621": [],
"45622": [],
"45623": [],
"45628": [
"CVE-2018-18308"
],
"45630": [],
"45632": [
"CVE-2018-18428"
],
"45633": [],
"45635": [],
"45636": [],
"45637": [],
"45639": [],
"45642": [],
"45643": [],
"45645": [],
"45646": [],
"45654": [],
"45655": [],
"45656": [],
"45657": [],
"45659": [],
"45661": [],
"45662": [],
"45663": [],
"45664": [],
"45665": [],
"45666": [],
"45667": [],
"45668": [
"CVE-2018-18437"
],
"45672": [
"CVE-2018-18416"
],
"45673": [],
"45676": [
"CVE-2018-10823"
],
"45677": [
"CVE-2018-10824"
],
"45678": [
"CVE-2018-10822"
],
"45681": [
"CVE-2018-18417"
],
"45682": [],
"45683": [],
"45684": [],
"45685": [],
"45686": [
"CVE-2018-18419"
],
"45688": [],
"45689": [],
"45690": [],
"45691": [
"CVE-2018-18548"
],
"45692": [],
"45693": [],
"45698": [],
"45699": [],
"45700": [],
"45701": [],
"46486": [
"CVE-2019-9581"
],
"45703": [],
"45704": [],
"45706": [],
"45707": [],
"45713": [],
"45717": [],
"45718": [],
"45719": [
"CVE-2018-18803"
],
"45720": [
"CVE-2018-18804"
],
"45721": [
"CVE-2018-18805"
],
"45722": [
"CVE-2018-18795"
],
"45723": [
"CVE-2018-18793"
],
"45724": [
"CVE-2018-18794"
],
"45725": [
"CVE-2018-18797"
],
"45726": [
"CVE-2018-18799"
],
"45727": [
"CVE-2018-18798"
],
"45728": [
"CVE-2018-18800"
],
"45729": [
"CVE-2018-18760"
],
"45730": [
"CVE-2018-18801"
],
"45731": [
"CVE-2018-18761"
],
"45733": [
"CVE-2018-18763"
],
"45734": [
"CVE-2018-18762"
],
"45735": [
"CVE-2018-18755"
],
"45736": [],
"45737": [],
"45739": [],
"45740": [],
"45741": [],
"45747": [],
"45751": [],
"45752": [],
"45753": [],
"45754": [],
"45755": [
"CVE-2018-18777",
"CVE-2018-18776",
"CVE-2018-18775"
],
"45756": [],
"45757": [],
"45758": [],
"45763": [],
"45764": [],
"45766": [],
"45767": [],
"45768": [],
"45773": [],
"45774": [
"CVE-2018-15707",
"CVE-2018-15705"
],
"45775": [],
"45776": [],
"45777": [],
"45779": [],
"45780": [
"CVE-2018-19458"
],
"45783": [
"CVE-2018-18865"
],
"45784": [],
"45793": [
"CVE-2018-10517"
],
"45794": [],
"45795": [],
"45799": [],
"45801": [],
"45802": [],
"45803": [],
"45807": [],
"45808": [],
"45809": [
"CVE-2018-19040",
"CVE-2018-19041",
"CVE-2018-19042",
"CVE-2018-19043"
],
"45810": [],
"45811": [],
"45812": [],
"45813": [],
"45815": [],
"45816": [],
"45817": [],
"45818": [],
"45820": [],
"45822": [
"CVE-2018-18774",
"CVE-2018-18773",
"CVE-2018-18772"
],
"45825": [],
"45826": [],
"45827": [],
"45830": [],
"45831": [],
"45833": [],
"45834": [],
"45835": [],
"45836": [],
"45837": [],
"45838": [],
"45839": [
"CVE-2018-19135"
],
"45840": [],
"45841": [],
"45842": [],
"45843": [],
"45844": [],
"45845": [],
"45847": [],
"45848": [],
"45849": [],
"45852": [
"CVE-2018-15768",
"CVE-2018-15767"
],
"45853": [
"CVE-2018-18619"
],
"45855": [],
"45856": [],
"45857": [],
"45858": [],
"45860": [],
"45861": [
"CVE-2018-19246"
],
"45862": [],
"45863": [],
"45864": [],
"45868": [],
"45875": [],
"45876": [],
"45877": [],
"45878": [],
"45879": [],
"45880": [
"CVE-2018-19287"
],
"45881": [],
"45882": [],
"45883": [
"CVE-2018-19136"
],
"45892": [],
"45894": [],
"45895": [],
"45896": [],
"45897": [],
"45899": [],
"45900": [],
"45902": [
"CVE-2018-18923"
],
"45903": [],
"45904": [],
"45918": [
"CVE-2017-6026"
],
"45920": [],
"45927": [],
"45928": [],
"45929": [],
"45930": [],
"45932": [],
"45933": [
"CVE-2018-8021"
],
"45935": [],
"45937": [
"CVE-2018-19616"
],
"45962": [],
"45941": [
"CVE-2018-19749"
],
"45942": [
"CVE-2018-11742",
"CVE-2018-11741"
],
"45944": [],
"45945": [
"CVE-2018-19799"
],
"45946": [
"CVE-2018-19750"
],
"45947": [
"CVE-2018-19751"
],
"45948": [
"CVE-2018-15716"
],
"45949": [
"CVE-2018-19752"
],
"45954": [
"CVE-2018-19782"
],
"45955": [],
"45957": [
"CVE-2018-20159"
],
"45958": [
"CVE-2018-19877"
],
"45959": [],
"45963": [],
"45964": [
"CVE-2018-19126",
"CVE-2018-19125"
],
"45967": [
"CVE-2018-19913"
],
"45969": [],
"45970": [
"CVE-2018-13134"
],
"45971": [
"CVE-2018-7921"
],
"45972": [
"CVE-2018-7358",
"CVE-2018-7357"
],
"45973": [],
"45974": [],
"45975": [],
"45976": [],
"45977": [],
"45978": [],
"45979": [
"CVE-2018-15961"
],
"45987": [],
"45989": [
"CVE-2018-7690"
],
"45990": [
"CVE-2018-7691"
],
"45991": [
"CVE-2015-7254"
],
"45992": [],
"45994": [],
"45995": [],
"45997": [],
"46000": [
"CVE-2018-19371"
],
"46010": [],
"46011": [
"CVE-2018-20166"
],
"46012": [
"CVE-2018-19828"
],
"46013": [
"CVE-2018-19829"
],
"46014": [
"CVE-2018-19933"
],
"46015": [
"CVE-2018-13045"
],
"46017": [
"CVE-2018-1821"
],
"46027": [],
"46035": [],
"46036": [
"CVE-2018-19138"
],
"46037": [],
"46041": [],
"46050": [
"CVE-2018-19277"
],
"46054": [
"CVE-2018-20418"
],
"46055": [],
"46060": [
"CVE-2018-10008"
],
"46061": [],
"46065": [
"CVE-2019-5009"
],
"46076": [],
"46077": [],
"46079": [
"CVE-2018-17997"
],
"46080": [
"CVE-2019-3501"
],
"46081": [
"CVE-2018-20326"
],
"46082": [],
"46083": [],
"46084": [],
"46085": [
"CVE-2018-20526",
"CVE-2018-20525"
],
"46086": [
"CVE-2018-20221"
],
"46090": [],
"46091": [],
"46092": [
"CVE-2014-5395"
],
"46094": [],
"46095": [],
"46097": [],
"46100": [],
"46102": [
"CVE-2018-7355"
],
"46106": [
"CVE-2018-14485"
],
"46108": [
"CVE-2018-10008"
],
"46109": [
"CVE-2019-9622"
],
"46110": [],
"46111": [],
"46112": [],
"46113": [],
"46114": [],
"46115": [],
"46116": [],
"46117": [],
"46118": [
"CVE-2019-5893"
],
"46119": [],
"46121": [],
"46122": [],
"46132": [],
"46133": [],
"46134": [],
"46136": [],
"46137": [],
"46138": [],
"46139": [],
"46140": [],
"46141": [],
"46144": [],
"46145": [],
"46146": [],
"46147": [],
"46148": [],
"46149": [
"CVE-2019-6249"
],
"46150": [],
"46151": [],
"46152": [],
"46153": [],
"46154": [],
"46163": [
"CVE-2019-5722"
],
"46164": [
"CVE-2018-10093"
],
"46168": [],
"46171": [
"CVE-2018-13374"
],
"46172": [],
"46173": [],
"46174": [
"CVE-2018-5782"
],
"46179": [
"CVE-2019-6275",
"CVE-2019-6274",
"CVE-2019-6273",
"CVE-2019-6272"
],
"46180": [
"CVE-2019-6441"
],
"46182": [
"CVE-2018-9206"
],
"46187": [
"CVE-2019-2413"
],
"46190": [],
"46191": [],
"46192": [],
"46200": [
"CVE-2019-6263"
],
"46206": [
"CVE-2013-6227"
],
"46207": [],
"46209": [],
"46210": [],
"46211": [],
"46212": [],
"46213": [],
"46214": [],
"46217": [],
"46219": [],
"46221": [
"CVE-2018-15710",
"CVE-2018-15708"
],
"46223": [],
"46224": [],
"46225": [],
"46226": [],
"46227": [],
"46228": [],
"46229": [],
"46230": [],
"46231": [],
"46232": [],
"46233": [],
"46234": [],
"46235": [],
"46237": [
"CVE-2018-20503"
],
"46238": [],
"46239": [],
"46240": [
"CVE-2019-6710"
],
"46243": [
"CVE-2019-1652"
],
"46244": [],
"46245": [],
"46247": [
"CVE-2019-6780"
],
"46251": [
"CVE-2019-6804"
],
"46252": [],
"46253": [
"CVE-2019-6967"
],
"46254": [
"CVE-2019-6716"
],
"46259": [],
"46260": [],
"46262": [
"CVE-2019-1653"
],
"46263": [
"CVE-2019-1642"
],
"46266": [],
"46268": [],
"46270": [],
"46271": [],
"46273": [
"CVE-2019-6979"
],
"46274": [],
"46276": [],
"46482": [],
"46282": [],
"46305": [
"CVE-2018-15657"
],
"40053": [],
"46308": [],
"46310": [],
"46311": [],
"46315": [],
"46316": [],
"46317": [],
"46318": [],
"46319": [],
"46320": [],
"46324": [],
"46325": [],
"46326": [
"CVE-2019-7391"
],
"46327": [
"CVE-2018-19276"
],
"46328": [],
"46329": [],
"46330": [],
"46333": [],
"46336": [],
"46438": [],
"46344": [],
"46347": [],
"46348": [],
"46349": [
"CVE-2019-7646"
],
"46350": [],
"46351": [],
"46352": [],
"46353": [
"CVE-2019-6714"
],
"46354": [],
"46483": [],
"46440": [],
"46366": [
"CVE-2019-7541"
],
"46368": [],
"46372": [
"CVE-2018-20009"
],
"46373": [
"CVE-2018-20010"
],
"46374": [
"CVE-2018-20011"
],
"46375": [
"CVE-2018-19914"
],
"46376": [
"CVE-2018-19915"
],
"46377": [
"CVE-2018-20556"
],
"46379": [
"CVE-2018-17996"
],
"46384": [
"CVE-2018-14575"
],
"46386": [
"CVE-2019-8341"
],
"46387": [],
"46389": [],
"46398": [
"CVE-2019-8391"
],
"46399": [
"CVE-2019-8390"
],
"46400": [
"CVE-2019-8387"
],
"46401": [
"CVE-2018-19908"
],
"46402": [],
"46404": [],
"46405": [
"CVE-2019-8404"
],
"46406": [],
"46407": [],
"46408": [],
"46413": [
"CVE-2019-8394"
],
"46414": [
"CVE-2018-20782"
],
"46418": [],
"46419": [],
"46420": [],
"46423": [],
"46424": [
"CVE-2019-8924",
"CVE-2019-8923"
],
"46425": [
"CVE-2019-8929",
"CVE-2019-8928",
"CVE-2019-8927",
"CVE-2019-8926",
"CVE-2019-8925"
],
"46426": [],
"46427": [
"CVE-2019-10030"
],
"46429": [
"CVE-2019-8937"
],
"46446": [
"CVE-2017-17417"
],
"46450": [
"CVE-2019-3475",
"CVE-2019-3474"
],
"46451": [
"CVE-2018-20220",
"CVE-2018-20219",
"CVE-2018-20218"
],
"46452": [
"CVE-2019-6340"
],
"46453": [
"CVE-2019-10030",
"CVE-2018-19990"
],
"46454": [
"CVE-2019-9041"
],
"46455": [],
"46456": [],
"46457": [],
"46459": [
"CVE-2019-6340"
],
"46461": [],
"46462": [],
"46463": [],
"46467": [
"CVE-2019-9184"
],
"46468": [],
"46471": [
"CVE-2019-9623"
],
"46480": [],
"46481": [
"CVE-2019-9194"
],
"46494": [
"CVE-2019-7751"
],
"46495": [
"CVE-2019-9553"
],
"46496": [
"CVE-2019-9554"
],
"46497": [],
"46498": [
"CVE-2019-9556"
],
"46500": [],
"46505": [],
"46511": [
"CVE-2019-8943",
"CVE-2019-8942"
],
"46512": [],
"46517": [],
"46518": [
"CVE-2018-6671",
"CVE-2018-6671"
],
"46520": [
"CVE-2019-9625",
"CVE-2019-9625"
],
"46525": [
"CVE-2019-11444"
],
"46526": [
"CVE-2019-11445"
],
"46527": [
"CVE-2018-9276"
],
"46528": [
"CVE-2018-11686"
],
"46531": [
"CVE-2019-9769"
],
"46537": [
"CVE-2019-9618"
],
"46538": [
"CVE-2019-8953"
],
"46541": [],
"46542": [],
"46545": [
"CVE-2019-9834"
],
"46546": [
"CVE-2019-9692"
],
"46548": [],
"46549": [
"CVE-2014-10079",
"CVE-2014-10078"
],
"46550": [],
"46551": [
"CVE-2018-1133"
],
"46555": [],
"46557": [
"CVE-2019-9647"
],
"46558": [
"CVE-2019-9650"
],
"46559": [],
"46560": [],
"46562": [],
"46563": [],
"46573": [],
"46574": [],
"46575": [],
"46576": [],
"46577": [],
"46579": [],
"46580": [
"CVE-2019-6279"
],
"46581": [
"CVE-2019-6282"
],
"46582": [],
"46583": [],
"46585": [
"CVE-2019-5418"
],
"46586": [],
"46587": [],
"46588": [],
"46590": [],
"46591": [],
"46592": [],
"46593": [],
"46595": [],
"46597": [],
"46598": [],
"46599": [],
"46602": [],
"46603": [],
"46606": [],
"46608": [
"CVE-2019-7400"
],
"46609": [],
"46610": [],
"46611": [
"CVE-2019-10009"
],
"46612": [],
"46614": [],
"46615": [
"CVE-2019-8385"
],
"46616": [],
"46617": [
"CVE-2019-10226"
],
"46618": [],
"46619": [],
"46620": [
"CVE-2019-6965"
],
"46622": [],
"46623": [],
"46624": [],
"46629": [
"CVE-2019-10261"
],
"46630": [],
"46631": [],
"46632": [
"CVE-2019-7441"
],
"46633": [
"CVE-2019-7440"
],
"46634": [
"CVE-2018-17057"
],
"46635": [
"CVE-2019-9053"
],
"46637": [],
"46638": [],
"46640": [],
"46642": [],
"46643": [],
"46644": [],
"46658": [],
"46659": [
"CVE-2019-10008"
],
"46661": [],
"46663": [],
"46664": [
"CVE-2019-10874"
],
"46666": [
"CVE-2019-9593",
"CVE-2019-9592",
"CVE-2019-9591"
],
"46667": [
"CVE-2019-10887"
],
"46669": [
"CVE-2019-10893"
],
"46671": [],
"46672": [],
"46674": [
"CVE-2019-10273"
],
"46681": [],
"46684": [],
"46687": [
"CVE-2019-11017"
],
"46691": [
"CVE-2019-11446"
],
"46694": [
"CVE-2019-11193"
],
"46706": [
"CVE-2019-9955"
],
"46710": [
"CVE-2019-10945"
],
"46728": [
"CVE-2019-2588"
],
"46729": [
"CVE-2019-2616"
],
"46734": [],
"46738": [
"CVE-2019-11374"
],
"46739": [
"CVE-2019-11375"
],
"46741": [
"CVE-2019-11398"
],
"46751": [
"CVE-2019-7438"
],
"46753": [
"CVE-2019-11537"
],
"46759": [
"CVE-2019-0186",
"CVE-2019-0186"
],
"46764": [],
"46765": [
"CVE-2019-11569"
],
"46766": [],
"46767": [],
"46768": [
"CVE-2019-11415"
],
"46769": [],
"46770": [
"CVE-2019-11416"
],
"46771": [
"CVE-2019-11564"
],
"46772": [
"CVE-2019-3799"
],
"46773": [
"CVE-2019-10678",
"CVE-2019-10664"
],
"46774": [],
"46776": [],
"46784": [
"CVE-2019-11429"
],
"46777": [],
"46780": [
"CVE-2019-2725"
],
"46785": [
"CVE-2019-5420"
],
"46793": [
"CVE-2019-9017"
],
"46790": [],
"46792": [],
"46786": [
"CVE-2019-3929"
],
"46787": [],
"46788": [
"CVE-2019-11504"
],
"46794": [
"CVE-2019-9978"
],
"46803": [
"CVE-2019-7286"
],
"46806": [],
"46810": [],
"46816": [],
"46817": [],
"46819": [],
"46818": [],
"46821": [],
"46822": [],
"46823": [],
"46824": [],
"46830": [],
"46831": [],
"46860": [],
"46861": [],
"46862": [],
"46837": [],
"46842": [],
"46843": [],
"46844": [],
"46845": [],
"46848": [],
"46853": [
"CVE-2019-11419"
],
"46855": [],
"46856": [],
"46857": [],
"46858": [],
"46859": [
"CVE-2018-10608"
],
"46865": [
"CVE-2014-9415"
],
"46867": [
"CVE-2014-9417"
],
"46868": [
"CVE-2014-9418"
],
"46871": [],
"46872": [],
"46873": [],
"46874": [],
"46875": [],
"46876": [],
"46883": [],
"46884": [],
"46888": [
"CVE-2019-8622"
],
"46889": [
"CVE-2019-8623"
],
"46890": [
"CVE-2019-8611"
],
"46891": [
"CVE-2019-8591"
],
"46892": [
"CVE-2019-8605"
],
"46893": [],
"46899": [],
"46900": [],
"46901": [],
"46902": [],
"46908": [],
"46909": [],
"46911": [],
"46913": [
"CVE-2019-8613"
],
"46923": [],
"46924": [],
"46925": [],
"46926": [],
"46927": [],
"46929": [],
"46930": [],
"46937": [],
"46939": [
"CVE-2019-9792"
],
"46940": [
"CVE-2019-9816"
],
"46941": [
"CVE-2019-10529"
],
"46946": [
"CVE-2019-0708"
],
"46802": [],
"46805": [],
"46807": [],
"46863": [],
"46851": [
"CVE-2019-5526"
],
"46854": [],
"46866": [
"CVE-2014-9416"
],
"46877": [],
"46878": [],
"46879": [],
"46916": [],
"46917": [
"CVE-2019-0863"
],
"46912": [
"CVE-2019-0881"
],
"46914": [
"CVE-2019-8565"
],
"46918": [],
"46919": [],
"46920": [
"CVE-2019-0803"
],
"46922": [],
"46933": [],
"46938": [
"CVE-2019-0841"
],
"46945": [
"CVE-2014-4113"
],
"46795": [
"CVE-2018-17173"
],
"46797": [],
"46808": [
"CVE-2017-1274"
],
"46812": [
"CVE-2019-5786"
],
"46813": [
"CVE-2019-9193"
],
"46814": [
"CVE-2019-2725"
],
"46839": [
"CVE-2019-12099"
],
"46880": [
"CVE-2019-11231"
],
"46915": [
"CVE-2017-18357"
],
"46928": [
"CVE-2019-0752"
],
"46932": [
"CVE-2019-12137"
],
"46934": [
"CVE-2019-12372"
],
"46942": [],
"46796": [
"CVE-2018-20580"
],
"46798": [],
"46799": [],
"46804": [
"CVE-2019-10685"
],
"46811": [],
"46815": [
"CVE-2018-20485",
"CVE-2018-20484"
],
"46820": [
"CVE-2019-7652"
],
"46825": [],
"46826": [],
"46827": [],
"46828": [
"CVE-2019-7442"
],
"46832": [],
"46833": [],
"46834": [],
"46835": [],
"46838": [
"CVE-2019-11600"
],
"46840": [],
"46841": [],
"46846": [
"CVE-2018-7841"
],
"46847": [],
"46849": [],
"46850": [],
"46852": [],
"46864": [
"CVE-2018-19550"
],
"46869": [
"CVE-2019-12185"
],
"46881": [],
"46882": [
"CVE-2019-12195"
],
"46885": [],
"46886": [
"CVE-2019-9881",
"CVE-2019-9880",
"CVE-2019-9879"
],
"46887": [
"CVE-2018-6443"
],
"46894": [
"CVE-2019-12252"
],
"46895": [
"CVE-2019-12189"
],
"46896": [
"CVE-2019-11368"
],
"46897": [
"CVE-2019-11370"
],
"46898": [
"CVE-2019-11369"
],
"46903": [],
"46910": [
"CVE-2019-12279"
],
"46921": [],
"46931": [
"CVE-2019-12314"
],
"46935": [],
"46936": [
"CVE-2019-12347"
],
"46968": [],
"46980": [
"CVE-2019-12788"
],
"46962": [],
"46972": [
"CVE-cve\u00e2\u0080\u00912019"
],
"46973": [
"CVE-2019-12735"
],
"46976": [
"CVE-2019-0841"
],
"46978": [],
"46960": [
"CVE-2018-19864"
],
"46961": [
"CVE-2019-1663"
],
"46969": [
"CVE-2019-8352",
"CVE-2019-4279"
],
"46970": [
"CVE-2018-20434"
],
"46974": [
"CVE-2019-10149"
],
"46984": [],
"46956": [
"CVE-2018-5406",
"CVE-2018-5405",
"CVE-2018-5404"
],
"46957": [],
"46958": [
"CVE-2019-10866"
],
"46959": [
"CVE-2019-12593"
],
"46963": [
"CVE-2019-12538"
],
"46964": [
"CVE-2019-12541"
],
"46965": [
"CVE-2019-12542"
],
"46966": [
"CVE-2019-12543"
],
"46967": [
"CVE-2019-9621"
],
"46971": [
"CVE-2019-12477"
],
"46977": [
"CVE-2019-11398"
],
"46981": [],
"46982": [
"CVE-2019-12616"
],
"46983": [
"CVE-2019-6588"
],
"46985": [],
"46995": [
"CVE-2019-12323"
],
"46997": [],
"47001": [
"CVE-2019-11706"
],
"47002": [
"CVE-2019-11704"
],
"47003": [
"CVE-2019-11703"
],
"47004": [
"CVE-2019-11705"
],
"47015": [],
"47026": [],
"47028": [
"CVE-2019-0959"
],
"47029": [
"CVE-2019-0943"
],
"47038": [
"CVE-2019-11707"
],
"47079": [],
"47084": [],
"47085": [],
"47086": [
"CVE-2019-1117"
],
"47087": [
"CVE-2019-1118"
],
"47088": [
"CVE-2019-1127"
],
"47089": [],
"47090": [],
"47091": [],
"47092": [
"CVE-2019-1119"
],
"47093": [],
"47094": [
"CVE-2019-1120"
],
"47095": [
"CVE-2019-1128"
],
"47096": [],
"47097": [
"CVE-2019-1121"
],
"47098": [
"CVE-2019-1122"
],
"47099": [
"CVE-2019-1123"
],
"47100": [],
"47101": [],
"47102": [],
"47103": [
"CVE-2019-1124"
],
"47113": [],
"47119": [
"CVE-2019-2107"
],
"47120": [
"CVE-2019-0708"
],
"47127": [],
"47131": [],
"47148": [
"CVE-2019-12480"
],
"47158": [
"CVE-2019-8624"
],
"47162": [
"CVE-2019-8649"
],
"47178": [
"CVE-2019-14267"
],
"47189": [
"CVE-2019-8662"
],
"47190": [
"CVE-2019-8671"
],
"47191": [
"CVE-2019-8672"
],
"47192": [
"CVE-2019-8647"
],
"47193": [
"CVE-2019-8660"
],
"47194": [
"CVE-2019-8646"
],
"47207": [
"CVE-2019-8661"
],
"47147": [],
"46988": [
"CVE-2018-19113"
],
"46989": [],
"46991": [],
"46996": [
"CVE-2019-10149"
],
"46998": [],
"47009": [
"CVE-2019-12181"
],
"47012": [],
"47017": [],
"47070": [
"CVE-2019-8513"
],
"47072": [
"CVE-2019-12181"
],
"47105": [
"CVE-2019-13494"
],
"47115": [
"CVE-2019-1019"
],
"47116": [],
"47122": [],
"47126": [
"CVE-2018-12897"
],
"47128": [
"CVE-2019-0841"
],
"47133": [
"CVE-2019-13272"
],
"47134": [
"CVE-2018-8453"
],
"47135": [
"CVE-2019-1089"
],
"47149": [],
"47163": [
"CVE-2019-13272"
],
"47164": [
"CVE-2018-18955"
],
"47165": [
"CVE-2018-18955"
],
"47166": [
"CVE-2018-18955"
],
"47167": [
"CVE-2018-18955"
],
"47168": [
"CVE-2017-7308"
],
"47169": [
"CVE-2017-10001"
],
"47170": [
"CVE-2016-8655"
],
"47171": [
"CVE-2017-4915"
],
"47172": [
"CVE-2017-5899"
],
"47175": [],
"47173": [
"CVE-2019-12181"
],
"47174": [],
"47176": [
"CVE-2019-1132"
],
"46999": [
"CVE-2019-13294"
],
"47016": [
"CVE-2019-1821"
],
"47019": [
"CVE-2019-12828"
],
"47030": [],
"47031": [],
"47039": [
"CVE-2018-15710",
"CVE-2018-15708"
],
"47047": [],
"47067": [],
"47073": [
"CVE-2019-0232"
],
"47076": [
"CVE-2007-0213"
],
"47080": [
"CVE-2002-0082"
],
"47114": [
"CVE-2016-2056"
],
"47129": [
"CVE-2018-15133",
"CVE-2017-16894"
],
"47130": [
"CVE-2019-13577"
],
"47137": [
"CVE-2019-13577"
],
"47155": [],
"47186": [
"CVE-2019-6814"
],
"47187": [],
"47195": [],
"47208": [
"CVE-2018-1335"
],
"47209": [],
"47077": [],
"46987": [
"CVE-2019-11080"
],
"46992": [],
"46993": [],
"47000": [
"CVE-2019-3778",
"CVE-2019-11269"
],
"47005": [
"CVE-2018-20470"
],
"47006": [
"CVE-2018-20469"
],
"47007": [
"CVE-2018-20472"
],
"47010": [],
"47011": [],
"47013": [
"CVE-2019-13292"
],
"47014": [],
"47021": [
"CVE-2019-11354"
],
"47023": [
"CVE-2019-12745"
],
"47024": [
"CVE-2019-12801"
],
"47022": [
"CVE-2019-12744"
],
"47027": [
"CVE-2019-12276"
],
"47033": [],
"47034": [],
"47035": [],
"47036": [],
"47037": [],
"47044": [
"CVE-2018-20434"
],
"47045": [],
"47046": [],
"47058": [],
"47059": [],
"47060": [],
"47061": [
"CVE-2019-0285"
],
"47062": [
"CVE-2019-13063"
],
"47063": [],
"47064": [],
"47065": [],
"47066": [],
"47069": [
"CVE-2019-13024"
],
"47071": [
"CVE-2019-9701"
],
"47075": [],
"47078": [
"CVE-2019-13344"
],
"47106": [
"CVE-2019-13493"
],
"47107": [
"CVE-2019-13491"
],
"47109": [
"CVE-2019-13346"
],
"47110": [
"CVE-2019-13597"
],
"47111": [
"CVE-2019-10349"
],
"47112": [
"CVE-2019-12991",
"CVE-2019-12989"
],
"47117": [],
"47118": [
"CVE-2019-1943"
],
"47121": [
"CVE-2019-13396"
],
"47123": [
"CVE-2019-13605",
"CVE-2019-13360"
],
"47124": [
"CVE-2019-13359"
],
"47125": [
"CVE-2019-13383"
],
"47132": [],
"47136": [],
"47138": [
"CVE-2018-16763"
],
"47139": [],
"47140": [],
"47141": [],
"47142": [],
"47143": [],
"47144": [],
"47145": [],
"47146": [
"CVE-2019-13029"
],
"47150": [],
"47152": [],
"47153": [],
"47154": [],
"47159": [
"CVE-2019-13977"
],
"47160": [],
"47177": [
"CVE-2018-1042"
],
"47179": [
"CVE-2019-10267"
],
"47180": [
"CVE-2019-10267"
],
"47181": [
"CVE-2019-10266"
],
"47182": [
"CVE-2019-14328"
],
"47184": [],
"47185": [],
"47188": [
"CVE-2019-3948"
],
"47196": [
"CVE-2019-2861"
],
"47198": [],
"47199": [],
"47203": [],
"47204": [],
"47205": [],
"47206": [
"CVE-2019-14221"
],
"47211": [],
"47215": [],
"47210": [
"CVE-2019-14348"
],
"47212": [
"CVE-2019-14696"
],
"47213": [],
"47214": [
"CVE-2019-14312"
],
"47216": [],
"47217": [
"CVE-2019-14346"
],
"47218": [],
"47233": [
"CVE-2019-12255"
],
"47236": [],
"47237": [
"CVE-2019-8690"
],
"47248": [],
"47254": [],
"47257": [
"CVE-2019-8663"
],
"47259": [
"CVE-2019-8016"
],
"47260": [
"CVE-2019-8017"
],
"47261": [
"CVE-2019-1145"
],
"47262": [
"CVE-2019-1148"
],
"47263": [
"CVE-2019-1144"
],
"47264": [
"CVE-2019-1149"
],
"47265": [
"CVE-2019-1150"
],
"47266": [
"CVE-2019-1151"
],
"47267": [
"CVE-2019-1150"
],
"47268": [
"CVE-2019-1152"
],
"47269": [
"CVE-2019-1153"
],
"47270": [
"CVE-2019-8043"
],
"47271": [
"CVE-2019-8024"
],
"47272": [
"CVE-2019-8050"
],
"47273": [
"CVE-2019-8048"
],
"47274": [
"CVE-2019-8049"
],
"47275": [
"CVE-2019-8041"
],
"47276": [
"CVE-2019-8042"
],
"47277": [
"CVE-2019-8046"
],
"47278": [
"CVE-2019-8045"
],
"47279": [
"CVE-2019-8044"
],
"47282": [],
"47285": [],
"47309": [],
"47316": [
"CVE-2019-8689"
],
"47318": [],
"47319": [],
"47322": [
"CVE-2019-10709"
],
"47328": [],
"47197": [
"CVE-2019-13069"
],
"47231": [
"CVE-2019-13623"
],
"47238": [],
"47253": [],
"47258": [],
"47306": [
"CVE-2019-1170"
],
"47307": [
"CVE-2019-10149"
],
"47321": [
"CVE-2019-14339"
],
"47332": [],
"47333": [],
"47334": [],
"47341": [],
"47344": [
"CVE-2011-2921"
],
"47345": [],
"47377": [],
"47378": [],
"47227": [
"CVE-2019-15104"
],
"47228": [
"CVE-2019-15105"
],
"47229": [
"CVE-2019-15106"
],
"47230": [
"CVE-2019-15107"
],
"47243": [],
"47244": [],
"47256": [],
"47298": [
"CVE-2019-9851"
],
"47313": [],
"47320": [
"CVE-2019-14378"
],
"47329": [],
"47337": [],
"47346": [
"CVE-2019-1935"
],
"47347": [
"CVE-2019-1622",
"CVE-2019-1620",
"CVE-2019-1619"
],
"47348": [
"CVE-2019-1663"
],
"47353": [
"CVE-2017-16709"
],
"47354": [
"CVE-2019-11539"
],
"47358": [
"CVE-2019-15029"
],
"47375": [
"CVE-2019-10669"
],
"47376": [
"CVE-2017-10001"
],
"47297": [
"CVE-2019-11510"
],
"47219": [
"CVE-2014-4035"
],
"47220": [
"CVE-2018-0296"
],
"47221": [
"CVE-2019-14804"
],
"47222": [],
"47223": [],
"47224": [
"CVE-2019-14748"
],
"47225": [
"CVE-2019-14749"
],
"47226": [
"CVE-2019-14750"
],
"47232": [],
"47234": [
"CVE-2019-14927"
],
"47235": [
"CVE-2019-14931"
],
"47247": [
"CVE-2019-14974"
],
"47249": [],
"47250": [
"CVE-2019-13101"
],
"47251": [],
"47252": [
"CVE-2019-14422"
],
"47255": [],
"47280": [],
"47281": [],
"47283": [],
"47284": [],
"47286": [],
"47287": [
"CVE-2018-13379"
],
"47288": [
"CVE-2018-13379"
],
"47289": [],
"47293": [
"CVE-2019-15107"
],
"47294": [
"CVE-2019-14430"
],
"47295": [],
"47301": [
"CVE-2019-11013"
],
"47302": [
"CVE-2019-15501"
],
"47303": [
"CVE-2019-15092"
],
"47304": [
"CVE-2019-14470"
],
"47305": [
"CVE-2019-10227"
],
"47308": [
"CVE-2019-15637"
],
"47310": [
"CVE-2019-9083"
],
"47311": [],
"47312": [],
"47314": [],
"47315": [],
"47323": [
"CVE-2019-15813"
],
"47324": [
"CVE-2019-15814"
],
"47325": [
"CVE-2019-15811"
],
"47326": [],
"47327": [
"CVE-2019-10101"
],
"47331": [
"CVE-2019-15081"
],
"47335": [],
"47338": [
"CVE-2019-13235",
"CVE-2019-13234"
],
"47339": [
"CVE-2019-13236"
],
"47340": [
"CVE-2019-13237"
],
"47343": [
"CVE-2019-14280"
],
"47349": [],
"47350": [
"CVE-2019-15889"
],
"47351": [
"CVE-2019-10677"
],
"47356": [],
"47361": [],
"47362": [],
"47363": [
"CVE-2019-16068"
],
"47364": [
"CVE-2019-16072"
],
"47365": [
"CVE-2019-16065"
],
"47366": [],
"47368": [],
"47369": [],
"47370": [],
"47371": [
"CVE-2019-16119"
],
"47372": [
"CVE-2019-16117"
],
"47373": [
"CVE-2019-16118"
],
"47379": [],
"47380": [],
"47381": [
"CVE-2019-1245"
],
"47382": [
"CVE-2019-1244"
],
"47383": [],
"47410": [],
"47414": [],
"47415": [
"CVE-2019-8641"
],
"47418": [],
"47445": [],
"47450": [],
"47451": [],
"47452": [],
"47453": [],
"47478": [],
"47479": [
"CVE-2019-8717"
],
"47484": [
"CVE-2019-1364"
],
"47485": [
"CVE-2019-1343"
],
"47486": [
"CVE-2019-1344"
],
"47487": [
"CVE-2019-1345"
],
"47488": [
"CVE-2019-1346"
],
"47489": [
"CVE-2019-1347"
],
"47494": [],
"47495": [],
"47525": [],
"47528": [
"CVE-2019-8197"
],
"47552": [],
"47563": [],
"47565": [
"CVE-2019-8765"
],
"47578": [],
"47586": [],
"47590": [
"CVE-2019-8820"
],
"47591": [],
"47592": [],
"47607": [],
"47608": [
"CVE-2019-8662",
"CVE-2019-8641"
],
"47609": [
"CVE-2019-8195"
],
"47610": [
"CVE-2019-8196"
],
"47657": [],
"47662": [],
"47665": [],
"47671": [],
"47674": [],
"47677": [],
"47678": [],
"47679": [],
"47692": [
"CVE-2019-15794"
],
"47693": [
"CVE-2019-15793",
"CVE-2019-15792",
"CVE-2019-15791"
],
"47694": [],
"47707": [
"CVE-2019-1429"
],
"47709": [],
"47711": [],
"47716": [],
"47717": [],
"47718": [],
"47719": [],
"47721": [],
"47723": [],
"47727": [],
"47728": [],
"47732": [],
"47757": [],
"47766": [],
"47767": [],
"47768": [
"CVE-2019-1476"
],
"47769": [
"CVE-2019-16451"
],
"47771": [
"CVE-2019-6192"
],
"47786": [],
"47791": [],
"47794": [],
"47797": [],
"47839": [],
"47848": [],
"47853": [],
"47855": [],
"47856": [],
"47857": [],
"47859": [],
"47860": [],
"47861": [],
"47862": [],
"47863": [],
"47864": [],
"47865": [],
"47866": [],
"47867": [],
"47868": [],
"47869": [],
"47870": [],
"47871": [],
"47873": [],
"47878": [],
"47894": [],
"47904": [],
"47906": [],
"47907": [],
"47909": [],
"47911": [],
"47912": [],
"47919": [],
"47920": [],
"47921": [
"CVE-2020-0009"
],
"47937": [],
"47942": [],
"47947": [],
"47952": [],
"47955": [],
"47964": [
"CVE-2020-0610",
"CVE-2020-0609"
],
"47970": [],
"47987": [
"CVE-2020-8416"
],
"47993": [],
"47357": [],
"47389": [
"CVE-2019-1253"
],
"47394": [],
"47400": [],
"47421": [
"CVE-2015-5287"
],
"47429": [],
"47444": [],
"47454": [
"CVE-2019-15943"
],
"47463": [
"CVE-2019-2215"
],
"47466": [],
"47468": [],
"47471": [
"CVE-2019-8452"
],
"47477": [],
"47482": [],
"47490": [],
"47493": [
"CVE-2019-14737"
],
"47502": [
"CVE-2019-14287"
],
"47503": [],
"47504": [],
"47506": [],
"47507": [
"CVE-2019-17624"
],
"47508": [],
"47509": [],
"47510": [],
"47521": [],
"47522": [],
"47523": [],
"47527": [
"CVE-2019-9491"
],
"47529": [
"CVE-2019-3010"
],
"47538": [],
"47543": [
"CVE-2019-13272"
],
"47549": [],
"47551": [],
"47556": [],
"47568": [],
"47570": [],
"47574": [],
"47575": [],
"47577": [],
"47580": [
"CVE-2019-11660"
],
"47582": [],
"47584": [],
"47593": [],
"47594": [],
"47597": [],
"47599": [],
"47601": [
"CVE-2017-13156"
],
"47604": [],
"47605": [],
"47606": [],
"47615": [],
"47617": [],
"47637": [],
"47642": [],
"47645": [],
"47647": [],
"47656": [],
"47658": [],
"47660": [],
"47661": [],
"47664": [],
"47667": [],
"47668": [],
"47675": [],
"47676": [],
"47684": [
"CVE-2019-1405",
"CVE-2019-1322"
],
"47685": [],
"47687": [],
"47695": [],
"47696": [],
"47701": [
"CVE-2018-14665"
],
"47703": [
"CVE-2019-18862"
],
"47705": [],
"47706": [],
"47708": [],
"47710": [],
"47712": [],
"47713": [],
"47714": [
"CVE-2017-4901"
],
"47715": [
"CVE-2017-4905"
],
"47724": [],
"47726": [
"CVE-2019-18276"
],
"47729": [],
"47733": [],
"47734": [],
"47735": [],
"47740": [],
"47743": [],
"47746": [],
"47747": [],
"47751": [
"CVE-2019-15627"
],
"47752": [
"CVE-2019-9810",
"CVE-2019-11708"
],
"47753": [],
"47754": [],
"47755": [],
"47759": [],
"47763": [],
"47775": [],
"47779": [
"CVE-2019-19241"
],
"47780": [
"CVE-2019-19726"
],
"47788": [],
"47802": [],
"47803": [
"CVE-2019-19726"
],
"47804": [],
"47805": [
"CVE-2019-1405",
"CVE-2019-1322"
],
"47810": [],
"47812": [],
"47831": [],
"47818": [],
"47825": [],
"47829": [
"CVE-2019-5596"
],
"47830": [],
"47838": [],
"47845": [],
"47852": [],
"47880": [
"CVE-2019-1184"
],
"47883": [],
"47896": [],
"47897": [
"CVE-2019-18194"
],
"47905": [],
"47908": [],
"47910": [],
"47915": [],
"47916": [],
"47932": [],
"47933": [
"CVE-2020-0601"
],
"47935": [
"CVE-2019-1215"
],
"47938": [],
"47940": [],
"47943": [],
"47944": [
"CVE-2019-15742"
],
"47945": [
"CVE-2019-19031"
],
"47950": [],
"47957": [
"CVE-2019-9213",
"CVE-2018-5333"
],
"47962": [
"CVE-2019-19363"
],
"47965": [],
"47974": [
"CVE-2019-19032"
],
"47975": [
"CVE-2018-8413"
],
"47995": [
"CVE-2019-18634"
],
"47390": [],
"47405": [],
"47408": [
"CVE-2019-5392"
],
"47412": [
"CVE-2019-16724"
],
"47416": [
"CVE-2019-0708"
],
"47439": [
"CVE-2019-16645"
],
"47442": [
"CVE-2019-1914",
"CVE-2019-1913",
"CVE-2019-1912"
],
"47456": [
"CVE-2017-0148",
"CVE-2017-0147",
"CVE-2017-0146",
"CVE-2017-0145",
"CVE-2017-0144",
"CVE-2017-0143"
],
"47472": [],
"47500": [],
"47515": [
"CVE-2019-11932"
],
"47519": [
"CVE-2019-17662"
],
"47531": [
"CVE-2019-15954"
],
"47536": [
"CVE-2019-10969",
"CVE-2019-10963"
],
"47554": [],
"47558": [
"CVE-2015-0008"
],
"47559": [
"CVE-2015-0009"
],
"47566": [
"CVE-2019-3978"
],
"47573": [
"CVE-2019-16278"
],
"47576": [
"CVE-2017-15222"
],
"47602": [
"CVE-2019-16662"
],
"47625": [
"CVE-2019-7265"
],
"47626": [],
"47629": [
"CVE-2019-10849"
],
"47673": [
"CVE-2019-17424"
],
"47683": [
"CVE-2019-0708"
],
"47686": [
"CVE-2019-1821"
],
"47697": [
"CVE-2019-11409"
],
"47698": [],
"47699": [
"CVE-2019-16113"
],
"47700": [
"CVE-2019-11539"
],
"47750": [
"CVE-2019-16702"
],
"47792": [
"CVE-2018-19276"
],
"47799": [],
"47837": [
"CVE-2019-16278"
],
"47885": [
"CVE-2019-15999"
],
"47888": [
"CVE-2017-3623"
],
"47889": [],
"47891": [
"CVE-2019-15039"
],
"47924": [
"CVE-2019-3929"
],
"47936": [],
"47956": [],
"47984": [
"CVE-2020-7247"
],
"47384": [
"CVE-2019-16197"
],
"47385": [
"CVE-2019-12922"
],
"47386": [
"CVE-2019-16173",
"CVE-2019-16172"
],
"47387": [],
"47388": [],
"47392": [
"CVE-2016-10258"
],
"47395": [],
"47398": [],
"47399": [
"CVE-2019-16399"
],
"47401": [],
"47402": [],
"47403": [
"CVE-2019-16531"
],
"47407": [
"CVE-2019-16679"
],
"47417": [
"CVE-2019-1262"
],
"47419": [],
"47420": [
"CVE-2019-5485"
],
"47422": [],
"47423": [],
"47424": [],
"47425": [],
"47426": [
"CVE-2019-16894"
],
"47431": [],
"47427": [],
"47428": [],
"47430": [],
"47432": [],
"47433": [],
"47434": [],
"47435": [],
"47436": [],
"47437": [
"CVE-2019-16759"
],
"47438": [
"CVE-2019-16692"
],
"47440": [],
"47441": [],
"47446": [],
"47447": [
"CVE-2019-16759"
],
"47448": [
"CVE-2019-12562"
],
"47455": [],
"47457": [
"CVE-2019-17080"
],
"47459": [
"CVE-2018-7251"
],
"47460": [],
"47462": [],
"47465": [],
"47467": [],
"47469": [
"CVE-2019-17225"
],
"47470": [
"CVE-2019-4013"
],
"47474": [],
"47475": [
"CVE-2019-17132"
],
"47480": [
"CVE-2019-13529"
],
"47483": [
"CVE-2019-6971"
],
"47491": [],
"47492": [],
"47496": [],
"47497": [],
"47498": [
"CVE-2019-17503",
"CVE-2019-17504"
],
"47501": [
"CVE-2019-1759"
],
"47505": [],
"47612": [
"CVE-2019-7670"
],
"47613": [
"CVE-2018-12650"
],
"47614": [
"CVE-2019-10846"
],
"47611": [
"CVE-2018-12234"
],
"47516": [],
"47517": [],
"47518": [],
"47520": [],
"47524": [],
"47537": [
"CVE-2019-17220"
],
"47539": [],
"47540": [],
"47541": [],
"47542": [],
"47544": [
"CVE-2019-18418"
],
"47545": [],
"47546": [],
"47547": [],
"47548": [],
"47550": [],
"47553": [
"CVE-2019-11043"
],
"47555": [
"CVE-2019-16662"
],
"47557": [],
"47560": [],
"47561": [],
"47562": [],
"47567": [],
"47569": [],
"47571": [],
"47572": [],
"47581": [],
"47583": [],
"47585": [],
"47587": [],
"47588": [],
"47589": [],
"47595": [],
"47596": [],
"47598": [
"CVE-2019-10475"
],
"47600": [
"CVE-2019-14347"
],
"47603": [],
"47616": [
"CVE-2019-7254"
],
"47618": [
"CVE-2019-7254"
],
"47619": [
"CVE-2019-7256"
],
"47620": [
"CVE-2019-7262"
],
"47621": [
"CVE-2019-3398"
],
"47622": [
"CVE-2019-7257"
],
"47623": [
"CVE-2019-7255"
],
"47624": [
"CVE-2019-7269"
],
"47627": [],
"47628": [
"CVE-2019-10847"
],
"47630": [
"CVE-2019-10848"
],
"47631": [],
"47632": [],
"47633": [
"CVE-2019-7671"
],
"47634": [
"CVE-2019-9189"
],
"47635": [
"CVE-2019-3398&"
],
"47636": [
"CVE-2019-7274"
],
"47638": [],
"47639": [
"CVE-2019-7273"
],
"47640": [
"CVE-2019-7272"
],
"47641": [
"CVE-2019-7276"
],
"47643": [
"CVE-2018-12653"
],
"47644": [
"CVE-2019-7666"
],
"47648": [],
"47649": [],
"47650": [
"CVE-2019-18873"
],
"47651": [
"CVE-2019-18396"
],
"47652": [],
"47653": [],
"47654": [],
"47659": [
"CVE-2019-18951"
],
"47663": [
"CVE-2019-16758"
],
"47666": [],
"47669": [],
"47670": [
"CVE-2019\u00e2\u0080\u0093143"
],
"47672": [
"CVE-2019\u00e2\u0080\u0093143"
],
"47688": [
"CVE-2019-10092"
],
"47689": [
"CVE-2019-10098"
],
"47690": [
"CVE-2019-17671"
],
"47691": [],
"47702": [],
"47704": [],
"47720": [],
"47722": [
"CVE-2017-12945"
],
"47725": [],
"47730": [],
"47731": [],
"47737": [],
"47738": [
"CVE-2019-19516"
],
"47739": [
"CVE-2019-5434"
],
"47741": [],
"47749": [
"CVE-2019-19576"
],
"47744": [
"CVE-2019-15276"
],
"47745": [],
"47748": [
"CVE-2018-9022",
"CVE-2018-9021"
],
"47756": [],
"47758": [],
"47760": [],
"47761": [],
"47762": [],
"47764": [],
"47765": [],
"47770": [
"CVE-2019-17554"
],
"47772": [],
"47773": [],
"47774": [],
"47776": [
"CVE-2019-19742"
],
"47777": [
"CVE-2019-19731"
],
"47778": [
"CVE-2019-19743"
],
"47781": [],
"47782": [],
"47783": [],
"47785": [],
"47787": [],
"47789": [
"CVE-2019-19368"
],
"47793": [
"CVE-2019-18935"
],
"47796": [],
"47798": [],
"47800": [],
"47806": [],
"47807": [],
"47808": [],
"47809": [],
"47811": [],
"47813": [],
"47814": [],
"47815": [],
"47816": [],
"47817": [],
"47819": [],
"47820": [],
"47821": [],
"47822": [],
"47823": [],
"47824": [],
"47826": [],
"47827": [],
"47828": [],
"47832": [],
"47834": [],
"47835": [],
"47836": [],
"47840": [
"CVE-2020-5192"
],
"47841": [
"CVE-2020-5191"
],
"47842": [],
"47843": [],
"47844": [],
"47846": [],
"47847": [],
"47850": [],
"47851": [],
"47854": [],
"47858": [],
"47874": [],
"47875": [],
"47876": [],
"47879": [
"CVE-2019-19844"
],
"47881": [],
"47882": [
"CVE-2019-20354"
],
"47884": [],
"47886": [],
"47887": [],
"47892": [],
"47893": [
"CVE-2018-4386"
],
"47895": [
"CVE-2019-2729"
],
"47898": [],
"47899": [
"CVE-2020-6756"
],
"47900": [],
"47901": [
"CVE-2019-19781"
],
"47902": [
"CVE-2019-1978"
],
"47903": [],
"47913": [
"CVE-2019-19781"
],
"47914": [
"CVE-2019-18859"
],
"47917": [],
"47918": [],
"47922": [],
"47923": [],
"47925": [
"CVE-2019-20204"
],
"47926": [],
"47927": [
"CVE-2020-2096"
],
"47928": [],
"47929": [],
"47930": [
"CVE-2019-19781"
],
"47931": [],
"47934": [],
"47939": [],
"47941": [],
"47946": [],
"47948": [
"CVE-2019-16405"
],
"47949": [],
"47954": [
"CVE-2020-7246"
],
"47951": [
"CVE-2018-10653"
],
"47958": [
"CVE-2019-16893"
],
"47959": [],
"47960": [],
"47961": [
"CVE-2020-6170"
],
"47966": [
"CVE-2020-7991"
],
"47967": [
"CVE-2019-19740"
],
"47968": [],
"47969": [],
"47971": [],
"47972": [],
"47973": [
"CVE-2020-8425",
"CVE-2020-8424"
],
"47976": [
"CVE-2020-7980"
],
"47977": [],
"47978": [],
"47979": [],
"47982": [
"CVE-2019-19509"
],
"47985": [],
"47986": [],
"47988": [
"CVE-2020-8512"
],
"47989": [
"CVE-2020-8547"
],
"47990": [
"CVE-2019-8449"
],
"47991": [
"CVE-2018-7777"
],
"47992": [],
"47994": [],
"47996": [],
"48262": [],
"48005": [],
"48006": [],
"48008": [],
"48010": [],
"48011": [],
"48013": [],
"48014": [],
"48015": [],
"48031": [
"CVE-2020-7949"
],
"48034": [],
"48035": [
"CVE-2020-3837"
],
"48100": [],
"48111": [],
"48121": [
"CVE-2020-9283"
],
"48132": [],
"48133": [],
"48136": [],
"48137": [],
"48216": [
"CVE-2020-0796"
],
"48228": [],
"48236": [],
"48237": [],
"48255": [
"CVE-2020-9375"
],
"48259": [],
"48269": [],
"48276": [],
"48284": [],
"48285": [],
"48286": [],
"48287": [],
"48288": [],
"48290": [],
"48291": [],
"48292": [],
"48301": [],
"48302": [],
"48304": [
"CVE-2020-5735"
],
"48305": [],
"48342": [
"CVE-2020-3161"
],
"48402": [],
"48434": [],
"48441": [],
"48493": [],
"48501": [],
"48502": [],
"48503": [],
"48521": [
"CVE-2020-8617"
],
"43200": [],
"44481": [],
"38079": [],
"43197": [],
"47999": [],
"48000": [
"CVE-2014-2630"
],
"48009": [],
"48021": [
"CVE-2018-11479"
],
"48028": [],
"48036": [
"CVE-2019-19363"
],
"48039": [],
"48041": [],
"48043": [],
"48044": [],
"48045": [],
"48046": [],
"48048": [],
"48049": [],
"48050": [],
"48052": [
"CVE-/2019-1863"
],
"48054": [],
"48055": [],
"48056": [],
"48057": [
"CVE-2019-18915"
],
"48060": [],
"48068": [],
"48069": [],
"48070": [],
"48071": [
"CVE-2019-1125",
"CVE-2019-1125)"
],
"48072": [],
"48075": [],
"48078": [],
"48079": [
"CVE-2020-0683"
],
"48080": [],
"48085": [],
"48087": [],
"48129": [
"CVE-2019-2215"
],
"48131": [],
"48148": [],
"48160": [],
"48171": [],
"48172": [],
"48173": [],
"48174": [],
"48180": [
"CVE-2019-1458"
],
"48185": [
"CVE-2020-8794"
],
"48187": [],
"48193": [],
"48206": [],
"48211": [],
"48227": [],
"48231": [],
"48232": [],
"48235": [
"CVE-2020-3950"
],
"48246": [],
"48249": [],
"48251": [],
"48253": [],
"48257": [],
"48264": [],
"48267": [
"CVE-2020-0796"
],
"48277": [],
"48279": [],
"48281": [],
"48283": [],
"48293": [],
"48299": [],
"48306": [],
"48314": [],
"48317": [],
"48329": [],
"48337": [
"CVE-2020-3950"
],
"48339": [],
"48344": [],
"48346": [],
"48350": [],
"48351": [],
"48352": [],
"48359": [
"CVE-2020-2944"
],
"48364": [],
"48378": [],
"48387": [
"CVE-2020-12242"
],
"48388": [
"CVE-2019-15752"
],
"48391": [],
"48396": [],
"48397": [],
"48398": [],
"48400": [
"CVE-2019-3999"
],
"48414": [],
"48415": [],
"48418": [],
"48448": [
"CVE-2020-12608"
],
"48465": [],
"48469": [],
"48461": [],
"48464": [],
"48499": [],
"48505": [
"CVE-2020-5752"
],
"48507": [],
"48510": [],
"48517": [],
"48543": [],
"48563": [],
"48564": [],
"48570": [],
"48573": [
"CVE-2020-13866"
],
"48004": [],
"48037": [
"CVE-2019-20215"
],
"48038": [
"CVE-2020-7247"
],
"48051": [],
"48053": [
"CVE-2019-0604"
],
"48092": [
"CVE-2019-12518"
],
"48130": [
"CVE-2015-7611"
],
"48139": [
"CVE-2020-8793"
],
"48140": [
"CVE-2020-8794"
],
"48153": [
"CVE-2020-0688"
],
"48156": [
"CVE-2020-8012"
],
"48168": [
"CVE-2020-0688"
],
"48169": [
"CVE-2020-8657",
"CVE-2020-8656",
"CVE-2020-8655",
"CVE-2020-8654"
],
"48170": [],
"48181": [
"CVE-2015-1830"
],
"48182": [
"CVE-2019-11043"
],
"48183": [
"CVE-2019-5825"
],
"48184": [
"CVE-2018-17463"
],
"48186": [
"CVE-2020-6418"
],
"48191": [
"CVE-2019-15949"
],
"48192": [],
"48214": [],
"48223": [
"CVE-2020-10220",
"CVE-2019-19509"
],
"48224": [
"CVE-2020-10189"
],
"48233": [
"CVE-2019-15126"
],
"48239": [],
"48268": [
"CVE-2020-8515"
],
"48272": [],
"48273": [
"CVE-2019-4716"
],
"48274": [
"CVE-2019-20499"
],
"48275": [
"CVE-2020-0646"
],
"48331": [
"CVE-2020-10884",
"CVE-2020-10883",
"CVE-2020-10882"
],
"48332": [
"CVE-2020-7961"
],
"48333": [
"CVE-2019-9082",
"CVE-2018-20062"
],
"48334": [],
"48335": [
"CVE-2020-8644"
],
"48336": [
"CVE-2018-18326",
"CVE-2018-18325",
"CVE-2018-15812",
"CVE-2018-15811",
"CVE-2017-9822"
],
"48338": [
"CVE-2019-17558"
],
"48343": [
"CVE-2020-10199"
],
"48353": [
"CVE-2020-5849",
"CVE-2020-5847"
],
"48363": [
"CVE-2020-6857"
],
"48389": [],
"48410": [
"CVE-2016-4437"
],
"48421": [
"CVE-2020-11652",
"CVE-2020-11651"
],
"48483": [
"CVE-2020-7209"
],
"48491": [
"CVE-2020-11108"
],
"48508": [
"CVE-2020-2555"
],
"48513": [
"CVE-2020-13166"
],
"48514": [
"CVE-2017-15889"
],
"48537": [
"CVE-2020-0796"
],
"48540": [
"CVE-2020-3956"
],
"48569": [],
"48177": [],
"48368": [],
"47997": [],
"47998": [],
"48001": [
"CVE-2020-8495",
"CVE-2020-8493"
],
"48002": [
"CVE-2019-10716"
],
"48003": [],
"48007": [],
"48012": [],
"48016": [],
"48017": [],
"48018": [
"CVE-2019-15975"
],
"48019": [
"CVE-2019-15984",
"CVE-2019-15976"
],
"48020": [
"CVE-2019-15978",
"CVE-2019-15977"
],
"48022": [],
"48024": [],
"48025": [
"CVE-2020-8656",
"CVE-2020-8655",
"CVE-2020-8654"
],
"48026": [],
"48027": [],
"48029": [
"CVE-2019-6146"
],
"48030": [
"CVE-2020-7108"
],
"48040": [
"CVE-2020-8839"
],
"48042": [
"CVE-2020-8825"
],
"48047": [],
"48066": [],
"48064": [
"CVE-2020-8947"
],
"48074": [],
"48076": [],
"48077": [],
"48082": [],
"48083": [],
"48086": [],
"48089": [],
"48090": [],
"48094": [],
"48095": [],
"48098": [],
"48099": [],
"48105": [
"CVE-2019-7004"
],
"48106": [],
"48107": [],
"48108": [],
"48109": [],
"48110": [],
"48113": [],
"48114": [],
"48115": [],
"48117": [],
"48118": [],
"48119": [
"CVE-2019-19774"
],
"48122": [],
"48124": [],
"48125": [],
"48127": [],
"48128": [],
"48134": [
"CVE-2020-8819"
],
"48135": [],
"48138": [],
"48141": [],
"48142": [
"CVE-2020-10173"
],
"48143": [
"CVE-2020-1938"
],
"48144": [
"CVE-2020-8813"
],
"48145": [
"CVE-2020-8813"
],
"48146": [
"CVE-2020-7246"
],
"48147": [
"CVE-2020-9038"
],
"48149": [],
"48151": [
"CVE-2020-8615"
],
"48152": [
"CVE-2019-19143"
],
"48154": [],
"48155": [
"CVE-2020-9374"
],
"48158": [
"CVE-2019-19142"
],
"48159": [],
"48161": [],
"48162": [
"CVE-2020-8778",
"CVE-2020-8777",
"CVE-2020-8776"
],
"48163": [],
"48164": [],
"48166": [],
"48176": [],
"48179": [],
"48188": [],
"48189": [],
"48190": [],
"48197": [],
"48202": [],
"48203": [],
"48204": [
"CVE-2020-9372",
"CVE-2020-9371"
],
"48205": [],
"48207": [
"CVE-2020-10221"
],
"48208": [
"CVE-2020-10220"
],
"48209": [
"CVE-2020-8866",
"CVE-2020-8865"
],
"48210": [
"CVE-2020-8866",
"CVE-2020-8865"
],
"48212": [
"CVE-2020-10230"
],
"48215": [
"CVE-2020-8518"
],
"48217": [],
"48218": [],
"48219": [],
"48220": [
"CVE-2020-10387"
],
"48221": [
"CVE-2020-10386"
],
"48225": [],
"48234": [],
"48240": [],
"48241": [
"CVE-2020-10879"
],
"48242": [],
"48244": [
"CVE-2020-12704"
],
"48245": [
"CVE-2020-10385"
],
"48247": [
"CVE-2020-5722"
],
"48248": [],
"48250": [
"CVE-2020-12707"
],
"48256": [],
"48258": [],
"48260": [],
"48261": [],
"48263": [],
"48266": [],
"48270": [
"CVE-2020-5726"
],
"48271": [],
"48280": [],
"48289": [
"CVE-2020-11456"
],
"48294": [],
"48295": [
"CVE-2019-18426"
],
"48296": [],
"48297": [
"CVE-2020-11455"
],
"48300": [
"CVE-2020-11457"
],
"48303": [],
"48308": [],
"48310": [],
"48311": [
"CVE-2019-20085"
],
"48312": [],
"48313": [],
"48315": [],
"48316": [
"CVE-2019-16383"
],
"48318": [],
"48319": [],
"48320": [
"CVE-2020-2555"
],
"48321": [],
"48322": [],
"48323": [],
"48324": [],
"48325": [],
"48326": [],
"48327": [],
"48328": [],
"48340": [],
"48341": [],
"48345": [],
"48348": [],
"48354": [],
"48356": [],
"48357": [],
"48358": [],
"48360": [],
"48361": [],
"48362": [],
"48365": [],
"48366": [],
"48367": [],
"48369": [],
"48370": [],
"48371": [],
"48372": [],
"48373": [],
"48375": [],
"48376": [],
"48377": [],
"48380": [],
"48381": [],
"48382": [],
"48383": [],
"48384": [],
"48385": [],
"48386": [],
"48390": [],
"48392": [],
"48393": [],
"48394": [],
"48395": [],
"48399": [],
"48401": [],
"48403": [],
"48404": [
"CVE-2020-12706"
],
"48405": [],
"48406": [],
"48408": [
"CVE-2019-0235"
],
"48409": [],
"48411": [],
"48413": [],
"48422": [],
"48416": [],
"48417": [],
"48419": [],
"48420": [],
"48423": [],
"48424": [],
"48425": [],
"48426": [],
"48427": [],
"48428": [],
"48429": [],
"48430": [],
"48431": [],
"48432": [],
"48433": [],
"48435": [],
"48436": [],
"48437": [],
"48438": [],
"48439": [],
"48440": [],
"48442": [
"CVE-2020-11108"
],
"48443": [
"CVE-2020-11108"
],
"48444": [],
"48445": [],
"48446": [],
"48447": [],
"48450": [],
"48451": [],
"48452": [],
"48453": [],
"48454": [],
"48456": [],
"48457": [
"CVE-2020-11530"
],
"48458": [],
"48459": [
"CVE-2019-15253"
],
"48460": [],
"48462": [
"CVE-2019-16112"
],
"48466": [],
"48467": [],
"48468": [],
"48470": [],
"48471": [],
"48472": [],
"48473": [
"CVE-2019-15083"
],
"48474": [
"CVE-2020-13118"
],
"48475": [],
"48476": [],
"48477": [
"CVE-2019-3025"
],
"48478": [],
"48479": [],
"48480": [],
"48481": [],
"48482": [],
"48484": [],
"48485": [],
"48486": [],
"48487": [],
"48488": [
"CVE-2020-12882"
],
"48489": [],
"48490": [],
"48492": [],
"48494": [],
"48496": [],
"48497": [],
"48500": [
"CVE-2020-13144"
],
"48504": [],
"48506": [],
"48509": [],
"48511": [],
"48512": [],
"48515": [],
"48516": [
"CVE-2020-12261"
],
"48518": [],
"48519": [
"CVE-2020-11108"
],
"48520": [],
"48522": [],
"48523": [],
"48524": [],
"48525": [],
"48526": [],
"48527": [],
"48528": [],
"48529": [],
"48530": [],
"48531": [],
"48532": [],
"48533": [],
"48534": [
"CVE-2020-13693"
],
"48535": [
"CVE-2020-3952"
],
"48536": [
"CVE-2020-13448"
],
"48538": [],
"48539": [
"CVE-2020-10596"
],
"48541": [],
"48542": [],
"48544": [],
"48545": [],
"48546": [],
"48547": [],
"48548": [],
"48549": [],
"48550": [],
"48551": [
"CVE-2019-17525"
],
"48552": [],
"48553": [],
"48554": [],
"48556": [],
"48557": [],
"48558": [],
"48559": [],
"48560": [],
"48561": [],
"48562": [],
"48567": [],
"48568": [
"CVE-2019-16113"
],
"48571": [],
"48572": [],
"48574": [],
"47393": [
"CVE-2019-16294"
],
"47404": [],
"47406": [],
"47795": [],
"47801": [],
"47849": [],
"47872": [],
"47963": [
"CVE-2020-0610",
"CVE-2020-0609"
],
"48613": [],
"48617": [],
"47081": [
"CVE-2019-5596"
],
"47409": [
"CVE-2019-8605"
],
"47411": [],
"47476": [],
"47526": [],
"47981": [],
"48579": [],
"48591": [],
"48594": [],
"48618": [
"CVE-2020-14011"
],
"47083": [],
"47157": [
"CVE-2019-2107"
],
"48194": [],
"48195": [],
"48196": [
"CVE-2020-14930"
],
"48587": [
"CVE-2020-12712"
],
"47161": [],
"47299": [],
"47330": [],
"47342": [],
"47359": [],
"47391": [],
"47413": [
"CVE-2019-16701"
],
"47443": [
"CVE-2019-16902"
],
"47449": [],
"48023": [],
"48058": [],
"48059": [],
"48061": [],
"48062": [],
"48065": [],
"48088": [],
"48093": [],
"48198": [
"CVE-2019-12765"
],
"48199": [],
"48200": [],
"48213": [],
"48222": [],
"48230": [],
"48238": [],
"48278": [],
"48307": [],
"48347": [],
"48349": [],
"48374": [],
"48580": [],
"48581": [
"CVE-2020-7030"
],
"48582": [
"CVE-2020-13228"
],
"48588": [],
"48590": [
"CVE-2020-5515"
],
"48593": [],
"48595": [],
"48605": [],
"48607": [
"CVE-2019-12905"
],
"48608": [],
"48609": [],
"48610": [],
"48611": [
"CVE-2019-12461"
],
"48612": [
"CVE-2019-12460"
],
"48615": [],
"48616": [],
"48619": [
"CVE-2020-14943"
],
"48860": [],
"48637": [],
"48638": [
"CVE-2020-13379"
],
"49589": [],
"49590": [],
"48697": [],
"48728": [],
"48729": [],
"48731": [
"CVE-2020-15956"
],
"48732": [],
"49083": [],
"49105": [],
"49119": [
"CVE-2012-5958"
],
"49206": [],
"49207": [],
"49283": [
"CVE-2020-35488"
],
"49337": [],
"49489": [],
"49566": [],
"49567": [],
"49568": [],
"49638": [],
"49685": [],
"49697": [],
"49730": [],
"49773": [],
"49789": [],
"49807": [],
"49844": [],
"49883": [],
"49898": [],
"49906": [],
"49917": [],
"48790": [],
"48794": [],
"48795": [],
"48796": [],
"48803": [],
"49062": [
"CVE-2020-0674"
],
"48808": [],
"48810": [],
"48815": [],
"48821": [],
"48836": [
"CVE-2020-17382"
],
"48839": [],
"48840": [],
"48873": [],
"48876": [],
"48953": [],
"48961": [],
"48962": [],
"48963": [
"CVE-2020-15238"
],
"48965": [],
"48966": [],
"48967": [],
"48968": [],
"48982": [
"CVE-2020-14425"
],
"48983": [],
"48993": [
"CVE-2020-13152"
],
"49002": [],
"49003": [],
"49004": [],
"49005": [],
"49006": [],
"49007": [],
"49008": [],
"49009": [],
"49010": [],
"49011": [],
"49012": [],
"49013": [],
"49014": [],
"49015": [],
"49016": [],
"49017": [],
"49018": [],
"49019": [],
"49020": [],
"49021": [],
"49022": [],
"49023": [],
"49041": [],
"49042": [],
"49043": [],
"49047": [],
"49049": [],
"49050": [],
"49053": [],
"49034": [],
"49577": [],
"49586": [],
"49588": [],
"48624": [],
"48625": [],
"48628": [],
"48644": [],
"48677": [],
"48678": [],
"48680": [],
"48685": [],
"48686": [],
"48687": [],
"48688": [],
"48689": [],
"48691": [],
"48695": [],
"48696": [],
"48726": [],
"48735": [],
"48740": [],
"48769": [],
"48776": [],
"48789": [],
"49066": [],
"49084": [],
"49086": [],
"49087": [],
"49088": [],
"49089": [],
"49100": [],
"49101": [],
"49108": [],
"49116": [
"CVE-2018-9958",
"CVE-2018-9958)"
],
"49134": [],
"49141": [],
"49142": [],
"49143": [],
"49144": [],
"49147": [],
"49157": [],
"49158": [],
"49179": [],
"49191": [],
"49195": [
"CVE-2020-6519"
],
"49203": [],
"49205": [],
"49211": [
"CVE-2020-5752"
],
"49214": [],
"49221": [],
"49226": [],
"49248": [],
"49259": [],
"49558": [],
"49322": [],
"49336": [],
"49342": [],
"49350": [],
"49363": [
"CVE-2020-28169"
],
"49370": [],
"49371": [],
"49379": [],
"49382": [
"CVE-2018-16156"
],
"49384": [],
"49409": [],
"49453": [],
"49491": [
"CVE-2020-7384"
],
"49514": [],
"49515": [],
"49516": [],
"49517": [],
"49518": [],
"49521": [
"CVE-2021-3156"
],
"49522": [
"CVE-2021-3156"
],
"49526": [],
"49527": [],
"49530": [
"CVE-2021-3394"
],
"49535": [],
"49541": [],
"49548": [],
"49549": [],
"49563": [],
"49572": [],
"49623": [],
"49624": [],
"49626": [],
"49630": [],
"49631": [],
"49632": [],
"49641": [],
"49645": [],
"49646": [],
"49647": [],
"49648": [],
"49653": [],
"49654": [],
"49655": [],
"49656": [],
"49660": [],
"49661": [],
"49671": [],
"49673": [],
"49678": [],
"49679": [],
"49689": [],
"49690": [],
"49691": [],
"49692": [],
"49694": [],
"49698": [],
"49701": [],
"49702": [],
"49703": [],
"49704": [],
"49706": [],
"49739": [],
"49765": [
"CVE-2021-27928"
],
"49841": [],
"49842": [],
"49845": [],
"49848": [],
"49850": [],
"49851": [],
"49852": [],
"49857": [],
"49858": [],
"49863": [
"CVE-2020-0674"
],
"49864": [
"CVE-2019-17026"
],
"49872": [
"CVE-2013-3893"
],
"49882": [],
"49888": [],
"49889": [],
"49890": [],
"49892": [],
"49893": [
"CVE-2021-21551"
],
"49899": [],
"49900": [],
"49925": [
"CVE-2020-15261"
],
"49210": [],
"48816": [
"CVE-2020-0618"
],
"48842": [],
"48954": [],
"48958": [
"CVE-2020-15688"
],
"48994": [
"CVE-2017-13772"
],
"49057": [],
"49293": [
"CVE-2020-26887"
],
"49584": [],
"49585": [],
"49587": [],
"48620": [
"CVE-2018-11311"
],
"48650": [],
"48651": [],
"48657": [
"CVE-2019-16116"
],
"48661": [
"CVE-2020-7115"
],
"49067": [
"CVE-2020-13151"
],
"49068": [
"CVE-2019-0230"
],
"49071": [
"CVE-2020-1472"
],
"49075": [
"CVE-2020-25988"
],
"49106": [
"CVE-2020-16602"
],
"49127": [],
"49169": [],
"49176": [],
"49216": [
"CVE-2019-7214"
],
"49217": [],
"49218": [],
"49261": [
"CVE-2020-14871"
],
"49418": [],
"49594": [],
"49599": [],
"49601": [],
"49613": [
"CVE-2020-13160"
],
"49621": [],
"49629": [
"CVE-2006-6576"
],
"49663": [
"CVE-2021-26855"
],
"49682": [],
"49695": [],
"49719": [],
"49745": [
"CVE-2020-16040"
],
"49746": [
"CVE-2020-6507"
],
"49754": [
"CVE-2020-12352",
"CVE-2020-12351"
],
"49757": [
"CVE-2011-2523"
],
"49782": [],
"49815": [
"CVE-2016-4971"
],
"49896": [
"CVE-2020-14871"
],
"49908": [
"CVE-2015-3306"
],
"49439": [],
"49440": [],
"49441": [
"CVE-2020-24881"
],
"49443": [],
"49444": [],
"49445": [],
"49447": [],
"49433": [],
"49434": [],
"49435": [],
"49296": [],
"49297": [],
"49298": [],
"49299": [
"CVE-2020-25901"
],
"48791": [],
"48792": [],
"48793": [
"CVE-2020-14008"
],
"48797": [],
"48798": [],
"48799": [],
"48800": [
"CVE-2019-11447"
],
"48801": [
"CVE-2020-6862"
],
"48804": [],
"48805": [],
"48807": [
"CVE-2020-13260"
],
"48809": [
"CVE-2020-13259"
],
"48811": [],
"48812": [
"CVE-2020-25540"
],
"48813": [
"CVE-2020-23835"
],
"48814": [
"CVE-2020-9467"
],
"48817": [
"CVE-2020-11804",
"CVE-2020-11803",
"CVE-2020-11700",
"CVE-2020-11699"
],
"48818": [
"CVE-2019-15715",
"CVE-2017-7615"
],
"48819": [],
"48820": [
"CVE-2020-25453"
],
"48822": [],
"48823": [
"CVE-2020-15921"
],
"48824": [],
"48825": [
"CVE-2018-17431"
],
"48826": [
"CVE-2020-35241"
],
"48827": [],
"48829": [],
"48830": [],
"48831": [],
"48832": [],
"48833": [],
"48834": [],
"48835": [
"CVE-2020-15922"
],
"48837": [
"CVE-2020-15930"
],
"48838": [],
"48843": [],
"48844": [],
"48845": [],
"48846": [],
"48847": [],
"48848": [],
"48849": [],
"48850": [],
"48851": [],
"48852": [],
"48857": [],
"48858": [],
"48861": [],
"48862": [],
"48863": [
"CVE-2020-26567"
],
"48864": [
"CVE-2019-19493"
],
"48865": [],
"48866": [],
"48867": [],
"48868": [],
"48869": [],
"48870": [],
"48871": [
"CVE-2020-3452"
],
"48872": [],
"48874": [],
"48875": [],
"48877": [],
"48878": [],
"48879": [],
"48880": [],
"48881": [],
"48882": [],
"48883": [],
"48884": [],
"48885": [],
"48886": [],
"48887": [],
"48888": [],
"48889": [
"CVE-2020-25762"
],
"48890": [],
"48891": [],
"48892": [],
"48893": [],
"48894": [],
"48895": [],
"48896": [],
"48897": [],
"48898": [],
"48899": [
"CVE-2020-24219"
],
"48900": [
"CVE-2020-24217"
],
"48901": [
"CVE-2020-24217"
],
"48902": [
"CVE-2020-24215"
],
"48903": [
"CVE-2020-24214"
],
"48904": [
"CVE-2019-10030"
],
"48905": [
"CVE-2020-25270"
],
"48906": [
"CVE-2020-25790"
],
"48907": [],
"48908": [],
"48909": [],
"48910": [],
"48911": [],
"48912": [],
"48913": [],
"48914": [],
"48915": [],
"48916": [],
"48917": [],
"48918": [],
"48919": [],
"48920": [],
"48921": [],
"48922": [],
"48923": [],
"48924": [],
"48925": [],
"48926": [],
"48927": [],
"48928": [],
"48929": [],
"48930": [],
"48931": [],
"48932": [],
"48933": [],
"48934": [],
"48935": [],
"48936": [],
"48937": [],
"48938": [],
"48939": [],
"48940": [],
"48941": [],
"48942": [
"CVE-2019-17240"
],
"48943": [],
"48944": [
"CVE-2017-16783"
],
"48945": [],
"48946": [],
"48947": [],
"48948": [],
"48949": [],
"48950": [],
"48951": [],
"48952": [],
"48955": [
"CVE-2019-15813"
],
"48956": [],
"48957": [],
"48959": [
"CVE-2020-5791"
],
"48960": [],
"48964": [
"CVE-2020-14864"
],
"48969": [],
"48970": [],
"48971": [],
"48972": [],
"48973": [],
"48974": [
"CVE-2020-27533"
],
"48975": [],
"48976": [],
"48977": [],
"48978": [],
"48979": [],
"48980": [],
"48981": [],
"48984": [],
"48985": [],
"48986": [],
"48987": [],
"48988": [],
"48989": [],
"48990": [],
"48991": [],
"48992": [],
"48995": [],
"48996": [],
"48997": [],
"48998": [],
"48999": [],
"49000": [
"CVE-2020-25015"
],
"49001": [
"CVE-2020-28328"
],
"49024": [
"CVE-2020-28249"
],
"49025": [],
"49026": [
"CVE-2020-28351"
],
"49027": [
"CVE-2020-15255"
],
"49028": [],
"49029": [],
"49030": [],
"49031": [],
"49032": [],
"49033": [],
"49037": [],
"49038": [],
"49039": [
"CVE-2020-1938"
],
"49040": [
"CVE-2020-26218"
],
"49044": [
"CVE-2020-15478"
],
"49045": [
"CVE-2020-5295"
],
"49046": [],
"49048": [],
"49059": [],
"49052": [],
"49054": [],
"49055": [],
"49056": [],
"49058": [],
"49060": [],
"49061": [],
"49291": [],
"49292": [],
"48201": [],
"49036": [],
"49707": [],
"49582": [
"CVE-2021-27370"
],
"48449": [],
"49574": [],
"49575": [],
"49576": [],
"49578": [],
"49580": [],
"49583": [],
"48642": [
"CVE-2020-5902"
],
"48614": [
"CVE-2018-12031"
],
"48621": [],
"48623": [],
"48626": [
"CVE-2020-15599"
],
"48627": [],
"48629": [],
"48630": [],
"48631": [],
"48633": [],
"48634": [
"CVE-2020-14947"
],
"48635": [],
"48636": [
"CVE-2020-23934"
],
"48639": [
"CVE-2019-3759"
],
"48640": [],
"48643": [
"CVE-ve-2020-59"
],
"48646": [],
"48647": [],
"48648": [],
"48649": [
"CVE-2020-14945"
],
"48652": [
"CVE-2020-15046"
],
"48653": [
"CVE-2020-14944"
],
"48654": [
"CVE-2019-5029"
],
"48853": [],
"48854": [],
"49092": [
"CVE-2020-24363"
],
"48856": [
"CVE-2020-11698"
],
"48655": [],
"48656": [],
"48659": [],
"48658": [],
"48660": [],
"48662": [],
"48663": [],
"48666": [
"CVE-2020-14946"
],
"48667": [
"CVE-2020-8605"
],
"48668": [
"CVE-2020-15046"
],
"48669": [
"CVE-2020-14461"
],
"48670": [],
"48671": [],
"48672": [],
"48673": [],
"48674": [],
"48676": [],
"48679": [
"CVE-2020-15600"
],
"48681": [
"CVE-2020-7680"
],
"48682": [
"CVE-2020-15364",
"CVE-2020-15363"
],
"48683": [],
"48684": [],
"48690": [],
"48692": [
"CVE-2016-9488"
],
"48693": [
"CVE-2020-15492"
],
"48694": [],
"48698": [
"CVE-2019-19985"
],
"48699": [
"CVE-2019-20361"
],
"48700": [],
"48701": [
"CVE-2019-16113"
],
"48702": [],
"48704": [],
"48705": [],
"48706": [],
"48707": [
"CVE-2020-11749"
],
"48708": [
"CVE-2020-15050"
],
"48709": [],
"48711": [
"CVE-2020-5902"
],
"48712": [],
"48713": [],
"48714": [
"CVE-2019-16667"
],
"48715": [],
"48716": [
"CVE-2020-8163"
],
"48720": [],
"48722": [
"CVE-2020-3452"
],
"48723": [
"CVE-2020-3187"
],
"48724": [
"CVE-2020-15038"
],
"48725": [],
"48727": [
"CVE-2020-8816"
],
"48730": [],
"48733": [],
"48734": [],
"48736": [],
"48737": [],
"48738": [],
"48739": [],
"48741": [],
"48742": [],
"48743": [],
"48744": [
"CVE-2020-17506"
],
"48745": [],
"48746": [
"CVE-2019-17240"
],
"48747": [
"CVE-2020-1147"
],
"48748": [],
"48749": [],
"48750": [],
"48751": [],
"48752": [],
"48753": [
"CVE-2020-24609"
],
"48755": [],
"48756": [],
"48757": [],
"48758": [],
"48759": [],
"48761": [
"CVE-2015-7808"
],
"48762": [],
"48763": [],
"48764": [],
"48765": [],
"48766": [],
"48768": [
"CVE-2020-15920"
],
"48770": [],
"48771": [],
"48772": [],
"48773": [],
"48774": [],
"48775": [],
"48777": [
"CVE-2020-24223"
],
"48778": [],
"48779": [],
"48780": [],
"48781": [],
"48783": [],
"48784": [
"CVE-2020-11819"
],
"48785": [
"CVE-2020-24609"
],
"48786": [],
"48787": [],
"48788": [],
"49063": [],
"49064": [],
"49069": [],
"49070": [
"CVE-2020-25820"
],
"49072": [
"CVE-2020-28092"
],
"49074": [
"CVE-2018-13382"
],
"49073": [
"CVE-2020-28091"
],
"49076": [],
"49077": [],
"49078": [],
"49079": [
"CVE-2020-24365"
],
"49080": [],
"49081": [],
"49082": [],
"49085": [
"CVE-2020-29233"
],
"49090": [],
"49091": [
"CVE-2020-7934"
],
"49093": [
"CVE-2020-29475"
],
"49094": [
"CVE-2020-13951"
],
"49096": [
"CVE-2019-12725"
],
"49097": [],
"49098": [
"CVE-2020-29471"
],
"49099": [
"CVE-2020-29470"
],
"49102": [],
"49103": [],
"49104": [],
"49107": [],
"49109": [],
"49110": [],
"49112": [
"CVE-2020-10963"
],
"49113": [
"CVE-2020-16171"
],
"49114": [],
"49115": [],
"49500": [],
"49117": [],
"49121": [],
"49122": [
"CVE-2020-24963"
],
"49124": [],
"49125": [
"CVE-2014-6287"
],
"49126": [],
"49128": [],
"49129": [
"CVE-2020-23972"
],
"49130": [
"CVE-2020-29395"
],
"49131": [],
"49132": [],
"49133": [],
"49135": [],
"49136": [],
"49137": [
"CVE-2020-29240"
],
"49138": [],
"49139": [],
"49183": [],
"49140": [],
"49145": [],
"49146": [],
"49148": [],
"49149": [],
"49150": [],
"49151": [],
"49152": [],
"49153": [],
"49154": [
"CVE-2020-35313"
],
"49155": [
"CVE-2020-35314"
],
"49156": [
"CVE-2020-14073"
],
"49159": [],
"49160": [],
"49161": [],
"49162": [],
"49163": [],
"49164": [
"CVE-2020-29469"
],
"49165": [],
"49166": [
"CVE-2020-28688"
],
"49167": [
"CVE-2020-28687"
],
"49168": [],
"49170": [],
"49171": [],
"49172": [],
"49173": [
"CVE-2020-27423"
],
"49174": [
"CVE-2020-27422"
],
"49175": [],
"49177": [],
"49178": [
"CVE-2020-25213"
],
"49180": [],
"49181": [],
"49182": [],
"49184": [],
"49186": [],
"49187": [],
"49188": [
"CVE-2020-29477"
],
"49189": [
"CVE-2020-28976",
"CVE-2020-28977",
"CVE-2020-28978"
],
"49190": [],
"49192": [],
"49193": [],
"49194": [],
"49196": [],
"49197": [],
"49198": [],
"49199": [],
"49202": [],
"49204": [],
"49208": [],
"49209": [],
"49212": [],
"49215": [],
"49219": [],
"49220": [],
"49222": [],
"49223": [],
"49224": [],
"49227": [],
"49228": [],
"49229": [],
"49230": [],
"49231": [],
"49232": [
"CVE-2020-2229"
],
"49233": [],
"49234": [],
"49235": [],
"49236": [],
"49237": [
"CVE-2020-2230"
],
"49238": [
"CVE-2020-11819"
],
"49239": [],
"49240": [],
"49241": [],
"49242": [],
"49243": [],
"49244": [
"CVE-2020-2231"
],
"49245": [],
"49246": [],
"49247": [],
"49249": [],
"49250": [],
"49251": [],
"49252": [],
"49253": [],
"49254": [],
"49255": [],
"49256": [],
"49257": [
"CVE-2018-19585",
"CVE-2018-19571"
],
"49258": [],
"49260": [],
"49262": [
"CVE-2020-3452"
],
"49559": [],
"49560": [],
"49561": [
"CVE-2020-8639"
],
"49264": [],
"49265": [],
"49266": [],
"49267": [],
"49268": [],
"49269": [],
"49270": [],
"49271": [],
"49272": [],
"49273": [],
"49274": [],
"49275": [],
"49276": [],
"49277": [],
"49278": [],
"49279": [],
"49280": [],
"49281": [
"CVE-2020-35416"
],
"49282": [],
"49284": [],
"49285": [],
"49286": [],
"49287": [],
"49288": [],
"49290": [],
"49300": [
"CVE-2020-25495"
],
"49301": [
"CVE-2020-25494"
],
"49302": [
"CVE-2020-20140"
],
"49303": [
"CVE-2020-20141"
],
"49304": [
"CVE-2020-20142"
],
"49305": [
"CVE-2020-20139"
],
"49306": [],
"49307": [
"CVE-2020-35151"
],
"49308": [],
"49309": [],
"49310": [],
"49726": [
"CVE-2020-23839"
],
"49312": [],
"49314": [],
"49315": [],
"49335": [],
"49316": [],
"49317": [
"CVE-2019-6715&"
],
"49318": [
"CVE-2020-35606"
],
"49319": [],
"49320": [],
"49321": [],
"49323": [],
"49324": [],
"49325": [],
"49326": [],
"49327": [],
"49329": [],
"49330": [
"CVE-2020-35665"
],
"49331": [],
"49332": [],
"49333": [],
"49334": [
"CVE-2018-19585",
"CVE-2018-19571"
],
"49338": [
"CVE-2019-16223"
],
"49339": [],
"49340": [
"CVE-2020-28413"
],
"49343": [
"CVE-2020-35598"
],
"49344": [],
"49345": [],
"49346": [
"CVE-2020-35437"
],
"49347": [],
"49348": [],
"49351": [
"CVE-2020-29597"
],
"49352": [],
"49353": [],
"49354": [],
"49355": [],
"49356": [],
"49357": [],
"49358": [],
"49359": [],
"49360": [],
"49361": [],
"49362": [],
"49364": [],
"49365": [],
"49366": [
"CVE-2020-35729"
],
"49367": [],
"49369": [],
"49372": [
"CVE-2021-3018"
],
"49373": [],
"49374": [],
"49375": [],
"49376": [],
"49377": [],
"49378": [
"CVE-2020-35737"
],
"49380": [],
"49381": [],
"49383": [
"CVE-2019-11229"
],
"49385": [
"CVE-2020-10199"
],
"49386": [],
"49388": [],
"49389": [],
"49390": [],
"49391": [],
"49392": [],
"49393": [],
"49395": [],
"49396": [],
"49397": [],
"49398": [
"CVE-2020-17519"
],
"49399": [],
"49401": [],
"49402": [],
"49403": [],
"49404": [],
"49405": [],
"49406": [],
"49407": [],
"49410": [],
"49412": [],
"49413": [],
"49415": [],
"49420": [],
"49421": [],
"49422": [
"CVE-2020-35578"
],
"49423": [],
"49424": [
"CVE-2021-3129"
],
"49425": [
"CVE-2021-1167"
],
"49426": [
"CVE-2020-35687"
],
"49427": [],
"49428": [],
"49429": [],
"49430": [],
"49431": [],
"49432": [],
"49436": [],
"49437": [],
"49438": [],
"49448": [],
"49449": [],
"49450": [
"CVE-2020-35749"
],
"49451": [
"CVE-2020-23342"
],
"49452": [],
"49454": [],
"49455": [],
"49456": [],
"49457": [],
"49458": [],
"49459": [],
"49460": [],
"49461": [
"CVE-2021-2109"
],
"49462": [],
"49463": [],
"49464": [],
"49465": [
"CVE-2019-3396"
],
"49467": [],
"49468": [
"CVE-2021-3298"
],
"49469": [
"CVE-2021-3294"
],
"49470": [],
"49471": [],
"49474": [
"CVE-2020-35729"
],
"49475": [],
"49476": [],
"49477": [],
"49478": [
"CVE-2021-3186"
],
"49479": [
"CVE-2020-14882"
],
"49483": [],
"49481": [],
"49482": [],
"49484": [],
"49485": [
"CVE-2020-25557",
"CVE-2020-25538"
],
"49486": [],
"49487": [
"CVE-2018-16763"
],
"49488": [],
"49490": [],
"49492": [],
"49493": [],
"49494": [
"CVE-2020-35754"
],
"49495": [],
"49496": [
"CVE-2021-3337"
],
"49497": [],
"49498": [],
"49499": [],
"49501": [],
"49502": [],
"49503": [],
"49504": [],
"49505": [],
"49507": [],
"49508": [],
"49509": [],
"49510": [],
"49511": [
"CVE-2021-3317"
],
"49512": [
"CVE-2019-89242"
],
"49513": [],
"49519": [
"CVE-2020-23522"
],
"49520": [],
"49523": [],
"49524": [],
"49525": [],
"49528": [],
"49529": [
"CVE-2021\u00e2\u0080\u0093267"
],
"49531": [],
"49532": [],
"49533": [],
"49534": [],
"49536": [
"CVE-2020-18724"
],
"49537": [
"CVE-2020-18723"
],
"49571": [],
"49539": [],
"49540": [],
"49542": [],
"49543": [],
"49544": [],
"49545": [],
"49546": [],
"49550": [],
"49551": [
"CVE-2020-22841"
],
"49552": [
"CVE-2017-5941"
],
"49553": [],
"49554": [],
"49555": [],
"49556": [],
"49557": [],
"49562": [],
"49564": [],
"49565": [],
"49569": [],
"49570": [],
"49573": [],
"49593": [],
"49595": [],
"49596": [],
"49597": [],
"49598": [
"CVE-2021-3355"
],
"49600": [
"CVE-2021-3378"
],
"49602": [
"CVE-2021-21972"
],
"49603": [],
"49604": [],
"49605": [],
"49606": [
"CVE-2020-25787"
],
"49607": [],
"49608": [
"CVE-2021-3291"
],
"49609": [],
"49610": [],
"49614": [
"CVE-2021-27885"
],
"49615": [],
"49616": [],
"49617": [],
"49618": [],
"49619": [],
"49620": [],
"49622": [],
"49625": [],
"49627": [
"CVE-2018-17254"
],
"49628": [],
"49633": [
"CVE-2020-14181"
],
"49634": [],
"49635": [],
"49637": [
"CVE-2021-27065",
"CVE-2021-26855"
],
"49639": [],
"49640": [],
"49642": [
"CVE-2021-26830"
],
"49643": [],
"49644": [],
"49649": [
"CVE-2021-27695"
],
"49650": [],
"49651": [
"CVE-2021-27964"
],
"49652": [],
"49657": [],
"49659": [
"CVE-2021-28379"
],
"49662": [],
"49666": [],
"49667": [],
"49668": [],
"49669": [
"CVE-2019-12962"
],
"49670": [],
"49672": [],
"49674": [],
"49676": [],
"49677": [],
"49680": [],
"49681": [],
"49683": [],
"49684": [],
"49686": [],
"49687": [],
"49688": [],
"49693": [
"CVE-2017-10001"
],
"49696": [
"CVE-2021-27890",
"CVE-2021-27889"
],
"49699": [
"CVE-2021-27946"
],
"49700": [],
"49705": [
"CVE-2018-14009"
],
"49708": [
"CVE-2012-6708"
],
"49709": [],
"49711": [
"CVE-2020-14209"
],
"49712": [],
"49713": [],
"49714": [],
"49665": [],
"49718": [],
"49720": [],
"49721": [
"CVE-2021-3111"
],
"49722": [],
"49723": [],
"49724": [],
"49725": [
"CVE-2017-15950"
],
"49727": [],
"49729": [],
"49731": [],
"49733": [],
"49734": [],
"49736": [],
"49735": [],
"49737": [],
"49738": [
"CVE-2021-22986"
],
"49740": [],
"49741": [],
"49742": [],
"49743": [],
"49744": [],
"49747": [],
"49748": [
"CVE-2020-14166"
],
"49749": [
"CVE-2021-30150"
],
"49750": [
"CVE-2020-5377"
],
"49751": [],
"49752": [
"CVE-2021-30147"
],
"49753": [
"CVE-2021-30149"
],
"49755": [
"CVE-2020-15160"
],
"49758": [],
"49759": [],
"49760": [
"CVE-2020-29238"
],
"49761": [],
"49762": [
"CVE-2020-35775"
],
"49763": [
"CVE-2021-28142"
],
"49764": [
"CVE-2021-29003"
],
"49766": [
"CVE-2020-11022"
],
"49767": [
"CVE-2020-11023"
],
"49769": [
"CVE-2021-26929"
],
"49771": [
"CVE-2020-15500"
],
"49772": [
"CVE-2021-30637"
],
"49774": [],
"49775": [
"CVE-2021-31152"
],
"49802": [],
"49777": [],
"49778": [],
"49779": [],
"49780": [
"CVE-2021-3138"
],
"49781": [
"CVE-2021-30044"
],
"49795": [
"CVE-2021-31327",
"CVE-2021-30042",
"CVE-2021-30039",
"CVE-2021-30034",
"CVE-2021-30030",
"CVE-2021-31329"
],
"49783": [],
"49784": [],
"49785": [
"CVE-2021-25679"
],
"49786": [
"CVE-2021-25680"
],
"49787": [
"CVE-2021-25681"
],
"49788": [
"CVE-2021-21425"
],
"49790": [],
"49791": [],
"49793": [
"CVE-2021-28935"
],
"49794": [],
"49797": [],
"49798": [],
"49799": [
"CVE-2021-3318"
],
"49800": [],
"49801": [],
"49803": [],
"49804": [
"CVE-2021-28419"
],
"49805": [],
"49806": [],
"49808": [
"CVE-2021-29460"
],
"49810": [
"CVE-2020-14295"
],
"49811": [],
"49813": [],
"49814": [
"CVE-2019-3810"
],
"49816": [],
"49817": [],
"49818": [
"CVE-2021-27973"
],
"49821": [],
"49822": [],
"49823": [],
"49825": [],
"49826": [],
"49827": [],
"49828": [],
"49829": [],
"49830": [],
"49831": [],
"49832": [],
"49833": [],
"49834": [],
"49835": [],
"49836": [],
"49837": [],
"49838": [],
"49839": [],
"49840": [
"CVE-2021-28242"
],
"49843": [],
"49846": [],
"49847": [],
"49849": [],
"49853": [],
"49854": [],
"49856": [
"CVE-2020-28337"
],
"49859": [],
"49860": [],
"49861": [],
"49862": [
"CVE-2019-12725"
],
"49865": [],
"49866": [],
"49867": [
"CVE-2021-31933"
],
"49868": [],
"49869": [],
"49870": [],
"49871": [],
"49873": [],
"49874": [],
"49875": [],
"49876": [
"CVE-2018-19422"
],
"49877": [],
"49878": [],
"49879": [
"CVE-2021-26855"
],
"49880": [
"CVE-2021-24245"
],
"49884": [],
"49885": [],
"49886": [],
"49887": [],
"49891": [],
"49895": [
"CVE-2021-26855"
],
"49897": [],
"49901": [
"CVE-2021-33561",
"CVE-2021-33562"
],
"49902": [
"CVE-2019-19208"
],
"49903": [
"CVE-2021-24299"
],
"49904": [],
"49905": [],
"49907": [
"CVE-2018-19423"
],
"49909": [
"CVE-2020-29607"
],
"49910": [
"CVE-2021-33570"
],
"49911": [
"CVE-2020-24949"
],
"49912": [
"CVE-2021-24308"
],
"49913": [
"CVE-2017-14535"
],
"49914": [
"CVE-2017-14537"
],
"49915": [],
"49918": [
"CVE-2018-16167"
],
"49919": [],
"49920": [],
"49921": [],
"49922": [],
"49923": [],
"49924": [],
"50311": [],
"49952": [],
"49953": [],
"49954": [],
"49957": [],
"49964": [],
"49965": [],
"49978": [],
"49979": [],
"50001": [],
"50002": [],
"50003": [],
"50153": [],
"50247": [],
"50266": [],
"50322": [],
"50433": [],
"50434": [],
"50510": [],
"50511": [],
"50516": [],
"50535": [],
"50536": [],
"50613": [],
"50314": [],
"50465": [],
"50466": [],
"49929": [],
"50061": [],
"49959": [
"CVE-2013-4988"
],
"49966": [],
"49977": [],
"49997": [],
"49999": [],
"50004": [],
"50005": [],
"50009": [],
"50010": [],
"50011": [
"CVE-2021-3560"
],
"50012": [],
"50013": [],
"50014": [],
"50023": [],
"50024": [],
"50025": [],
"50026": [],
"50028": [],
"50038": [],
"50040": [],
"50045": [],
"50047": [
"CVE-2021-35448"
],
"50083": [
"CVE-2021-34110"
],
"50130": [],
"50690": [],
"50135": [
"CVE-2021-22555"
],
"50184": [
"CVE-2021-35312"
],
"50188": [
"CVE-2018-20523"
],
"50212": [
"CVE-2020-5147",
"CVE-2020-5147)"
],
"50236": [],
"50258": [],
"50261": [],
"50273": [],
"50283": [],
"50289": [],
"50331": [],
"50332": [],
"50336": [],
"50337": [
"CVE-2020-11107"
],
"50385": [
"CVE-2021-22557"
],
"50401": [],
"50416": [],
"50431": [],
"50443": [],
"50448": [],
"50449": [],
"50470": [],
"50471": [],
"50472": [],
"50484": [],
"50494": [],
"50504": [],
"50517": [],
"50541": [
"CVE-2019-13272"
],
"50545": [],
"50558": [],
"50566": [],
"50574": [],
"50591": [],
"50598": [],
"50633": [],
"50642": [
"CVE-2021-43326"
],
"50650": [],
"50653": [],
"50654": [],
"50664": [],
"50689": [
"CVE-2021-4034"
],
"50691": [
"CVE-2019-11707"
],
"50696": [],
"50708": [],
"50728": [],
"50743": [],
"50745": [],
"50755": [],
"50756": [],
"50757": [],
"50758": [],
"50760": [],
"50761": [],
"50762": [],
"50763": [],
"50764": [],
"50765": [],
"50773": [],
"50776": [],
"50787": [],
"50789": [],
"50790": [],
"50791": [],
"50817": [],
"50804": [],
"50805": [],
"50806": [],
"50807": [],
"50808": [
"CVE-2022-0847"
],
"50810": [],
"50811": [],
"50812": [
"CVE-2022-25090"
],
"50813": [],
"50814": [],
"50815": [],
"50818": [],
"50819": [],
"50824": [],
"50834": [],
"50837": [],
"50852": [
"CVE-2022-23909"
],
"50858": [
"CVE-2021-43149"
],
"50859": [],
"50867": [],
"50868": [],
"50885": [],
"50886": [],
"50901": [],
"50902": [],
"50903": [],
"50911": [
"CVE-2021-22204"
],
"50912": [
"CVE-2021-44595"
],
"49936": [
"CVE-2021-31251"
],
"50034": [],
"50039": [
"CVE-2020-14871"
],
"50070": [
"CVE-2019-6447"
],
"50133": [
"CVE-2021-25155"
],
"50136": [
"CVE-2021-25162",
"CVE-2021-25161",
"CVE-2021-25160",
"CVE-2021-25159",
"CVE-2021-25158",
"CVE-2021-25157",
"CVE-2021-25156",
"CVE-2021-25155"
],
"50145": [],
"50160": [],
"50170": [],
"50216": [
"CVE-2006-1236"
],
"50282": [],
"50335": [],
"50347": [],
"50351": [
"CVE-2021-42165"
],
"50407": [],
"50408": [],
"50539": [],
"50565": [],
"50567": [],
"50568": [],
"50569": [
"CVE-2021-40859"
],
"50576": [
"CVE-2021-38759"
],
"50588": [
"CVE-2021-45043"
],
"50590": [
"CVE-2021-44228"
],
"50592": [
"CVE-2021-44228"
],
"50599": [],
"50618": [
"CVE-2019-16516"
],
"50620": [],
"50629": [],
"50638": [
"CVE-2021-35380"
],
"50639": [],
"50640": [
"CVE-2021-43857"
],
"50652": [
"CVE-2022-22836"
],
"50665": [],
"50688": [
"CVE-2022-21371"
],
"50720": [],
"50742": [],
"50290": [],
"50781": [],
"50783": [
"CVE-2022-25359"
],
"50793": [],
"50796": [],
"50798": [
"CVE-2022-25089"
],
"50821": [
"CVE-2020-17456"
],
"50822": [],
"50829": [
"CVE-2022-24112"
],
"50832": [
"CVE-2022-27226"
],
"50833": [
"CVE-2021-44529"
],
"50835": [],
"50836": [],
"50847": [
"CVE-2019\u00e2\u0080\u0093919"
],
"50848": [
"CVE-2019-17124"
],
"50856": [
"CVE-2021-36356",
"CVE-2021-35064"
],
"50857": [
"CVE-2021-43009"
],
"50861": [
"CVE-2021-46417"
],
"50870": [
"CVE-2021-4039"
],
"50873": [],
"50875": [],
"50878": [],
"50879": [],
"50880": [],
"50905": [],
"50892": [
"CVE-2021-42697"
],
"50894": [],
"50897": [
"CVE-cve 2021-4"
],
"50900": [
"CVE-2022-28213"
],
"50904": [
"CVE-2022-29457"
],
"50906": [
"CVE-2021-46378"
],
"50907": [
"CVE-2021-46379"
],
"50913": [
"CVE-2021-44596"
],
"50932": [
"CVE-2022-1388"
],
"50914": [
"CVE-2022-24706"
],
"50916": [],
"50917": [
"CVE-2019-13720"
],
"50918": [
"CVE-2022-30286"
],
"50919": [
"CVE-2021-46381"
],
"50930": [
"CVE-2021-43164"
],
"50936": [
"CVE-2021-46422"
],
"50940": [
"CVE-2022-29303"
],
"50126": [
"CVE-2021-31762"
],
"50463": [
"CVE-2021-31682"
],
"50461": [],
"50312": [],
"50313": [],
"50219": [],
"50415": [],
"50152": [
"CVE-2021-22146"
],
"50403": [],
"49636": [],
"49675": [],
"50462": [],
"50218": [],
"49894": [],
"49926": [],
"49927": [
"CVE-2020-13927",
"CVE-2020-11978"
],
"49928": [
"CVE-2014-8722"
],
"49930": [
"CVE-2021-21337"
],
"49931": [
"CVE-2021-28417"
],
"49932": [
"CVE-2021-28418"
],
"49933": [],
"49935": [
"CVE-2021-28420"
],
"49937": [
"CVE-2021-31642"
],
"50062": [
"CVE-2019-12744"
],
"49942": [
"CVE-2021-27519"
],
"49943": [
"CVE-2021-27520"
],
"49944": [],
"49945": [
"CVE-2021-27308"
],
"49949": [
"CVE-2018-6383"
],
"49951": [],
"49955": [],
"49958": [],
"49960": [
"CVE-2021-22911"
],
"49961": [
"CVE-2021-29440"
],
"49962": [
"CVE-2020-24186"
],
"49967": [
"CVE-2020-24186"
],
"49969": [
"CVE-2021-32403"
],
"49970": [],
"49971": [],
"49972": [],
"49973": [],
"49974": [],
"49975": [],
"49980": [
"CVE-2021-33904"
],
"49981": [
"CVE-2019-25046"
],
"49982": [
"CVE-2021-31950"
],
"49983": [
"CVE-2017-9380"
],
"49984": [
"CVE-2021-24174"
],
"49985": [],
"49986": [],
"49987": [],
"49988": [],
"49989": [],
"49990": [
"CVE-2021-34370"
],
"49991": [
"CVE-2021-34369"
],
"49992": [
"CVE-2020-11060"
],
"49993": [],
"49994": [],
"49995": [],
"49996": [],
"49998": [
"CVE-2018-15139"
],
"50007": [],
"50008": [],
"50016": [],
"50017": [],
"50018": [],
"50019": [],
"50021": [],
"50022": [],
"50027": [
"CVE-2021-31159"
],
"50029": [],
"50031": [],
"50032": [],
"50036": [],
"50037": [],
"50043": [],
"50044": [],
"50042": [
"CVE-2021-32305"
],
"50046": [],
"50201": [],
"50200": [],
"50049": [],
"50050": [],
"50051": [
"CVE-2021-24383"
],
"50052": [],
"50053": [],
"50054": [],
"50055": [],
"50056": [
"CVE-2021-21972"
],
"50460": [],
"50057": [
"CVE-2009-2265"
],
"50058": [],
"50108": [],
"50107": [],
"50063": [],
"50064": [],
"50066": [],
"50075": [],
"50074": [],
"50068": [
"CVE-2021-26078"
],
"50069": [],
"50071": [],
"50072": [],
"50073": [],
"50076": [],
"50077": [
"CVE-2020-35948"
],
"50078": [],
"50079": [
"CVE-2020-7750"
],
"50080": [
"CVE-2021-35956"
],
"50081": [],
"50082": [
"CVE-2021-24145"
],
"50084": [
"CVE-2021-24146"
],
"50085": [],
"50086": [],
"50087": [],
"50088": [],
"50089": [],
"50090": [],
"50091": [],
"50092": [],
"50093": [
"CVE-2021-24155"
],
"50094": [],
"50095": [],
"50096": [],
"50097": [],
"50098": [
"CVE-2021-42071"
],
"50099": [],
"50100": [],
"50101": [
"CVE-2019-14322"
],
"50102": [],
"50103": [],
"50104": [],
"50105": [],
"50106": [],
"50109": [],
"50110": [
"CVE-2018-15877"
],
"50111": [],
"50112": [],
"50113": [],
"50114": [],
"50115": [],
"50116": [],
"50117": [],
"50118": [
"CVE-2018-11784"
],
"50120": [],
"50119": [
"CVE-2019-0221"
],
"50121": [],
"50122": [
"CVE-2018-15139"
],
"50123": [],
"50127": [],
"50128": [],
"50129": [
"CVE-2021-42362"
],
"50131": [
"CVE-2021-35464"
],
"50132": [],
"50137": [
"CVE-2020-6010"
],
"50138": [],
"50139": [],
"50142": [
"CVE-2021-37593"
],
"50143": [],
"50144": [
"CVE-2021-31761"
],
"50146": [],
"50147": [],
"50148": [],
"50149": [
"CVE-2021-22145"
],
"50150": [],
"50151": [],
"50154": [],
"50155": [],
"50156": [],
"50158": [],
"50159": [],
"50161": [],
"50162": [],
"50163": [],
"50164": [],
"50165": [],
"50166": [
"CVE-2021-29995"
],
"50167": [],
"50169": [],
"50171": [],
"50172": [],
"50173": [],
"50174": [],
"50175": [
"CVE-2020-7246"
],
"50176": [],
"50177": [],
"50178": [
"CVE-2020-9496"
],
"50464": [
"CVE-2021-20837"
],
"50179": [
"CVE-2021-36654"
],
"50180": [],
"50181": [],
"50183": [],
"50185": [
"CVE-2020-35848",
"CVE-2020-35847"
],
"50187": [],
"50189": [],
"50190": [],
"50191": [
"CVE-2021-37425"
],
"50192": [],
"50193": [],
"50194": [],
"50195": [],
"50196": [],
"50197": [],
"50198": [],
"50199": [],
"50204": [],
"50205": [],
"50206": [],
"50207": [],
"50208": [],
"50209": [],
"50210": [],
"50211": [],
"50213": [],
"50214": [],
"50215": [],
"50217": [],
"50220": [],
"50221": [],
"50223": [],
"50224": [],
"50226": [],
"50227": [
"CVE-2021-3441"
],
"50228": [],
"50229": [],
"50230": [],
"50231": [],
"50232": [],
"50233": [],
"50234": [],
"50235": [],
"50237": [
"CVE-2019-18818"
],
"50238": [
"CVE-2019-19609"
],
"50239": [],
"50240": [],
"50241": [
"CVE-2020-5811"
],
"50242": [
"CVE-2021-34621"
],
"50243": [
"CVE-2021-26084"
],
"50244": [],
"50246": [],
"50248": [],
"50249": [],
"50250": [
"CVE-2021-40378"
],
"50251": [
"CVE-2021-40379"
],
"50252": [
"CVE-2021-40380"
],
"50253": [
"CVE-2021-40381"
],
"50256": [],
"50254": [
"CVE-2021-40382"
],
"50255": [],
"50259": [
"CVE-2021-40651"
],
"50260": [
"CVE-2021-40352"
],
"50262": [
"CVE-2021-39608"
],
"50263": [],
"50264": [],
"50441": [
"CVE-2021-36260"
],
"50265": [],
"50267": [],
"50268": [],
"50269": [],
"50270": [],
"50272": [],
"50274": [],
"50275": [],
"50276": [],
"50277": [],
"50278": [],
"50279": [],
"50280": [],
"50284": [],
"50285": [],
"50286": [],
"50287": [],
"50288": [],
"50292": [],
"50298": [],
"50294": [],
"50295": [],
"50296": [],
"50297": [],
"50299": [
"CVE-2021-34646"
],
"50300": [],
"50301": [],
"50302": [],
"50303": [],
"50304": [
"CVE-2021-29447"
],
"50305": [],
"50306": [],
"50307": [],
"50308": [],
"50310": [],
"50315": [],
"50316": [
"CVE-2019-13358"
],
"50317": [
"CVE-2021-40868"
],
"50318": [],
"50319": [],
"50320": [
"CVE-2021-40875"
],
"50321": [],
"50323": [],
"50324": [
"CVE-2021-24169"
],
"50325": [
"CVE-2021-24272"
],
"50326": [],
"50327": [],
"50328": [],
"50329": [],
"50333": [],
"50334": [],
"50338": [],
"50339": [],
"50340": [],
"50341": [],
"50342": [],
"50343": [
"CVE-2021-24610"
],
"50344": [
"CVE-2021-24276"
],
"50345": [
"CVE-2021-24274"
],
"50346": [
"CVE-2021-24275"
],
"50348": [],
"50349": [
"CVE-2021-24287"
],
"50350": [
"CVE-2021-24286"
],
"50352": [],
"50353": [],
"50355": [],
"50356": [],
"50357": [],
"50360": [],
"50361": [],
"50362": [],
"50363": [],
"50364": [],
"50365": [],
"50366": [
"CVE-2021-41318"
],
"50367": [],
"50370": [],
"50371": [
"CVE-2021-41381"
],
"50372": [],
"50373": [],
"50374": [],
"50375": [],
"50376": [],
"50377": [
"CVE-2021-26085"
],
"50378": [],
"50379": [],
"50380": [
"CVE-2021-26086"
],
"50381": [],
"50382": [
"CVE-2021-39327"
],
"50383": [
"CVE-2021-41773"
],
"50386": [],
"50387": [],
"50388": [],
"50389": [],
"50390": [],
"50391": [],
"50392": [],
"50393": [
"CVE-2021-42053"
],
"50394": [
"CVE-2021-32172"
],
"50395": [],
"50396": [],
"50397": [],
"50398": [],
"50399": [],
"50400": [],
"50402": [],
"50404": [],
"50405": [
"CVE-2020-10770"
],
"50406": [
"CVE-2021-42013"
],
"50409": [],
"50410": [],
"50411": [],
"50412": [],
"50413": [],
"50414": [
"CVE-2021-20031"
],
"50418": [
"CVE-2021-41878"
],
"50419": [],
"50420": [
"CVE-2020-11738"
],
"50421": [],
"50422": [
"CVE-2018-16060"
],
"50423": [
"CVE-2018-16061"
],
"50424": [],
"50425": [],
"50426": [
"CVE-2021-41382"
],
"50427": [
"CVE-2021-24719"
],
"50428": [
"CVE-2021-42566",
"CVE-2021-42565"
],
"50429": [],
"50430": [
"CVE-2021-20034"
],
"50437": [],
"50432": [],
"50435": [],
"50438": [
"CVE-2021-28164"
],
"50439": [],
"50440": [],
"50442": [
"CVE-2021-24444"
],
"50444": [],
"50445": [],
"50446": [
"CVE-2021-42013"
],
"50447": [],
"50450": [],
"50451": [],
"50452": [],
"50453": [],
"50454": [],
"50455": [],
"50456": [],
"50457": [
"CVE-2018-12613"
],
"50458": [],
"50467": [],
"50468": [
"CVE-2021-43339"
],
"50469": [
"CVE-2021-43338"
],
"50473": [],
"50474": [],
"50475": [],
"50476": [],
"50477": [
"CVE-2018-16763"
],
"50478": [
"CVE-2021-34429"
],
"50479": [],
"50480": [
"CVE-2021-29156"
],
"50482": [],
"50483": [],
"50485": [],
"50486": [],
"50487": [],
"50489": [],
"50488": [],
"50490": [],
"50491": [],
"50492": [],
"50493": [],
"50495": [],
"50496": [],
"50497": [],
"50498": [],
"50499": [],
"50501": [],
"50502": [
"CVE-2021-42325"
],
"50503": [],
"50505": [
"CVE-2021-43405"
],
"50506": [],
"50507": [],
"50509": [],
"50512": [
"CVE-2021-42013",
"CVE-2021-41773"
],
"50872": [],
"50513": [
"CVE-2021-43136"
],
"50514": [],
"50515": [],
"50518": [],
"50520": [
"CVE-2021-24664"
],
"50521": [],
"50522": [
"CVE-2021-43140"
],
"50523": [],
"50524": [],
"50525": [
"CVE-2021-43617"
],
"50526": [
"CVE-2021-42580"
],
"50527": [],
"50529": [
"CVE-2021-35323"
],
"50530": [],
"50531": [
"CVE-2021-42840"
],
"50532": [
"CVE-2021-22205"
],
"50533": [],
"50538": [],
"50540": [],
"50542": [
"CVE-2021-43650"
],
"50543": [],
"50544": [],
"50547": [],
"50548": [],
"50551": [],
"50553": [],
"50554": [],
"50555": [],
"50556": [],
"50560": [
"CVE-2021-44655"
],
"50557": [
"CVE-2021-40577"
],
"50561": [
"CVE-2021-44653"
],
"50562": [],
"50563": [],
"50564": [
"CVE-2021-39316"
],
"50570": [
"CVE-2021-44673"
],
"50571": [],
"50572": [],
"50573": [],
"50578": [],
"50579": [
"CVE-2020-23935"
],
"50580": [],
"50581": [
"CVE-2021-43798"
],
"50582": [],
"50583": [],
"50585": [],
"50586": [],
"50587": [],
"50589": [
"CVE-2021-43936"
],
"50593": [],
"50594": [
"CVE-2019-9581"
],
"50595": [],
"50596": [],
"50597": [],
"50601": [
"CVE-2021-44848"
],
"50602": [],
"50603": [],
"50608": [],
"50609": [
"CVE-2021-3817"
],
"50610": [],
"50611": [],
"50612": [],
"50614": [],
"50615": [],
"50616": [],
"50617": [],
"50619": [
"CVE-2021-24750"
],
"50621": [],
"50622": [],
"50623": [],
"50624": [
"CVE-2021-39312"
],
"50625": [],
"50626": [
"CVE-2021-45425"
],
"50627": [
"CVE-2021-45814"
],
"50628": [],
"50630": [],
"50632": [],
"50631": [],
"50634": [],
"50635": [],
"50636": [],
"50637": [],
"50641": [],
"50643": [],
"50644": [],
"50645": [],
"50646": [],
"50647": [],
"50648": [],
"50649": [],
"50651": [
"CVE-2021-44916"
],
"50655": [
"CVE-2021-24563"
],
"50656": [],
"50657": [],
"50658": [],
"50659": [],
"50660": [],
"50661": [],
"50662": [],
"50663": [
"CVE-2022-21661"
],
"50666": [],
"50667": [],
"50668": [],
"50669": [],
"50670": [],
"50671": [],
"50672": [],
"50673": [],
"50674": [],
"50675": [
"CVE-2022-23178"
],
"50676": [],
"50677": [],
"50678": [],
"50681": [],
"50682": [],
"50683": [],
"50684": [
"CVE-2022-23046"
],
"50685": [
"CVE-2021-24904"
],
"50686": [
"CVE-2021-24862"
],
"50687": [
"CVE-2021-24946"
],
"50692": [],
"50693": [],
"50694": [
"CVE-2021-37391"
],
"50695": [
"CVE-2021-24786"
],
"50697": [
"CVE-2021-24926"
],
"50698": [
"CVE-2015-9323"
],
"50699": [],
"50700": [
"CVE-2022-0332"
],
"50701": [],
"50702": [
"CVE-2017-9841"
],
"50703": [
"CVE-2021-24247"
],
"50704": [
"CVE-2021-24300"
],
"50705": [
"CVE-2021-24488"
],
"50706": [
"CVE-2022-0377"
],
"50707": [],
"50709": [],
"50712": [
"CVE-2022-22833"
],
"50713": [
"CVE-2022-22832"
],
"50714": [
"CVE-2022-22831"
],
"50715": [],
"50716": [
"CVE-2019-18818"
],
"50717": [
"CVE-2021-46398"
],
"50718": [
"CVE-2022-24263"
],
"50719": [],
"50738": [],
"50721": [
"CVE-2020-35749"
],
"50723": [
"CVE-2021-24901"
],
"50724": [
"CVE-2022-0448"
],
"50725": [],
"50726": [],
"50727": [
"CVE-2022-24223"
],
"50729": [
"CVE-2022-23366"
],
"50730": [],
"50731": [],
"50732": [],
"50733": [
"CVE-2021-24931"
],
"50734": [],
"50735": [],
"50736": [],
"50737": [],
"50739": [],
"50740": [],
"50741": [
"CVE-2021-45901"
],
"50744": [],
"50746": [
"CVE-2021-24966"
],
"50752": [
"CVE-2022-0441"
],
"50753": [],
"50754": [
"CVE-2022-22909"
],
"50759": [
"CVE-2021-43062"
],
"50766": [
"CVE-2021-24762"
],
"50767": [],
"50768": [
"CVE-2022-0557"
],
"50769": [],
"50770": [
"CVE-2021-45092"
],
"50771": [
"CVE-2021-46354"
],
"50772": [
"CVE-2021-25076"
],
"50774": [
"CVE-2022-25241"
],
"50775": [],
"50778": [],
"50779": [],
"50780": [],
"50782": [],
"50784": [],
"50785": [],
"50786": [],
"50788": [],
"50792": [
"CVE-2022-24124"
],
"50794": [
"CVE-2021-44665"
],
"50795": [
"CVE-2021-44664"
],
"50797": [
"CVE-2021-46387"
],
"50799": [
"CVE-2022-22947"
],
"50800": [
"CVE-2022-0848"
],
"50801": [],
"50802": [],
"50803": [],
"50809": [
"CVE-2022-0824"
],
"50816": [],
"50823": [],
"50825": [],
"50826": [
"CVE-2022-26965"
],
"50831": [],
"50828": [
"CVE-2021-45010",
"CVE-2021-40964"
],
"50830": [],
"50838": [],
"50839": [
"CVE-2021-26599"
],
"50840": [],
"50841": [],
"50842": [],
"50843": [],
"50844": [],
"50845": [],
"50846": [
"CVE-2021-43701"
],
"50849": [
"CVE-2021-24405"
],
"50850": [
"CVE-2021\u00e2\u0080\u0093421"
],
"50851": [],
"50853": [
"CVE-2022-1163"
],
"50854": [
"CVE-2022-26180"
],
"50855": [],
"50860": [
"CVE-2021-46416"
],
"50862": [
"CVE-2021-46418"
],
"50863": [
"CVE-2021-46419"
],
"50864": [],
"50865": [],
"50869": [],
"50871": [
"CVE-2022-0482"
],
"50874": [],
"50876": [],
"50877": [
"CVE-2021-42136"
],
"50881": [
"CVE-2022-24181"
],
"50882": [],
"50884": [],
"50888": [
"CVE-2022-1162"
],
"50889": [
"CVE-2022-1175"
],
"50890": [],
"50891": [],
"50893": [
"CVE-2021-43481"
],
"50895": [
"CVE-2022-1103"
],
"50896": [],
"50898": [],
"50899": [],
"50908": [
"CVE-2021-31674"
],
"50909": [
"CVE-2021-31673"
],
"50910": [],
"50915": [
"CVE-2022-24707"
],
"50931": [
"CVE-2021-45428"
],
"50920": [
"CVE-2022-27412"
],
"50921": [
"CVE-2022-28117"
],
"50922": [
"CVE-2022-27308"
],
"50923": [],
"50924": [
"CVE-2022-24734"
],
"50925": [
"CVE-2021-24581"
],
"50927": [],
"50928": [],
"50933": [
"CVE-2022-28079"
],
"50934": [
"CVE-2022-28080"
],
"50935": [
"CVE-2021-46424"
],
"50937": [
"CVE-2022-29727"
],
"50938": [],
"50939": [],
"50941": [
"CVE-2022-0967"
],
"50942": [],
"50943": [
"CVE-2022-23626"
],
"50946": [
"CVE-2022-30525"
],
"50948": [
"CVE-2021-46422"
],
"50949": [],
"50950": [
"CVE-2022-29298"
],
"50944": [
"CVE-2020-7246"
],
"50945": [
"CVE-2022-1588"
],
"50947": [
"CVE-2022-1631"
],
"50960": [],
"51028": [
"CVE-2022-23854"
],
"51027": [
"CVE-2022-32429"
],
"50996": [],
"50987": [],
"51031": [
"CVE-2022-37661"
],
"50962": [
"CVE-2022-30075"
],
"51012": [],
"50986": [],
"50984": [
"CVE-2022-29593"
],
"50968": [
"CVE-2022-29301"
],
"50967": [
"CVE-2022-29299"
],
"51006": [
"CVE-2022-1040"
],
"51017": [
"CVE-2021-4045"
],
"50991": [
"CVE-2022-34047"
],
"50989": [
"CVE-2022-34048"
],
"50990": [
"CVE-2022-34046"
],
"51015": [],
"50952": [
"CVE-2022-26134"
],
"51011": [
"CVE-2022-36267"
],
"51000": [
"CVE-2020-20277"
],
"50998": [
"CVE-2022-36446"
],
"51014": [
"CVE-2022-35513"
],
"50973": [
"CVE-2021-23017"
],
"51005": [
"CVE-2020-2038"
],
"50964": [
"CVE-2022-23642"
],
"51019": [
"CVE-2022-36633"
],
"50955": [
"CVE-2022-29296"
],
"51013": [
"CVE-2022-2651"
],
"50982": [],
"51009": [
"CVE-2022-30781"
],
"50971": [],
"50979": [
"CVE-2021-36711"
],
"51004": [
"CVE-2021-42751"
],
"51003": [
"CVE-2021-42750"
],
"51022": [],
"50965": [
"CVE-2022-31325"
],
"50978": [
"CVE-2022-31854"
],
"50994": [],
"51018": [
"CVE-2022-34140"
],
"51002": [
"CVE-2022-34140"
],
"50976": [
"CVE-2022-33098"
],
"50995": [],
"50997": [],
"50966": [],
"51026": [
"CVE-2022-24637"
],
"50961": [
"CVE-2020-5844"
],
"51032": [
"CVE-2022-31814"
],
"50963": [],
"51001": [
"CVE-2022-31101"
],
"51023": [],
"51021": [],
"50992": [
"CVE-2022-2551"
],
"50993": [
"CVE-2022-2552"
],
"51025": [],
"50951": [],
"51008": [],
"51007": [],
"50980": [],
"50969": [],
"50988": [],
"51020": [
"CVE-2022-2941"
],
"51024": [
"CVE-2022-2840"
],
"50970": [
"CVE-2022-29548"
],
"50983": [
"CVE-2022-35411"
],
"51030": [
"CVE-2022-31188"
],
"50985": [
"CVE-2022-35899"
],
"50977": [],
"50959": [],
"51029": [
"CVE-2022-37197"
],
"50975": [],
"50954": [],
"50953": [],
"50999": [
"CVE-2004-2466"
],
"50974": [
"CVE-2022-24562"
],
"50957": [
"CVE-2022-31886"
],
"50956": [
"CVE-2022-31885"
],
"51010": [],
"50958": [
"CVE-2021-37589"
],
"50972": [],
"51016": [],
"51438": [
"CVE-2022-2591"
],
"51355": [],
"51335": [
"CVE-2022-30076"
],
"51154": [
"CVE-2022-45297"
],
"51362": [],
"51055": [
"CVE-2022-36664"
],
"51323": [],
"51039": [
"CVE-2022-35583"
],
"51200": [
"CVE-2022-35543"
],
"51118": [
"CVE-2022-41441"
],
"51876": [],
"51539": [
"CVE-2022-47076",
"CVE-2022-47075"
],
"51149": [
"CVE-2022-40319"
],
"51148": [
"CVE-2022-39195"
],
"51308": [
"CVE-2020-11798"
],
"51347": [
"CVE-2023-26692"
],
"51976": [
"CVE-2024-24747"
],
"51257": [
"CVE-2023-0744"
],
"51961": [
"CVE-2023-34927"
],
"51869": [
"CVE-2024-27620"
],
"51734": [
"CVE-2022-35919"
],
"51497": [
"CVE-2023-32751"
],
"51498": [
"CVE-2023-32750"
],
"51496": [
"CVE-2023-32749"
],
"51053": [
"CVE-2022-40946"
],
"51774": [],
"51326": [
"CVE-2022-41333"
],
"51356": [
"CVE-2023-24709"
],
"51157": [
"CVE-2022-46770"
],
"51137": [],
"51931": [],
"51034": [],
"51730": [],
"51561": [
"CVE-2023-36355"
],
"51793": [],
"51798": [],
"51414": [
"CVE-2023-30350"
],
"51832": [],
"51294": [
"CVE-2023-26609"
],
"51516": [],
"51515": [],
"51514": [],
"51269": [
"CVE-2022-45701"
],
"51155": [],
"51742": [],
"51243": [
"CVE-2022-46552"
],
"51046": [],
"51248": [
"CVE-2020-5330",
"CVE-2019-15993"
],
"51129": [],
"51266": [
"CVE-2023-0830"
],
"51441": [],
"51685": [],
"51684": [],
"51686": [],
"51321": [],
"51382": [],
"51942": [
"CVE-2024-27356"
],
"51854": [],
"51851": [],
"51852": [],
"51607": [
"CVE-2022-28171"
],
"51915": [
"CVE-2023-6538"
],
"51885": [
"CVE-2023-3710"
],
"51190": [],
"51850": [],
"51784": [],
"51094": [],
"51096": [],
"51097": [],
"51095": [],
"51093": [],
"51091": [],
"51195": [
"CVE-2022-44149"
],
"51535": [
"CVE-2023-25187"
],
"51444": [
"CVE-2023-27823"
],
"51306": [],
"51300": [],
"51301": [],
"51299": [],
"51303": [],
"51304": [],
"51297": [],
"51298": [],
"51305": [],
"51302": [],
"51352": [
"CVE-2023-27100"
],
"51970": [],
"51158": [],
"51855": [],
"51642": [],
"51755": [],
"51138": [],
"51727": [],
"51888": [],
"51320": [],
"51455": [],
"51458": [],
"51457": [],
"51456": [],
"51459": [],
"51460": [],
"51487": [],
"51657": [],
"51366": [],
"51932": [],
"51886": [],
"51259": [],
"51107": [],
"51720": [],
"51907": [],
"51908": [],
"51906": [],
"51827": [],
"51828": [],
"51317": [],
"51732": [],
"51731": [],
"51853": [],
"51677": [],
"51192": [],
"51846": [],
"51887": [],
"51311": [],
"51786": [],
"51603": [],
"51325": [],
"51582": [],
"51881": [],
"51589": [],
"51556": [],
"51709": [],
"52004": [],
"52006": [],
"52007": [],
"52002": [],
"52003": [],
"51771": [],
"51772": [],
"51770": [],
"51775": [],
"51773": [],
"51179": [],
"51865": [],
"51537": [],
"51872": [],
"51035": [],
"51315": [],
"51542": [],
"51448": [],
"51363": [],
"51364": [],
"51365": [],
"51371": [],
"51367": [],
"51368": [],
"51369": [],
"51370": [],
"51857": [],
"51530": [],
"51606": [],
"51866": [],
"51769": [],
"51768": [],
"51130": [],
"51036": [],
"51183": [],
"51889": [],
"51884": [],
"51564": [],
"51255": [],
"51339": [],
"51993": [],
"51895": [],
"51244": [],
"51205": [],
"51576": [],
"51577": [],
"51379": [],
"51991": [],
"51082": [],
"51350": [],
"51503": [],
"51112": [],
"51834": [],
"51934": [],
"51180": [],
"51252": [],
"51331": [],
"51384": [],
"51217": [],
"51922": [],
"51763": [],
"51139": [],
"51194": [],
"51797": [],
"51896": [],
"51996": [],
"51361": [],
"51310": [],
"51764": [],
"51262": [],
"51787": [],
"51746": [],
"51815": [],
"51849": [],
"51432": [],
"51469": [],
"51261": [],
"51623": [],
"51333": [],
"51359": [],
"51571": [],
"51983": [],
"51225": [],
"51898": [],
"51470": [],
"51927": [],
"51546": [],
"51314": [],
"51825": [],
"51493": [],
"51117": [],
"51316": [],
"51555": [],
"51552": [],
"51328": [],
"51609": [],
"51538": [],
"51574": [],
"51376": [],
"51247": [],
"51882": [],
"51814": [],
"51816": [],
"51111": [],
"51221": [],
"51875": [],
"51327": [],
"51193": [],
"51447": [],
"51904": [],
"51829": [],
"51722": [],
"51930": [],
"51254": [],
"51141": [],
"51313": [],
"51134": [],
"51856": [],
"51708": [],
"51092": [],
"51550": [],
"51480": [],
"51762": [],
"51668": [],
"51847": [],
"51222": [],
"51543": [],
"51499": [],
"51925": [],
"51113": [],
"51879": [],
"51878": [],
"51646": [],
"51343": [],
"51391": [],
"51452": [],
"51099": [],
"51186": [],
"51264": [],
"51619": [],
"51488": [],
"51237": [],
"51150": [],
"51796": [],
"51883": [],
"51792": [],
"51747": [],
"51218": [],
"51340": [],
"51804": [],
"51342": [],
"51142": [],
"51781": [],
"51805": [],
"51867": [],
"51509": [],
"51256": [],
"51844": [],
"51750": [],
"51845": [],
"51749": [],
"51813": [],
"51812": [],
"51838": [],
"51837": [],
"51836": [],
"51839": [],
"51840": [],
"51808": [],
"51842": [],
"51841": [],
"51759": [],
"51147": [],
"51058": [],
"51654": [],
"51702": [],
"51758": [],
"51613": [],
"51643": [],
"51667": [],
"51590": [],
"51402": [],
"51705": [],
"51785": [],
"51085": [],
"51083": [],
"51468": [],
"51307": [],
"51870": [],
"51219": [],
"51272": [],
"51214": [],
"51215": [],
"51216": [],
"51086": [],
"51271": [],
"51617": [],
"51281": [],
"51282": [],
"51283": [],
"51284": [],
"51823": [],
"51824": [],
"51626": [],
"51963": [
"CVE-2023-48974"
],
"51905": [],
"51597": [],
"51378": [
"CVE-2023-29849"
],
"51377": [
"CVE-2023-29848"
],
"51175": [],
"51751": [],
"51502": [],
"51568": [],
"51098": [],
"51280": [
"CVE-2023-0943"
],
"51279": [],
"51462": [],
"51972": [],
"51245": [],
"51605": [],
"51604": [],
"51912": [
"CVE-2023-46022"
],
"51833": [],
"51955": [],
"51697": [],
"51160": [],
"51360": [],
"51541": [],
"51476": [
"CVE-2023-31698"
],
"51741": [
"CVE-2023-38836"
],
"51123": [],
"51612": [],
"51848": [],
"51108": [
"CVE-2022-3552"
],
"51357": [],
"51581": [
"CVE-2023-36163"
],
"51242": [],
"51054": [
"CVE-2022-35155"
],
"51712": [],
"51740": [
"CVE-2023-39362"
],
"51166": [
"CVE-2022-46169"
],
"51241": [
"CVE-2022-2846"
],
"51656": [
"CVE-2023-39115"
],
"51063": [],
"51062": [],
"51567": [],
"51957": [],
"51202": [],
"51383": [
"CVE-2023-31714"
],
"51319": [
"CVE-2023-24787"
],
"51296": [],
"51477": [
"CVE-2023-31699"
],
"51478": [
"CVE-2023-25440"
],
"51260": [
"CVE-2022-48110"
],
"51070": [],
"51729": [
"CVE-2023-4708"
],
"51135": [],
"51880": [
"CVE-2023-7137"
],
"51779": [],
"51422": [
"CVE-2023-29809"
],
"51600": [],
"51599": [],
"51601": [],
"51689": [],
"51809": [
"CVE-2023-3244",
"CVE-2023-3244)"
],
"51417": [
"CVE-2023-29983"
],
"51060": [
"CVE-2021-46360"
],
"51965": [],
"51144": [],
"51250": [
"CVE-2022-44877"
],
"51738": [],
"51918": [],
"51701": [
"CVE-2023-4407"
],
"51688": [
"CVE-2023-37759"
],
"51703": [],
"51704": [],
"51863": [],
"51916": [],
"51778": [],
"51862": [],
"51973": [],
"51954": [
"CVE-2024-24496"
],
"51953": [
"CVE-2024-24495"
],
"51952": [
"CVE-2024-24494"
],
"51868": [
"CVE-2024-25832",
"CVE-2024-25830"
],
"51818": [],
"51145": [
"CVE-2022-24632",
"CVE-2022-24630",
"CVE-2022-24629",
"CVE-2022-24627"
],
"51529": [],
"51683": [],
"51270": [
"CVE-2022-28368"
],
"51615": [],
"51353": [],
"51723": [],
"51944": [],
"51449": [],
"51430": [],
"51140": [],
"52005": [],
"51956": [],
"51864": [],
"51673": [
"CVE-2023-37569"
],
"51911": [],
"51950": [],
"51951": [],
"51803": [],
"51049": [],
"51285": [],
"51286": [],
"51287": [],
"51501": [],
"51220": [],
"51153": [],
"51067": [],
"51495": [],
"51573": [],
"51505": [],
"51436": [],
"51068": [],
"51295": [],
"51997": [],
"51947": [],
"51948": [],
"51263": [],
"51753": [],
"51381": [],
"51475": [],
"51903": [],
"51962": [],
"51569": [],
"51690": [],
"51234": [],
"51229": [],
"51418": [],
"51232": [],
"51230": [],
"51726": [],
"51233": [],
"51760": [],
"51526": [],
"51975": [],
"51052": [],
"51777": [],
"51559": [],
"51132": [],
"51871": [],
"51945": [],
"51979": [],
"51877": [],
"51125": [],
"51971": [],
"51047": [],
"51698": [],
"51119": [],
"51329": [],
"51586": [],
"51056": [],
"51920": [],
"51274": [],
"51253": [],
"51428": [],
"51426": [],
"51427": [],
"51425": [],
"51423": [],
"51429": [],
"51424": [],
"51104": [],
"51806": [],
"51647": [],
"51440": [],
"51527": [],
"51629": [],
"51640": [],
"51645": [],
"51638": [],
"51631": [],
"51595": [],
"51334": [],
"51715": [],
"51165": [],
"51164": [],
"51776": [],
"51278": [],
"51859": [],
"51388": [],
"51419": [],
"52000": [],
"51050": [],
"51275": [],
"51471": [],
"51949": [],
"51374": [],
"51926": [],
"51744": [],
"51936": [],
"51795": [],
"51570": [],
"51861": [],
"51860": [],
"51392": [],
"51737": [],
"51338": [],
"51710": [],
"51204": [],
"51780": [],
"51921": [],
"51059": [],
"51519": [],
"51628": [],
"51984": [],
"51820": [],
"51115": [],
"51670": [],
"51504": [],
"51394": [],
"51289": [],
"51288": [],
"51291": [],
"51290": [],
"51213": [],
"51136": [],
"51858": [],
"51587": [],
"51042": [],
"51318": [],
"51630": [],
"51337": [],
"51524": [],
"51439": [],
"51358": [],
"51045": [],
"51511": [],
"51246": [],
"51989": [],
"51938": [],
"51728": [],
"51791": [],
"51598": [],
"51431": [],
"51494": [],
"51811": [],
"51103": [],
"51521": [],
"51344": [],
"51974": [],
"51940": [],
"51994": [],
"51995": [],
"51413": [],
"51691": [],
"51235": [],
"51614": [],
"51618": [],
"51627": [],
"51620": [],
"51621": [],
"51943": [],
"51608": [],
"51236": [],
"51398": [],
"51754": [],
"51594": [],
"51799": [],
"51411": [],
"51061": [],
"51687": [],
"51651": [],
"51650": [],
"51653": [],
"51649": [],
"51648": [],
"51416": [],
"51415": [],
"51652": [],
"51672": [],
"51399": [],
"51201": [],
"51593": [],
"51386": [],
"51572": [],
"51592": [],
"51420": [],
"51197": [],
"51565": [],
"51454": [],
"51277": [],
"51982": [],
"51551": [],
"51563": [],
"51463": [],
"51545": [],
"51185": [],
"51517": [],
"51400": [],
"51238": [],
"51518": [],
"51387": [],
"51588": [],
"51312": [],
"51929": [],
"51910": [],
"51474": [],
"51790": [],
"51163": [],
"51251": [],
"51330": [],
"51133": [],
"51401": [],
"51437": [],
"51622": [],
"51121": [],
"51490": [],
"51322": [],
"51548": [],
"51549": [],
"51513": [],
"51988": [],
"51491": [],
"51161": [],
"51120": [],
"51373": [],
"51403": [],
"51372": [],
"51482": [],
"51745": [],
"51937": [],
"51292": [],
"51913": [],
"51273": [],
"51057": [],
"51464": [],
"51211": [],
"51958": [],
"51472": [],
"51671": [],
"51116": [],
"51999": [],
"51404": [],
"51718": [],
"51396": [],
"51919": [],
"51713": [],
"51714": [],
"51557": [],
"51536": [],
"51162": [],
"51473": [],
"51602": [],
"51990": [],
"51528": [],
"51110": [],
"51187": [],
"51534": [],
"51822": [],
"51810": [],
"51692": [],
"51914": [],
"51512": [],
"51176": [],
"51523": [],
"51525": [],
"51450": [],
"51558": [],
"51443": [],
"51442": [],
"51500": [],
"51923": [],
"51043": [
"CVE-2022-3141"
],
"51507": [
"CVE-2023-30868"
],
"51901": [],
"51486": [],
"51434": [],
"51435": [],
"51433": [],
"51492": [
"CVE-2023-0455"
],
"51897": [],
"51695": [],
"51694": [],
"51696": [],
"51639": [
"CVE-2023-39147"
],
"51562": [],
"51596": [],
"51033": [],
"51924": [],
"51985": [
"CVE-2023-39796"
],
"51484": [],
"51566": [],
"51986": [],
"51451": [],
"51743": [],
"51661": [],
"51662": [],
"51074": [],
"51807": [],
"51900": [],
"51736": [],
"51616": [],
"51465": [
"CVE-2023-30256"
],
"51349": [],
"51554": [],
"51553": [],
"51089": [],
"51088": [],
"51087": [],
"51660": [],
"51610": [
"CVE-2023-34635"
],
"51893": [],
"51591": [
"CVE-2023-37269"
],
"51421": [],
"51156": [],
"51663": [],
"51655": [],
"51788": [],
"51899": [],
"51959": [
"CVE-2022-4395"
],
"51831": [],
"51966": [],
"51632": [
"CVE-2023-2636"
],
"51998": [],
"51445": [],
"51826": [
"CVE-2023-3452)"
],
"51874": [],
"51716": [
"CVE-2022-4953"
],
"51658": [
"CVE-2023-2796"
],
"51659": [
"CVE-2023-3219"
],
"51664": [],
"51735": [
"CVE-2023-4278"
],
"51644": [
"CVE-2023-37979"
],
"51981": [],
"51987": [],
"51789": [],
"51739": [],
"51531": [
"CVE-2020-11027"
],
"51969": [],
"51510": [
"CVE-2021-24499"
],
"51038": [],
"51928": [],
"51122": [
"CVE-2022-1565"
],
"51560": [
"CVE-2022-4297"
],
"51835": [],
"51830": [],
"51711": [
"CVE-2022-25148"
],
"51533": [
"CVE-2023-3320"
],
"51224": [
"CVE-2020-25213"
],
"51717": [],
"51152": [],
"51075": [],
"51346": [
"CVE-2022-48177"
],
"51345": [
"CVE-2022-48178"
],
"51909": [],
"51184": [],
"51547": [],
"51520": [],
"51198": [
"CVE-2022-48197"
],
"51048": [],
"51101": [],
"51485": [],
"51069": [],
"51625": [],
"51624": [],
"51071": [],
"51902": [],
"51819": [],
"51207": [],
"51240": [],
"51249": [],
"51051": [],
"51041": [],
"51040": [],
"51636": [],
"51635": [],
"51992": [],
"51580": [],
"51109": [],
"51276": [],
"51532": [],
"51669": [],
"51978": [],
"51226": [],
"51227": [],
"51228": [],
"51293": [],
"51489": [],
"51446": [],
"51181": [],
"51209": [],
"51354": [],
"52001": [],
"51385": [],
"51073": [],
"51196": [],
"51080": [],
"51081": [],
"51102": [],
"51725": [],
"51066": [],
"51114": [],
"51100": [],
"51800": [],
"51665": [],
"51265": [],
"51748": [],
"51332": [],
"51412": [],
"51968": [],
"51393": [],
"51380": [],
"51939": [],
"51583": [],
"51090": [],
"51210": [],
"51159": [],
"51146": [],
"51964": [],
"51351": [],
"51077": [],
"51375": [],
"51267": [],
"51483": [],
"51706": [],
"51078": [],
"51584": [],
"51641": [],
"51065": [],
"51724": [],
"51223": [],
"51633": [],
"51105": [],
"51206": [],
"51461": [],
"51682": [],
"51707": [],
"51890": [],
"51891": [],
"51892": [],
"51894": [],
"51143": [],
"51506": [],
"51064": [],
"51212": [],
"51946": [],
"51733": [],
"51960": [],
"51873": [],
"51410": [],
"51578": [],
"51579": [],
"51479": [],
"51637": [],
"51540": [],
"51199": [],
"51700": [],
"51389": [],
"51128": [],
"51678": [],
"51611": [],
"51941": [],
"51079": [],
"51336": [],
"51170": [],
"51169": [],
"51171": [],
"51168": [],
"51172": [],
"51173": [],
"51174": [],
"51167": [],
"51182": [],
"51341": [],
"51106": [],
"51044": [],
"51076": [],
"51453": [],
"51752": [],
"51508": [],
"51203": [],
"51544": [],
"51324": [],
"51395": [],
"51585": [],
"51151": [],
"51719": [],
"51127": [],
"51126": [],
"51131": [],
"51699": [],
"51239": [],
"51917": [],
"51767": [],
"51268": [],
"51681": [],
"51680": [],
"51679": [],
"51309": [],
"51765": [],
"51072": [],
"51575": [],
"51935": [],
"51467": [],
"51466": [],
"51794": [],
"51188": [],
"51802": [],
"51801": [],
"51977": [],
"51843": [],
"51817": [],
"51037": [],
"52009": [],
"52008": [],
"52012": [],
"52010": [],
"52015": [],
"52013": [],
"52014": [],
"52017": [],
"52016": [],
"52011": [],
"52020": [
"CVE-2024-32113"
],
"52021": [],
"52023": [
"CVE-2022-35914"
],
"52022": [],
"52018": [
"CVE-2024-34241"
],
"52019": [
"CVE-2024-33559"
],
"52028": [],
"52029": [],
"52027": [],
"52024": [],
"52026": [],
"52025": [],
"52033": [
"CVE-2023-26602"
],
"52035": [
"CVE-2023-27636"
],
"52030": [],
"52041": [],
"52040": [],
"52034": [
"CVE-2022-23409"
],
"52037": [],
"52031": [],
"52038": [],
"52036": [],
"52039": [],
"52032": [
"CVE-2021-38283"
],
"52049": [],
"52051": [],
"52046": [],
"52042": [],
"52045": [],
"52052": [],
"52043": [],
"52047": [],
"52048": [],
"52044": [],
"52050": [],
"52055": [
"CVE-2024-28999"
],
"52056": [],
"52054": [],
"52053": [],
"52059": [],
"52057": [],
"52058": [],
"52060": [],
"52061": [],
"52062": [],
"52066": [
"CVE-2024-40422"
],
"52065": [],
"52063": [],
"52064": [],
"52067": [],
"52068": [],
"52069": [],
"52070": [],
"52071": [],
"52072": [],
"52073": [],
"52074": [],
"52077": [],
"52078": [],
"52076": [],
"52075": [],
"52079": [],
"52081": [],
"52080": []
} ././@PaxHeader 0000000 0000000 0000000 00000000033 00000000000 010211 x ustar 00 27 mtime=1775359349.820343
pyexploitdb-0.3.21/pyexploitdb.egg-info/ 0000755 0001751 0001751 00000000000 15164352566 017660 5 ustar 00runner runner ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359349.0
pyexploitdb-0.3.21/pyexploitdb.egg-info/PKG-INFO 0000644 0001751 0001751 00000007547 15164352565 020771 0 ustar 00runner runner Metadata-Version: 2.4
Name: pyexploitdb
Version: 0.3.21
Summary: An optimized Python3 library to fetch the most recent exploit-database,
Home-page: https://github.com/Hackman238/pyExploitDb
Author: Shane William Scott
Author-email: shane@shanewilliamscott.com
License: GPL-3.0-only
Project-URL: Source, https://github.com/Hackman238/pyExploitDb
Project-URL: Issue Tracker, https://github.com/Hackman238/pyExploitDb/issues
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Operating System :: OS Independent
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: GitPython>=3.1
Requires-Dist: requests>=2.28
Dynamic: author
Dynamic: author-email
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: license
Dynamic: license-file
Dynamic: project-url
Dynamic: requires-dist
Dynamic: requires-python
Dynamic: summary
## NOTICE
This is the new home of "pyexploitdb".
##
pyexploitdb (https://shanewilliamscott.com)
==
[](https://github.com/Hackman238/pyExploitDb/actions/workflows/master.yml)
[](https://snyk.io/test/github/Hackman238/pyExploitDb?targetFile=requirements.txt)
## Authors:
Shane William Scott
## About pyexploitdb
pyexploitdb builds and maintains local CVE↔EDB indexes from the official exploit-db repository with a focus on resilience and observability.
### Highlights
- Validates on-disk caches and normalises mappings to keep indexes trustworthy.
- Rebuilds quickly by parsing `files_exploits.csv` first and only scraping missing CVEs with bounded concurrency.
- Ships with a practical smoke-test suite (`python -m tests.smoke_test`) so releases can be verified before publishing.
## Upcoming features
> CPE database, indexes and mappings
## Installation
pip install pyexploitdb
> Note: This assumes pip is for your python3 environment. Use pip3 if pip is for your python2 environment.
## Example Usage
```python
from pyexploitdb import PyExploitDb
exploit_db = PyExploitDb()
exploit_db.debug = False
exploit_db.open_file()
results = exploit_db.search_cve("CVE-2018-14592")
for exploit in results:
print(f"{exploit['id']} -> {exploit['file']}")
```
`search_cve` returns a list of dictionaries (one per matching exploit). The library raises `pyexploitdb.PyExploitDbError` when required data is missing or network/git operations fail after retrying.
To rebuild the CVE caches from scratch without hammering exploit-db, metadata is extracted from `files_exploits.csv` first and any missing CVEs fall back to concurrent (throttled) scraping:
```python
from pyexploitdb import PyExploitDb
with PyExploitDb() as exploit_db:
exploit_db.update_db(workers=6) # adjust workers to control parallel HTTP fetches
```
## Tests
Run the practical smoke tests before publishing to PyPI:
```
python -m tests.smoke_test
```
## Example debug/verbose output
CVE-2018-1459
Found
Exploit DB Id: 45447
File: ./exploit-database/exploits/php/webapps/45447.txt
Date: 2018-09-24
Author: Haboob Team
Platform: webapps
Type: php
Port: 80
{'edbid': '45447', 'exploit': './exploit-database/exploits/php/webapps/45447.txt', 'date': '2018-09-24', 'author': 'Haboob Team', 'platform': 'webapps', 'type': 'php', 'port': '80'}
## Credits
Based on fork from https://github.com/GoVanguard/pyExploitDb by Shane Scott.
Originally based on fork of cve_searchsploit by Andrea Fioraldi.
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359349.0
pyexploitdb-0.3.21/pyexploitdb.egg-info/SOURCES.txt 0000644 0001751 0001751 00000000523 15164352565 021543 0 ustar 00runner runner LICENSE
README.md
pyproject.toml
setup.cfg
setup.py
pyexploitdb/__init__.py
pyexploitdb/cveToEdbid.json
pyexploitdb/edbidToCve.json
pyexploitdb.egg-info/PKG-INFO
pyexploitdb.egg-info/SOURCES.txt
pyexploitdb.egg-info/dependency_links.txt
pyexploitdb.egg-info/not-zip-safe
pyexploitdb.egg-info/requires.txt
pyexploitdb.egg-info/top_level.txt ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359349.0
pyexploitdb-0.3.21/pyexploitdb.egg-info/dependency_links.txt 0000644 0001751 0001751 00000000001 15164352565 023725 0 ustar 00runner runner
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359349.0
pyexploitdb-0.3.21/pyexploitdb.egg-info/not-zip-safe 0000644 0001751 0001751 00000000001 15164352565 022105 0 ustar 00runner runner
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359349.0
pyexploitdb-0.3.21/pyexploitdb.egg-info/requires.txt 0000644 0001751 0001751 00000000036 15164352565 022256 0 ustar 00runner runner GitPython>=3.1
requests>=2.28
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359349.0
pyexploitdb-0.3.21/pyexploitdb.egg-info/top_level.txt 0000644 0001751 0001751 00000000014 15164352565 022404 0 ustar 00runner runner pyexploitdb
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359319.0
pyexploitdb-0.3.21/pyproject.toml 0000644 0001751 0001751 00000000136 15164352527 016534 0 ustar 00runner runner [build-system]
requires = ["setuptools>=61", "wheel"]
build-backend = "setuptools.build_meta"
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1775359349.8211083
pyexploitdb-0.3.21/setup.cfg 0000644 0001751 0001751 00000000312 15164352566 015440 0 ustar 00runner runner [flake8]
select = E501,F811,F823,F831,F841,E502,E703,E704,E713,E741,E742,E743,W291,W601,W602
exclude = .git,.idea,tmp,backup,log,images,venv
max-line-length = 120
[egg_info]
tag_build =
tag_date = 0
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1775359319.0
pyexploitdb-0.3.21/setup.py 0000644 0001751 0001751 00000003044 15164352527 015333 0 ustar 00runner runner from pathlib import Path
from setuptools import find_packages, setup
README_PATH = Path(__file__).parent / "README.md"
with README_PATH.open(encoding="utf-8") as fh:
long_description = fh.read()
setup(
name="pyexploitdb",
version="0.3.21",
author="Shane William Scott",
author_email="shane@shanewilliamscott.com",
description="""An optimized Python3 library to fetch the most recent exploit-database,
create searchable indexes for CVE->EDBID and EDBID -> CVE, and provide
methods to perform searches.""",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/Hackman238/pyExploitDb",
project_urls={
"Source": "https://github.com/Hackman238/pyExploitDb",
"Issue Tracker": "https://github.com/Hackman238/pyExploitDb/issues",
},
license="GPL-3.0-only",
packages=find_packages(exclude=("tests", "tests.*")),
package_data={"pyexploitdb": ["*.json"]},
install_requires=["GitPython>=3.1", "requests>=2.28"],
python_requires=">=3.10",
zip_safe=False,
classifiers=(
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Operating System :: OS Independent",
),
)