Abstract
Software security is a concept of protecting software from a malicious breach. The main objective of software security is to assure proper functioning of software without threats to privacy and individuality. Technology and industry experts have accepted the significance of this undertaking, but the awareness about handling such issues still lacks appropriate solutions. Software security is a novel field of the computer world that started as early as 2001. Software security is an extensive system that is not constrained to a security mechanism or access control. It includes an appropriate design impossible for intruders to contravene. Perfect software always beholds robust security designs. Software development process with its weaknesses and vulnerabilities is subject to exploitation by the attackers. The software is vulnerable to invasions, damage, and modifications. The software program can be infected replicating across the network and causing large-scale damage. Most IT project managers and developer react to cyber and security threats by relying on operational controls available through a network, operating system, web or database servers. They fail to address the insecurity at the root level. Attacker’s job is easier in current times and successful attacks gain media coverage and an extensive reporting. Many applications are being developed on OpenSource and hackers can easily obtain the specifications of these OpenSource systems. Software security starts with software development. This paper does a secondary research on various practices of software security, their flaws and drawbacks and attempts to propose a novel approach for software security. The proposal is in light of cyber threats currently prevalent over vulnerable software applications.
Abstract 2
Introduction 4
Objectives of Software Security 5
Security as a Software Issue 6
Existing Approaches to Software Security 7
Preliminaries 9
Problem Description 9
The Problem 9
Drawbacks of Previous Approaches 10
Cyber Threats to Resolve 10
Approach to Software Security 11
Conclusion 14
Works Cited 15
Introduction
Software security is a concept of protecting software from a malicious breach. The main objective of software security is to assure proper functioning of software without threats to privacy and individuality. Technology and industry experts have accepted the significance of this undertaking, but the awareness about handling such issues still lacks appropriate solutions (McGraw, 2004).
Software security is a novel field of the computer world that started as early as 2001. The commencement of this field in the academic world has proved that how much it is worth mentioning and requires the attention of technology geniuses. A systematic analysis and the building of secure software is a challenging and mandatory prospect for software architects. The recent manifestation of software security hampers the acceptance to the best practices. Defects associated with security implications may last forever in software includes mainly of two things; first is the presence of bugs like buffer overflows and secondly, the designing defects like incompatible error management. The threat of intruders always exists that can breach into the system through these defects. Security is the most common type of threat to the internet enabled software applications. This risk augments further due to the expandability and extensibility of the software. Application of best security practices facilitates an early knowledge of software developing practices and recognizing the security threats. An understanding of software security risks at the beginning of its lifecycle protects the software and provides insights to designing compatible artifacts for it (McGraw, 2004).
Software security is an extensive system that is not constrained to a security mechanism or access control. It includes an appropriate design impossible for intruders to contravene. Perfect software always beholds robust security designs. According to the experts, only adding security features cannot be sufficient to combat threats, for instance, the use of SSL for the cryptographically protecting communications can never accomplish the task perfectly (McGraw, 2004).
Overall, most development experts and architects are not sufficiently aware of the software security issue. The foremost best practice obligates proper training of development staff on such serious concerns. The key part of the training should emphasize on the demonstration of the problem and its impact. An ideal training on software security should consist of all or several of the below points:
• Robust security design
• The guidelines and principles of software development
• Risks related to implementation
• Design defects
• Analytical techniques
• Software exploitation and security testing.
(McGraw, 2004; Goertzel, 2009)
Objectives of Software Security
An objective of Software Security is to promise a secure software system that fulfills following aspects:
• The system can be treated as susceptible, and it should remain defect free as much as possible
• The system should be so robust that continues working instead of security attacks.
• It should be capable of averting breach issues by resisting the violation of software defects exploitation of or by tolerating the outcomes due to the exploits by hackers.
• The system should be eligible to restrict the damage caused by any security attack or to terminate further propagation of developed errors.
(McGraw, 2004)
Security as a Software Issue
Developing and executing software without any security precaution can be a high risk. Organizations stock up, process and transfer their confidential information via the internet enabled intensive software systems. Financial transactions, tax, insurance and bank transfers, registration to the hospital, schools, and social networking all have developed a massive data that is connected with internet based software systems. This accumulation and exposure to global connectivity has transformed this data into sensitive information that can be vulnerable to the unauthorized exploitation. This period of information warfare has given birth to cyber terrorism and Web-based crimes (Allen et al., 2009).
Existing Approaches to Software Security
Described below are some of the existing approaches to software security integration.
Software Security Engineering
Software security engineering approach proffers designing patterns to strengthen the security during the design segment. Designers execute this approach through implementing distinct UML solutions to the problem. The limitation of this approach is the lack of methodologies for imposing them accurately and systematically into the software. For novel and unique best practices, the software security division of computer technology can learn from other computer relevant disciplines. These may include security requirements engineering, software architectural technology developments such as code scanning, or information flow. Common implementation threats involve buffer overflows, access control, race conditions, arbitrariness, verification systems, applied cryptography, and trust administration (Mouheb, Djedjiga, et al., 2009).
Aspect-Oriented Modelling for Software Security
Aspect-Oriented Modelling for Software Security presents an approach that provides solutions based over aspect orientation. This approach offers an organized and systematic mode of security to the designer that covers every step including designing to execution and does not demand high proficiency. This approach consists of three main steps:
Specification of Security Hardening Solutions: With the assistance of security APIs, UML-based solutions are designed to identify the security issues that are presented as Security Hardening Patterns. AOP is specific to these patterns in filtering the security solutions from other software functionalities.
Specification of Security Requirements: Developers through editing a Security Hardening Plan specify the obligatory security requirements.
Selection of Actual Hardening Patterns: Experts conduct this step via selection from security hardening plans provided by designers and index of proposed patterns.
Refinement and Aspects Generation: After the selection, the solution is refined and executed.
Security Aspects weaving into the Code: The security hardening process is accomplished by entwining the security features into the software source code generated earlier (Mouheb, Djedjiga et al., 2009).
Threat-Driven Approach for Software Security
Complete software protection from intrusion is not possible by network level and OS level security approaches. These approaches still require more knowledge of application semantics and the best practice is to identify the threat at an early stage. Threat-Driven Approach is based on the recognition and alleviation of those security risks that violate the security purposes or policies. This approach helps in determining accurate timing and site of security application. It discovers the behaviors of the security threats rather than its properties like other approaches and acts as an intermediary between security targets and security feature applications (Xu & Kendall, 2006).
Penetrate and Patch Approach
Many vendors treat security as an add-on feature and continue to develop products without security shields. In such cases, these products need a security solution when the software is publicly hacked. At this stage, a patch becomes mandatory to tackle the menace and resolve the security threat (Goertzel, 2009).
Preliminaries
Web-Application security issues have become common incidents. The consequence of such incidents is severe and directly affects an organization financially. Many organizations struggle with security flaws in their products and do not have any strategic approach for software security. The development and security teams are not aligned for optimal results (Evans & Hossain, 2014).
This paper does a research on various practices of software security, their flaws and drawbacks and attempts to propose a robust approach for software security. The proposal is in light of cyber threats currently prevalent over vulnerable software applications.
Problem Description
The Problem
Software development process with its weaknesses and vulnerabilities is subject to exploitation by the attackers. The software is vulnerable to invasions, damage, and modifications. The software program can be infected replicating across the network and causing large-scale damage. Industry experts recognize the threat that is growing with the advent of the open internet technologies. The growth of the internet and a collaboration of networks and computer hardware with Web-based transactions has added to the attacking threat, sophistication and ease of carrying out the attack. The capability of current systems to scale and extend is another dimension that adds to the threat to software security (Allen et al., 2009).
A Software designed with security as a priority has a predictable functionality with less probability of succumbing to malicious attacks, thereby having fewer vulnerabilities and conforming to requirements, standards and procedures. Such a feature in a software is the result of multiple activities that are planned and systematic and ensure software security at all levels. Additionally a secure software system would be tolerant, resistant and resilient to attacks. Such a goal is achieved only when the software's design is in such a way that they can differentiate between legitimate inputs and attack patterns (Allen et al., 2009).
Drawbacks of Previous Approaches
Most IT project managers and developer react to cyber and security threats by relying on operational controls available through a network, operating system, web or database servers. They fail to address the insecurity at the root level. The operational approach of handling software security is dependent upon the operational infrastructure. The software-based mechanism of operational controls may also be compromised thereby leaving a gap in the security analysis in the advent of a threat (Allen et al., 2009). Security engineering approach requires high expertise in security thereby making it difficult to find expert developers. Aspect Oriented Programming approach lacks features that are required for a security hardening specification and is usually programming language dependent (Mouheb et al., 2009). Threat-driven approach is based on traditional model of security explicitly identifying security threats behavior, thereby making it obsolete for newer cyber threats that require agility in approach (Xu & Kendall, 2006). The penetrate-and-patch approach is a desperate attempt to solve a security threat by providing a fix. This approach has high drawback as most of the time patches do not get apply. It is better to design a system beforehand, test, find and remove bugs than react after receiving a security threat (Goertzel, 2009).
Cyber Threats to Resolve
Attacker’s job is easier in current times and successful attacks gain media coverage and an extensive reporting. Many applications are being developed on OpenSource and hackers can easily obtain the specifications of these OpenSource systems. Seasoned attackers exploit specific vulnerabilities in the OpenSource software systems for the specific and targeted exploitation of the data. The defendant that includes the software designer and the developer needs to address all software vulnerabilities. On the other hand, the attacker or hacker with malicious intent needs to find only one vulnerability in the system (Allen et al., 2009). The main cyber threats to tackle are
Vulnerable Web-Applications
Outdated security patches and Unencrypted sensitive data
Wrong or missing passwords
Approach to Software Security
The software is a foremost target of security risks. Complete safeguard of software from attacks is not possible at operating system and network-level security approaches (e.g. firewall, cryptography, intrusion detection). The best approach is to have security the application software level itself. Below is the discussion of my approach to security for the cyber threats identified.
#Vulnerable Web-Applications
This is the number one threat to Information Systems in the current age of application software services. An effective way to minimize the threat is to have an approach of introducing security at the design level. At each stage of the software cycle and doing the code development using the approach of Test Driven Development that encourages “test to fail”.
Pre-Design / Requirements Phase
At the start of the design of the application or during requirements gathering, it is to be identified the required level of security for the application. The software security must be defined as High, Medium or Low. Based on this the security process will be implemented during the rest of the software development cycle.
Design Phase
Based on the identified security level, the software design must happen with identifying the relevant security mechanisms for all aspects of the software. The best practice is to design based on a Single Responsibility Model with minimal or restricted public access to features, specifically the admin features of the application. Such a design would reduce the impact in an event of any attack. During the design phase, for each of the use-cases identify the associated threats for each of those scenarios. The threat identification at this stage would uncover common threats that might come across during the development for example SQL-Injection attacks. The pre-identification of threats would help in mitigating the risks associated with each threat. Security bugs and vulnerabilities are usually administered during the coding phase. It is important to cater to this during the design phase itself. The design phase must consist of specific guidelines for the coding and development phase. If available, use specific templates for documentation, coding, implementation and integration of security features. If no base template is available, then specific guidelines must be provided to developers for documenting the code. All tools must be specified that must be used for code review and analysis perspective and make it mandatory for the developers to follow guidelines.
Coding and Development Phase
A test suite must be developed first that would identify all major vulnerabilities for the web application. Based on the test suite the code must be developed. Nightly builds would compile the code and execute the test cases for all scenarios including business logic and security features. Those test cases that will fail would identify the vulnerabilities. Also, relevant automated tools must be used for identifying security threats and vulnerabilities. Code review tools must also be used for reviewing the code for code-related aspects. As much as possible automated tools must be used to have consistent results.
#Outdated Security Patches and Unencrypted Sensitive Data
It is important to have all security patches updated for the base platforms being used. An updated version of security patch must be installed from the vendor or the implementing platform. The information being transferred within the software must be encrypted at all levels i.e. while saving the into a database or moving around with the application.
#Wrong or Missing Passwords
All passwords must be properly stored, encrypted with a proper process for password retrieval and validation.
Conclusion
Software defects, bugs, and other faults impair the software to function in a desired manner. The biggest threat to the software functionality is a security flaw. Software vulnerabilities that make a software insecure to use and exploitable are the highest of software flaws. The growth of the internet, connected and distributed applications, complex and highly scalable software systems have all added to the threat to the security of software systems. Software that fails to be updated with changing environments wears out easily. Modern information systems have security as the most important factor of their design. Software security is not a reactive process; rather it is a proactive process where security design must be administered at all stages of the software development life cycle. The software development process must undergo a transformation at each stage to support software security. Security is no longer an IT technical team’s issue. Security has a larger impact on the credibility and the business of the organization with measurable financial losses and gains. The software security approach in this paper would ensure that right security measures are embedded at each software development stages, utilizing industry-accepted processes, tools and methods.
Works Cited
Allen, J., et al. Software Security Engineering. Addison-Wesley Professional, 2009.
Evans, Zachary, and Hossain Shahriar. "Web Session Security: Attack and Defense Techniques."
Goertzel, Karen Mercedes. "Introduction to software security." Build Security In (2009).
McGraw, Gary. "Software security." Security & Privacy, IEEE 2.2 (2004): 80-83.
Mouheb, Djedjiga, et al. "An Aspect-Oriented Approach for Software Security Hardening:
Xu, Dianxiang, and Kendall E. Nygard. "Threat-driven modeling and verification of secure
software using aspect-oriented Petri nets." Software Engineering, IEEE Transactions on
32.4 (2006): 265-278.
