Part 1 | Basic Concepts for Secure Software

Chapter 1: Security Fundamentals

Understanding Security
faith
__Trust
__bits are invisible
__Competence and Imperfection
__Trust is a spectrum
__Trust Decision
__Implicitly Trusted Components
__Increase product reliability
Classical principles
__CIA Principles of Information Security
__Gold Standard
__Privacy

Chapter 2 Threat Modeling

hostile perspective
Four questions
Threat Modeling
__Model-based work
__Asset Identification
__Identifying the attack surface
__Identifying Trust Boundaries
__Threat Identification
__Threat Mitigation
Privacy Considerations
Threat Modeling: The Ubiquitous

Chapter 3 Mitigating Security Threats

Threat Handling
Structural easing strategy
__Minimize attack surface
__Narrow vulnerability window
__Minimize data exposure
Access Policy and Access Control
interface
communication
Storage

Chapter 4 Security Design Patterns

Design properties
__Economic Patterns of Design
__Transparent design
Minimize exposure
__Minimum privileges
__Minimum information
__Safety is the foundation
__Allow list rather than block list
__Prevent predictability
__Safe Failure
Strong enforcement
__Complete arbitration
__Minimum common mechanism
Redundancy
__Defense in Depth
__privilege separation
Trust and Responsibility
__Resistance to trust
__Accepting Security Responsibility
anti-pattern
__Confused Agent
__The backwash of trust
__Third-party hooks
__Unpatchable components

Chapter 5: Encryption Techniques for Security

Encryption tools
random number
__Doctor Random Number
__Cryptographically secure pseudorandom numbers
Message Authentication Code
__Use message authentication codes to prevent tampering
__Replay attack
__Secure MAC communication
Symmetric encryption
__disposable pads
__Advanced Encryption Standard
Use symmetric encryption
Asymmetric encryption
__RSA encryption system
digital signature
digital certificate
Key exchange
Use encryption

Part 2 | Secure Software Design

Chapter 6 Security Design Principles
Integrating security into design
__Clarification of design assumptions
__Scope definition
__Set security requirements
__Threat Modeling
Implementation of mitigation
__Interface Design
__Data Processing Design
Integrating Privacy into Software Design
Complete Software Lifecycle Planning
Trade-off processing
Design simplicity

Chapter 7 Security Design Review

Implementation Plan for Security Design Review
__Purpose of performance
__Performance Period
__Documentation is essential
Security Design Review Process
__examine
__question
__discrimination
__cooperation
__write
__Follow-up measures
Design Security Assessment
__Use the four questions as a guide
__If we dig a little deeper
__Privacy Review
__Update Review
Managing Disagreements
__Communicate tactfully
Case Study: Difficult Reviews
__Reconciliation of disagreements
Practice, practice, practice

Part 3 l Security Implementation

Chapter 8: Safe Programming
Why Secure Programming Is Difficult
__malicious influence
__Vulnerability is a bug
__Vulnerability Chain
__Bugs and Entropy
__wariness
Case Study: Goto Fail Vulnerability
__Vulnerability in a single line of code
__Beware of the foot gun
Lessons from __goto fail
Coding vulnerabilities
__atomic
__Time difference attack
__Serialization
prime suspect

Chapter 9: Examples of Vulnerabilities in Low-Level Coding

Arithmetic vulnerability
__Fixed-width integer vulnerability
__Floating Point Precision Vulnerability
__Example: Floating-Point Underflow
__Example: Integer Overflow
__Safe Operation
Memory access vulnerability
__Memory Management
__Buffer Overflow
__Example: Memory Allocation Vulnerability
Case Study: The Heartbleed Security Disaster

Chapter 10 Security Threats of Untrusted Input

Input validation
__Validity Determination
__Inspection criteria
__Reject invalid input
__Correct incorrect input
String vulnerability
__String length problem
__Unicode issues
Injection vulnerability
__SQL injection
__Path Navigation
__Regular expression
__The dangers of XML
Mitigation measures for injection attacks

