Latest / DevQuestions with Tim Corey / 324. What Should We Do When We Have Had a Data Breach

Transcript

324. What Should We Do When We Have Had a Data Breach · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: You just experience a data breach.
• 0:02
  SPEAKER_01: As a developer, what should you do next?
• 0:04
  SPEAKER_01: Now I'm not talking about handling the breach itself, but there's an important set of tasks that developers should do post data breach to further secure your systems and ensure that your code is not causing a future breach.
• 0:18
  SPEAKER_01: And if you haven't experienced a data breach yet, this will be a really good proactive set of steps that you can take to secure your systems.
• 0:25
  SPEAKER_01: So let's talk about it in today's episode of DevQuestions.
• 0:36
  SPEAKER_00: Welcome to the DevQuesti podcast with Tim Corey.
• 0:40
  SPEAKER_01: Software development is more than just writing code.
• 0:43
  SPEAKER_01: So let's talk about the rest of it.
• 0:45
  SPEAKER_01: Specifically, let's talk about what to do after a data breach.
• 0:48
  SPEAKER_01: Let me be clear again, this is not advice about the actual breach itself.
• 0:53
  SPEAKER_01: In the case of a breach, talk to the relevant authorities, employ an expert to help you, and let the affected parties know.
• 0:59
  SPEAKER_01: But as a software developer, you do have next steps.
• 1:03
  SPEAKER_01: Steps that you should be taking to prevent a breach in the first place, but also that are much more popular with management after a breach.
• 1:13
  SPEAKER_01: Use this time when people are aware of a danger to do the most good for your application and your company.
• 1:19
  SPEAKER_01: And if you haven't had data breach yet, still follow us advice if you can.
• 1:24
  SPEAKER_01: Now, the boss may say, yes, that's great advice, but this isn't a priority right now.
• 1:29
  SPEAKER_01: If you do get that message, well, at least you have it in writing that these are the things that you suggested.
• 1:35
  SPEAKER_01: That way, if there is a breach later in the future, you can say, okay, now we've had this breach, let's go back to what I suggested and do those steps.
• 1:45
  SPEAKER_01: That way, not only have you said, here's a plan for what to do now, but also you kind of subtly pointed out, I talked about this.
• 1:55
  SPEAKER_01: And then you can further secure your application.
• 1:59
  SPEAKER_01: Security, it's hard, right?
• 2:02
  SPEAKER_01: It's something that doesn't show up in new features.
• 2:06
  SPEAKER_01: It's not something that's that's flashy and great to see.
• 2:10
  SPEAKER_01: But at the same time, it's really important.
• 2:12
  SPEAKER_01: So by going through this list and saying, hey, let's do these things, being proactive, you get the opportunity to at least put it in front of your boss.
• 2:21
  SPEAKER_01: And maybe they say yes.
• 2:23
  SPEAKER_01: And if they say, no, you know what, that feature is more important than securing your application, well, that's fine.
• 2:29
  SPEAKER_01: That's their prerogative, but now you have it in writing for when it does come up later.
• 2:34
  SPEAKER_01: Okay, so let's say you've had a breach or you're preparing for a breach.
• 2:38
  SPEAKER_01: Either way, what are the things you should do?
• 2:41
  SPEAKER_01: Number one, inspect every place where you're gathering user input.
• 2:47
  SPEAKER_01: So too often people trust users.
• 2:50
  SPEAKER_01: It just don't do it.
• 2:52
  SPEAKER_01: Never trust the user.
• 2:53
  SPEAKER_01: But it's very easy.
• 2:54
  SPEAKER_01: Maybe you have just a comment field somewhere and you say, leave a comment here.
• 3:00
  SPEAKER_01: Well, are you making sure that that data is stripped out of any type of escape characters or other ways to bypass security?
• 3:11
  SPEAKER_01: Or are you just putting that in the database?
• 3:14
  SPEAKER_01: Don't just put it in the database.
• 3:16
  SPEAKER_01: Make sure you clean the data first.
• 3:18
  SPEAKER_01: Inspect every place where you're gaining or gathering user input.
• 3:24
  SPEAKER_01: Make sure that every single one of them you are stripping out anything that could be an escape character.
