Fundamental Practices for Secure Software Development

2ND EDITION

A Guide to the Most Effective Secure Development Practices in Use Today

February 8, 2011
Editor Stacy Simpson, SAFECode Authors
Mark Belk, Juniper Networks Matt Coles, EMC Corporation Cassio Goldschmidt, Symantec Corp. Michael Howard, Microsoft Corp. Kyle Randolph, Adobe Systems Inc. Mikko Saario, Nokia Reeny Sondhi, EMC Corporation Izar Tarandach, EMC Corporation Antti Vh-Sipil, Nokia Yonko Yonchev, SAP AG

Foreword
In 2008, the Software Assurance Forum for Excelof this report in an effort to help others in the lence in Code (SAFECode) published the first version industry initiate or improve their own software

bringing these methods together and sharing them with the larger community, SAFECode hopes to move the industry beyond defining theoretical best practices to describing sets of software engineering practices that have been shown to improve

assurance programs and encourage the industryfundamental secure development methods. This

the security of software and are currently in use at leading software companies. Using this approach enables SAFECode to encourage the adoption of

wide adoption of what we believe to be the most work remains our most in-demand paper and has original release.

best practices that are proven to be both effective and implementable even when different product taken into account. requirements and development methodologies are Though expanded, our key goals for this paper

been downloaded more than 50,000 times since its However, secure software development is not only a goal, it is also a process. In the nearly two and a half years since we first released this paper, the process and improve alongside innovations and advancements in the information and communications technology industry. Much has been learned not but also through the ongoing internal efforts of aims to help disseminate that new knowledge. of building secure software has continued to evolve

remainkeep it concise, actionable and pragmatic.

Whats New
This edition of the paper prescribes new and updated security practices that should be applied ties of the software development lifecycle. These practices have been shown to be effective across diverse development environments. While the

only through increased community collaboration, SAFECodes member companies. This 2nd Edition Just as with the original paper, this paper is not

during the Design, Programming and Testing activi-

original also covered Training, Requirements, Code Handling and Documentation, these areas were given detailed treatment in SAFECodes papers on

meant to be a comprehensive guide to all possible provide a foundational set of secure development practices that have been effective in improving

secure development practices. Rather, it is meant to

security engineering training and software integrity our focus in this paper to concentrate on the core areas of design, development and testing.

in the global supply chain, and thus we have refined

software security in real-world implementations by SAFECode members across their diverse development environments.

The paper also contains two important, additional sections for each listed practice that will further increases its value to implementersCommon Weakness Enumeration (CWE) references and Verification guidance.

It is important to note that these are the practiced practices employed by SAFECode members, which we identified through an ongoing analysis of our members individual software security efforts. By ii

CWE References
SAFECode has included CWE references for each
SAFECode has published a series of papers on software supply chain integrity that aim to help others understand and minimize the risk of vulnerabilities being inserted into a software product during its sourcing, development and distribution. The software integrity controls discussed in the papers are used by major software vendors to address the risk that insecure processes, or a motivated attacker, could undermine the security of a software product as it moves through the links in the global supply chain. The controls aim to preserve the quality of securely developed code by securing the processes used to source, develop, deliver and sustain software and cover issues ranging from contractual relationships with suppliers, to securing source code repositories, to helping customers confirm the software they receive is not counterfeit. Copies of The Software Supply Chain Integrity Framework: Defining Risks and Responsibilities for Securing Software in the Global Supply Chain and Overview of Software Integrity Controls: An Assurance-Based Approach to Minimizing Risks in the Software Supply Chain are available at www.safecode.org.

listed practice where applicable. Created by MITRE Corp., CWE provides a unified, measurable set of software weaknesses that can help enable more of software security practices. By mapping our

effective discussion, description, selection and use recommended practices to CWE, we wish to provide a more detailed illustration of the security issues these practices aim to resolve and a more precise

starting point for interested parties to learn more.

Verification
A common challenge for those managing software security programs is the need to verify that development teams are following prescribed security

practices. SAFECode aims to address that challenge with this new edition. Wherever possible, we have included methods and tools that can be used to verify whether a practice was applied. This is an

emerging area of work and SAFECode hopes to use in this area.

community feedback to further bolster its guidance Software vendors have both a responsibility and SAFECode has collected and analyzed the secure

a business incentive to ensure software security. development methods currently in use among its with highly actionable advice for improving soft-

SAFECode encourages all software developers and into their own development environments. The result of efforts like these will not only benefit

vendors to consider, tailor and adopt these practices

members in order to provide others in the industry ware security. This is a living document and we plan to continue to update it as the industry and pracand suggestions as to how we can continue to improve this papers usefulness to readers. tices evolve. Thus, SAFECode encourages feedback

industry through a more secure technology ecoconfidence in the quality and safety of software

system, but also provide a higher level of end-user that underpins critical operations in governments, critical infrastructure and businesses worldwide.

iii

Table of Contents
Foreword
Whats New CWE References Verification ii ii iii iii 2 2 2 5 5 6 7 8 8 9 10 10 10 11

Secure Coding Practices

Minimize Use of Unsafe String and Buffer Functions CWE References Verification Resources Validate Input and Output to Mitigate Common Vulnerabilities CWE References Verification Resources

12 12 13 14 15 15 17 17 18

Introduction Secure Design Principles

Threat Modeling CWE References Verification Resources Use Least Privilege CWE References Verification Resources Implement Sandboxing CWE References Verification Resources

Use Robust Integer Operations for Dynamic Memory Allocations and Array Offsets 19 CWE References Verification Resources Use Anti-Cross Site Scripting (XSS) Libraries CWE References Verification Resources Use Canonical Data Formats CWE References Verification Resources 20 20 21 22 24 24 26 27 27 28 28

iv

Avoid String Concatenation for Dynamic SQL Statements CWE References Verification Resources Eliminate Weak Cryptography CWE References Verification Resources Use Logging and Tracing CWE References Verification Resources

29 29 30 31 32 33 34 35 37 37 38 38 39 39 39 40 41 41 42 42

Technology Recommendations
Use a Current Compiler Toolset CWE References Verification Resources Use Static Analysis Tools CWE References Verification Resources

44 44 45 45 46 47 49 49 49 50 51 51

Summary of Practices Moving Industry Forward Acknowledgements

Testing Recommendations
Determine Attack Surface Use Appropriate Testing Tools Perform Fuzz / Robustness Testing Perform Penetration Testing CWE References Verification Resources

Introduction
A review of the secure software development processes used by SAFECode members reveals that there are corresponding security practices for each activity in the software development lifecycle that can improve software security and are applicable across diverse environments. The examination of these vendor practices reinforces the assertion that software security must be addressed

Secure Design Principles

Threat Modeling
The most common secure software design practice used across SAFECode members is Threat Modeling, a design-time conceptual exercise where a systems dataflow is analyzed to find security vulnerabilities and identify ways they may be exploited. Threat Modeling is sometimes referred to as Threat Analysis or Risk Analysis.

throughout the software development lifecycle to single box on a checklist. Moreover, these security members, a testament to their ability to be inteenvironments.

be effective and not treated as a one-time event or methods are currently in practice among SAFECode grated and adapted into real-world development The practices defined in this document are as

Proactively understanding and identifying threats and potential vulnerabilities early in the development process helps mitigate potential design issues that are usually not found using other techniques, such as code reviews and static source analysis. In essence, Threat Modeling identifies issues before or mitigated as early as possible in the software

code is writtenso they can be avoided altogether development lifecycle. Threat Modeling can also cannot be identified by other means.

diverse as the SAFECode membership, spanning and database applications, as well as operating To aid others within the software industry in

cloud-based and online services, shrink-wrapped systems, mobile devices and embedded systems. adopting and using these software assurance best practices effectively, this paper describes each identified security practice across the software advice based on the experiences of SAFECode members.

uncover insecure business logic or workflow that Rather than hope for an analysis tool to find

potential security vulnerabilities after code is implemented, its more efficient for software development teams to identify potential product

development lifecycle and offers implementation

vulnerability points at design time. This approach

enables them to put in place defenses covering all

possible input paths and institute coding standards to help to control the risk right from the beginning. It is worth noting that an analysis tool lacks knowledge of the operating environment in which the system being analyzed executes.

By their nature, systemic architectural issues are Thus, Threat Modeling can be considered a cost-

more costly to fix at a later stage of development. efficient, security-oriented activity, because fixing

is relatively well established but has not yet been

finalized, and in the Agile model, the activity could

occur during initial design or be a recurring activity most likely to undergo change.

issues early in the process may be as easy as changing an architecture diagram to illustrate a change similar issues after coding has begun could take fied after code was committed, or even a major even later by customers in the field. to a solution yet to be coded. In contrast, addressing months of re-engineering effort if they are identirelease or a patch release if an issue was identified Leveraging the full benefits of Threat Modeling when designing systems can be challenging as software designers and architects strive to identify all possible issues and mitigate them before moving forward. This can be difficult to achieve,

during each iteration or sprintwhen the design is The process of Threat Modeling begins with the threats. Different SAFECode practitioners have

identification of possible and commonly occurring adopted different approaches to the task of enu-

merating threats against the design being analyzed: STRIDE this methodology classifies threats into 6 groups: Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service and Elevation of Privilege. Threat Modeling is executed by looking at each component of the system and determines if any threats that fall into these categories exist for that component and its relationships to the rest of the system. Misuse cases The employment of misuse cases helps drive the understanding of how attackers might attack a system. These cases

so the focus must be on the high-risk issues that

can be identified at design time. In addition, Threat Modeling results should be continuously updated become relevant, and threats may be mitigated or clearly visible use case limitations. as design decisions change and added threats may during development or by virtue of documentation Threat Modeling can be done at any time in the the process should be performed as early in the

should be derived from the requirements of the system, and illustrate ways in which protective measures could be bypassed, or areas where there are none. For example, a misuse case

systems lifecycle, but to maximize effectiveness development process as possible. Distinct software development methodologies will have different points where system design may change: in a

involving authentication would state By suc-

cessively entering login names, an attacker can harvest information regarding the validity (or not) of such login names. Brainstorming if an organization does

traditional waterfall development model, Threat Modeling would be performed when the design

not have expertise in building threat models,

having a security-oriented discussion where the

designers and architects evaluate the system is better than not considering potential application weaknesses at all. Such brainstorming

in design to enable less costly mitigations. Even

without available mitigations or design changes introduced, a complete Threat Model provides a applications. good way to measure and manage security risk in The end result of a Threat Modeling exercise may vary, but it will certainly include an annotated diagram of the system being evaluated, as well as a list of the associated threats (mitigated and not). It has been observed in some cases that Threat Modeling as part of recurring activities in the Software Development Lifecycle helps to drive a

should not be considered a complete solution, and should only serve as a stepping stone to a more robust Threat Modeling exercise. Threat library a format that makes threat professionals. Such a library must be open to of threats. Publicly available efforts like CWE

identification more accessible to non-security changes to ensure it reflects the evolving nature (Common Weakness Enumerationa dictionary Application Security Project) Top Ten and CAPEC (Common Attack Pattern Enumeration and Classification that describes common methods of exploiting software) can be used to help build this library. Use of a Threat library can be a knowledge (helping teams that lack sufficient knowledge themselves) or combine elements of other Threat Modeling methods (such as classification). linking a threat to misuse cases and a STRIDE