Chapter 11 Web Security

Framework-based construction
Web Security Model
__HTTP protocol
__Digital Certificates and HTTPS
__Same-source policy
__Web Cookies
Common Web Vulnerabilities
__Cross-site scripting (XSS)
__Cross-Site Request Forgery (CSRF)
Other Vulnerabilities and Mitigations

Chapter 12 Security Testing

What is Security Testing?
Security Testing for Goto Fail Vulnerabilities
__Function Test
__Testing functions with vulnerabilities
__Security Test Cases
__Limitations of Security Testing
Writing security test cases
__Input Validation Testing
__XSS vulnerability testing
Fuzz testing
Security Regression Testing
Availability Testing
__Resource consumption
__Threshold test
__Distributed Denial of Service Attack (DDoS Attack)
Security Testing Best Practices
__Test-Driven Development
__Utilizing integrated testing
__Catch up on security testing

Chapter 13: Safe Development Best Practices

Code quality
__Code Management Habits
__Exception and Error Handling
__Security Documentation
__Security Code Review
Dependency
__Select security components
__Interface Security
__Don't reinvent security tools
Competing with Legacy Security
Vulnerability Classification
__DREAD Evaluation
__Creating a working attack code
__Classification decision
Maintaining a safe development environment
__Separation of operating and development environments
__Development Tool Security
__Product Launch

Chapter 14: The Never-ending Journey of Security

Practice and act
__Security is everyone's job
__Internalization of security
The Future of Security
__Improving software quality
__Managing Complexity
__From Minimizing Transparency to Maximizing Transparency
__Improving software authenticity, trust, and accountability
The Last Mile: Completing the Final Step
In conclusion

Appendix A Sample Software Design Document
Appendix B Glossary
Appendix C: Questions to Consider
Appendix D Key Summary Materials

| What this book covers |

- Identify critical assets, attack surfaces, and trust boundaries in your system.
- Evaluate the effectiveness of various threat mitigation measures
- Work with well-known mitigation measures and security design patterns
- Vulnerabilities such as cross-site scripting, cross-site request forgery, and memory defects
- Preemptive identification of code vulnerabilities using security testing
- Objective evaluation of software design to find security flaws

| Target audience for this book |

- People who are new to security, especially those who find security difficult.
- Readers who are interested in security but lack knowledge and awareness of security.
- Security experts leading the security field

[What this book covers]

The book consists of 14 chapters, and the overall content is divided into three parts covering concepts, design, and implementation.

[Part 1: Basic Concepts for Secure Software]

Part 1 provides the conceptual foundation for this book.
Chapter 1, "Security Fundamentals," outlines the fundamentals of information security and personal information protection.
Chapter 2, "Threat Modeling," introduces threat modeling and concretizes the core concepts of attack surface and trust boundary in the context of asset protection.
The following three chapters introduce valuable tools available to readers to build secure software.
Chapter 3, "Mitigating Security Threats," describes commonly used strategies to defensively mitigate identified threats, and Chapter 4, "Security Design Patterns," presents several effective security design patterns and examines some anti-patterns to avoid.
Chapter 5, "Cryptographic Techniques," covers complex techniques that use standard cryptographic libraries to mitigate common risks, but does not delve into the underlying mathematics (which is rarely necessary in practice).

[Part 2, Secure Software Design]

Part 2 covers the most unique and likely most helpful material for the book's intended audience.
Chapters 6, "Secure Design Principles," and 7, "Security Design Reviews," provide guidance on secure software design and practical techniques for achieving it, approaching the topics from the perspectives of the designer and the reviewer, respectively.
This also explains why it is important to incorporate security from the beginning of software design.

In Part 2, we explore specific methodologies for integrating the ideas explored in Part 1 into security design.
The review methodology is based on my industry experience and also covers a step-by-step process that you can apply to your own work.
As an example of how to put this idea into practice, let's look at the sample design document in Appendix A.