• 3:30
  SPEAKER_01: And you might say, well, Tim, that's that's that list is huge.
• 3:33
  SPEAKER_01: Well, then what you do is you just say, these are the things we allow.
• 3:37
  SPEAKER_01: And don't allow angle brackets or you know, double dashes or whatever the case may be that might escape out data.
• 3:46
  SPEAKER_01: And then also make sure that when you're using that information, that you also store it safely.
• 3:53
  SPEAKER_01: There are tools that will help you put it in the database safely.
• 3:58
  SPEAKER_01: So, for example, uh, when it comes to store procedures, or you're using Dapper in general, you can use parameterized SQL.
• 4:05
  SPEAKER_01: So you're not just saying, hey, let's build this string based upon user input.
• 4:10
  SPEAKER_01: Don't do that.
• 4:10
  SPEAKER_01: That's SQL injection 101.
• 4:12
  SPEAKER_01: Don't do that.
• 4:14
  SPEAKER_01: Instead, use parameters.
• 4:16
  SPEAKER_01: That way, even if there is bad data that gets through, you are protected against that.
• 4:21
  SPEAKER_01: Now, you don't want to let bad data through to that point, but this is defense in depth.
• 4:27
  SPEAKER_01: Don't just have one wall, have multiple.
• 4:29
  SPEAKER_01: Now, that does mean that you need to think about the data that's in your database and not always treat it as safe.
• 4:38
  SPEAKER_01: Because maybe it got through the first layer and went into the database and it didn't have a second layer at that time.
• 4:45
  SPEAKER_01: Maybe someone edited the database manually.
• 4:48
  SPEAKER_01: Maybe there is an app out there that's writing to the database that doesn't have a safety and security in place.
• 4:54
  SPEAKER_01: Well, this is where, first of all, layers help because if you had a layer closer to the database, like even the store procedures themselves, that would protect you by catching it at that point.
• 5:05
  SPEAKER_01: But still don't trust data and database just because it's in your database.
• 5:10
  SPEAKER_01: Make sure that you're checking that data too.
• 5:13
  SPEAKER_01: And that comes number two, inspect every place you get data from that's an untrusted source.
• 5:20
  SPEAKER_01: I don't trust most of my own database because it came from users initially.
• 5:26
  SPEAKER_01: So even that can be an untrusted source.
• 5:29
  SPEAKER_01: But then if you pull data from an API, if you pull it from another application in some way, if you have any type of data transfer between applications, don't trust those.
• 5:40
  SPEAKER_01: Because what if they get hacked?
• 5:42
  SPEAKER_01: Well, then they're gonna be inside your walls.
• 5:45
  SPEAKER_01: And they can then send unsafe data over to you and then breach you.
• 5:50
  SPEAKER_01: And it's a cascade effect.
• 5:52
  SPEAKER_01: Instead, have defense in depth.
• 5:55
  SPEAKER_01: Make sure that you put walls around your things so that even if somebody else is compromised or another app is compromised, that you are not compromised as well.
• 6:05
  SPEAKER_01: So inspect every place you get data from that's an untrusted source, and then figure out how to secure that data or then turn it into trusted data.
• 6:16
  SPEAKER_01: Number three, shrink down the permissions of every connection string.
• 6:21
  SPEAKER_01: So talking to a database is very, very common.
• 6:24
  SPEAKER_01: That's you have to do that.
• 6:27
  SPEAKER_01: But too often we have connection strings that are admin level.
• 6:31
  SPEAKER_01: This should not be.
• 6:33
  SPEAKER_01: Now it depends on your database and your data source where you're using what you can cannot secure.
• 6:38
  SPEAKER_01: But let's talk about Microsoft SQL.
• 6:40
  SPEAKER_01: That's a pretty popular database option.
• 6:43
  SPEAKER_01: With Microsoft SQL, the easiest thing to do is just give system administrative permissions to your credentials, and then everything works.
• 6:52
  SPEAKER_01: Don't do that.
• 6:54
  SPEAKER_01: Never do that.
• 6:55
  SPEAKER_01: But I know it's easy and your application will work.
• 7:00
  SPEAKER_01: And if you give it too strict of permissions, it might break.
• 7:03
  SPEAKER_01: That's the thing.
• 7:04
  SPEAKER_01: You want it to break.
