Technical debt is a fact of life for anyone working in software development: work that needs to be done to make the system cleaner and simpler and cheaper to run over the long term, but that the business doesn't know about or doesn't see as a priority. This is because technical debt is mostly hidden from the people that use the system: the system works ok, even if there are shortcuts in design that make the system harder for developers to understand and change than it should be; or code that’s hard to read or that has been copied too many times; maybe some bugs that the customers don’t know about and that the development team is betting they won’t have to fix; and the platform has fallen behind on patches. It’s the same for most application security vulnerabilities. The system runs fine, customers can’t see anything wrong, but there’s something missing or not-quite-right under the hood, and bad things might happen if these problems aren't taken care of in time. Where does Technical Debt come from? Technical debt is the accumulation of many decisions made over the life of a system. Martin Fowler has a nice 2x2 matrix that explains how these decisions add to a system’s debt load: I think that this same matrix can be used to understand more about where application security problems come from, and how to deal with them. Deliberate Decisions Many appsec problems come from the top half of the quadrant, where people make deliberate, conscious decisions to short cut security work when they are designing and developing software. This is where the “debt” metaphor properly applies, because someone is taking out a loan against the future, trading off time against cost – making a strategic decision to save time now, get the software out the door knowing that they have taken on risks and costs that will have to be repaid later. This is the kind of decision that technology startups make all the time. Thinking Lean, it really doesn't matter if a system is secure if nobody ever uses it. So build out important features first and get customers using them, then take care of making sure everything’s secure later if the company lasts that long. Companies that do make it this far often end up in a vicious cycle of getting hacked, fixing vulnerabilities and getting hacked again until they rewrite a lot of the code and eventually change how they think about security and secure development. Whether you are acting recklessly (top left) or prudently (top right) depends on whether you understand what your security and privacy obligations are, and understand what risks you are taking on by not meeting them. Are you considering security in requirements and in the design of the system and in how it’s built? Are you keeping track of the trade-offs that you are making? Do you know what it takes to build a secure system, and are you prepared to build more security in later, knowing how much this is going to cost? Unfortunately, when it comes to application security, many of these decisions are made irresponsibly. But there also situations when people don’t know enough about application security to make conscious trade-off decisions, even reckless decisions. They are in the bottom half of the quadrant, making mistakes and taking on significant risks without knowing it. Inadvertent Mistakes Many technical debt problems (and a lot of application security vulnerabilities) are the result of ignorance: from developers not understanding enough about the kind of system they are building or the language or platform that they are using or even the basics of making software to know if they are doing something wrong or if they aren't doing something that they should be doing. This is technical debt that is hidden even from people inside the team. When it comes to appsec, there are too many simple things that too many developers still don’t know about, like how to write embedded SQL properly to protect an app from SQL Injection, or how important data input validation is and how to do it right, or even how to do something as simple as aForgot Password function without messing it up and creating security holes. When they’re writing code badly without knowing it, they’re in the bottom left corner of the technical debt quadrant – reckless and ignorant. But it’s also too easy for teams who are trying to be responsible (bottom right) to miss things or make bad mistakes, because they don’t understand the black magic of how to store passwords securely or because they don’t know about Content Security Policy protection against XSS in web apps, or how to use tokens to protect sessions against CSRF, or any of the many platform-specific and situation-specific security holes that they have to plug. Most developers won’t know about these problems unless they get training, or until they fail an audit or a pen test, or until the system gets hacked, or maybe they will never know about them, whether the system has been hacked or not. Appsec Vulnerabilities as Debt Thinking of application security vulnerabilities as debt offers some new insights, and a new vocabulary when talking with developers and managers who already understand the idea of technical debt. Chris Wysopal at Veracode has gone farther and created a sensible application security debt model that borrows from existing cost models for technical debt, calculating the cost of latent application security vulnerabilities based on risk factors: breach probability and potential breach cost. Financial debt models like this are intended to help people (especially managers) understand the potential cost of technical debt or application security debt, and make them act more responsibly towards managing their debt. But unfortunately tracking debt costs hasn't helped the world’s major governments face up to their debt obligations and it doesn't seem to affect how most individuals manage their personal debt. And I don't think that this approach will create real change in how businesses think of application security debt or technical debt, or how much effort they will put in to addressing it. Too many people in too many organizations have become too accustomed to living with debt, and they have learned to accept it as part of how they work. Paying off debt can always be put off until later, even if later never comes. Adding appsec vulnerabilities to the existing debt that most managers and developers are already dealing with isn't going to get vulnerabilities taken care of faster, even vulnerabilities that have a high “interest cost”. We need a different way to convince managers and developers that application security needs to be taken seriously.