of software weakness types), OWASP (Open Web

culture that accepts security as an integral aspect

of software designthe benefit is cumulative, with ones.

later iterations building on the experience of earlier Different approaches offer varying requirements

quick way to take advantage of industry security

of prior security expertise in order to achieve good

results, and it is possible to choose the one that better suits the situation at hand, and later on change to another approach based on the improving awareness to security in the involved participants. As a conceptual exercise, Threat Modeling will highly benefit from close communication since

Once identified, each threat must be evaluated it (using a risk rating system such as Common

and mitigated according to the risk attached to Vulnerability Scoring System (CVSSv2), for example), the resources available, the business case and the system requirements. This will help prioritize the order in which threats should be addressed durthe mitigation. At times, this will drive changes ing development, as well as the costs involved in

having all those responsible present in one location can lead to lively, results-generating discussion. However, geographically dispersed teams will

still be able to conduct Threat Modeling exercises disposal, from remote presence setups to spreadsheets and diagrams sent over email. The speed of the exercise may vary, but there are no specific

using the many means of communication at their

negative impacts to the end result if the exercise for example.

becomes a question-answer discussion using email, Tools are available that support the Threat Model-

Verification
A comprehensive verification plan is a direct derivative of the results of the Threat Model activity. The Threat Model itself will serve as a clear roadmap for verification, containing enough information so that each threat and mitigation can be verified. During verification, the Threat Model and the

ing process with automated analysis of designs and suggestions for possible mitigations, issue-tracking integration and communication related to the

process. Some practitioners have honed their Threat Modeling process to the point where tools are used to automate as much of it as possible, raising the layer of support with standard diagramming, test cases, and execution of recurring tasks. repeatability of the process and providing another annotation, integration with a threat database and

mitigated threats, as well as the annotated architectural diagrams, should also be made available to testers in order to help define further test cases and refine the verification process. A review of the Threat Model and verification results should be declare code complete. made an integral part of the activities required to An example of a portion of a test plan derived from a Threat Model could be:
Threat Identified Session Hijacking Design Element(s) GUI

CWE References
Much of CWE focuses on implementation issues, and Threat Modeling is a design-time event. There to the threat modeling process, including:

are, however, a number of CWEs that are applicable CWE-287: Improper authentication is an example ing threat of weakness that could be exploited by a Spoof-

Mitigation Ensure random session identifiers of appropriate length

Verification Collect session identifiers over a number of sessions and examine distribution and length Assert that communication cannot be established without the use of SSL

CWE-264: Permissions, Privileges, and Access ing, Repudiation and Elevation of Privilege threats

Controls is a parent weakness of many TamperTampering with data in transit Process A on server to Process B on client Use SSL to ensure that data isnt modified in transit

CWE-311: Missing Encryption of Sensitive Data is an example of an Information Disclosure threat is one example of an unmitigated Denial of Service threat CWE-400: (uncontrolled resource consumption)

Resources
References: OWASP; Open Web Application Security Project; http://www.owasp.org http://cwe.mitre.org CWE; Common Weakness Enumeration; CAPEC; Common Attack Pattern http://capec.mitre.org

Software Security; Chapter 2, A Risk Addison-Wesley; 2006.

Management Framework; McGraw;

Security Mechanisms for the Internet; org/rfc/rfc3631.txt

Bellovin, Schiller, Kaufman; http://www.ietf.

Capturing Security Requirements through Misuse Cases; Sindre and Opdahl; http:// folk.uio.no/nik/2001/21-sindre.pdf McGraw; Addison-Wesley; 2006.

Enumeration and Classification;

CVSSv2; Common Vulnerability Scoring System; http://www.first.org/cvss/ Presentations: AND-304: Threat Modeling: Lessons Learned and Practical Ways To Improve Your Software; RSA Conference 2010; Dhillon & Shostack Books, Articles and Reports: The Security Development Lifecycle; Chapter 9, Stage 4: Risk Analysis; Microsoft Press; Howard & Lipner

Software Security; Chapter 8, Abuse Cases; Tools / Tutorials: The Microsoft SDL Threat Modeling Tool; getstarted/threatmodeling.aspx http://www.microsoft.com/security/sdl/

Software Security Assurance: State-of-theArt Report; Section 5.2.3.1, Threat, Attack, and Vulnerability Modeling and Assess-

ment; Information Assurance Technology Analysis Center (IATAC), Data and Analysis mil/iatac/download/security.pdf Center for Software (DACS); http://iac.dtic.

Use Least Privilege

The concept of executing code with a minimum set of privileges is as valid today as it was 30 years ago when it was described in Saltzer and Schroeders seminal paper, The Protection of Information in is simple, but it can be hard to achieve in some

Android requires applications to describe the applications AndroidManifest.xml file. to describe application capabilities. assigned to them. entitlements.

permissions needed by the application in the

Windows Phone 7 uses WMAppManifest.xml Symbian applications can have capabilities iOS applications have the concept of .NET applications can describe required permissions in the app.manifest file. java.policy. Java can do likewise in the policy file named Windows applications and services run under an account (a Security Identifier [SID]) that is granted group membership and privileges. account that has implicit privileges.

Computer Systems. The concept of least privilege cases. Even though least privilege means different things in different environments, the concept is the same: Every program and every user of the system should operate using the least set of privileges necessary to complete the job. Least privilege is important because it can help

reduce the damage caused if a system is compromised. A compromised application running with full privileges can perform more damage than a privileges. The value of operating with reduced privileges cannot be stressed enough.

compromised application executing with reduced

Linux applications and daemons run under an Some Linux distributions (e.g. MeeGo) use 1003.1e draft (also referred to as POSIX.1e). Some Linux distributions (e.g.; Fedora and technologies including SIDs and labels.

The concept of privilege varies by operating system, development technologies and deployment scenarios. For example:

capabilities derived from the now-defunct POSIX

Most mobile platforms will force all non-operwith minimal privilege, but developers should still only select the privileges or permissions For example:

RedHat) use SELinux, which provides extensive

ating system code to run in a sandbox running

Some Linux distributions (e.g.; Ubuntu and Suse) use AppArmor, which supports some POSIX tion profiles. 1003.1e draft capabilities and supports applica-

required for the application to execute correctly.

 Grsecurity is a set of patches for Linux that access control (RBAC) mechanisms.

provide, amongst other security tools, role-based

CWE References
Like sandboxing, the core CWE is the following: CWE-250: Execution with Unnecessary Privileges

In short, privileges, capabilities and entitlements

determine which sensitive operations can be per-

formed by applications and users. In the interests of kept to a minimum.

Verification
Verifying an application is running with least privilege can be subjective, but there are some tools that can provide details to help an engineer underto a running process: stand which permissions and privileges are granted In Windows, Application Verifier will issue violations are detected at runtime.

security, it is imperative that sensitive operations be There are two development aspects of least privilege that must be considered. The first is making sure that the application operates with minimum fully in a least privilege environment. Develop-

privileges and the second is to test the application ers are notorious for building and smoke-testing

LuaPriv warnings if potential least privilege

applications using full privilege accounts, such as

For Windows Phone 7, the Windows Phone Capability Detection Tool can help determine what the permission set should be for a Windows Phone 7 application.

root or members of the administrators group. This usually conducted in low-privilege environments. It is strongly recommended that all developers privilege accounts.

can lead to problems during deployment, which are

Least privilege is typically enforced in applications

and testers build and test applications using least The second point of consideration is to thoroughly test the application in a least privilege environment to shake out least-privilege related bugs. It is recommended that the application under test related issues noted and fixed. be subject to a complete test pass and all securityFinally, a least privilege environment must include tamper proof configuration, otherwise applicacapabilities. tions or users might be able to grant more trusted

via configurable user or code permissions. Therefore, performing regular audits or reviews of the default permissions can be an effective means toward ensuring least privilege in secure code. The review

can be based on a software specification, outlining user roles or the functions of supplementary comthe software, for example, with integration tests. ponents, or via a post-implementation validation of

Resources
Books, Articles and Reports: The Protection of Information in Computer Systems; Saltzer, Schroeder; http://www. cs.virginia.edu/~evans/cs551/saltzer/

ols.fedoraproject.org/OLS/Reprints-2008/ hallyn-reprint.pdf Tools / Tutorials: Android Manifest.permission; http:// Manifest.permission.html developer.android.com/reference/android/

nixCraft; Linux Kernel Security (SELinux vs

AppArmor vs Grsecurity); Gite; http://www. cyberciti.biz/tips/selinux-vs-apparmor-vsgrsecurity.html

MSDN Library; Application Manifest File for Windows Phone; http://msdn.microsoft. com/en-us/library/ff769509(v=VS.92).aspx MSDN Library; How to: Use the Windows Phone Capability Detection Tool; http:// msdn.microsoft.com/en-us/library/ gg180730(VS.92).aspx

SAP Developer Network; Integrated Identity and User Management; http://www. sdn.sap.com/irj/sdn/go/portal/prtroot/ netweaver-developers-guide-2004s/ com.sap.km.cm.docs/library/netweaver/ SAP%20NetWeaver%20Developer%27s%20 Guide%202004s/IUAM%20Further%20 Information.ca

MSDN Library; Windows Application Verifier; http://msdn.microsoft.com/en-us/library/ dd371695(VS.85).aspx

Authorizations in SAP Software: Design and Press; 2010. Presentations:

Configuration; Lehnert, Bonitz & Justice; SAP

Linux Capabilities: Making Them Work; Linux Symposium 2008; Hallyn, Morgan; http://

Implement Sandboxing
While the concept of sandboxing processes is not new, the industry has seen an increase in interest written. in the topic since the first version of this paper was Running a process in a users session on many

Features provided by operating systems to support sandboxing functionality include: Integrity Levels on Windows Dropping process privileges Disabling high-privilege user accounts used by the process Running each application as a unique user Permission Manifests File system jails Applications that are installed on a large number of systems (>1 million, for example) and process untrusted data from the Internet are highly Process-level memory isolation

popular operating systems usually implies that the which the user is entitled. No distinction is made between what a users web browser should have

process has all of the privileges and access rights to

access to and what their word processing software abuse of those privileges:

should have access to. This model has three risks of a. Unrestricted execution of arbitrary native code achieved via memory corruption bugs able to the user b. Abuse of functionality using the privileges availc. Executing arbitrary code from within a manenvironment

encouraged to implement sandboxing. In addition, applications that are installed as plugins to highthe host applications sandbox. risk applications like browsers should work within Many current mobile platforms run all applications in a sandboxed environment by default.

aged code (C#, Java, Python, Ruby etc) runtime

Using a managed language, such as C# or Java,

defends against the first scenario by managing

CWE References
There is one parent CWE that relates directly to sandboxing: CWE-265: Privilege / Sandbox Issues

memory on behalf of the application. Managed

runtimes also have their own sandboxes to defend against the second scenario using policy-driven code access security. When switching to a managed language is not an option, such as in large legacy code bases, sandboxing offers an alternative mitigation by utilizing operating system security features to restrict the abilities of a sandboxed process.

Verification
Ensure that all ingredients provided by the platform for a sandbox are implemented correctly

10

by reviewing the resources below for the target entire sandbox protection ineffective.

platform. One missing ingredient can render the Review the attack surface that is available from within the sandbox. This can be accomplished using tools like SandKit, which enumerates all resources that are accessible from within the sandbox. Validate that each item found zation checks. performs adequate input validation and authori Review the sandbox policy to ensure the

Resources (continued)
Tools / Tutorials: Chromium Sandbox Design Document; design-documents/sandbox http://www.chromium.org/developers/

OS X Sandboxing Design; http:// www.chromium.org/developosx-sandboxing-design ers/design-documents/sandbox/ iOS Application Programming Guide: http://developer.apple.com/library/ tual/iphoneosprogrammingguide/

least amount of access necessary is granted.

For example, review an Android applications that are too relaxed.

The Application Runtime Environment; ios/documentation/iphone/concepRuntimeEnvironment/RuntimeEnvi-

androidmanifest.xml for granted permissions

Resources
Books, Articles and Reports: Practical Windows Sandboxing Part 1; Leblanc; http://blogs.msdn.com/b/ david_leblanc/archive/2007/07/27/ aspx

ronment.html#//apple_ref/doc/uid/ TP40007072-CH2-SW44l Android Security and Permissions; topics/security/security.html

http://developer.android.com/guide/

practical-windows-sandboxing-part-1. Inside Adobe Reader Protected Mode Part 1 Design; McQuarrie, Mehra, Mishra, Randolph, Rogers; http:// blogs.adobe.com/asset/2010/10/ part-1-design.html

The AndroidManifest.xml file; http:// manifest/manifest-intro.html SandKit/

developer.android.com/guide/topics/

SandKit; http://s7ephen.github.com/

inside-adobe-reader-protected-mode-

11

Secure Coding Practices

In this section, the focus shifts to the low-level members. development-related practices used by SAFECode

Development engineers should be instructed to

avoid using these classes of function calls. Using

tools to search the code for these calls helps verify that developers are following guidance and helps identify problems early in the development cycle. Building the execution of these tools into the

Minimize Use of Unsafe String and Buffer Functions

Memory corruption vulnerabilities, such as buffer overruns, are the bane of applications written in C and C++. An analysis of buffer overrun vulner-

normal compile/build cycle relieves the developers from having to take special efforts to meet these goals.

abilities over the last 10 years shows that a common cause of memory corruption is unsafe use of stringand buffer-copying C runtime functions. Functions such as, but not limited to, the following function families are actively discouraged by SAFECode removed over time from older code. strcpy family strncpy family strcat family strncat family scanf family sprint family memcpy family gets family members in new C and C++ code, and should be

It is important to be aware of library- or operating system-specific versions of these function classes. to strcpy called lstrcpy and Linux has a memcpy too should be avoided. For example, Windows has a functional equivalent equivalent called bcopy, to name a few, and these Some example replacement functions include:
Unsafe Function strcpy strncpy strcat strncat scanf sprintf memcpy gets Safer Function strcpy_s strncpy_s strcat_s strncat_s scanf_s sprintf_s memcpy_s gets_s

12

Developers using C++ should consider using the

classes built into the standard language library to than using strcpy or strncpy in C++, developers should use std::string objects.

source code. However, the benefit of using these

manipulate buffers and strings. For example, rather

options is high as in many cases over 50 percent of insecure functions are migrated to safer function calls in legacy code for very little engineering effort.

The memcpy function deserves special mention

CWE References
There are many CWE entries that related to memory- and buffer-related issues, including: CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer Input (Classic Buffer Overflow) Value CWE-120: Buffer Copy without Checking Size of CWE-805: Buffer Access with Incorrect Length

because many developers believe it is safe. It is safe when used correctly, but if an attacker controls the number of bytes to copy, or the developer incorrectly calculates the buffer size, then the function

becomes insecure. SAFECode believes that developers should move away from using memcpy in favor of memcpy_s as the latter forces the developer to think about the maximum destination buffer size.

Automatic use of safer functions

Both Microsoft Visual C++ and GNU gcc offer an option to migrate some buffer-copying function

calls to safer calls if the destination buffer size is

known at compile time. Consider adding the following definitions to the respective compiler options: Visual C++: D_CRT_SECURE_CPP_OVERLOAD_ STANDARD_NAMES=1 gcc: D_FORTIFY_SOURCE=2 O2 Some SAFECode members note that using these options can make code review more complex because the resulting object code differs from the

13

Verification
The following tools and techniques can be used to verify this practice is used.
Tool or Technique banned.h Coverity Fortify SCA 360 Outcome No function deprecation warnings when compiling with this header No warnings from the OVERRUN_STATIC checker C/C++: Buffer Overflow None of the following warnings: C/C++: Format String C/C++: Buffer Overflow (Off-by-One) C/C++: Buffer Overflow (Signed Comparison) C/C++: Out-of-Bounds Read C/C++: Out-of-Bounds Read (Off-by-One) C/C++: Out-of-Bounds Read (Signed Comparison) Klocwork Microsoft Visual C++ No warnings from the NNTS, NNTS.TAINTED, SV.STRBO.GETS, SV.STRBO. UNBOUND_COPY, SV.STRBO.UNBOUND, SPRINTF checkers None of the following warnings: C4996 The following require the code to be compiled with /analyze: C6029 C6053 C6057 C6059 C6200 C6201 C6202 C6203 C6204 RATS No Severity: High warnings

14

Resources
Books, Articles and Reports: Please Join Me in Welcoming memcpy() msdn.com/b/sdl/archive/2009/05/14/ to-the-sdl-rogues-gallery.aspx Presentations: strlcpy and strlcat Consistent, Safe, String Copy and Concatenation; USENIX org/events/usenix99/millert.html Tools / Tutorials: banned.h; http://www.microsoft. com/downloads/en/details. 9ee2-fa86aad1e3c9 aspx?FamilyID=6aed14bd-4766-4d9d Strsafe.h; http://msdn.microsoft.com/ en-us/library/ms647466(VS.85).aspx SafeStr; https://buildsecurityin.us-cert. BSI.html to the SDL Rogues Gallery; http://blogs. please-join-me-in-welcoming-memcpy-

Validate Input and Output to Mitigate Common Vulnerabilities

Checking the validity of incoming data and rejecting non-conformant data can remedy the most common vulnerabilities that lead to denial of service,

data or code injection and misuse of end user data. In some cases, checking data validity is not a trivial exercise; however, it is fundamental to mitigating risks from common software vulnerabilities.

Checking the validity of outgoing data can remedy many web-based vulnerabilities, such as cross site scripting, as well as mitigate information leakage issues. Data enter and exit an application in the form

99; Miller, de Raadt; http://www.usenix.

of a byte stream, which is then interpreted into

variables with specific parameters for length and validity before it is processed by the application,

data type. Input validation refers to checking data whereas output validation refers to validating application data after it is processed, with the purpose of For successful data validation, the variables conguidelines: matching the expectations of its intended recipient. tents should be validated according to the following Input variable must be checked for existence

gov/bsi/articles/knowledge/coding/271-

and for conformance to specified data lengths. its simplest and shortest representation. Also referred to as canonicalization. This topic is Formats on page 27.

Data must be normalized, or transformed into

discussed in more detail in Use Canonical Data

15

 Data must be checked for conformance with output recipients.

data types specified by the application and its

To be effective, this approach requires disciplined

application of data validation to all input and outshould be supported by an explicit requirement document.

put. The implementation of data validation libraries in a secure development standard or specification In some user applications types, notably web-based applications, validating and/or sanitizing output is critical in mitigating classes of attacks against

For fields with clear value ranges, data must be range.

checked for conformance with a specified value

A whitelist filter should be applied to limit input to allowed values and types. For data where defining such a whitelist is not possible, the

data validation should be performed against a blacklist of disallowed values and data types. A whitelist is a list or register of data elements and types that are explicitly allowed for use within the context of a particular application. By contrast, a blacklist is a list or register of data elements and

user applications, arising from vulnerabilities such cross-site request forgery.

as cross-site scripting, HTTP response splitting and For applications running on a remote server and

consumed over the network from a user client, data validation should take place on the server. Implementing data validation within the user client can

types that are explicitly disallowed for use within a particular application. Whitelisting typically constrains the application inputs to a pre-selected list and rejects only the banned data elements and/or types. Applications should not rely solely on using blacklists as there are often many ways around especially true for web-based applications.

be bypassed and is discouraged. If data validation at the user client cant be avoided, it should be associated with data validation at the server application and the corresponding error handling. Data validation should also not be neglected for

of values, whereas blacklisting gives more freedom

the list using various escaping mechanisms. This is Another approach with greater flexibility is to

applications that exchange data with other applications without user interaction, particularly for applications that expose functions via remotely callable interfaceseither via proprietary or

use data validating libraries for input and output

validation and cleanup during development. Such

standardized protocols such as SOAP, REST or others. can use regular expressions or string comparisons for validation against data type descriptors.

data validating libraries are available for almost all

Interfaces that accept text and structured XML data,

programming languages and application platforms.

16

Last but not least, nontransparent and harder-tobe checked for data length and field validity.

validate binary or encoded data should at minimum Additionally, the source of the binary data may be of digital signatures as a data validation method

Verification
An effective way to verify this practice is to look for the application. The specific methods should be the existence and use of validation methods within described in secure development guidelines, requiring the use of libraries or manual input and output verification and when they should be used. The verification of the proper application of the recommended methods can be performed via standardized QA methods such as code reviews or automated code scanning tools. Verification should be performed during the active application development phase, ideally in close collaboration phases. with interface definitions during application design

verified with the use of digital signatures. The use should, in general, be deployed for data exchanges exchanges in banking transactions. In these cases, signature validation should be the very first check that is applied.

with integrity protection requirements, such as the

CWE References
Input and output validation is often the parent issue that leads to many classes of vulnerability forgery. CWE captures the high-level nature of following:

such as XSS, buffer overruns and cross-site request this weakness in a number of CWEs including the CWE-20: Improper Input Validation CWE-183: Permissive Whitelist CWE-184: Incomplete Blacklist CWE-625: Permissive Regular Expression

17

Resources
Books, Articles and Reports: Writing Secure Code 2nd Ed; Chapter 10, All Input is Evil!; Howard, LeBlanc; Microsoft Press.

Tools / Tutorials: SAP Developer Network Secure Programming Guides; http://www.sdn.sap. com/irj/scn/go/portal/prtroot/docs/ 8015f3951d1a

library/uuid/334929d6-0a01-0010-45a9 Input and Data Validation; ASP.NET; http://wiki.asp.net/page.aspx/45/ input-and-data-validation/

Protecting Your Web Apps: Two Big Mis-

takes and 12 Practical Tips to Avoid Them; Kim, Skouis; SANS; http://www.sans.org/ reading_room/application_security/protect-

ing_web_apps.pdf

Data Validation; OWASP; http://www.

JavaWorld; Validation with Java and XML Schema, Part 1; Mclaughlin; http://www. 0908-validation.html?page=1 javaworld.com/javaworld/jw-09-2000/jw-

owasp.org/index.php/Data_Validation flash-validators/

Flash Validators; http://code.google.com/p/ Struts; OWASP; http://www.owasp.org/ index.php/Struts Java Data Validation Swing Components; Components/Data-Validation.htm

http://www.java2s.com/Code/Java/Swing-

18

Use Robust Integer Operations for Dynamic Memory Allocations and Array Offsets
There are three types of integer issues that can result in security vulnerabilities such as buffer overflows: Overflow and underflow Signed versus unsigned errors Data truncation These integer issues can occur during arithmetic, boolean and binary operations. assignment, cast, type conversion, comparison, shift, Its important to note that this issue can apply to all programming languages, not just C and C++. The proper solution is to use robust integer

Do not use signed integers for arguments to use unsigned integers instead.

memory allocation functions or array offsets;

Check that the number of elements expected

(e.g.; number of bytes in a request) is no larger

than a predetermined value that is smaller than the largest amount of memory the application should allocate. of integers: Other general best practices for robust handling Pay attention to the assumptions about sign and size of data types in and across different languages, platforms, compilers, or managed to unmanaged code. For example, a size_t is a difA size_t is the size of a memory address, so it is a 32-bit value on a 32-bit platform, but a 64-bit value on a 64-bit platform. Compile code with the highest possible warning level, such as /W4 when using Visual C++ or Wall when using gcc. ferent type depending on the platform you use.

datatypes, such as the ones provided in the SafeInt library, which force robust handling of all integer operations. When this solution is not feasible recommended: to implement, the following best practices are Use unsigned integers (such as DWORD and size_t) for array indexes, pointer offsets, and buffer sizes.

When available, enable compiler features to detect integer issues, such as ftrapv in gcc. Catch exceptions for detected integer issues if

Use unsigned integers for while, do, and for

loops. An integer overflow can occur in the loop during increment and decrement operations of the index variable. These overflows may cause number of bytes from a buffer.

they are provided by the platform or language. cial directive to throw exceptions for detected integer issues. For example, use the checked keyword in C#.

Some languages and platforms may need a spe-

either an infinite loop or reading/writing a large

19

 It is not necessary to use robust integer operations when the integers involved cannot be manipulated by an attacker. Assumptions like evolves.

Verification
A blend of actions is recommended to verify that safe integer arithmetic has been implemented: Review static analysis output for arithmetic

this must be evaluated regularly as the software

issues. Results vary widely by static analysis tool. pilation with a high warning level enabled, such as /W4. Results vary by compiler. In general, compilers are typically more effective at identifying signed/unsigned mismatches and truncation issues than overflows and underflows. Examples of warnings related to integer issues include C4018, C4389 and C4244.

CWE References
CWE-129: Improper Validation of Array Index CWE-190: Integer Overflow or Wraparound CWE-131: Incorrect Calculation of Buffer Size CWE-680: Integer Overflow to Buffer Overflow CWE-805: Buffer Access with Incorrect Length Value

Review compiler output resulting from a com-

Investigate all use of pragmas that disable

compiler warnings about integer issues. Comment them out, re-compile and check all new integer-related warnings.

Develop fuzzing models that exercise inputs

used for pointer arithmetic, such as arguments the models exercise boundary conditions, such as 1 and 0xFFFFFFFF.

used for payload size and array offset. Also, have

Manually review the code for functions that

allocate memory or perform pointer arithmetic. small and well-understood range.

Make sure that the operands are bounded into a

20

The following tools and techniques can be used to verify this practice is used.
Tool or Technique Coverity Outcome No warnings from the OVERRUN_DYNAMIC, MISRA_CAST, NEGATIVE_RETURNS, REVERSE_ NEGATIVE, TAINTED_SCALAR checker C/C++: Buffer Overflow (Off-by-One) C/C++: Format String C/C++: Out-of-Bounds Read C/C++: Out-of-Bounds Read (Off-by-One) C/C++: Integer Overflow C/C++: Buffer Overflow C/C++: Buffer Overflow (Signed Comparison) C/C++: Out-of-Bounds Read (Signed Comparison) Klocwork No warnings from the SV.TAINTED. ALLOC_SIZE, ABV.TAINTED Buffer, SV.TAINTED.CALL.INDEX_ACCESS, SV. TAINTED.INDEX_ACCESS checkers No Severity: High warnings

Resources
Books, Articles and Reports: Phrack; Basic Integer Overflows; html?issue=60&id=10#article Blexim; http://www.phrack.org/issues.

Safe Integer Operations; Plakosh; Pearson Education; https://buildsecurityin. us-cert.gov/bsi/articles/knowledge/ coding/312-BSI.html?layoutType=plain MSDN Library; Integer Handling with msdn.microsoft.com/en-us/library/ ms972705 the C++ SafeInt Class; LeBlanc; http://

Fortify SCA 360

The Art of Software Security Assessment: Identifying and Preventing ald, Shuh; ISBN: 978-0321444424. Tools / Tutorials: MSDN Library; Reviewing Code for Integer Manipulation Vulnerabilities; en-us/library/ms972818 Software Vulnerabilities; Dowd, McDon-

Howard; http://msdn.microsoft.com/

RATS

21

Use Anti-Cross Site Scripting (XSS) Libraries

This section is a web-specific variant of Validate ties above. input and output to mitigate common vulnerabiliCross Site Scripting (XSS) stands for a class of

DOM-based XSS, can also misuse input for cious scripts on the user client side.

legitimate client-side scripts to execute mali3. Once the user browser displays the static or

dynamically-generated HTML, generated from the misused input field, the malicious script is identified as such by the user browser and automatically executed. With its automated browser-side execution, the script runs under the browser privilege of the user client and is is shared with the browser. able to access and misuse private user data that

vulnerabilities in applications that allow the injection of active scripting data into script-enabled application screens. XSS-based attacks most often target script-interpreting web clients, generally web browsers. XSS attacks occur by maliciously injecting script into an application that fails to

validate incoming and outgoing data. A successfully conducted attack that exploits XSS vulnerabilities privilege escalation, user impersonation, code propagation of XSS based attacks. the following steps: can lead to serious security violations such as user injection, user client hijacking and even background A cross site scripting attack is typically executed in 1. Attacker identifies input fields into a web-based application, which lack input validation and are reused to generate static or dynamic output in a subsequent script-enabled application

As a defense-in-depth measure, XSS issues can be avoided by validating all output that may include untrusted user client-originating input. The large

number of input and output fields in a typical web application, however, makes manual validation of validation, the use of anti-XSS libraries, or web every field impractical. As an alternative to manual UI frameworks with integrated XSS protection,

can minimize the developers efforts by correctly

validating application input and outputs. Anti-XSS

libraries are available for most web application plat-

screen. Attackers may use visible or hidden input fields in the input pages, or input parameters exchanged via web application URLs.

forms, where exposure to XSS attacks is highest. The resources section contains a list of the most popular ones; further references are available from the web platform vendors support documentation. Generally, anti-XSS measures must be built in to tions are present:

2. The attacker misuses the identified input fields to inject active scripts in the application flow. The script code may be delivered directly in the input field, remotely via a custom URL or

software applications when the following condi1. Application accepts input from users

based on a previous injection. A variant of XSS,

22

2. The input is used for dynamic content generation, or is displayed to users in a subsequent script-enabled application screen.

If users are allowed to enter a URL within the permit only the selection of approved URLs. Encode all web applications outputs so that any inserted scripts are prevented from being form.

input field, restrict the domain of the URL and

While XSS protections can be used to a large extent by applying output validation techniques, input validation addresses the root cause of the XSS

transmitted to user browsers in an executable Use HTML meta elements to clearly identify the character encoding in the output document.

vulnerabilities. As a general rule, both must always to the techniques outlined in section Validate

be used in conjunction with each other. In addition Input and Output to mitigate common vulner-

abilities, the basic development rules to avoid XSS selection, are as follows: Constrain Input: Define a codepage (such as charset = characters. ISO-8859-1) to narrow down problematic

vulnerabilities, as well as criteria for anti XSS library

Depending on the output context and the

encoding used, convert problematic metacharacters originating from user input, for &quot; example in HTML < to &lt; , > to &gt; , and to

Wherever feasible, encode the whole page displayed to the user to plain HTML. This measure has to be used carefully as it also deactivates capabilities for dynamic web page content and customizations.

Filter meta-characters based on their

intended interpreter (e.g. HTML client, web browser, file system, database, etc.) Used alone, this practice is not secure; therefore ered an extra defensive step.

filtering meta-characters should be consid Normalize input, or bring it to a specified form before its validation. Validate all user input at the server: Against a whitelist, to accept only known unproblematic characters or data types

In addition, most of the current web browsers offer options for deploying user client-side protection measures, via browser plug-ins, or as in integral part of the browser UI rendering engine. By adding an HTTPOnly flag to client-side cookies, user clients

can also be instructed to limit cookie use and make cookies unavailable to access from an active script or one embedded in the browser objects (Java applet, ActiveX control, etc.). Anti-virus solutions can also validate to some extent user client-side application inputs and detect attacks. For local

23

applications with script-enabled UIs, placing the UIs in a sandboxed file system location can also help to reduce the available attack surface. Client-side protection measures against XSS are, and their consistent use by users cant be relied

Verification
Verification follows the basic rules laid out in the section Validate Input and Output to Avoid Com-

mon Security Vulnerabilities. Detailed strategies for mitigating XSS vulnerabilities are also listed in the referenced CWE. issues: The following methods can be used to find XSS Automated code scanning tools with application data flow analysis capabilities Code scanning or reviews to verify the application of anti-XSS libraries or proper application input and output validation methods

however, web browser or client platform specific upon. Therefore, client-side protection against XSS should not be considered a replacement for server side protection that uses input and output validation methods or anti-XSS libraries.

CWE References
The following CWE is relevant to XSS issues: CWE-79: Improper Neutralization of Input DurThere are many child CWEs that relate to web vulnerabilities: CWE-81: Improper Neutralization of Script in an Error Message Web Page CWE-82: Improper Neutralization of Script in Attributes of IMG Tags in a Web Page Attributes in a Web Page CWE-83: Improper Neutralization of Script in CWE-84: Improper Neutralization of Encoded URI Schemes in a Web Page CWE-85: Doubled Character XSS Manipulations CWE-86: Improper Neutralization of Invalid Characters in Identifiers in Web Pages XSS Syntax CWE-87: Improper Neutralization of Alternate ing Web Page Generation (Cross-site Scripting)

24

The following tools and techniques can be used to verify this practice is used.
Tool or Technique Fortify SCA 360 Outcome None of the following warnings: .NET: Cross-Site Scripting (Persistent) .NET: Cross-Site Scripting (Reflected) .NET: Cross-Site Scripting (Poor Validation) Java: Cross-Site Scripting (DOM) Java: Cross-Site Scripting (Persistent) Java: Cross-Site Scripting (Reflected) Java: Cross-Site Scripting (Poor Validation) JavaScript: Cross-Site Scripting (DOM) PHP: Cross-Site Scripting (Persistent) PHP: Cross-Site Scripting (Reflected) PHP: Cross-Site Scripting (Poor Validation) Python: Cross-Site Scripting (Persistent) Python: Cross-Site Scripting (Reflected) Python: Cross-Site Scripting (Poor Validation) SQL: Cross-Site Scripting (Persistent) SQL: Cross-Site Scripting (Reflected) SQL: Cross-Site Scripting (Poor Validation) VB/VB.NET: Cross-Site Scripting (Persistent) VB/VB.NET: Cross-Site Scripting (Reflected) VB/VB.NET: Cross-Site Scripting (Poor Validation) ColdFusion: Cross-Site Scripting (Persistent) ColdFusion: Cross-Site Scripting (Reflected) ColdFusion: Cross-Site Scripting (Poor Validation)

Klocwork

No warnings from the NNTS , NNTS.TAINTED, SV.STRBO.GETS, SV.STRBO. UNBOUND_COPY, SV.STRBO.UNBOUND,_SPRINTF checkers

25

Resources
References: Apache Wicket; http://wicket.apache.org/ OWASP Top 10 2010, Cross Site ScriptTop_10_2010-A2 ing; http://www.owasp.org/index.php/

OWASP XSS (Cross Site Scripting) Prevention Cheat Sheet; http://www.owasp.org/index. vention_Cheat_Sheet php/XSS_%28Cross_Site_Scripting%29_Pre SAP Developer Network, Secure Programming Guides; http://www.sdn.sap. com/irj/scn/go/portal/prtroot/docs/ 8015f3951d1a

Wikipedia Entry; http://en.wikipedia.org/ wiki/Cross_site_scripting IE 8 XSS Filter; http://www.microsoft.com/ aspx

library/uuid/334929d6-0a01-0010-45a9 MSDN Library; Microsoft Anti-Cross Site

windows/internet-explorer/features/safer.

Scripting Library V1.5: Protecting the Contoso Bookmark Page; Lam; http://msdn.microsoft.com/en-us/library/aa973813.aspx

Tools / Tutorials: OWASP Enterprise Security API; Interface Encoder; http://owasp-esapi-java.googleesapi/Encoder.html

Microsoft Code Analysis Tool .NET

(CAT.NET) v1 CTP-32 bit; http://www.

code.com/svn/trunk_doc/latest/org/owasp/ OWASP PHP AntiXSS Library; http://www. owasp.org/index.php/Category:OWASP_ PHP_AntiXSS_Library_Project www.codeplex.com/AntiXSS

microsoft.com/downloads/en/details. c93f24cc9f9d&displaylang=en

aspx?FamilyId=0178e2ef-9da8-445e-9348-

Microsoft Web Protection Library; http:// OWASP Reviewing Code for Cross-site scripting; http://www.owasp.org/index.php/ Reviewing_Code_for_Cross-site_scripting Mozilla Content Security Policy; http:// people.mozilla.org/~bsterne/contentsecurity-policy/index.html

26

Use Canonical Data Formats

Where possible, applications that use resource names for filtering or security defenses should use times known as standardization or normalization, is the process for converting data that establishes into a standard, normal, or canonical form. For

attacking web applications. Successful attacks may allow for unauthorized data reading, unauthorized data modification or even denial of service, thus ability respectively. compromising confidentiality, integrity and availCanonical representation ensures that the various forms of an expression do not bypass any security or filter mechanisms. Best design practices suggest all decoding should be executed first using

canonical data forms. Canonicalization, also some-

how various equivalent forms of data are resolved example, within the context of a windows file path, any one of the following paths: C:\my files\Hello World.docx C:\my files\Hello World.docx (same as above, but the o in docx is a Cyrillic letter, U+043E) c:\my files\hello worLD.docx c:\myfile~1\hellow~1.doc C:/my files/Hello World.docx \\?\c:\files\hello.pdf %homedrive%\my files\Hello World.docx \\127.0.0.1\C$\my files\Hello World.docx C:\my files\.\..\my files\Hello World.docx \ :-) \..\my files\\\\Hello World.docx Besides the use of numerous canonical formats, attackers on the web often take advantage of rich encoding schemes available for URL, HTML,

the data file Hello World.docx may be accessible by

appropriate APIs until all encoding is resolved. Next, the input needs to be canonicalized. Only then can authorization take place.

CWE References
The CWE offers many examples of canonicalization issues, including: Errors CWE-21: Pathname Traversal and Equivalence CWE-22: Improper Limitation of a Pathname to a Restricted Directory (Path Traversal) CWE-35: Path Traversal: .../...// CWE-36: Absolute Path Traversal CWE-37 Path Traversal: /absolute/pathname/ here here CWE-38 Path Traversal: \absolute\pathname\ CWE-39 Path Traversal: C:dirname CWE-40 Path Traversal: \\UNC\share\name\

XML, JavaScript, VBScript and IP addresses when

27

Verification
Few tools can find real canonicalization issues, but automated techniques can find areas where or customization may be required to remove or

Resources
Books, Articles and Reports: Writing Secure Code 2nd Ed.; Chapter 11 Canonical Representation Issues; Howard & Leblanc; Microsoft Press.

path traversal weaknesses exist. However, tuning de-prioritize path-traversal problems that are only privileged users.

exploitable by the softwares administrator or other Examples of automated tests include adding extra path details (such as path traversal characters), changing case and using escaped characters at

Hunting Security Bugs; Chapter 12 Canonicalization Issues; Gallagher, Jeffries & Lanauer; Microsoft Press. Tools / Tutorials: OWASP ESAPI Access Reference Map API; http://owasp-esapi-java.googlecode.com/svn/ enceMap.html

random when running stress tests that exercise file access. This could be considered a form of directed fuzz testing.

trunk_doc/latest/org/owasp/esapi/AccessRefer OWASP ESAPI Access Control API; InterfaceAccess Controller; http://owasp-esapi-java.googlecode. com/svn/trunk_doc/latest/org/owasp/esapi/ AccessController.html

The following tools and techniques can be used to verify this practice is used.
Tool or Technique Coverity Fortify SCA 360 Outcome No warnings from the TAINTED_ STRING checker ColdFusion: Path Manipulation C/C++: Path Manipulation .NET: Path Manipulation Java: Path Manipulation PHP: Path Manipulation Python: Path Manipulation VB/VB.NET: Path Manipulation Veracode None for the aforementioned CWE weakness Tests used: Automated Static

Microsoft KnowledgeBase; How to Programmatically Test for Canonicalization Issues with ASP. NET; http://support.microsoft.com/kb/887459 MSDN Library; PathCanonicalize Function (Win32); http://msdn.microsoft.com/en-us/library/ bb773569(VS.85).aspx

MSDN Library; .Net Framework 4 URI class; tem.uri.aspx

http://msdn.microsoft.com/en-us/library/sys-

SAP Developer Network Secure Programming Guides; http://www.sdn.sap.com/ irj/scn/go/portal/prtroot/docs/library/

uuid/334929d6-0a01-0010-45a9-8015f3951d1a

28

Avoid String Concatenation for Dynamic SQL Statements

Building SQL statements is common in databasedriven applications. Unfortunately, the most common way and the most dangerous way to build SQL statements is to concatenate untrusted data string concatenation should not be used to build with string constants. Except in very rare instances, SQL statements. Common misconceptions include

SQL injection flaws can often be detected using

automated static analysis tools. False positives may when proper input validation was performed. Most importantly, false negatives may be encountered when custom API functions or third-party librarbecause the code is not available for analysis.

arise when automated static tools cannot recognize

ies invoke SQL commands that cannot be verified Successful SQL injection attacks can read sensitive data, modify data and even execute operating system level commands.

the use of stored procedures, database encryption, secure socket layer (SSL), and removal and duplication of single quotes as ways to fix SQL injection

vulnerabilities. While some of those techniques can hinder an attack, only the proper use of SQL placeholders or parameters can build SQL statements securely. Different programming languages, libraries and

CWE References
There is one major CWE: CWE-89: Improper Neutralization of Special Elements used in an SQL Command (SQL Injection)

frameworks offer different functions to create SQL

statements using placeholders or parameters. As a

developer, it is important to understand how to use this functionality correctly as well as to understand the importance of avoiding disclosing database information in error messages.

Proper database configuration is a vital defense in depth mechanism and should not be overlooked: ideally, only selected stored procedures should

have execute permission and they should provide no direct table access. System accounts servicing privilege necessary for the application to run. If to only support parameterized queries. database requests must be granted the minimum possible, the database engine should be configured

29

Verification
OWASP offers pertinent testing advice to uncover SQL injection issues (see Resources). Various tools can help detect SQL injection vulnerabilities:
Tool or Technique Microsoft CAT.NET (using SQL Injection checks) Microsoft Visual Studio Code Analysis Microsoft FxCop (Microsoft.Security category) W3AF (sqli and blindSqli plugins) Fortify SCA 360

Outcome No A SQL injection vulnerability was found warnings No CA2100 warnings No CA2100 warnings No warnings ColdFusion: SQL Injection C/C++: SQL Injection .NET: SQL Injection .NET: SQL Injection (Castle Active Record) .NET: SQL Injection (Linq) .NET: SQL Injection (NHibernate) .NET: SQL Injection (Subsonic) Java: SQL Injection Java: SQL Injection (JDO) Java: SQL Injection (Persistence) Java: SQL Injection (Ibatis Data Map) JavaScript: SQL Injection PHP: SQL Injection Python: SQL Injection SQL: SQL Injection VB/VB.NET: SQL Injection

Veracode

None for the aforementioned CWE weakness Tests used: Automated Static, Automated Dynamic, Manual

30

Resources
References: OWASP; SQL Injection; http://www.owasp. org/index.php/SQL_Injection Books, Articles and Reports: Giving SQL Injection the Respect it Deserves; Howard; http://blogs.msdn.com/sdl/ the-respect-it-deserves.aspx archive/2008/05/15/giving-sql-injection Unixwiz.net; SQL Injection Attacks by techtips/sql-injection.html

Tools / Tutorials: OWASP; Guide to SQL Injection; Guide_to_SQL_Injection http://www.owasp.org/index.php/

OWASP; Testing for SQL Injection;

http://www.owasp.org/index.php/

Testing_for_SQL_Injection_(OWASP-DV-005) Web Application Attack and Audit Frame SAP Developer Network Secure Programming Guides; http://www.sdn.sap. com/irj/scn/go/portal/prtroot/docs/ 8015f3951d1a work (W3AF); http://w3af.sourceforge.net/

Example; Friedl; http://www.unixwiz.net/

library/uuid/334929d6-0a01-0010-45a9-

31

Eliminate Weak Cryptography

Over the last few years, serious weaknesses have been found in many cryptographic algorithms and protocols and random number generation. Due to the widespread use of cryptography for securing authentication, authorization, logging, encryption or data validation/sanitization application protection in particular, cryptography-related ware applications security.

Though vendors need to account for cryptographic export restrictions, FIPS 140-2 is an example of a sound standard to consider.

their implementation, including underlying security

The following algorithms and cryptographic technologies should be treated as insecure: MD4 MD5 SHA1 Symmetric cryptographic algorithms (such as DES, which only supports 56-bit key length) imposing the use of keys shorter that 128-bits Stream ciphers (such as RC4 and ARC) should be ciphers correctly and securely mode discouraged due to the difficulty of using stream

processes, and their confidentiality and integrity weaknesses can have a serious impact on a softWhen appropriate for communication purposes,

especially network communications, strong prefer-

ence should be given to standardized protocols that (SSL), Transport Layer Security (TLS), IPSec, Kerberos, OASIS WS-Security, W3C XML Encryption and XML Signature, etc.rather than using low-level crypunique cryptographic protocol.

have undergone public reviewSecure Socket Layer

Block ciphers using Electronic Code Book (ECB) Any cryptographic algorithm that has not been subject to open academic peer review The design, implementation and public review of cryptographic technology has inherent technical complexities. Even in small development projects with easy task coordination, security weaknesses can result from the improper use of cryptography. To avoid common implementation errors, applications should reuse cryptographic functions as a

tographic algorithms and developing a custom or If low-level cryptography must be used, only standardized cryptographic algorithms and implementations, known to be presently secure, should be used in software development. When appropriate, consideration should be given to

government-approved or required algorithms. For

example, U.S. federal government customers require FIPS 140-2 validation for products using cryptography. FIPS 140-2 defines a set of algorithms that have been determined to be sound, as well as an assessment process that provides a level of assurance of the quality of cryptographic implementations.

service, and design and implementation of proprietary cryptographic methods should be avoided. The mandatory use of the common cryptographic functions should be required by internal developbelow. ment standards or policies and verified as outlined

32

Application developers must use high quality

random number generation functions when creating cryptographic secrets, such as encryption keys. Cryptographic code should never use algorithmic random number generation functions, such as System.Random in C# or VB.NET. rand() in C or C++, java.util.Random in Java and Another key element for eliminating weak cryptogto cryptographic keys. Cryptographic keys are used during program execution to perform encryption, decryption and integrity verification operations. Their exposure to malicious users via insecure

Symmetric encryption keys are also frequently used in network communication over open networks such as the Internet. In these cases, preference

should be given to asymmetric key cryptographic algorithms to distribute symmetric keys. These algorithms have, by design, lower exposure of secret key material in the remote communica-

tion, and with security protocol standardization efforts, enable more secure distribution of keys revocation infrastructures. over specialized key distribution, management and For key protection beyond the secured endpoints, application developers should consider providing manage keys used by the application. security guides to help administrators protect and

raphy is ensuring secure management of and access

program flow, configuration or mismanagement software applications and security protocols.

can result in serious weaknesses in the security of Treating keys as application data with very high throughout the application lifecycle should be among the top priorities in secure application

CWE References
The CWE includes a number of cryptographic weaknesses under the following umbrella: CWE-310: Cryptographic Issues Under this weakness are issues like: CWE-326: Inadequate Encryption Strength CWE-327: Use of a Broken or Risky Cryptographic Algorithm Mode CWE-329: Not Using a Random IV with CBC CWE-320: Key Management Errors CWE-331: Insufficient Entropy CWE-338: Use of Cryptographically weak PRNG

security requirements and ensuring their security

development. While at rest, keys should always be managed within a secure system configuration database, a secure file system or hardware storage location. Access to system keys must be granted explicitly to applications via key storage access control mechanisms or role assignment of the

applications users. After reading key material from a secure key, storage applications shouldnt embed or persistently store keys or key material elsewhere. Key material must be securely erased from memory when it is no longer needed by the application.

33

Verification
Applications should be verified for compliance to the use of cryptographic operations. internal development standards or requirements for During the application design phase, internal

During application development, verification must

focus on checking the source code implementation ensuring the secure handling of keys, including while they are in use or at rest. The verification

for the correct use of the prescribed guidelines and

standards should require statements about the

can be conducted either by source code review, or by automated source code scanners. The validadirections: tion should be performed in the following general Reuse of centrally-provided cryptographic and random number functions Check against invocation of banned cryptographic algorithms, known to be insecure Check against hard-coded or self-developed functions for random number generation, that shouldnt be used encryption, integrity protection or obfuscation Secure management and use of keys Secure configuration for keys to keys by default Check for proper protocol selection to application interaction channels that require protection cryptography-based confidentiality or integrity

availability of cryptographic functions to meet the specification. Where cryptographic functions are used, the verification has to focus on driving the for:

use cases and requirements outlined in application

application planning toward prescribed guidelines The cryptography-providing libraries that should be used How the libraries should be accessed from within the application destroyed How keys should be created, accessed, used and Where relevant, the security protocol that keys or communication

should be used for exchanging cryptographic

34

Tool or Outcome Technique Fortify SCA 360 None of the following warnings: C/C++: Weak Cryptographic Hash C/C++: Weak Cryptographic Hash (Hard-coded Salt) C/C++: Weak Encryption (Inadequate RSA Padding) C/C++: Weak Encryption (Insufficient Key Size) Java: Weak Cryptographic Hash (Hard-coded Salt) Java: Weak Encryption Java: Weak Encryption (Inadequate RSA Padding) Java: Weak Encryption (Insufficient Key Size) PHP: Weak Cryptographic Hash PHP: Weak Cryptographic Hash (Hard-coded Salt) PHP: Weak Encryption (Inadequate RSA Padding) PHP: Weak Encryption SQL: Weak Cryptographic Hash VB/VB.NET: Weak Cryptographic Hash VB/VB.NET: Weak Encryption (Insufficient Key Size) ColdFusion: Weak Cryptographic Hash ColdFusion: Weak Encryption JavaScript: Weak Cryptographic Hash JavaScript: Weak Encryption JavaScript: Weak Encryption (Insufficient Key Size) Klocwork No warnings from the SV.FIU.POOR_ENCRYPTION checker

Resources
References: NIST; Computer Security Division Computer Security Resource Center; Cryptographic Module Validation groups/STM/cmvp/index.html Program (CMVP); http://csrc.nist.gov/ National Institute of Standards and

Technology (NIST) Federal Information rity Requirements for Cryptographic tions/fips/fips140-2/fips1402.pdf

Processing Standard (FIPS) 140-2; SecuModules; http://csrc.nist.gov/publica RSA Laboratories; Public-Key Cryptography Standards (PKCS); http://www.rsa. com/rsalabs/node.asp?id=2124

Public-Key Infrastructure (X.509)

(pkix);Description of Working Group; charter.html

http://www.ietf.org/html.charters/pkix W3C XML Encryption Work Group; http://www.w3.org/Encryption http://www.w3.org/Signature W3C XML Signature Work Group; Cryptographically secure pseudorandom number generator; http://en.wikipedia. org/wiki/Cryptographically_secure_ pseudorandom_number_generator commoncriteriaportal.org/

Common Criteria Portal: http://www.

35

Resources (continued)
Books, Articles and Reports: The Developers Guide to SAP NetWeaver Security; Raepple; SAP Press; 2007. Cryptography Engineering: Design PrinSchneier and Kohno; Wiley 2010.

Tools / Tutorials: Oracle ; Java SE Security Cryptography Extension; http://www.oracle.com/technetwork/ java/javase/tech/index-jsp-136007.html Generic Security Services Application wiki/GSSAPI

ciples and Practical Applications; Ferguson,

Program Interface; http://en.wikipedia.org/ The Generic Security Service API Version 2 update 1; http://tools.ietf.org/html/ rfc2743

The Security Development Lifecycle; Chapter 20; SDL Minimum Cryptographic Standards; Howard & Lipner; Microsoft Press. Security Engineering: A Guide to Building 5; Cryptography; Anderson; http://www. cl.cam.ac.uk/~rja14/book.html Programming Satans Computer; Anderson and Needham; http://www.cl.cam. ac.uk/~rja14/Papers/satan.pdf Dependable Distributed Systems, Chapter

The Generic Security Service API Version rfc2744

2: C-bindings; http://tools.ietf.org/html/

Randomness Requirements for Security; http://tools.ietf.org/html/rfc4086

SDL Crypto Code Review Macro; Howard;

http://blogs.msdn.com/b/michael_howard/ macro.aspx

archive/2007/06/14/sdl-crypto-code-review-

36

Use Logging and Tracing

In the event of a security-related incident, it is important for personnel to piece together relevant details to determine what happened, and this requires secure logging. The first practice embraced by SAFECode members is to use the logging feacreating new logging infrastructure. Developers should use the Event Log APIs for Windows and syslog for Linux and MacOS. In some cases, it is tures of the operating system if possible rather than

Unambiguous username or email address Client machine address (IP address) UTC time & date Event code (to allow rapid filtering) Event description Event outcome (e.g. user access allowed or rejected) Changes to application security configuration Configuration changes to level of logged events Maintenance of log records for security or system events A good best practice is to differentiate between shooting, and audit logs, relevant for forensic

appropriate to use non-OS logging, for example W3C log files used by web servers. The underlying infrastructure for these logging technologies is secure as they provide tamper protection. It is critically important that any logging system provide controls to prevent unauthorized tampering. Some processes, for example those running in a sandbox,

monitoring logs, relevant for configuration troubleanalysis for the application security issue exploitation. This best practice helps avoid an overload of log records with useless event records. Both types of logs should be configurable during application tion of levels of richness of logging information. runtime, with the configuration allowing the defini-

may require a broker-process to hand off event data insufficient rights to update log files.

to the logging system because the process itself has Developers should log enough data to trace and

correlate events, but not too much. A good example words and credit card information. For cases where the logging of such information cant be avoided, is written in the log record. logged include: events the sensitive data has to be made hidden before it Examples of minimum information that should be User access authentication and authorization

of too much is logging sensitive data such as pass-

CWE References
There are three main CWE logging references software engineers should be aware of: CWE-778: Insufficient Logging CWE-779: Logging of Excessive Data CWE-532: Information Leak Through Log Files

37

Verification
Verification for the use of logging and tracing

Resources
References: Common Criteria for Information Technology Security Evaluation; Part 2: Security functional components; July 2009; http://www.commoncriteriaportal.org/files/ccfiles/CCPART2V3.1R3.pdf IETF; RFC 5425 Transport Layer Security (TLS) Transport Mapping for Syslog; org/search/rfc5425 Miao, Ma and Salowey; http://tools.ietf. Books, Articles and Reports: The Security Development Lifecycle; Howard & Lipner; Microsoft Press. Tools / Tutorials: SAP Help Portal; Security Audit Log (BC-SEC); http://help.sap.com/ p. 279 Repudiation Threat Tree Pattern;

should be benchmarked to industry standards,

internal development standards or the require-

ments of product security certification programs

such as Common Criteria. In the verification process, testers should check configuration capabilities of application logging and tracing functionalities and keep in mind that the level of logging information ment in which the application operates. is not standardized and is subjective to the environThe methods that can be used to verify proper use of logging and tracing include code reviews, code scans and security assessments. Results from threat modeling should also be used to evaluate the security risk exposure of the application and determine the level of necessary auditing needed.

saphelp_nw70ehp2/helpdata/en/68/ c9d8375bc4e312e10000009b38f8cf/ frameset.htm

SAP Help Portal; Security Audit Log of

AS Java; http://help.sap.com/saphelp_ 44db2935f0d502af295/frameset.htm

nw70ehp2/helpdata/en/03/37dc4c25e43

38

Testing Recommendations
Testing activities validate the secure implementation of a product, which reduces the likelihood of security bugs being released and discovered by

Determine Attack Surface

A prerequisite for effective testing is to have an upto-date and complete understanding of the attack gathered from an up-to-date threat model. Attack surface data can also be gathered from port scanAnalysis Tool (see Resources). surface. A great deal of attack surface detail can be

customers and/or malicious users. The goal is not robustness and security of the software.

to add security by testing, but rather to validate the Automated testing methods are intended to find certain types of security bugs, and should be performed on the source code of all products under development because the cost of running such automated tests is low. In addition to automated tests, security test cases can be based on results from threat modeling, misuse cases (use cases

ning tools and tools like Microsofts Attack Surface Once the attack surface is understood, testing can then focus on areas where the risk or compliance requirements are the highest. In most cases, this includes any protocol and parser implementations that process inputs. In some cases, parts of immediate external interface.

the attack surface may be elsewhere than on the Attack surface can be determined from the products requirements and design by looking at the inputs to the programnetworking ports, IPC/RPC, the product, for example, with a port scanner. Periodically validating the attack surface of the actual ties being opened up in the system by a change code can also assist in preventing new vulnerabilior bug fix. Products with a large attack surface or attack.

that should be prevented), or previously identified quality assurance test cases in that instead of try-

bugs. Often, security test cases differ from regular ing to validate expected functionality, security test

cases try to uncover application failures by creating Though security testing is sometimes done as

unexpected and malicious input and circumstances. acceptance testing prior to making the product

user input, web interfaces, and so on, or by scanning

available to customers, it is likely to be more costeffective and detect regressions and errors better when brought to an earlier phase in the software development lifecycleto module or integration testing, for example. Security test case creation can even precede implementation, as in test or behavior-driven development models.

complex input processing are more susceptible to

Use Appropriate Testing Tools

Different tools have different focuses. Fuzz testing tools aim to detect errors in the program code, and do not rely on knowledge of previously known

39

vulnerabilities, although new fuzz test cases should be added to detect any newly discovered vulnerabilities. See Perform Fuzz/Robustness testing

is typically larger if test tools are run by an external group that may not have complete understanding on the system.

below for further information about fuzz testing. Some network and web application vulnerability scanners can also target programming errors. Some of these scanners can test against known classes of vulnerabilities such as SQL injections and cross-site scripting vulnerabilities. Many scanning tools are used by IT staff to verify their systems are correctly

Perform Fuzz / Robustness Testing

Fuzz testing is a reliability and security testing technique that relies on building intentionally malformed data and then having the software

under test consume the malformed data to see how it responds. The science of fuzz testing is maturing general use are available, but in some cases softto suit specialized file and network data formats rapidly. Fuzz testing tools for standard protocols and ware developers must build bespoke fuzz testers used by their application. Fuzz testing is an effective testing technique because it uncovers weaknesses in data-handling code that may have been missed by code reviews or static analysis.

updated and configured rather than used by devel-

opers. But some tools, especially those that focus in administrative issues, can be very useful at finding security issues. Network packet analyzers and network or web

finding application-level vulnerabilities, rather than

proxies that allow man-in-the-middle attacks and data manipulation are typically used for exploratory testing. The use of these tools often requires extensive knowledge of the underlying protocols. session identifiers or message headers on the fly. Automation at all stages of the testing process is important because automation can tirelessly For example, a web proxy could be used to change

The process of fuzz testing can be lengthy, so autogiven to higher exposure entry points for fuzz testaccessible TCP port, because higher exposure entry points are more accessible to attackers. In order to perform effective fuzz testing, select

mation is critical. It is also important that priority be ing, for example, an unauthenticated and remotely

augment human work. On the other hand, the use of automated tools will require careful setup and tweaking to get proper results. An automated tool

tools that best support the networking protocols

or data formats in use. If none can be found in the the low-level process required to build effective fuzz tools is beyond the scope of this paper, the for readers interested in learning more.

that is blindly run against a system without undertest some parts of the system at all, or test it with

marketplace, fuzz test tools should be built. Though

standing the system or its attack surface might not the wrong type of inputs. The risk of this happening

Resources section below provides some references

40

Fuzz testing is not static. Fuzz testing cases

should evolve as new vulnerabilities are found.

Penetration test cases can be based on misuse cases or attacker stories, requirements that specify what should not be possible.

For example, if a vulnerability is discovered in the

applications file parser, a fuzz test case should be test case should be added to the library of tests

created that would trigger that condition. This new that are run regularly against the application. In format has not been previously fuzz tested.

The advantage of using competent, third-party penetration testers is their breadth of experience. The challenge is finding third-party testers that will do technologies. Developing an in-house penetration team has the advantage of maintaining internal

some cases, a new fuzzer may be needed if the data Fuzz testing may be used in conjunction with other testing types. For example, a more focused vulnerability scanner can be used to inject fuzz inputs to the target product.

an effective job for the product type, architecture or

product knowledge from one test to the next. However, it takes time for an internal team to develop the experience do a complete penetration and skill sets to
It should be stressed that testing is not a replacement for a development process that helps build more secure software, but rather that security testing is a core part of such a software development process.

Perform Penetration Testing

The goal of penetration testing is to break the system by applying testing techniques usually

testing job and ing should be

employed by attackers, either manually or by using attack tools. Penetration testing is a valuable tool for discovering vulnerabilities that reside in the systems business logic. High-level business logic

penetration testprioritized after secure design and coding and

aspects are often hard to detect from the code level. However, it is important to realize that a penetrapoor development and testing practices. tion test cannot make up for an insecure design or Some SAFECode members have dedicated penetration testing teams while others employ external penetration and security assessment vendors. Some SAFECode members use both in-house and external security penetration expertise. Penetration testing should be performed along with standard func-

other security testing measures.

CWE References
Security testing should cover any aspect of the system or application and therefore should valiweaknesses.

date the effectiveness of controls for all types of Fuzz testing mainly targets exception and incorrect input handling (CWE-20). However, sometimes application. the input might be valid, but mishandled by the

tional testing as part of a comprehensive test plan.

41

First-line input handling weaknesses include, for example: CWE-118: Improper Access of Indexable Resource CWE-703: Failure to Handle Exceptional Conditions CWE-228: Improper Handling of Syntactically Invalid Structure Elements CWE-237: Improper Handling of Structural CWE-229: Improper Handling of Values CWE-233: Parameter Problems Protocol-level security testing is useful for detectProtection Mechanism Failure, such as CWE-757: tiation (Algorithm Downgrade) or CWE-345: Insufficient Verification of Data Authenticity. ing, for example, weaknesses related to CWE-693: Selection of Less-Secure Algorithm During Nego-

Mitigating controls to identified threats, abuse cases, or attacker stories as requirements Security test case descriptions Security test results Penetration testing or security assessment reports

Resources
Attack surface tools include: Process Explorer: http://technet.microaspx soft.com/en-us/sysinternals/bb896653.

WinObj: http://technet.microsoft.com/ en-us/sysinternals/bb896657.aspx Determining open ports can be done, org/)

for example, using nmap (http://nmap.

Penetration testing could, in theory, find any type of weakness depending on the skill of the people performing the penetration test.

On Unix systems, listing open files can be done with the lsof command, open ports can be viewed with netstat, and

Verification
The existence of security testing can be verified by evaluating: Documented business risks or compliance

running processes and which files they are opening can be traced with strace. Attack Surface Analyzer Beta http:// www.microsoft.com/downloads/en/ 4ebb-8f0a-c49c746b44b9 details.aspx?FamilyID=1283b765-f57d-

requirements that provide prioritization for all testing activities. Failed or missed test cases should be evaluated against these.

42

Resources (continued)
Examples of software security testing references include: The Art of Software Security Testing: Identifying Software Security Flaws; Wysopal, 2006. Nelson, Dai Zovi & Dustin; Addison-Wesley Open Source Security Testing Methodology Manual. ISECOM, http://www.isecom.org/ Classification. MITRE, http://capec.mitre. org/ Common Attack Pattern Enumeration and

MiniFuzz: http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyI D=b2307ca4-638f-4641-9946-dc0a5abe8513 SDL Regex Fuzzer; http://www. microsoft.com/downloads/en/details. caa71855451f include:

aspx?FamilyID=8737519c-52d3-4291-9034Examples of protocol testing and proxy tools Scapy: http://www.secdev.org/projects/ scapy PortSwigger Web Security; Burp Proxy; Other fuzz testing resources include: Fuzzing: Brute Force Vulnerability Discovery; Sutton, Greene, & Amini, Addison-Wesley December 1, 2009 http://blogs.adobe. sons_learned.html Fuzzing Reader Lessons Learned; Randolph; com/asset/2009/12/fuzzing_reader_-_les BlueHat v8: Fuzzed Enough? When its OK to Put the Shears Down; http://technet.microsoft.com/en-us/security/dd285263.aspx

Examples of common fuzz testers are listed

http://portswigger.net/burp/proxy.html

below. Different test tools are useful for dif-

ferent targets, and sometimes it is necessary

to build an additional tool to actually get the

malformed data to the right place (for example, layer but not necessarily the parser for the data that had been compressed). Zzuf: http://caca.zoy.org/wiki/zzuf Peach: http://peachfuzzer.com/ Radamsa: https://code.google.com/p/ ouspg/wiki/Radamsa Untidy: http://untidy.sourceforge.net/

fuzzing a compressed file tests the compression

Writing Fuzzable Code; Microsoft Security com/b/sdl/archive/2010/07/07/writingfuzzable-code.aspx

Development Lifecycle; http://blogs.msdn.

43

Technology Recommendations
Use a Current Compiler Toolset
As noted earlier in this paper, memory-corruption issues, including buffer overruns and underruns, are a common source of vulnerabilities in C and

Insecure code warnings Safe exception handling Automatic migration of insecure code to secure code The two most common C and C++ compilers are

C++ code. It is easy to fix many memory-corruption issues by moving away from low-level languages like C and C++ to higher-level languages such as programming language is much harder to do in

Microsoft Visual C++ and GNUs gcc. Because of the security enhancements in newer versions of each should use: of these tools, software development organizations Microsoft Visual C++ 2008 SP1 or later. Microsoft Visual C++ 2010 is preferred owing to better stack-based buffer overrun defenses. gcc 4.4.x or later. Software development organizations should following options: compile and/or link native C and C++ code with the Microsoft Visual C++ /GS for stack-based buffer overrun defenses /DYNAMICBASE for image and stack randomization support /NXCOMPAT for CPU-level No-eXecute (NX) /SAFESEH for exception handler protection /we4996 for insecure C runtime function function use) detection and removal (see Minimize unsafe

Java or C# for new projects. However, using a new practice because the migration cost of training and put at risk as engineers grapple with the nuances

hiring can be expensive, and time-to-market can be inherent in an updated toolset. There is also a very place that must be maintained. Finally, for some

large base of legacy C and C++ code in the marketclasses of software, C or C++ is the most appropriubiquitous. Because memory-corruption vulner-

ate programming language, and the languages are abilities in C and C++ are serious, it is important to use C and C++ compilers that offer compile-time bugs automatically. Such defenses can make it and run-time defenses against memory-corruption harder for exploit code to execute predictably and correctly. Examples of defenses common in C and C++ compilers include: Stack-based buffer overrun detection Address space layout randomization Non-executable memory

44

 gcc fstack-protector or fstack-protector-all for stack-based buffer overrun defenses fpie pie for image randomization D_FORTIFY_SOURCE=2 and Wformat-secuand removal (see Minimize use of unsafe functions) ftrapv to detect some classes of integer arithmetic issues (see Audit dynamic memory allocations and array offsets) While this topic mainly focuses on native C and C++ code, other toolsets can take advantage of operating system defenses, such as address space Examples include: rity for insecure C runtime function detection

CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer Value CWE-805: Buffer Access with Incorrect Length CWE-129: Improper Validation of Array Index CWE-190: Integer Overflow or Wraparound CWE-131: Incorrect Calculation of Buffer Size

Verification
A Microsoft tool named the BinScope Binary Analyzer can verify if most of the compiler and

linker options (/GS, /DYNAMICBASE, /NXCOMPAT and /SAFESEH) are enabled in a Windows image. The tool should yield a Pass for every binary that ships with an application.

layout randomization and non-executable memory. Microsoft Visual C# 2008 SP1 and later (address data memory by default)

Verifying that /we4996 is enabled requires looking for the compiler setting in all build files, or looking header file: for the following line of code in an application-wide #pragma warning(3 : 4996) Developers can verify that gcc-compiled applicacommand-line instruction: tions are position independent with the following readelf h <filename> | grep Type Position independent executables are type DYN

space layout randomization and non-executable

Microsoft Visual Basic 2008 SP1 and later executable data memory by default)

(address space layout randomization and non-

CWE References
Most of the defenses added by the compiler or linker address memory-corruption issues such as: CWE-120: Buffer Copy without Checking Size of Input (Classic Buffer Overflow)

45

Resources
References: Hardened Linux from Scratch Version SVN-20080603; Chapter 2.6 Position Independent Executables; http://linuxfromscratch.xtra-net.org/hlfs/view/unstable/ glibc-2.4/chapter02/pie.html Books, Articles, and Reports MSDN Library; Windows ISV Software Security Defenses; Howard, Miller, Lambert & Thomlinson; December 2010; http://msdn. Presentations: Exploit Mitigation Techniques (in OpenBSD, http://www.openbsd.org/papers/ven05deraadt/index.html of course); The OpenBSD Project; de Raadat;

Tools / Tutorials : BinScope Binary Analyzer: http://www. microsoft.com/downloads/en/details. 81c-5905-4799-826a-772eafd4440a aspx?displaylang=en&FamilyID=90e61 Patch: Object size checking to prevent

(some) buffer overflows: http://gcc.gnu.org/ ml/gcc-patches/2004-09/msg02055.html

GCC extension for protecting applications trl.ibm.com/projects/security/ssp/

from stack-smashing attacks: http://www.

microsoft.com/en-us/library/bb430720.aspx

Process Explorer: http://technet.microsoft. com/en-us/sysinternals/bb896653

46

Use Static Analysis Tools

Static analysis tools are now commonly used by tools is highly recommended to find common vulnerability types. development organizations, and the use of such

advantage of spell checkers. Because many vulnerunreasonable to expect most vulnerabilities to be fixed immediately after a routine scan completes. Performing a Threat Model before starting a code

abilities are hard to spot but simple to solve, its not

Static code analysis tools can help to ensure coding mistakes are caught and corrected as soon as possible. Tools that integrate with development

analysis effort can also help in the triage process, as it can help focus auditors on critical or risky components, getting defects from those areas prioritized to be addressed first. First time static analysis tools users should expect some up-front investment to get the greatest benefit from the tools. Before running a static

environments are usually considered easier to use and often lead to faster bug resolution; they also help get developers used to identifying security

defects as they develop code and before they checkin. Using static analysis tools that are integrated with development environments does not replace the need for codebase-wide analysis. Developers may have a modified view of the current code base (e.g., on a dedicated maintenance branch) or may only be dealing with a limited set of source code

analysis tool for the first time, it is recommended

to clean the code from compiling warnings. Still, an initial run will result in a significant list of findings. Depending on the project size, management should consider dedicating team resources to do the initial triage. Once triage is complete, some findings may be determined to be false due to contextual

(e.g., one module or application tier). Both scenarios can result in false negatives resulting from limited data flow and control flow analysis and other problems that full-codebase and/or main branch analysis (at product build time) would otherwise find. Ideally, static code analysis tools should be site

information the static analysis tool does not have, and some issues that were considered by the tool to be less severe may be elevated in priority to be risk or other factors, which the tool is not aware).

addressed (again due to context, such as business Tuning the tool and the code using standard annofindings, and providing training to developers can familiar both with the tool output and software

licensed to the entire development team, includ-

tation language (SAL) will often result in fewer false greatly aid in the triage effort as they become more security concepts. Maintaining a dedicated team of security-savvy developers to review static analysis results may be helpful for resource-constrained

ing QA, making this tool as commonly used by the development team as spell checkers that are built in to modern word processors. Both experienced and inexperience developers can greatly benefit from analysis tools much like all writers take

47

development teams, but in the long run does the good and bad, from the folks who created them. Once a tree is clean of static analysis warnings,

team a disservice by masking or hiding results, both

rules can often be added to account for internal

coding standards or APIs (e.g., to indicate certain

internally-developed interfaces affect the security

the revision control system should be configured warnings and the code needs to be regularly

of code passing through them, either negatively or positively). Caution must be taken when updating rules between builds, especially in large complex bugs discovered) may result in a reduction of codebasesmodifying existing rules (for analysis findings as analysis improves, but adding new rules for new issues may result in additional findings. These new findings would need to be triaged and done by developers (i.e. adding new code). Rule

to prohibit check-ins of code that introduces new audited for pragmas that disable warnings. Devel-

opment teams often create a separate build system with static analysis tools running continuously. This practice minimizes the impact on the time it takes to generate a new build.

may result in spikes in metrics not due to anything updates should be planned to keep up-to-date with a project off its rails.

Several static code analysis tools are capable of generating results even if the codebase is incomplete or does not compile. While teams may greatly benefit from testing code before reaching integration checkpoints, analyzing code that does not compile Its also important to understand that static code analysis tools are a complement to manual code review, not a substitute. A clean run does not

changes in the security landscape without throwing Depending on the codebase size, a full analysis can take a considerable amount of time to run. Tuning can help reduce the time required for analysis. It is also recommended to reduce the initial set of things that the tool looks for, such as to specific security issues, or simply to security issues only

is highly discouraged as it yields suboptimal results.

guarantee the code is perfect. It merely indicates patterns.

the code is free of well-known and well-understood Static analysis tools really shine when a new vulnerability is discovered: automated tools can perform an initial assessment of a large body of software a lot quicker than manual code review can be

(rather than traditional quality defects, like memory leaks, which are better discovered by other tools). can help reduce analysis time and may result in This initial modification to what is being analyzed fewer findings leading to better overall adoption.

Then, as development teams get more comfortable with the tool, they can open up the rule set to find more issues. Some tools also perform analysis in two or more stages, usually a build stage and a

performed. Many static analysis tools operate using flexible and extensible rules, which can be added to when new vulnerability classes are discovered or modified for changes in common APIs. New

separate analysis stage. The analysis stage can be

48

performed in parallel with other build activities

(such as linking or dynamic testing) and can take disk resources, which can speed up analysis.

Resources
References: List of tools for static code analysis; http://en.wikipedia.org/wiki/ List_of_tools_for_static_code_analysis Books, Articles, and Reports: Secure Programming with Static Analysis; Chess & West; Addison-Wesley 2007. The Security Development Lifecycle; Chapter Howard & Lipner; Microsoft Press.

advantage of dedicated processing power and CPU/ Regardless of the tool and the type of technology all SAFECode companies employ multiple tools

employed, no one tool today finds all faults. In fact, throughout the development lifecycle. Furthermore, neither static nor dynamic analysis can recognize sophisticated attack patterns or business logic

flaws, so they should not be considered a replacement for code reviews. While tools can reliably identify vulnerability types, automated severity factor business risk such as asset value, cost of brand reputation.

21 SDL-Required Tools and Compiler Options;

metrics cannot be taken for granted as they dont down time, potential for law suits and impact of

SecurityInnovation; Hacker Report: Static

Analysis Tools, November 2004 Edition; http:// www.securityinnovation.com/pdf/si-reportstatic-analysis.pdf

CWE References
Static analysis tools find a plethora of security vulnerabilities, so one could argue that many CWEs can be found through the use of analysis tools.

Cigital Justice League Blog; Badness-ometers are good. Do you own one?; McGraw; http:// www.cigital.com/justiceleague/2007/03/19/ Presentations: Using Static Analysis for Software Defect Detection; William Pugh; July 6, 2006; cid=-8150751070230264609 Tools / Tutorials: MSDN Library; Analyzing C/C++ Code Quality com/en-us/library/ms182025.aspx by Using Code Analysis; http://msdn.microsoft. http://video.google.com/videoplay?do

badness-ometers-are-good-do-you-own-one/

Verification
Static analysis tools are themselves a form of verification. While a clean analysis tool run does not imply an application is secure, it is a good indicator of rigor by the development team.

MSDN Library; FxCop; http://msdn.microsoft. com/en-us/library/bb429476(VS.80).aspx

49

Summary of Practices
Section Secure Design Principles Practice Threat Modeling Use Least Privilege Implement Sandboxing Secure Coding Practices Minimize Use of Unsafe String and Buffer Functions Validate Input and Output to Mitigate Common Vulnerabilities Use Robust Integer Operations for Dynamic Memory Allocations and Array Offsets Use Anti-Cross Site Scripting (XSS) Libraries Use Canonical Data Formats Avoid String Concatenation for Dynamic SQL Statements Eliminate Weak Cryptography Use Logging and Tracing Testing Recommendations Determine Attack Surface Use Appropriate Testing Tools Perform Fuzz / Robustness Testing Perform Penetration Testing Technology Recommendations Use a Current Compiler Toolset Use Static Analysis Tools Page number 2 7 10 12 15 19 22 27 29 32 37 39 39 40 41 44 47

50

Moving Industry Forward

One of the more striking aspects of SAFECodes work in putting this paper together was an oppor-

Acknowledgements
Brad Arkin, Adobe Systems Incorporated Eric Baize, EMC Corporation Gunter Bitz, SAP AG Danny Dhillon, EMC Corporation Robert Dix, Juniper Networks Steve Lipner, Microsoft Corp. Gary Phillips, Symantec Corp. Alexandr Seleznyov, Nokia Janne Uusilehto, Nokia

tunity to review the evolution of software security since the first edition was published. Though

practices and resources in the two and a half years much of the advancement is a result of innovation happening internally within individual software companies, SAFECode believes that an increase in

industry collaboration has amplified these efforts of-the-art across the industry.

and contributed positively to advancing the stateTo continue this positive trend, SAFECode encourtailor and adopt the practices outlined in this

ages other software providers to not only consider, paper, but to also continue to contribute to a broad industry dialogue on advancing secure software to review and update the practices in this paper based on the experiences of our members and development. For its part, SAFECode will continue

the feedback from the industry and other experts. To this end, we encourage your comments and contributions, especially to the newly added work www.safecode.org.

on verification methods. To contribute, please visit

51

About SAFECode
The Software Assurance Forum for Excellence in Code (SAFECode) is a non-profit organization exclusively dedicated to increasing trust in information and communications technology products and services through the advance-

ment of effective software assurance methods. SAFECode practices for developing and delivering more secure and Adobe Systems Incorporated, EMC Corporation, Juniper

is a global, industry-led effort to identify and promote best reliable software, hardware and services. Its members include Networks, Inc., Microsoft Corp., Nokia, SAP AG and Symantec Corp. For more information, please visit www.safecode.org.

Product and service names mentioned herein are the trademarks of their respective owners.

SAFECode 2101 Wilson Boulevard Suite 1000 Arlington, VA 22201

(p) 703.812.9199 (f) 703.812.9350 (email) [email protected] www.safecode.org

2011 Software Assurance Forum for Excellence in Code (SAFECode)