• 7:06
  SPEAKER_01: You want to say, hey, this is too restrictive, let's loosen it up a bit.
• 7:11
  SPEAKER_01: Rather than saying, hey, this works, we think it's secure enough.
• 7:16
  SPEAKER_01: Make sure you lock it down.
• 7:18
  SPEAKER_01: This is why I personally love store procedures.
• 7:21
  SPEAKER_01: And I know that some people go, oh, that's that's old technology.
• 7:24
  SPEAKER_01: It's not.
• 7:25
  SPEAKER_01: But one of the things it allows you to do is say the connection string I'm using only has the ability to execute these store procedures.
• 7:35
  SPEAKER_01: It cannot read tables, it cannot list the tables, it cannot drop tables, it cannot create entries, it cannot do SQL injection and do anything bad because of the fact that we're locked down to only executing certain store procedures.
• 7:50
  SPEAKER_01: Which means that even if a person grabbed the connection string and got the username and password, they still can couldn't do anything more than the application can do.
• 8:00
  SPEAKER_01: That's locking down your connection string.
• 8:03
  SPEAKER_01: But if you say, well, it's the entity framework connection string and it has to be able to create tables and drop tables, that's an admin.
• 8:12
  SPEAKER_01: So if you're using the same connection string, that's a problem.
• 8:14
  SPEAKER_01: You can use a different connection string, one that can only read certain tables or do certain things.
• 8:21
  SPEAKER_01: Lock down every connection string possible.
• 8:24
  SPEAKER_01: If it's APIs, try to get a read-only API as opposed to a read-write API if you don't need to write.
• 8:31
  SPEAKER_01: All these things are least possible permissions.
• 8:36
  SPEAKER_01: That's what you're looking for.
• 8:37
  SPEAKER_01: Not the most possible permissions, not the easiest to use, the least possible permissions.
• 8:43
  SPEAKER_01: Lock this down.
• 8:44
  SPEAKER_01: Number four, audit who has access to secure data or systems and reduce that list as much as possible.
• 8:55
  SPEAKER_01: If you have a web server, that web server, let's say it runs on-prem, and so it's it's gonna in a server room somewhere.
• 9:02
  SPEAKER_01: Well, that server is going to have unencrypted access to connection strings.
• 9:10
  SPEAKER_01: It's gonna know how it talked to APIs, it's gonna know whatever your database credentials are, and it's gonna have that information unsecured.
• 9:20
  SPEAKER_01: Even if you encrypt all that information, it has to decrypt it in order to use it.
• 9:24
  SPEAKER_01: So in its memory, it's unencrypted.
• 9:26
  SPEAKER_01: So if someone has access to physically access that room, well, they might have access to get your unsecured passwords.
• 9:36
  SPEAKER_01: So secure those rooms, secure access to your systems.
• 9:40
  SPEAKER_01: If it's Azure, don't let everybody have an Azure admin access.
• 9:44
  SPEAKER_01: Give them only the rights that they need.
• 9:46
  SPEAKER_01: And the same is true for your data.
• 9:48
  SPEAKER_01: Not everybody needs to even be able to see the production database.
• 9:54
  SPEAKER_01: Personally, I don't like any of my developers to have any access to anything production, which may be mind-blowing.
• 10:03
  SPEAKER_01: How do you debug things?
• 10:05
  SPEAKER_01: Well, the way we do it is we take the production database every night, we back it up, we clean out the sensitive data, and then we create a new dev database from that.
• 10:17
  SPEAKER_01: Well, now we have as close as possible to production to recreate almost everything.
• 10:23
  SPEAKER_01: And the same is true for debugging when it comes to connecting to servers and systems.
• 10:28
  SPEAKER_01: I have a pre-production site, I have a staging site, I have a dev site that are as close as possible to the production site so that we should be able to recreate things that happen in production, in development, or in pre-prod, or in staging.
• 10:45
  SPEAKER_01: So we never have to have access to production.
• 10:49
  SPEAKER_01: So that as few people as possible have access to that secure data.
• 10:54
  SPEAKER_01: This reduces your overall exposure level as an organization.
• 11:01
  SPEAKER_01: Number five, if you've had a data breach, or if it's been a long time, rotate all your keys and passwords, all your API keys, all your database passwords, everything.