[Part 3, Security Implementation]

Chapters 8 through 14 cover security during the implementation phase, looking at deployment, operations, and end-of-life stages.
As a step after secure design, Part 3 of this book explores how to develop software while preventing further introduction of vulnerabilities.
Each chapter in Part 3 contains code, explaining how vulnerabilities can be exploited in code and how to prevent them.


Chapter 8, "Secure Programming," introduces the security problems programmers face and what real-world vulnerabilities look like in code.
Chapter 9, "Examples of Vulnerabilities in Low-Level Coding," covers how weaknesses in computer arithmetic and the C-style explicit management of dynamic memory allocation compromise security.
Chapter 10, "Security Threats of Untrusted Input," and Chapter 11, "Web Security," cover a variety of common bugs that have been well known for a long time but still remain unsolved (such as injection attacks, path traversal, XSS, and CSRF vulnerabilities).
Chapter 12, "Security Testing," covers testing techniques that are underused but can help ensure code safety.
Chapter 13, "Safe Development Best Practices," concludes the secure implementation guide by covering some best practices and common pitfalls.

The code covered in Part 3 generally presents vulnerabilities that should be avoided, followed by patched versions showing how to make the code secure (marked as "Vulnerable Code" and "Fixed Code" respectively).
Therefore, the code in this book is not intended to be copied and used directly in the software of an operating environment.
Even modified code can introduce vulnerabilities and other issues in different environments, so the code presented in this book should not be considered safe for all applications.

Finally, Chapter 14, "The Never-ending Journey of Security," outlines several ways in which we anticipate this book will have a positive impact.
We summarize the key points covered in this book and look ahead to the future.
Moreover, it begins by outlining a vision for how this book can contribute to improving software security, and then discusses experimental ideas that could help incrementally improve software security.

[supplement]

Appendix A is a sample design document that demonstrates a design that takes real-world security into account.
Appendix B is a glossary of software security terms used throughout this book.
Appendix C contains several open-ended exercises and questions that motivated readers might be interested in exploring.
Appendix D is a collection of materials summarizing key concepts and processes.

