KbVulnerabilityService Object Services | 14 | ![]() |
The KbVulnerabilityService module is defined in the file named:
The KbVulnerabilityService module presents a service to create, manipulate, examine, and destroy information relating to computer security and survivability vulnerabilities.
It's version information is:
$Id: KbVulnerabilityService.idl,v 1.48 1997-08-07 17:03:17-04 wlf Exp $
It is defined in the Java package named:
org.cert.KbVulnerabilityService
module KbVulnerabilityService
{
Forward declarations:
interface CounterMeasure;
interface Impact;
interface SecurityPolicy;
interface Vulnerability;
interface VulnerabilityCase;
interface VulnerabilityConfiguration;
interface VulnerabilityFactory;
interface VulnerabilityMetric;
interface VulnerabilityReport;
interface VulnerabilityReportFactory;
Sequence declarations:
typedef sequence<CounterMeasure> SeqOfCounterMeasure;
typedef sequence<Impact> SeqOfImpact;
typedef sequence<SecurityPolicy> SeqOfSecurityPolicy;
typedef sequence<Vulnerability> SeqOfVulnerability;
typedef sequence<VulnerabilityCase> SeqOfVulnerabilityCase;
typedef sequence<VulnerabilityConfiguration> SeqOfVulnerabilityConfiguration;
typedef sequence<VulnerabilityFactory> SeqOfVulnerabilityFactory;
typedef sequence<VulnerabilityMetric> SeqOfVulnerabilityMetric;
typedef sequence<VulnerabilityReport> SeqOfVulnerabilityReport;
typedef sequence<VulnerabilityReportFactory> SeqOfVulnerabilityReportFactory;
enum VulnerabilityState
{
unspecified_state,
open_state,
closed_state
};
When the vulnerability is first diagnosed, a CounterMeasure might be defined to perform some work-around. Some time after the vendor produces a patch, an additional CounterMeasure might be defined with instructions to put on the patch. Even later, after the vulnerability is fixed in a new version of the component, an additional CounterMeasure might be defined with instructions to upgrade to the new version.
interface CounterMeasure {
The name attribute contains a short natural language name of the countermeasure. This name might appear in hierarchical (tree-like) GUI elements as a placeholder for the countermeasure.
readonly attribute string name;
The description attribute contains the complete natural language explanation of the countermeasure.
attribute string description;
};
interface SecurityPolicy {
The name attribute contains a natural language name for the security policy that is intended to be used as a label for the security policy. It might be used as a icon name in a GUI.
attribute string name;
The description attribute contains the natural language description of the security policy. A more formal policy language will later be added, when more research indicates the best language choice.
attribute string description;
};
interface VulnerabilityMetric {
The value attribute contains the current action-motivation level.
readonly attribute long value;
};
interface VulnerabilityCase {
The name attribute contains a short natural language name for the VulnerabilityCase. This name is expected to be used in GUI's.
attribute string name;
The description attribute contains a natural language explanation of the VulnerabilityCase.
attribute string description;
The probability attribute contains the subjective estimate of the probability that this VulnerabilityCase suffers from the associated Vulnerability. The range of this attribute is [0..1] inclusive. It is a floating point number. An exact assignment of ``0'' indicates the belief on the part of the analyst that this case does not suffer from the vulnerability and an assignment of ``1'' indicates the belief that this case does suffer from the vulnerability.
The probability and the accuracy attributes together determine the possible range of probabilities that this case does suffer from this vulnerability.
attribute float probability;
The accuracy attribute contains the subjective estimate of the accuracy of the value contained in the probability attribute above. The range of the accuracy attribute is [0..1] inclusive. This attribute should be interpreted as an expected error in the probability attribute.
For example, if probability contains a value of 0.4 and accuracy contains a value of 0.1, then the probability that this case suffers from this vulnerability is estimated to lie somewhere bewteen 0.3 (0.4 - 0.1) and 0.5 (0.4 + 0.1).
Some common numbers:
probability | accuracy | interpretation |
---|---|---|
0.5 | 0.5 | complete unknown |
0.0 | 0.0 | does not have vulnerability |
1.0 | 0.0 | does have vulnerability |
attribute float accuracy;
The components attribute represents the relationship between one VulnerabilityCase object and many Component objects. The sequence of Component objects is expected to contain objects that identify the VulnerabilityCase environment plus those objects that contribute ComponentFeatures to the higher level Vulnerability object's VulnerabilityConfiguration.
readonly attribute
KosCollection::Set
/*
of
KbComponentService::Component
*/
components;
The counter_measures attribute represents the one-to-many aggregate relationship between one VulnerabilityCase object and one or more CounterMeasure objects. The sequence of CounterMeasure objects is expected to be a set of countermeasures that each independently reduce the significance of or eliminate the vulnerability for this particular vulnerability case.
readonly attribute
KosCollection::Set
/*
of
CounterMeasure
*/
counter_measures;
The test_procedures attribute represents the one-to-many aggregate relationship between the VulnerabilityCase object and one or more Procedure objects. It is expected that each object in the sequence of Procedure objects represents an independent concrete vulnerability detection procedure. Such a procedure is expected to disclose the absolute minimum amount of information about the vulnerability itself and only provide a probabilistic result in the floating point range [0..1] indicating the probability that the given system (sequence of Component objects) exhibits this vulnerability.
readonly attribute
KosCollection::Set
/*
of
KbProcedureService::ExistenceTestProcedure
*/
test_procedures;
The exploitation_procedures attribute represents the one-to-many aggregate relationship between the VulnerabilityCase object and one or more Procedure objects. It is expected that each object in the sequence of Procedure objects represents an independent concrete vulnerability exploitation procedure. Such a procedure is expected to fully exploit the vulnerability itself on the given system (sequence of Component objects).
readonly attribute
KosCollection::Set
/*
of
KbProcedureService::VulnerabilityExploitationProcedure
*/
exploitation_procedures;
The create_test_procedure operation is used to both create a new Procedure object and form an association between the VulnerabilityCase object and the newly created Procedure object.
KbProcedureService::Procedure create_test_procedure(
in string name
);
The destroy_test_procedure operation is used to both break the association between the VulnerabilityCase object and a Procedure object and to destroy the Procedure object.
void destroy_test_procedure(
in KbProcedureService::Procedure tp
);
The create_exploitation_procedure operation is used to both create a new Procedure object and form an association between the VulnerabilityCase object and the newly created Procedure object.
KbProcedureService::Procedure create_exploitation_procedure(
in string name
);
The destroy_exploitation_procedure operation is used to both break the association between the VulnerabilityCase object and a Procedure object and to destroy the Procedure object.
void destroy_exploitation_procedure(
in KbProcedureService::Procedure ep
);
The create_counter_measure operation is used to both create a new CounterMeasure object and form an association between the VulnerabilityCase object and the newly created CounterMeasure object.
CounterMeasure create_counter_measure(
in string name
);
The destroy_counter_measure operation is used to both break the association between the VulnerabilityCase object and a CounterMeasure object and to destroy the CounterMeasure object.
void destroy_counter_measure(
in CounterMeasure cm
);
The reference_component operation is used to form an association between the VulnerabilityCase object and an already existing CounterMeasure object.
void reference_component(
in KbComponentService::Component cmp
);
The unreference_component operation is used to break the association between the VulnerabilityCase object and a Component object.
void unreference_component(
in KbComponentService::Component c
);
};
exception FeatureInUse {
The reason attribute contains a natural language explanation for why the exception was raised.
string reason;
};
Implementation note: If we support an OR relationship, it should be restricted to prevent representing multiple different vulnerabilities as one vulnerability.
interface VulnerabilityConfiguration {
The expression atribute contains the first order predicate logic expression that specifies the conditions under which the parent Vulnerability is present in a system.
attribute string expression;
The is composed of association defines a one-to-many relationship between a VulnerabilityConfiguration object and one or more ComponentFeature objects.
readonly attribute
KosCollection::Set
/*
of
KbComponentService::ComponentFeature
*/
vulnerability_features;
The reference_component_feature operation is used to create an association between the VulnerabilityComponent object and an already existing ComponentFeature object. After the successful completion of this operation, an additional feature is available to be used in the configuration expression.
void reference_component_feature(
in KbComponentService::ComponentFeature cf
);
The unreference_component_feature is used to break the association between the VulnerabilityConfiguration object and the ComponentFeature object. In order for this operation to succeed, the ComponentFeature cannot be referenced in the configuration expression at the time of the operation call, otherwise the FeatureInUse exception is raised.
void unreference_component_feature(
in KbComponentService::ComponentFeature cf
)
raises(
FeatureInUse
);
};
interface Impact {
The name attribute contains a short natural language name that is provided to identify this object in a GUI.
attribute string name;
The description attribute contains a full natural language explanation of the potential impact of the vulnerability.
attribute string description;
};
A Vulnerability object is a minimal abstraction of all of the concrete VulnerabilityCases that share the same feature-based explanation. This level of abstraction is intended to represent the commonly held view of a vulnerability; that is, if two systems exhibit the same behavior with the same inputs, then they share the same vulnerability.
A Vulnerability object is the focal point of all vulnability analysis work.
interface Vulnerability {
The name attribute contains a short natural language name for this vulnerability to be used in a GUI environment.
attribute string name;
The identification attribute contains the official globally unique identification for this vulnerability. It is expected that this identification is the only official way for external systems to refer to a vulnerability. It is distinct from the identification attribute in the VulnerabilityReport interface.
attribute string identification;
The description attribute contains a natural language overview description of the vulnerability.
attribute string description;
The security_policy attribute represents the one-to-one containment relationship between the Vulnerability object and a SecurityPolicy object. It is expected that the SecurityPolicy object represents the most fine-grained security policy that cannot be implemented on a system that exhibits this vulnerability.
readonly attribute
SecurityPolicy security_policy;
The message_thread attribute represents the thread of messages (e.g., email, phone, beeper, ...) that have been sent and/or received during the analysis of this vulnerability. It does not contain handling messages; that thread exists elsewhere.
readonly attribute
KbMessageService::MessageThread message_thread;
The vulnerability_configuration attribute represents the one-to-one aggregate containment relationship between one Vulnerability object and one VulnerabilityConfiguration object. It is expected that the configuration represents a complete feature-based specification of this vulnerability.
readonly attribute
VulnerabilityConfiguration
vulnerability_configuration;
The vulnerability_cases attribute represents the one-to-many aggregate relationship between the Vulnerability object and one or more VulnerabilityCase objects. It is expected that these objects will each represent concrete cases of this abstract vulnerability.
readonly attribute
KosCollection::Set
/*
of
VulnerabilityCase
*/
vulnerability_cases;
The exploitation_procedures attribute represents the one-to-many aggregate containment relationship between the Vulnerability object and one or more VulnerabilityExploitationProcedure objects. It is expected that each object in the sequence of VulnerabilityExploitationProcedure objects represents an independent abstract vulnerability exploitation procedure. Such a procedure is expected to be a natural language explanation of how to exploit the vulnerability.
readonly attribute
KosCollection::Set
/*
of
KbProcedureService::VulnerabilityExploitationProcedure
*/
exploitation_procedures;
The test_procedures attribute represents the one-to-many aggregate containment relationship between the Vulnerability object and one or more ExistanceTestProcedure objects. It is expected that each object in the sequence of ExistanceTestProcedure objects represents an independent abstract vulnerability existance test procedure. Such a procedure is expected to disclose the absolute minimum amount of information about the vulnerability itself and only provide a result indicating the probability that a system exhibits this vulnerability.
readonly attribute
KosCollection::Set
/*
of
KbProcedureService::ExistenceTestProcedure
*/
test_procedures;
readonly attribute Impact exploit_impact;
readonly attribute
KosCollection::Set
/*
of
CounterMeasure
*/
counter_measures;
The create_vulnerability_case operation creates a new VulnerabilityCase object and adds it to the Vulnerability object's sequence of associated VulnerabilityCase objects. These are the cases that the Vulnerability object is intended to abstract.
VulnerabilityCase create_vulnerability_case(
in string name
);
The destroy_vulnerability_case operation removes the specified VulnerabilityCase object from the Vulnerability object's list of associated cases and then detroys it.
void destroy_vulnerability_case(
in VulnerabilityCase vc
);
};
A VulnerabilityReport object is the focal point of all vulnerability handling work.
interface VulnerabilityReport {
The name attribute contains a short natural language name for this report that is expected to be used in a GUI environment.
attribute string name;
The identification attribute contains the official globally unique identification for this vulnerability report. It is expected that this identification is the only official way for external systems to refer to a vulnerability report. It is distinct from the identification attribute in the Vulnerability interface.
attribute string identification;
The description attribute contains a natural language description of the report.
attribute string description;
The state attribute contains the current handling state of a report.
attribute VulnerabilityState state;
The referenced_vulnerabilities association attribute contains a set of Vulnerability objects. Each Vulnerability object is expected to represent a vulnerability that is directly involved in this vulnerability report.
readonly attribute
KosCollection::Set
/*
of
Vulnerability
*/
referenced_vulnerabilities;
The message_thread association attribute contains one MessageThread object. The MessageThread object is expected to represent all messages sent or received that are related to this vulnerability report. It does not include messages relating to the analysis of referenced vulnerabilities. Each Vulnerability object manages its own MessageThread object that contain analysis messages.
readonly attribute
KbMessageService::MessageThread message_thread;
The report_messages association attribute contains a set of Message objects, each of which is to be interpreted as a vulnerability report of the same vulnerability.
readonly attribute
KosCollection::Set
/*
of
KbMessageService::Message
*/
report_messages;
The references association attribute contains a set of URL objects. Each URL object is expected to represent a reference to some external file whose contents are related to this vulnerability report.
readonly attribute
KosCollection::Set /* of Kb::URL */ references;
The actions association attribute contains a set of Action objects. Each Action object is expcted to represent some action related to this vulnerability report that has been or will be taken.
readonly attribute
KosCollection::Set
/*
of
KbAction::Action
*/
actions;
The metric association attribute contains one VulnerabilityMetric object.
readonly attribute VulnerabilityMetric metric;
readonly attribute
KosCollection::Set
/*
of
KbDocumentService::Document
*/
spawned_documents;
The reference_vulnerability operation adds an existing Vulnerability object to the set of associated Vulnerability objects contained in the vulnerabilities association attribute.
void reference_vulnerability(
in Vulnerability vul
);
The unreference_vulnerability operation removes an existing Vulnerability object from the set of Vulnerability objects contained in the vulnerabilities association attribute.
void unreference_vulnerability(
in Vulnerability vul
);
The reference_report_message operation adds an existing Message object to the set of associated Message objects contained in the report_messages association attribute.
void reference_report_message(
in KbMessageService::Message msg
);
The unreference_report_message operation removes an existing Message object from the set of Message objects contained in the report_messages association attribute.
void unreference_report_message(
in KbMessageService::Message rm
);
The reference_document operation adds an existing Document object to the set of associated Document objects contained in the documents association attribute.
void reference_document(
in KbDocumentService::Document d
);
The unreference_document operation removes an existing Document object from the set of Document objects contained in the documents association attribute.
void unreference_document();
The reference_action operation adds an existing Action object to the set of associated Action objects contained in the actions association attribute.
void reference_action(
in KbAction::Action a
);
The unreference_action operation removes an existing Action object from the set of Action objects contained in the actions association attribute.
void unreference_action(
in KbAction::Action a
);
The create_reference operation creates a new Action object and adds it to the set of associated Action objects contained in the actions association attribute.
Kb::URL create_reference(
in string name
)
raises(
Kb::CreationException
);
The destroy_reference operation removes an existing Action object from the set of Action objects contained in the actions association attribute and then destroys it.
void destroy_reference(
in Kb::URL u
);
};
interface VulnerabilityReportFactory {
The vulnerability_reports association attribute contains a set of VulnerabilityReport objects. Each VulnerabilityReport object is expected to represent one individual vulnerability report.
readonly attribute
KosCollection::Set
/*
of
VulnerabilityReport
*/
vulnerability_reports;
The create_vulnerability_report operation creates a new VulnerabilityReport object and adds it to the set of VulnerabilityReport objects in the vulnerability_reports association attribute.
VulnerabilityReport create_vulnerability_report(
in string name
)
raises(
Kb::CreationException
);
The get_vulnerability_report operation finds a VulnerabilityReport object from the set of VulnerabilityReport objects in the vulnerability_reports association attribute.
VulnerabilityReport get_vulnerability_report(
in string name
);
The find_vulnerability_reports operation finds multiple VulnerabilityReport objects from the set of VulnerabilityReport objects in the vulnerability_reports association attribute.
SeqOfVulnerabilityReport find_vulnerability_reports(
in string name,
in any value
);
};
interface VulnerabilityFactory {
The vulnerabilities association attribute contains a set of Vulnerability objects. Each Vulnerability object is expected to represent one individual vulnerability.
readonly attribute
KosCollection::Set
/*
of
Vulnerability
*/
vulnerabilities;
The create_vulnerability operation creates a new Vulnerability object and adds it to the set of Vulnerability objects in the vulnerabilities association attribute.
Vulnerability create_vulnerability(
in string name
);
The get_vulnerability operation finds a Vulnerability object from the set of Vulnerability objects in the vulnerabilities association attribute.
Vulnerability get_vulnerability(
in string name
);
The find_vulnerabilities operation finds multiple Vulnerabilityt objects from the set of Vulnerability objects in the vulnerabilities association attribute.
SeqOfVulnerability find_vulnerabilities(
in string name,
in any value
);
};
const string KbVulnerabilityFactoryName = "KbVulnerabilityFactory";
};