• 11:12
  SPEAKER_01: And you may say, well, I don't even know where all those are.
• 11:15
  SPEAKER_01: There's a red flag.
• 11:16
  SPEAKER_01: Figure it out, document it, make sure you know every single security entry, every single password, every single API, what it's used for, by who, who has access to it, when it was last changed, and how to change it.
• 11:31
  SPEAKER_01: These should all be procedures.
• 11:33
  SPEAKER_01: And I know we get busy, we don't do it.
• 11:36
  SPEAKER_01: This is a great opportunity to change that.
• 11:39
  SPEAKER_01: Put some security in place so that when it comes to rotating keys and passwords, it's just easy to do.
• 11:46
  SPEAKER_01: When it's hard to do, here's what happens.
• 11:49
  SPEAKER_01: Maybe you have an employee who goes rogue or you know gets frustrated at the organization and they end up being fired.
• 11:56
  SPEAKER_01: So security comes by, sends it to HR.
• 12:00
  SPEAKER_01: HR says, hey, we're gonna frog march you out of here.
• 12:02
  SPEAKER_01: You can't have access to anything.
• 12:03
  SPEAKER_01: We've locked down your passwords, all this, all this stuff, right?
• 12:07
  SPEAKER_01: But if your security keys for your database or your Azure information, or whatever these API keys, whatever these other things are, if they're hard to rotate, well, all of a sudden now you have an exposure window where you have a disgruntled worker who has had access to all these things, who might have written it down, or might still remember a password who could do things that you don't want done.
• 12:31
  SPEAKER_01: This happens a lot.
• 12:33
  SPEAKER_01: So make sure it's very easy to change these things.
• 12:37
  SPEAKER_01: Here's another thing.
• 12:38
  SPEAKER_01: Maybe you have a fellow coworker that you love.
• 12:42
  SPEAKER_01: They're great, they're awesome, and they just get a better opportunity.
• 12:45
  SPEAKER_01: Maybe they're moving out of the country, maybe they're you know moving to a different state and they found a great job somewhere else.
• 12:50
  SPEAKER_01: There's no hard feelings at all.
• 12:52
  SPEAKER_01: Everyone's happy, you have a party, et cetera.
• 12:54
  SPEAKER_01: They leave.
• 12:55
  SPEAKER_01: What's the first thing you should do?
• 12:58
  SPEAKER_01: Change all the passwords.
• 13:00
  SPEAKER_01: Now, is this because you hate them?
• 13:03
  SPEAKER_01: No.
• 13:03
  SPEAKER_01: Is this because you don't trust them?
• 13:05
  SPEAKER_01: No.
• 13:06
  SPEAKER_01: What this is, is a security measure.
• 13:09
  SPEAKER_01: It protects them and it protects you.
• 13:12
  SPEAKER_01: I have been in situations where we trusted the person, the person had no ill intent, but they still had access to a system they should not have had access to.
• 13:23
  SPEAKER_01: And they wanted to help someone out.
• 13:25
  SPEAKER_01: So they accessed the system they should not have had access to, and they did things that were no longer the correct policy.
• 13:34
  SPEAKER_01: And because they didn't know, because they'd left.
• 13:37
  SPEAKER_01: Well, now they have done something that caused a problem that blows back on them.
• 13:43
  SPEAKER_01: They get blamed for something, they get in trouble for something that really what it was was just an all-around bad situation.
• 13:52
  SPEAKER_01: They shouldn't have had access.
• 13:53
  SPEAKER_01: They should have tried it and go, oh, that's right.
• 13:55
  SPEAKER_01: I'm no longer an employee there.
• 13:57
  SPEAKER_01: I can't access that.
• 13:57
  SPEAKER_01: So they don't feel bad anymore telling a person they're trying to help, hey, I can't help you anymore.
• 14:03
  SPEAKER_01: So they don't feel bad.
• 14:05
  SPEAKER_01: And then you don't have to track down problems.
• 14:07
  SPEAKER_01: You don't have this whole big issue because they did help somebody in the wrong way.
• 14:12
  SPEAKER_01: So rotate all your keys and passwords every time a person leaves on a routine schedule, and definitely anytime you have any kind of disgruntled person.