[Author's Note]

This book is a guide for software professionals who want to better understand essential concepts in software security and learn how to design and implement secure software.
I've been fortunate enough to innovate on some of the topics covered here, and I've watched others evolve and take root.
Based on my experience in the industry, this book is full of actionable ideas to make the software you work with more secure.

This book addresses two central themes.
Encouraging software professionals to focus on security early in the software development process and ensuring that the entire team not only takes responsibility for security but also participates in the security process.
Clearly, there is still considerable room for improvement in both of these areas, and this book shows how to achieve these goals.

I've had the rare opportunity to work on the front lines of software security throughout my career, and now I want to share what I've learned as widely as possible.
Over 20 years ago, I worked at Microsoft on a team that pioneered threat modeling for a large software company.
A few years later, I was working on developing the same technique at Google, and it was a completely new way of approaching problems.
Part 2 of this book explores the insights I gained from over 100 design reviews I conducted.
By looking back on the path we have taken, we gain a broader perspective and can explain everything in a new way.

Designing, building, and operating software systems is inherently risky.
Every choice made at every step either increases or decreases the risk of introducing security vulnerabilities.
This book covers what I know best and what I have learned through direct experience.
In this book, I will convey security thinking from the first principles and examine how security can be embedded throughout development.
The design and code examples provided in this course are largely technology-agnostic and therefore very broadly applicable.
The text contains a variety of anecdotes, metaphors, and examples to convey abstract ideas as effectively as possible.

There are individual differences in how we acquire security thinking.
So, by focusing on developing your intuition, I hope to help you come up with new ways to promote a software security perspective in your work.
In my experience, I'd like to add that even those who are naturally security savvy can always gain more insight.

This book covers a vast amount of material concisely, and while writing it, I felt that such conciseness was essential to the book's success.
Software security is a vast and profound field, so I hope this book will be more widely read if it is concise.
I hope that readers will find this new perspective helpful in thinking about security and can easily apply it to their own work.
- Lauren Kornfelder

[Translator's Note]

The topic of security can feel somewhat stiff and difficult.
It is considered a specialist field because of its complex concepts and difficult mathematics, and although it is of great interest to everyone, it is considered difficult to approach.
However, this book is a different kind of fun than other professional security books.
This book is an introductory book to security engineering, covering fundamental security concepts and a variety of security practices in software development.
While there have been quite a few books published on the topic of security, I believe there have been few that target both security professionals and software developers.

Author Lauren Kornfelder, a key figure in the fields of network security and cryptography who proposed the concept of public key infrastructure (PKI) and developed the STRIDE model, an outstanding achievement in the field of threat modeling, together with Praerit Garg, says that security is a very important element in modern software development.
In this book, Kornfelder provides a comprehensive guide, from conceptual to practical, on how software developers and security professionals can consider security when designing and developing software.
Rather than listing difficult concepts, the author uses real-world examples and case studies from his field to lower the barriers to approaching security, which will be of great help to developers.

This book covers a wide range of security-related topics, from security concepts to threat and vulnerability analysis, security modeling, and case studies.
It also contains many helpful tips for implementing security in each organization or company, such as Security Design Review (SDR).
Therefore, this book can be used as a reference for anyone involved in security, including developers, security experts, system architects, and security managers who want to integrate security into the software development process.
I am confident that this book will be of great help in developing more secure software.
- Kim Young-gi

These days, it's common to receive phishing messages claiming your account was logged in from a new device, accessed from overseas, or that you have unused assets that need to be retrieved immediately.
Some of them are so clever that it's become common to worry that you might accidentally access them and have your PC or phone hacked.
Last summer, a software update file error from a cybersecurity company called CrowdStrike caused a large number of Windows PCs to blue screen and prevent Windows from booting properly, causing chaos at banks, airlines, and broadcasting stations around the world, and even causing computer paralysis at an airport in South Korea.
In fact, these problems have become so commonplace that it is difficult to count them all on one hand.

With everything connected to the Internet, we live in a world where even a small mistake or a single malicious attack can cause enormous damage.
Yet, in software development, security is often relegated to a lower priority.
With the challenge of keeping up with rapidly changing markets and consumer demands, security is often considered only at the final stages of development.
Moreover, for many in the IT industry, security is still seen as a difficult and daunting issue that must be left to experts.


In the future, malicious attacks will become much more sophisticated as they combine with AI technology, and the resulting damage could be beyond imagination.
We have entered an era where software security can no longer be left solely to experts.
The truth is that it should have been that way a long time ago, and we just turned a blind eye to it.
We have entered an era where not only developers and security experts, but all industry professionals must perform their duties with security in mind to protect themselves, their organizations, and their customers' valuable assets from malicious attacks and accidents.


The main purpose of this book is to explain the concepts and methodologies that software developers need to design and implement secure software with security in mind. However, it focuses on cultivating the mindset necessary for security based on insight into the essence of security. As I was translating it, I felt that it is an ideal book for understanding security not only for developers but also for all industry professionals.


Lauren Kornfelder, the author of this book, is better qualified than anyone to talk about the essence of security.
He was a security pioneer who not only laid the foundation for modern security techniques at Microsoft and Google, but also pioneered the digital certificate system, which is the core foundation of encryption technology widely used today.
The author's extensive practical experience and deep insights spanning over 20 years are reflected throughout this book.
While translating this book, I also felt that the fragmented knowledge about security that I had gained from working in the IT industry for a long time was coming together into one big picture.


I hope that readers of this book will have similar experiences and find it helpful in keeping their software and digital assets safe.
- Park Ki-seong