U.S. Flag Official website of the Department of Homeland Security

Note: This page is part of the us-cert.gov archive.This document is part of the US-CERT website archive. These documents are no longer updated and may contain outdated information. Links may also no longer function. Please contact info@us-cert.gov if you have any questions about the US-CERT website archive.

TLP:WHITE

Estimating Benefits from Investing in Secure Software Development

Published: February 15, 2007 | Last revised: July 31, 2013

Author(s): Ashish Arora, Rahul Telang, and Steven Frank Maturity Levels and Audience Indicators: L2  / L M  SDLC Life Cycles: Management Copyright: Copyright © Carnegie Mellon University 2005-2012.

Abstract

This article discusses the costs and benefits of incorporating security in software development and presents formulas for calculating security costs and security benefits.

Background

The press is full of articles about how lack of secure software leads to security breaches. The number of reported incidents is on the rise, and the same is true about the security vulnerabilities found and disclosed in many major software applications. The CERT Coordination Center received 3,782 reports of vulnerabilities in the year 2003 alone and has reported more than 82,000 incidents involving various cyber attacks. These vulnerabilities cause significant losses to the user organizations. Cavusoglu et al. [Cavusoglu 04] and Cambell et al. [Cambell 03] estimate that such losses can run in millions. Similar observations are reported in CSI/FBI surveys.

While major software companies are committing themselves to designing more secure software, there is little work that demonstrates the value of secure software. For one thing, unlike physical goods manufacturers such as automakers, software vendors do not face legal liability if vulnerabilities in their products are exploited. Thus there is no direct cost of poor security. However, a paper by Telang and Wattal is the first piece of evidence that vulnerability announcements are adversely linked to market prices of software vendors [Telang 05]. Using an event study methodology, the authors show that the market reacts negatively to software vendors whose products have revealed significant vulnerability. The authors conclude that this is due to loss of reputation, cost of patching, etc. The study provides some evidence that the market is willing to punish the vendor for lack of security and hence creates incentives for providing more secure software. Microsoft is using the level of vulnerabilities and therefore the level of patches needed as a measure of improved cost/benefit [Microsoft 08].

However, as we noted, there is relatively little published work that quantifies the benefits from investing in secure software development. The cost of incorporating security in software development practices is still a new area of work and consequently there are relatively few publications. In a work by Soo Hoo, Sadbury, and Jaquith, the return on secure software engineering was shown to be 21% [Soo Hoo 01]. Data presented by Fortify indicates that the cost of correction of security flaws at the requirements level  is up to 100 times less than the cost of correction of security flaws in fielded software. The COCOMO developers have found that the cost of fixing errors of all types at requirements time is about 20 times less than the cost of fixing errors in fielded software. Regardless of which statistic is used, there would seem to be a substantial cost savings for fixing security flaws at during requirements development rather than fixing security flaws after software is fielded. For vendors, the cost is magnified by the expense of developing and releasing patches. However, it seems clear that cost savings exist even in the case of custom software when security flaws are corrected early in the development process.

Extant Work

Our approach to quantifying the value of secure software development is to focus on the cost of security and the benefits of security separately.

Cost of Secure Software