• 14:23
  SPEAKER_01: That's number five.
• 14:24
  SPEAKER_01: Number six, reduce the amount of data you retain.
• 14:29
  SPEAKER_01: Companies tend to be hoarders when it comes to data.
• 14:32
  SPEAKER_01: They store everything.
• 14:33
  SPEAKER_01: And developers, we kind of encourage this.
• 14:35
  SPEAKER_01: Hey, you know what?
• 14:36
  SPEAKER_01: We might need this, we might need this.
• 14:38
  SPEAKER_01: And before you know it, you have these massive databases where you're storing things indefinitely.
• 14:43
  SPEAKER_01: When we used to store things in filing cabinets, it was a little easier because at some point we're like, we have too much stuff.
• 14:50
  SPEAKER_01: And so we create a system and say, hey, every three years this gets archived.
• 14:55
  SPEAKER_01: Every seven years, these get deleted.
• 14:57
  SPEAKER_01: Every 10 years, this was what happened, this is what happens.
• 15:00
  SPEAKER_01: Because we knew we didn't have the physical space.
• 15:03
  SPEAKER_01: But when it's digital, it's a little easier to say, well, we could store this forever.
• 15:09
  SPEAKER_01: We don't need to have the order history with address and other sensitive personal identifiable information of a person who hasn't been an employee for or hasn't been a user for a decade, right?
• 15:23
  SPEAKER_01: There has to be some type of scenario where you say, you know what, we're going to archive off this data.
• 15:28
  SPEAKER_01: It doesn't mean you delete the data.
• 15:31
  SPEAKER_01: It might just mean that you put it into a different place that doesn't have direct access very often.
• 15:36
  SPEAKER_01: And it might take some type of background job to retrieve that information.
• 15:40
  SPEAKER_01: So maybe that person has been gone for a decade, maybe come back a year later.
• 15:46
  SPEAKER_01: Well, you could have a system that says, okay, hey, we're going to retrieve your old information, but it might take a day or two.
• 15:52
  SPEAKER_01: And where it might take 15 minutes, whatever the case may be.
• 15:55
  SPEAKER_01: But you have a background job that says, hey, let's go out to the repository, let's find the archive data, let's look through it for this person, let's repopulate the information, et cetera.
• 16:04
  SPEAKER_01: But that way you're not storing on your server all the sensitive information that if you did have a data breach, all of it goes.
• 16:12
  SPEAKER_01: You have to let people for the past decade know that you lost their information.
• 16:17
  SPEAKER_01: Instead, try to retain as little as possible.
• 16:21
  SPEAKER_01: You don't need every bit of data.
• 16:23
  SPEAKER_01: Here's a key way to see if you need it.
• 16:26
  SPEAKER_01: Do you use it?
• 16:28
  SPEAKER_01: Do you use it?
• 16:29
  SPEAKER_01: Do you actually use it?
• 16:30
  SPEAKER_01: Not just a display, do you actually use it for something?
• 16:35
  SPEAKER_01: What you could do, for example, yes, my Amazon history, my purchase history, yeah, that's something that is probably important because I can go back and say, hey, when did I last purchase this?
• 16:45
  SPEAKER_01: And it may have been six years ago.
• 16:47
  SPEAKER_01: But my search history, no, that's not important.
• 16:50
  SPEAKER_01: Get rid of it after 30 days or 60 days, because at that point it's no longer relevant.
• 16:56
  SPEAKER_01: And there's other things as well, what I watched, all the things that it's not high-level important data.
• 17:04
  SPEAKER_01: So figure out how to identify what's important, what's not.
• 17:07
  SPEAKER_01: Even if you say, you know what, you watched this movie, but we didn't track how far into it you watched.
• 17:14
  SPEAKER_01: We didn't track where you left off because it's been a year.
• 17:17
  SPEAKER_01: So you tracked that yes, you watched it.
• 17:20
  SPEAKER_01: That's just one bit in the database.
• 17:22
  SPEAKER_01: Whereas where you want, you know, how long you watched it for, where you left off, et cetera, that's just information you don't need to keep.
• 17:29
  SPEAKER_01: It is additional storage.
• 17:31
  SPEAKER_01: Okay.