in part one , we captured sms messages using a broadcastreceiver. in , among a set of options, we chose to pass the needed sms information (sender, message and timestamp) as a serializable 'popmessage' object from the background to the foreground alert dialog that we constructed in : in this last section, we will complete this basic application by handling the user actions through button clicks. there are two actions the user may perform: close the sms popup window once the message is read choose to respond to it using his favorite sms program. we used intents in the previous parts of this series, as asynchronous messages to pass data between components: // in our broadcastreceiver class, we're passing the // sms message pop_msg to the popsmsactivity, i.e. our ui. intent.setclass(context, popsmsactivity.class); intent.setflags(intent.flag_activity_new_task); intent.putextra("msg", pop_msg); context.startservice(intent); the above code uses an explicit intent , i.e an intent that indicates a particular class ( popsmsactivity ) to pass data to. it is basically a direct call to another component (service, activity...). but intents can also be used to send messages to the android system so that the latter can determine what course of action to take. implicit intents do not designate a specific class which should be called by the system, but the action which we would like to be performed by the system. how does android know which component(s) to call in order to perform that action? because those applications/components that can handle the action have previously registered themselves in the system. but how did they do that? the same way we did with our custom sms receiver in our application's manifest in part one of this series: by using an intent-filter , we indicated to the android system that our application was a candidate for handling the sms_received event. intent filters are how components declare their capabilities so that other components can use them. android will look at the action, data, and category of the intent as part of its intent resolution process. a given component can declare any number of intent filters, corresponding to the number of actions it can potentially handle. if a component does not have intent-filters, it can only respond to explicit intents. when there are several components that have the same intent filters, android will present the user with a list to choose from. what the smsreply() method below is doing, is asking android to bring up any mms-sms program it can find on the phone : /***/ private void smsreply(string sender, string body){ intent sendintent = new intent(intent.action_view); sendintent.putextra("address", sender); sendintent.putextra("sms_body", body); sendintent.settype("vnd.android-dir/mms-sms"); startactivity(sendintent); this.finish(); // close this activity now } this is what it looks like on the phone, once the "reply" button is clicked and the sms program (second screen) is brought up automatically to send a response: the gohome(), sweet home method called on closing the dialog, simply takes the user back to the phone home screen : /***/ private void gohome(){ intent intent = new intent(intent.action_main); intent.addcategory(intent.category_home); intent.setflags(intent.flag_activity_new_task); startactivity(intent); this.finish(); } that's it. we now have our first working version of an sms popup application, and we can start building whatever new features we might think of on top of it. here's one example of what can be done, by adding the list of phone contacts, sounds, and a settings screen. source: tony's blog .

The widely adopted SCM tools we use today, GitHub and Gitlab, are built on the dated architecture and design of git, but this has some security gaps we'll explore.

In order to leverage observability, we need a significant shift in our corporate culture that encapsulates the entire company and goes beyond the tools.

Continue on a journey into the world of cloud-native observability: go out onto the playing field to understand who the players are and what teams they form.

Explore the difference between two well-known Auth building methods: AWS Cognito and JSON Web Token. Plus, take a look at the AWS Cognito application process.

Check out the benefits of deploying a service mesh, popular tools for deploying a Service Mesh, and more here in this article.

One of the best ways to tighten your Kubernetes security is by implementing ten tactics that have become industry standard.

Some great links about technical debt: Technical Debt - from metaphor to theory and practice (presentation) Special IEEE Explore issue on Technical Debt (Nov 2012) Must read if you're passionate about quality and have seen or heard some of the issues mentioned in these materials.

Kubernetes monitoring helps to identify problems within a Kubernetes cluster. Know more about Kubernetes monitoring and why it is important here in this blog!

CDK has landed, and the AWS community is hyped, but what exactly is CDK, how it works, and what does it mean for the world of Infrastructure-as-Code?

Gain context of three separate API solutions which can be used to validate name input fields within an application as you follow along with this demonstration.

Docker container packages up the code of an application and all its dependencies so that the application can run unchanged in any environment.

This tutorial is an attempt to integrate CockroachDB CDC with Azure Event Hubs via our existing Kafka support.

Its primary focus is to automate the deployment of applications inside software containers and the automation of operating system-level virtualization on Linux.

Monitoring your “important” data only gets you so far. If you really want data quality coverage, it's time to go deep and broad with your data monitors.

Embedding a microservice into another is not a common practice, but it could open to new ways for developing service-oriented applications.

Find out how companies can leverage EDI integration solutions to drive their business forward. Also, explore the potential limitations posed by EDI.

Learn more about Docker desktop and rancher desktop.

VS Code Timeline can take snapshots of different save points of a file. This can help you save lost work that Git may not be able to.