Major roadblocks to quantify the cost of secure software development include lack of precise data, lack of consensus on measurement metrics, and relatively recent focus on security. However, there has been significant work on quantifying and estimating the cost of software development. Some of the early work started with the COCOMO (Constructive Cost Model) model (see [Clark 98] for details). This model has been revised significantly, and various other models for estimating the effort and duration for software development have been proposed and implemented by industry (see http://sern.ucalgary.ca/courses/seng/621/W98/johnsonk/cost.htm).

One way to think about the cost of security is to think security in terms of quality. There is some work in software engineering literature that focuses on the cost of software quality. Generally, quality improvements in software are associated with better design, more testing, and inspection, all of which directly affect the cost [Krishnan 97, Slaughter 98]. Of course the benefits of such activities may still outweigh the costs. Slaughter et al. divide the cost of better quality as “conformance based” and “non-conformance” based. Conformance is the ability to reach desired quality. To achieve desired quality one either (a) eliminates the source that causes defects (by improved training, quality improvement meetings, design reviews, etc.) or (b) eliminates the defects by valuating and auditing the product (code inspection, testing, software measurement activities, etc). The researchers then quantify return on investment on quality improvement by using the data from a firm and show that this ROI is positive and significant.

Unfortunately, formulating and implementation any of the cost metrics for software quality is difficult because these measures tend to be either product specific, technology specific, or firm specific [Boehm 76] and hence hard to generalize. In another work, Krishnan, Kriebel, Kekre, and Mukhopadhyay show that having better personnel, more use of case tools, and more up front investments in planning, design, etc. improve product quality [Krishnan 00].

Given the fact that quantification for better software quality has been demonstrated, one can start from the same approach for security as well. However, all of these studies implicitly assume that more quality merely reduces the number of bugs but does not affect product size (i.e., to achieve more quality one need not necessarily add more lines), does not affect product complexity, etc. If we believe incorporating more security in the product is similar to quality, one can use the metrics proposed in the studies mentioned above to measure the cost of security.

However, potentially incorporating security affects the product design more substantively than incorporating quality. In other words, making a product more secure may mean more or less complexity in the product, more or less size, and more or less functionality in the product. Thus one may incur indirect costs in product design that are over and above conformance costs like training cost, case tool cost, etc.

Benefits of Secure Software

For understanding the benefits of secure software, we focus on the work that describes methods and models for supporting decision making regarding investments in information security from a user perspective, i.e., from the perspective of an IT-using organization that wishes to protect itself against cyber attacks. Insofar as secure software development is one way of investing in information security, this research is relevant.

Some typical examples of this work include [Arora 04], [Soo Hoo 01], [Butler 02], [Pinto 04], and [Mead 04]. In addition, there are a number of articles published in the popular press that take a similar approach. We adapt this approach to a software development context, applying it to the problem of assessing the return on investing in secure software development practices.

The approach in all these studies is similar. In particular, the benefits are measured as the capitalized dollar value of losses averted as a result of secure software development practices. The studies differ mainly in how they seek to measure the avoided losses. In Arora et al., Pinto et al., and Mead et al. the data required to estimate losses with and without security investments (including possibly secure software development practices) are based on administrative data. A crucial issue here is calculating bypass rates. Bypass rates measure what percentage of loss event (such as intrusions, attacks, virus infections, and insider theft) are stopped by the existing security measures (and therefore not captured by administrative data on observed intrusions or losses). The observed frequency of a given type of loss event is multiplied by the inverse of the bypass rate to obtain the baseline rate for that type of loss event. Separately, administrative data or other sources (such as estimates by managers) are used to estimate the range of losses, measured in dollars, suffered by the organization corresponding to that loss event. In Arora et al. the losses are measured in terms of the resources required for remediation, and the resources are then converted into monetary units. The estimates of average loss and the estimated baseline frequency are combined to produce an estimate of baseline loss (sometimes called baseline risk). A similar procedure is followed to calculate the expected loss after security measures are implemented (also sometimes called residual risk). Note that security measures may reduce both the frequency of loss events and their impact (i.e., losses due to those events). The difference between the baseline risk and residual risk yields the expected benefit (also sometimes called avoided risk).

The other studies cited differ mostly in how the data are obtained. Kevin So Hoo shows how publicly available data can be used. He uses published data from CSI/FBI surveys to estimate losses and frequencies of loss events. Butler’s method economizes on administrative data and relies on informed but subjective assessments by experienced security managers regarding the likely types of loss events, the losses from such events, and their frequencies. It also relies on such subjective assessments to obtain the residual risk. Another important difference is in the way in which the loss data are elicited. Instead of eliciting the monetary value of the dollar loss for all loss events, for some types of events managers respond on a Likert scale. Butler then converts all monetary and non-monetary loss data into a common severity scale for aggregation. Since the cost of security investments is mostly measured in dollars, Butler’s method does not directly support a return on security calculation. However, his method can be modified to allow a calculation of a return on security.

The forgoing research is aimed at estimating the benefits of cybersecurity related investments. Our framework for understanding the business relevance draws on this literature by acknowledging that a key benefit of secure software development is that users of the software will have greater avoided risk relative to baseline. The value of secure software therefore includes a component that is calculated analogously to the value of investing in information security. The details will differ depending on the context. For internal software development teams, the benefit will include the difference between baseline and residual risk. For custom software development (where an independent vendor is responsible for development), the benefit will include the part of the difference that the vendor captures (through higher payment, bonus, future business or testimonials and references leading to future business). The benefit must be scaled by the number of users, as is the case for a product developed for several users (such as shrinkwrap software). Since the vendor and users are, in this case, distinct organizations, one must adjust the benefits to reflect the portion of the benefits captured by vendors. In some cases, service level agreements and other contractual provisions may provide additional constraints.

In proposing this, we are also mindful of the many challenges in obtaining data. In particular, when the developer belongs to a different organization than the user, the developer is unlikely to have access to administrative records to form estimates of the frequency of loss events and the associated losses. Similarly, developers may be unable to estimate such quantities. Further, developers may be unable to estimate the fraction of the benefits created that they capture. Instead, for vendors, factors such as loss of reputation and loss of future sales are likely to be more salient. Accordingly, our proposed framework is flexible in allowing respondents to estimate value in alternative ways. We are careful, however, to minimize the possibility of double counting.

There are other potential benefits. An important one is that software that has fewer vulnerabilities will also need fewer patches and security related updates. Thus, a second component of the benefit of secure software development is the reduction in patching costs. Although there is no published method for estimating avoided patching costs, one could adapt the risk framework for this. Thus, the benefit would be measured as the difference between the baseline patching cost and the residual patching cost. The baseline patching cost is measured as the observed number of vulnerabilities per year per thousand lines of code multiplied by the discovery rate, multiplied by the average cost of patching per vulnerability. In this context, the discovery rate is needed because not all vulnerabilities present in a system are likely to be discovered. Indeed, Rescorla’s findings suggest that in large systems, the rate at which vulnerabilities are discovered is roughly constant over time, implying that even as the number of vulnerabilities remaining in a system (i.e., those that have not yet been discovered) falls, the discovery rate increases in proportion, leaving the overall number of vulnerabilities discovered per period constant. More recent research casts some doubt on this assertion [Rescorla 04, Ozment 05]. The third category of benefits includes the estimated monetary value of avoided risk of regulatory penalties, contractual penalties, and other sanctions.

Cost and Benefit Calculators

Two programs are available for download: one to calculate the benefits gained from added software security measures and one to calculate the costs associated with added software security measures. Both were designed in Excel using Visual Basic for Applications. For the programs to operate, you must have macros enabled.

Calculating Security Benefits

To calculate the benefits gained from adding security to a software project, it is necessary to gather the following information:

  • program size: The program’s size in number of source lines of code.

  • bug frequency: The number of bugs (both security and non-security bugs) that appear in the program per thousand source lines of code (tsloc).

  • costs incurred from bugs: The overall cost per bug.

The program’s size is a fairly easy number to ascertain from anyone on the development team, and recent research indicates that it may be possible to roughly determine the number of lines of code from a compiled program based on file size.

Bug frequency is a combination of the total number of non-security bugs plus the total number of security bugs that occur per thousand lines of code. Research currently indicates that the number of security bugs per thousand lines of code ranges from around 1 to 6. There are in fact commercial enterprises that are working on the problem of identifying bugs in source code, such as Coverity, as well as others who engage in independent code reviews.

The costs incurred from a bug are divided into pre-release costs and post-release costs. The following information is required to determine the cost component:

  • pre-release component

    • the percentage of bugs detected and fixed pre-release

    • the average cost per bug fix pre-release

  • post-release component

    • the percentage of security bugs believed to be discovered and exploited by attackers. (This number may be a guess on the part of the user, so it is best to try running the program with a series of guesses to build up a range of values.)

    • public relations costs, including the amount of effort expended in terms of man months plus any additional costs incurred

    • legal costs, including the amount of effort expended in terms of man months plus any additional costs incurred

    • client support costs in terms of man months expended

    • the effect on future sales revenue lost due to a security breach. Sales are assumed to recover after one year.

    • additional incidental costs in dollars

    • the overall cost involved in diagnosing a problem post-release in man months plus incidentals

    • the overall cost involved in patching software post-release in man months plus incidentals

    • the overall cost involved in software testing post-release in man months plus incidentals

    • the user’s average cost per man month

  • post-security component

    • the estimated reduction in the overall number of bugs (in percentage) that will occur due to increased security standards and controls

    • the estimated raise in bug detection pre-release due to increased security standards and controls

There are two separate equations used in the benefits calculation. The first one calculates the expected losses before security is added, and the second calculates the expected costs after security is added. The equations are as follows:

Benefit Equation (One): Expected Cost Pre-Security

Pre-Release Component = (PercentageOfBugsDiscoveredPreRelease * PreReleaseFixCost)

Exploit Component = (((NumberOfSecurityBugs / (NumberofSecurityBugs + NumberOfNonSecurityBugs)) * (1- PercentageOfBugsDiscoveredPreRelease)) * (PercentBugsExploited * TotalCosts))

Where:

TotalCosts = Total PR Costs + Total Legal Costs + Total Client Support Costs + Lost Profits + Other Costs

LostProfits= (PercentSalesLost * TotalSalesRevenue) * ProfitMargin

Post-Release Component = (1 – PercentDiscoveredPostRelease) * PostReleaseTotal

Where:

PostReleaseTotal = TotalDiagnosticCost + TotalPatchCost + TotalTestingCost

ExpectedCostPreSecurity = (Pre-ReleaseComponent + ExploitComponent + Post-ReleaseComponent) * NumberOfBugs * ProjectSize

Where:

NumberOfBugs = SecurityBugs + NonSecurityBugs

ProjectSize = Number of Lines of Code / 1000

Benefit Equation (Two): Expected Cost Post-Security

Pre-Release Component = (PercentageOfBugsDiscoveredPreRelease * (1 + IncreaseInPercentDiscoveredPreRelease) * PreReleaseFixCost)

Exploit Component = (((NumberOfSecurityBugs / (NumberofSecurityBugs + NumberOfNonSecurityBugs)) * (1- PercentageOfBugsDiscoveredPreRelease)) * (PercentBugsExploited * TotalCosts))

Where:

TotalCosts = Total PR Costs + Total Legal Costs + Total Client Support Costs + Lost Profits + Other Costs

LostProfits = (PercentSalesLost * TotalSalesRevenue) * ProfitMargin

Post-Release Component = (1 – PercentDiscoveredPostRelease) * (1 + IncreaseInPercentDiscoveredPreRelease) * PostReleaseTotal

Where:

PostReleaseTotal = TotalDiagnosticCost + TotalPatchCost + TotalTestingCost

ExpectedCostPostSecurity = (Pre-ReleaseComponent + ExploitComponent + Post-ReleaseComponent) * NumberOfBugs * ProjectSize

Where:

NumberOfBugs = SecurityBugs + NonSecurityBugs

ProjectSize = Number of Lines of Code / 1000

Benefit Equation (Three): Total Benefit

Total Benefit = Equation One – Equation Two

Calculating Security Costs

For calculating the cost of secure development, we modify the extant models to incorporate security features. Some of recent work in secure software development attempts to extend the existing cost estimation models (in particular COCOMO-II) to incorporate security features. The underlying idea of this approach is that incorporating security probably increases the effort required to develop the product. Thus conceptually,

ΔE = E(with security) - E(without security)

where E is the effort level in person month (PM) and ΔE is the additional effort required to develop a secure product. Since COCOMO-II has been used extensively in estimating E(without security) and users are quite familiar with such models, one can also estimate E(with security) with some confidence. The formula for effort level E (in person month) is given by

E (estimated) = a KLOCSF x Π (EM)

where KLOC is lines of code in thousands and SF is a scaling factor. In particular, SF can be set as SF = 1.01 + 0.01 SUM(Wi), where Wi are five scaling factors. EM are effort multipliers (there are 17 of them). Both Wi and EM are rated on the scale from very low, low nominal, high, very high, and extra high. The weight of each factor has been quantified based on calibration with various projects and continues to evolve. (See http://sunset.usc.edu/events/2003/March_2003/COCOMO_II_2003_Recalibration.pdf.)

Thus one of the strategies in calculating ΔE is to posit that incorporating more security affects KLOC, SF, and EM. If we can measure the percentage changes in these (for example, more security may mean that one of EM may shift from nominal to very high) then one can estimate how such a change will affect the effort level of the final product. Thus, if a manager can provide information on how incorporating security changes the effort multipliers and scaling factors, then we can use the formula above to calculate the additional cost incurred due to security.

Thus some recent work (still under research) has proposed this strategy, along with the fact that besides changing the EM or Ws, more security may induce some extra drivers not considered in COCOMO-II. For example, Boehm et al. propose a driver SECU that is additional to existing drivers in COCOMO and hence affects the effort level [Boehm 04]. Unfortunately, it is not entirely clear what the impact of new driver is and how it should constrain other drivers (to avoid double counting).

Based on the synthesis of the existing literature and practices, we first outline major costs that may be incurred when adding security to the software development and then suggest ways to measure them.

Major cost items:

  1. Use of new CASE tools or hardware/software that is required for developing secure software. If these tools are generic and can be used with other projects as well, their capital costs should be prorated appropriately.

  2. User training – Security requirements may require the firm to provide the developers some training. The costs are twofold: (1) there is the direct cost of training (i.e., hiring and paying someone to train employees; (2) there is an opportunity cost in term of time when employees are undergoing training. Both should be incorporated.

  3. Increase in the effort level (person month) due to security components and cost of increased effort. This is based on the formulae above.

  4. Impact of delay in product introduction due to additional security. More effort may cause project delay. In software, delay may or may not be costly. For example, [Hendricks 97] find that firms lose 5.25% in market value when delay in products is announced.

Thus to calculate the cost of additional software security, the following information must be obtained from the appropriate project staff member:

  • an estimate of the percentage change in source code size from adding security protection. For example, the staff member may believe the program’s size will grow 5% in number of lines of code due to increased security measures.

  • the estimated complexity (from very low to very high) of the software project before and after security is added. For example, the staff member may think the software project’s complexity was low before adding security measures but moderate or high afterwards.

  • an estimate of the level of program documentation (from very low to very high) required before and after security measures are increased

  • the estimated systems analyst capability (overall experience from very low to very high) before and after security is added (i.e., an estimate of the effect that the addition of security measures will have on the system analysts’ technical capabilities)

  • the estimated programming team capability (overall development experience from very low to very high) before and after security is added (i.e., an estimate of the effect that the addition of security measures will have on the programming teams’ technical capabilities)

  • an estimate of familiarity with tools that are required to add security to the software project. The staff member is asked how he or she feels the development teams’ experience with those tools is (from very low to very high) before and after addition of security.

  • an estimate of the change in development time required (from very low to very high) before and after security measures are added. For example, the staff member may believe that before security was needed, the project would take a moderate amount of time to complete, but after security is added it will take a very high amount of development time.

  • an estimate of the overall effort (in man months) required to develop the software before security is added. There may be records indicating that it takes on average 5 man months to complete a similar project, for example.

  • the average cost per man month, which is the amount spent on average per 30 days of an employee’s time

  • an estimate of reliability requirements (from very low to very high) before and after security. Before adding security, the staff member may have believed that the program only needed to be highly reliable, whereas to meet the claims and safety requirements of a security system it needs to be very highly stable.

  • an estimate of the cost of required user training

    • To calculate this, include the number of employees being trained, the average time (in days) they spend in training, and the average cost per employee per day.

  • an estimate of any losses that will be incurred due to a delayed market entry (in dollars)

Cost Equation (One): Effort Cost

EffortCost = NewEffort * CostPerPersonMonth

NewEffort = OldEffort * EffortChange

Where:

EffortChange = ((1 + PercentCodeSizeIncrease)^1.15) * (ComplexityBefore / Complexity After) * (Documentation Before / Documentation After) * (AnalystCapabilityBefore / AnalystCapabilityAfter) * (ProgrammerCapabilityBefore / ProgrammerCapabilityAfter) * (ToolsBefore / ToolsAfter) * (TimeBefore / TimeAfter) * (ReliabilityBefore / ReliabilityAfter)

The numerator and denominator of each of the terms in the “EffortChange” calculation is derived from the user’s answers to the corresponding values above and is assigned a numerical value from the University of Southern California’s Center for Software Engineering COCOMO cost driver research. We chose COCOMO because it is widely known and non-proprietary. There are other possible models for estimating effort cost, such as SLIM, Function Points, and ESTIMACS (see, for instance, [Kemerer 87]).

The following table contains each cost driver’s corresponding value for each choice (very low to very high), where applicable.

 

Complexity

Development
Time

Documentation
Requirements

Analyst
Capability

Programmer
Capability

Tools

Required Reliability

Very High

1.34

1.29

1.23

.81

.85

.78

1.26

High

1.17

1.11

1.11

.88

.91

.9

1.1

Moderate

1

1

1

1

1

1

1

Low

.87

N/A

.91

1.11

1.09

1.09

.92

Very Low

.73

N/A

N/A

1.22

1.19

1.17

.82

Cost Equation (Two): Opportunity Costs

OpportunityCost = NumberOfEmployeesInTraining * AverageLengthOfTraining * (AverageEmployeeCost / 365)

Cost Equation (Three): Cost of new CASE tools or hardware/software

Cost of New hardware and software = Capital expense to buy additional hardware and software for (prorated by the project). So if the cost of additional capital expense can be divided into 10 projects equally, then the cost = Capital Expense/10.

Cost Equation (four): Total Cost

TotalCost = EffortCost + TrainingCost + OpportunityCost + Cost of new CASE tools or hardware/software + DelayToMarketCost

References

[Arora 04]

Arora, A.; Hall, D.; Piato, C. A.; Ramsey, D.; & Telang, R. “Measuring the Risk-Based Value of IT Security Solutions.” IEEE IT Professional 6, 6 (Nov.-Dec. 2004): 35-42.

[Boehm 76]

Boehm, B.; Brown, J. R.; & Lipow. “Quantitative Evaluation of Software Quality,” 592-605. Proceedings of the 20th International Conference on Software Engineering, 1976.

[Boehm 04]

Boehm, B.; Colbert, E.; Chen, Y.; Wu, D.; & Reifer, D. “Costing the Development of Secure Systems.” Eighth Annual PSM Users' Group Conference: Measurement for Enterprise Excellence. Keystone, CO, July 26-30, 2004.

[Butler 02]

Butler, Shawn. “Security Attribute Evaluation Method: A Cost-Benefit Approach,” 2002.

[Campbell 03]

Campbell, K.; Gordon, L. A.; Loeb, M. P.; & Zhou, L. “The Economic Cost of Publicly Announced Information Security Breaches: Empirical Evidence from the Stock Market.” Journal of Computer Security 11, 3 (2003): 431-448.

[Cavusoglu 04]

Cavusoglu, H.; Mishra, B.; & Raghunathan, S. “The Effect of Internet Security Breach Announcements on Market Value: Capital Market Reactions for Breached Firms and Internet Security Developers.” International Journal of Electronic Commerce 9, 1 (Fall 2004): 69-104.

[Clark 98]

Clark, B.; Chulani, S.; & Boehm, B. “Calibrating the COCOMO II Post-Architecture Model,” 477–480. Proceedings of the 20th International Conference on Software Engineering, 1998.

[Hendricks 97]

Hendricks K. B. & Singhal, V. R. “Delays in New Product Introductions and the Market Value of the Firm: The Consequences of Being Late to the Market.” Management Science 43, 4 (1997): 422-436.

[Kemerer 87]

Kemerer, C. “An Empirical Validation of Software Cost Estimation Models.” Communication of the ACM, May 1987, 416-429.

[Krishnan 97]

Krishnan, M. S. “Cost Quality and User Satisfaction of Software Products: An Empirical Analysis.” Technical Report. 1997.

[Krishnan 00]

Krishnan, M. S.; Kriebel, C.; Kekre, S.; & Mukhopadhyay, T. “An Empirical Analysis of Cost and Conformance Quality in Software Products.” Management Science 46 (2000): 745-759.

[Mead 04]

Xie, Nick (Ning); Mead, Nancy R.; Chen, Peter; Dean, Marjon; Lopez, Lilian; Ojoko-Adams, Don; & Osman, Hasan. SQUARE Project: Cost/Benefit Analysis Framework for Information Security Improvement Projects in Small Companies (CMU/SEI-2004-TN-045, ADA431118). Pittsburgh, PA: Software Engineering Institute, Carnegie Mellon University, 2004.

[Microsoft 08]

MSDN. The Microsoft Security Development Lifecycle (SDL): Measurable Improvements for Flagship Microsoft Products, 2008.

[Ozment 05]

Ozment, A. “The Likelihood of Vulnerability Rediscovery and the Social Utility of Vulnerability Hunting.” Fourth Workshop on the Economics of Information Security. Cambridge, MA, June 2-3, 2005.

[Pinto 04]

Pinto, C. Ariel; Arora, Ashish; Hall, Dennis; & Schmitz, Edward. Challenges To Sustainable Risk Management, 2004.

Slaughter 98]

Slaughter, S.; Harter, D. E.; & Krishnan, M. S. “Evaluating the Cost of Software Quality.” Communication of the ACM 41, 8 (August 1998).

[Soo Hoo 01]

Soo Hoo, Kevin; Sadbury, A. W.; & Jaquith, A. R. “Return on Security Investments.” Secure Business Quarterly 1, 2 (2001).

[Rescorla 04]

Rescorla, E. “Is Finding Security Holes a Good Idea?The Third Workshop on Economics and Information Security. Minneapolis, MN, 2004.

[Telang 04]

Telang, Rahul & Wattal, Sunil. “Effect of Vulnerability Disclosures on Market Value of Software Vendors – An Event Study Analysis.” Workshop on Information Systems and Economics, Washington, DC, 2004.

 


Back to Top