• 17:32
  SPEAKER_01: Number seven, check every boundary.
• 17:36
  SPEAKER_01: So if you have two applications and they talk to each other, make sure that communication is secure.
• 17:44
  SPEAKER_01: Whether it be using HTTPS, whether it be credentials, whether it be some type of authentication, encryption system, whatever the case may be, check between the systems.
• 17:55
  SPEAKER_01: This is where people get in, is in the boundaries.
• 17:59
  SPEAKER_01: Where they sit between two things, maybe they listen for that communication between each other, or whether they can impersonate one thing to talk to another thing, check every boundary.
• 18:10
  SPEAKER_01: Which is why microservices are the worst in this type of situation.
• 18:16
  SPEAKER_01: Because there's lots of boundaries.
• 18:18
  SPEAKER_01: There might be thousands of different ways to connect to all these different systems.
• 18:23
  SPEAKER_01: That can be a massive security nightmare.
• 18:27
  SPEAKER_01: So be very careful.
• 18:28
  SPEAKER_01: You might say, well, our microservices are all internal.
• 18:31
  SPEAKER_01: Guess what?
• 18:32
  SPEAKER_01: So are your users, and not all of those should you trust.
• 18:35
  SPEAKER_01: Not all of your admins should you trust.
• 18:39
  SPEAKER_01: So let's make sure you check every boundary to make sure that you're not leaking information, that you're not leaving a hole open for someone to exploit.
• 18:48
  SPEAKER_01: And if you do find, hey, we didn't do this, look at every other boundary to see if that same thing was occurred in other boundaries as well.
• 18:57
  SPEAKER_01: Number eight, check your logs for sensitive data.
• 19:03
  SPEAKER_01: Logging is a good thing.
• 19:04
  SPEAKER_01: Logging helps you track down errors.
• 19:07
  SPEAKER_01: Having good logs that really give you a sense of what was going on before an issue occurred, during the issue, and after the issue, really, really helpful.
• 19:16
  SPEAKER_01: And too often what you'll find is when you're trying to track down an issue, the logs weren't in detail enough.
• 19:21
  SPEAKER_01: And that's frustrating.
• 19:23
  SPEAKER_01: But your logs are a place to accidentally send out sensitive information.
• 19:31
  SPEAKER_01: So let's say you have an exception where a user is filling a form out and they fill out this data, including maybe their phone number, their social security number, something else that's sensitive.
• 19:42
  SPEAKER_01: And they fill out the whole thing out, but they put some kind of data in there that crashes the application.
• 19:48
  SPEAKER_01: It shouldn't, but let's say it does.
• 19:50
  SPEAKER_01: And your log catches that exception and stores all the data that's in the form.
• 19:55
  SPEAKER_01: Well, that might include the phone number, the person's name, the person's address, their social security number, or other sensitive information.
• 20:03
  SPEAKER_01: Now that's in the log files, not just in your database.
• 20:08
  SPEAKER_01: Now your log files probably have a different level of security than your database does.
• 20:14
  SPEAKER_01: Maybe your entire development team has access to your logs where almost none of your developers have access to production data.
• 20:22
  SPEAKER_01: So all of a sudden, you've exported this secure information to a less secure informate place.
• 20:29
  SPEAKER_01: So that's a problem.
• 20:31
  SPEAKER_01: Check your logs, make sure you're not capturing sensit information.
• 20:35
  SPEAKER_01: And if you are, delete it, figure out how to get rid of it, obfuscate it, you know, swap it out.
• 20:42
  SPEAKER_01: So when you're capturing things that are sensitive, maybe put stars in their place.
• 20:47
  SPEAKER_01: Whatever the case may be, make sure that you clean the data in your logs, clean it out of anything sensitive.
• 20:56
  SPEAKER_01: Number nine, update what you log to make it easier to catch problems.
• 21:00
  SPEAKER_01: So, yeah, sometimes that means more log statements, but realistically, going back to what we talked about with reducing the data, what do you actually use of your logs?
• 21:11
  SPEAKER_01: Too often people say, Well, I need to catch every single problem and I need to make sure I can track all these things.
• 21:18
  SPEAKER_01: And you have massive logs that you never look at, or the only thing you look at is a graph where you say, Oh, the number of exceptions has gone down recently, or whatever the case may be.
• 21:30
  SPEAKER_01: That's not actually helpful, and you're you're catching way too much stuff, which means you don't look at anything.
• 21:37
  SPEAKER_01: It's better to have three log entries that are valuable than to have 300 where 30 of them might be valuable.
• 21:47
  SPEAKER_01: Because you might not ever find those 30.
• 21:50
  SPEAKER_01: But you'll see all three if there's only three.
• 21:53
  SPEAKER_01: So make sure that you log what is important and you make sure that you're making it easy.
• 22:00
  SPEAKER_01: Easier to actually catch problems.
• 22:02
  SPEAKER_01: That probably means reducing a lot of your logging.
• 22:07
  SPEAKER_01: It also might mean adding some logging too.
• 22:10
  SPEAKER_01: That's for sure.
• 22:12
  SPEAKER_01: But it probably means reducing a lot of your logging.
• 22:16
  SPEAKER_01: Number 10, update your documentation on how to secure data.
• 22:21
  SPEAKER_01: This means when new developers come in, they know exactly how to scrub information that comes from the user.
• 22:28
  SPEAKER_01: They know how to check the boundaries for any type of data loss.
• 22:32
  SPEAKER_01: They know how to make sure they protect certain fields from going into the log files.
• 22:39
  SPEAKER_01: All these things are important to document.
• 22:41
  SPEAKER_01: So you know very clearly how to do these things so that maybe your system is secure today, but it might not be tomorrow when the new developer works on a new system.
• 22:52
  SPEAKER_01: You want to make sure that you're secure today and in the future.
• 22:57
  SPEAKER_01: So there's my top 10 list.
• 23:00
  SPEAKER_01: And you know what?
• 23:00
  SPEAKER_01: That's not a comprehensive list.
• 23:02
  SPEAKER_01: There's definitely more things you could do after a data breach depending on your circumstances.
• 23:09
  SPEAKER_01: But this list is going to get you well on your way to securing your applications.
• 23:13
  SPEAKER_01: The two biggest things that endanger your applications are obvious mistakes and compromise employees.
• 23:21
  SPEAKER_01: So obvious mistakes, it's, you know what, we allowed users to just put whatever they want and we didn't check to make sure it's valid data.
• 23:30
  SPEAKER_01: Obvious mistakes is we forgot to put HTTPS on the communication between those two microservices.
• 23:36
  SPEAKER_01: Obvious mistakes is where you use the SA password, the system administrator password, on your connection string.
• 23:44
  SPEAKER_01: These are all obvious mistakes.
• 23:46
  SPEAKER_01: And then compromise employees might mean that yes, they're being blackmailed to do something.
• 23:51
  SPEAKER_01: That's probably not the case normally.
• 23:53
  SPEAKER_01: It may be that they're trying to be helpful and going places they shouldn't go.
• 23:58
  SPEAKER_01: It may mean that they don't realize the danger and they just do something.
• 24:04
  SPEAKER_01: It may mean that they're disgruntled and want to hurt you.
• 24:14
  SPEAKER_01: But these are the two biggest areas of security holes in your organization.
• 24:20
  SPEAKER_01: It's not about the this dark hacker that's sitting in the back room that's got his whole team working on nuanced ways of getting in.
• 24:28
  SPEAKER_01: You may have that, but that's not the most common thing.
• 24:32
  SPEAKER_01: The most common thing is that you make mistakes and leak data because of it.
• 24:38
  SPEAKER_01: You make mistakes and it make it easy for a kid who's just learned how to do a basic SQL injection to access your system and access your data.
• 24:47
  SPEAKER_01: Like these basic mistakes are a big part of data breaches.
• 24:53
  SPEAKER_01: So this list is going to help you eliminate both of those issues and it's going to make it harder for you to be breached.
• 24:59
  SPEAKER_01: Now, no system is breach-proof, but that's no excuse for making it easy.
• 25:06
  SPEAKER_01: Make sure that you protect your system as much as possible.
• 25:09
  SPEAKER_01: Thanks for listening.
• 25:10
  SPEAKER_01: As always, I am Tim Corey.
• 25:12
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 25:16
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to IamtimCorey.com and enroll in a course.