Using Reference Models

0:00Hello and welcome. My name is Keith Barker. And when we sit at a computer,

0:05whether it's a mobile

0:06device or laptop or desktop or something else, and we go out to the internet,

0:09there's a lot of

0:10things that are happening in the background to make that all successful. And a

0:13lot of that is

0:14based on network activity where we send a request out to the server and we get

0:17a response back.

0:18Now, there's a couple of ways of approaching how we could understand all those

0:21details that happen.

0:22One is to say, "Wow, that's just amazing." And just leaving a big bubble says,

0:26"Amazing." Or,

0:27we could break it down into individual components or layers. And one way of

0:32slicing it up and chopping

0:34into smaller components that we can understand is using the concept of a model

0:38or a reference model.

0:39And that's what this set of videos are all about is how to use a reference

0:42model to better understand

0:44how the computer network works. So in preparation for this, I have some props

0:48ready to go. I also

0:49have some live demonstrations and hands-on lab for you to use to practice with

0:53to really get

0:53insight and understanding regarding the parts and pieces to make the basic

0:57network function.

0:58So if you're ready, I'm ready. And I'll see you in the next video as you take a

1:01big picture look

1:02at the world of using reference models to understand how computer networks work

1:06.

0:00I'd like to start off with this topology, which is the fancy way of saying a

0:04representation of a

0:05given network. So we have a computer down here and I'd like to think about a

0:09typical computer. Maybe

0:10it's a Windows computer like this one, a Windows 11 computer or maybe it's

0:14running Linux or

0:14maybe it's running macOS and maybe we're connected to the network with a

0:18physical cable like a patch

0:19cable. And here is an example of a patch cable that would go from our computer.

0:23For example,

0:24our computing device. There's a really teeny computer right here. Here's this

0:27network port. So we go

0:28ahead and connect there. Then we take the other end and plug it into our

0:31network infrastructure

0:32device. Now in this case, it happens to be a switch. So plug it in there and

0:36boom, that's our

0:37physical connectivity. So let's go take a look at that in our topology. So here

0:40in our topology,

0:41here is a representation of our computer. And here's that little cable right

0:44here that's connecting

0:45the computer over into the physical network device. So that's one way of

0:49connecting to a

0:50network. We could also connect to a network via wireless. We have some wireless

0:53gear that's

0:54connecting over the airwaves, but eventually that wireless connection is going

0:57to connect to a physical

0:58network. So let's imagine that we are sitting right here at our computer and we

1:02want to access a

1:03server. And this server over here in the network topology is a server called

1:07server1.negutlab.com.

1:10And this is just here in a lab environment. I currently have this little server

1:13sitting.

1:13And in computer networking, we have two primary roles. We have a role of a

1:16client, meaning we're

1:17making a request like asking for something like going to a store or restaurant

1:21and saying I would

1:22like this or I would like that. And then we also have the component or entity

1:25that's providing that

1:27service. And that's called a server. So in this topology, client one, if it was

1:31going to a website,

1:32for example, like server1.negutlab.com, our server would be this server

1:36providing the web services.

1:38And the client would be the device making the request. So as far as a client or

1:41a computer

1:41device making a request, let's make sure we're both clear on what that really

1:45looks like. Let's

1:46go to client nug and we'll make a request to get some content from this server.

1:50So I'm going to go

1:51ahead and click right here on client nug to bring that up. That's our little

1:53Windows client machine

1:54from the topology. And here it is. If we bring up a command prompt here on this

1:58little client

1:59computer, we can find out what its address is on the network by typing in a

2:02command called IP can

2:03fig on Windows. And there's its address. So think of an address like a street

2:08name and a house number

2:09that we use to reach somebody. That's the address we have right here on this

2:12local computer. So if

2:14we wanted to access a server on minimize this command prompt here, we could go

2:17ahead and open

2:17up a browser. So I'll go ahead and open up Chrome as an example of a browser.

2:21And here I have a little

2:22shortcut for server one dot nugget lab dot com. So if we click on that in the

2:27background, this computer

2:28put together a request, sent it to that server server at server one dot nugget

2:32lab dot com. And

2:33this is the response we got back. And this kind of activity between a client

2:37asking for services and

2:38a server responding back happens on the internet billions of times a day. So to

2:43better understand

2:44all the details that happen behind the scenes with these computers and servers

2:48as they're

2:48communicating back and forth over the network, we can leverage the concept of a

2:51reference model.

2:52So one way of breaking the individual pieces down into smaller components using

2:56reference models,

2:56we're like taking a say a recipe, we'll say this represents a recipe. And we

3:00have a whole

3:01bunch of different ingredients as part of that recipe. And they've been put

3:04together and processed

3:05in the right order. And then it's finally delivered. So as a user as a customer

3:09, all we get is the

3:10meal. But behind the scenes, the individual components and how they're put

3:13together is how we understand

3:16that meal. And just like a recipe identifies the individual components that go

3:20into a meal,

3:20we can also use a reference model to help us understand the individual pieces

3:25and parts

3:25that are making all of this work here between the client and the server.

3:29Another way of thinking

3:29of it is thinking of it like a building. So here's our foundation. And then

3:33maybe we have a first

3:34floor and a second floor and a third floor. And then beyond that we have things

3:37like plumbing and

3:38electrical and other details that go in. But by taking it piece by piece and

3:42part by part,

3:43we can better understand all the components like a recipe that makes it work.

3:47And that's one of

3:47the benefits of using a reference model and the OG of reference model, the

3:51original reference model

3:53is called the OSI reference model. And that stands for open system interconnect

3:58model. But we just

3:59call the OSI model. So what I look forward to getting to do with you in this

4:03set of videos is

4:04taking a closer look at the OSI reference model, including the details that can

4:08happen behind the

4:09scenes at a computer, very much like a recipe with this individual ingredients.

4:13And then apply

4:14that knowledge regarding the OSI reference model to the actual computer network

4:18protocols that we

4:18actually use today. So if you are ready to join me as we unravel the mystery of

4:23the reference models

4:24and better understand how computers actually can communicate over a network,

4:28join me in the next

4:29video and we'll take a closer look at the original OSI reference model.

0:00In this video, as we take a look at the OSI reference model, here is the seven

0:05individual

0:06components. Think of like seven ingredients that go into what has to happen to

0:10go ahead and allow

0:11a computer like client like here to communicate with a server like server one

0:15over here. So,

0:16let's be the client making the request. I'd like a website where the client is

0:19saying something like

0:20I'd like to see this web page and the server saying, okay, here it is. And

0:25again, the model

0:25concept can help us break down the entire detail behind the scenes what has to

0:30happen for the client

0:31to make that request in the first place and then for the server to respond to

0:34it. I'd like to share

0:35with you a couple of easy ways to remember the various names or sections of the

0:40OSI reference

0:40model. Again, the purpose of this model as we start digging into the individual

0:44sections is to better

0:46understand what has to happen at the computer and at the server for

0:49communications to happen between

0:51them. And as a spoiler alert, the client who's making the request has to do a

0:55little bit of work

0:56at each of these layers before it's going to go ahead and actually send that

1:00traffic out on the

1:01network. So before we begin, let's talk about a great way of helping to

1:05remember the various names

1:07of the OSI reference model. So as a help in remembering the names of the OSI

1:11reference model,

1:12let's go ahead and use the first letter of each of the names. So I'll go ahead

1:16and put a little

1:17mark there P for physical D for data link and for network T for transport S for

1:22session P for

1:22presentation A for application. And one way of remembering these, and I'm going

1:26to start from

1:27the ground up on this first example, is to use a phrase and that phrase could

1:31be something like

1:32please. So there's the P and please reminding us of the first letter of the

1:35first layer of physical.

1:37And then as we go up, we'll say do and maybe the whole phrase please do not.

1:42Now, whether or not

1:43you like sausage pizza, we're going to encourage you with this phrase to please

1:47do not throw

1:48sausage pizza away. Please do not throw sausage pizza away. So if you can

1:53repeat that phrase,

1:54that's going to be a little clue as far as the first initial of each of the

1:58layers in the OSI

2:00reference model. Another phrase I heard many, many years ago was the phrase all

2:05people seem

2:06to need data processing. But you know, that one doesn't roll off the tongue

2:13quite as well as

2:14please do not throw sausage pizza away. And also this one starts from, you know

2:17, layer seven working

2:18all the way down to layer one. But either way is fine. If you want to just pick

2:22one of those,

2:22memorize it, write it out. That will help you in remembering the various names

2:27of the layers in

2:28the OSI reference model. Now, I'd like to ask you a question. If this computer,

2:32and we haven't

2:33covered the facts of this yet, but if this computer is going to send a request

2:36for like say web

2:37services over to a server, I'm going to ask you a question about how many of

2:40these layers do you

2:41think this computer has to go through before it actually sends the data out to

2:46the server?

2:48And the answer to that question is all of it. So in the brain of this computer

2:54in the background,

2:55when the user types in, for example, let's go to this website or that website

2:58behind the scenes,

2:59the computer is going through these individual layers in this model to get all

3:03the data it needs

3:05before it ships that data over that patch cable in this example over to the

3:09network. And then it's

3:10the network's job to forward that traffic over to the server who then receives

3:13that request.

3:14And when the server receives that request, guess what it has to do? It has to

3:17basically go in the

3:18reverse direction and process all that traffic and data that came in. So it's

3:22also going to the work

3:23of all these logical layers. And part of that would be things like, Oh, this

3:26traffic that's coming

3:26from the client is for me. And I do have a web service running in this clients

3:30requesting it,

3:31and I respond back. But logically, it has to go ahead and receive and process

3:34that data in pretty

3:36much the reverse order. Now I have some great news for you. The OSI reference

3:40model is just a model.

3:43It is not a literal protocol that we use today. It's just an idea that helps us

3:49compartmentalize

3:50and better understand the individual details. So what I'm going to do is I'm

3:53going to encourage

3:54you to memorize the names of the seven layers. Please do not throw sausage

3:59pizza away, physical

4:00day link network transport session presentation application, or use another

4:03phrase to help you

4:04remember what it is. So once you've memorized what these layer names are, the

4:09good news is,

4:10because this is just a model, we don't actually use literally the OSI reference

4:16model when computers

4:17are talking over network, because today we use a protocol called TCP IP and IP

4:23stands for internet

4:24protocol. And the good news about IP is that it does not, it does not use every

4:29single

4:30literal layer of the OSI reference model. The actual protocol itself that we

4:34use has five.

4:36So it makes sense for us to better understand what this protocol stack is, then

4:40we'll also take a look

4:41at how we can leverage the OSI reference model in understanding how the

4:45protocol that we use on

4:46the internet today, the internet protocol, how it works. So before we go to the

4:50next video,

4:50we start comparing and contrasting the reference model to the actual protocol

4:54stack that we use

4:55today, I would encourage you to take a few minutes right now and write out the

4:59phrase you want to

5:00use to help you remember the actual names of the layers in the OSI reference

5:05model, because we're

5:06going to use some of those, not all of them, but some of those as we take a

5:09look at the TCP IP

5:10protocol stack coming up. So when you take it a minute and you've written out

5:14the phrase you want

5:14to use to remember the layers of the OSI reference model, and you can do it a

5:18couple times without

5:19referring to the video, when you're ready to go on, join me in the next video

5:22and we'll compare the

5:23OSI reference model to an actual TCP IP protocol stack that we use today. So I

5:28'll see you in just a

0:00So here is a little representation of our network.

0:02Here is our client computer,

0:04and here is the server they have not moved since the last video.

0:08And here are our options for identifying what's happening behind the scenes.

0:11The OSI reference model, as I mentioned in the previous video,

0:14is just an idea.

0:16And it was created decades ago,

0:18just as a logical way of representing what has to go on in the brain of this

0:21computer

0:22before it starts sending the data over the network,

0:24that'll then be forwarded to the server who then process it.

0:27So with that in mind, that this is just an idea.

0:30It's not a real set of protocols,

0:32and a protocol is a fancy word for saying a set of rules.

0:35So for example, as I speak to you, I'm currently speaking in English,

0:39and there are certain rules that are set up regarding English.

0:42And if you understand how English works,

0:43and I understand how English works, we can communicate together.

0:46Now, if I understood French, which I don't,

0:48but let's pretend for a moment that I did,

0:50and I wanted to communicate with you in French,

0:52and you don't understand French at all,

0:54we wouldn't be able to communicate.

0:55So whenever you hear the word protocol,

0:57think of like an agreement or set of rules that two devices,

1:01in this case, the whole network, are going to agree to and understand,

1:05so they can go ahead and interact with each other.

1:07So going back to the OSI reference model, it's just an idea.

1:10Now, a long time after the OSI reference model came out,

1:13the Department of Defense in the United States came out with a protocol stack,

1:17an actual set of rules and agreements that could be used to communicate,

1:20and they called it, and they still do, the TCP/IP protocol stack.

1:25We'll talk in a little bit why they call it TCP/IP,

1:28but this is the actual Department of Defense set of protocols

1:32that can be run on a computer and a server,

1:34and if the network devices all in between them can understand that protocol as

1:37well,

1:38we can have the client make a request, have that delivered to the server,

1:41and then the server can respond back.

1:42Now, the DOD's TCP/IP protocol suite, or TCP/IP protocol stack,

1:46you call it a suite of protocols, think of it like a collection that works

1:50together,

1:51or you can call a stack that represents a set of protocols

1:54that all can work together, even though they created it.

1:56When they created it, it had four layers.

1:58They had this layer right here, and this one, and this one, and this one,

2:02but you can see how it didn't really match up to the actual reference model

2:05of just a real protocol that they created and that we currently use today.

2:10So here's the magic about where we're at today.

2:13Today, and I'm going to call this actual or real,

2:16because this is actually what we use today,

2:18we use the TCP/IP protocol stack.

2:21There's a couple different flavors, IPv4 and IPv6,

2:24but we use the actual TCP/IP protocol stack, but here's the catch.

2:28We actually borrow some of the names from the OSA reference model

2:33as we talk about and discuss the actual TCP/IP protocol stack that we use today

2:38.

2:38For example, here's the one-to-one match-ups,

2:40even though in the TCP/IP protocol stack,

2:42it has one layer called network access.

2:45We actually borrow and use the name physical,

2:48and also borrow and use the name data link

2:51to represent this bottom part here,

2:53which in the TCP/IP protocol stack is just called network access,

2:56but we borrow the actual names from the OSA reference model.

3:00Now, that was a period of time where that was established,

3:04and that is the norm today.

3:05So if somebody's talking about layer one or layer two in the TCP/IP protocol

3:10stack today,

3:11they're talking about this component layer one, this section.

3:13Think of it like that ingredient of the recipe,

3:15and layer two would be the data link.

3:18And then for the third layer here,

3:20the OSA reference model called it the network layer or layer three.

3:23In the TCP/IP protocol stack, they called it the internet layer,

3:27but once again, we borrowed the actual name from the OSA reference model

3:31as we refer to it today.

3:33Think of it like, you know, if somebody's name is Robert

3:35and we could go ahead and call him Bob,

3:37even though that's not its real name, we just use it as a reference,

3:40and everybody knows that we're talking about Robert.

3:42Same thing with the actual protocol stack we use today with TCP/IP,

3:45even though it's the actual protocol stack that was created

3:48with originally four big layers.

3:50We've sliced and diced and borrowed some of the layer numbers and names

3:54as we actually use the TCP/IP protocol stack today.

3:57Then at layer four is the same across the board.

4:00The OSA reference model has this compartment or layer called transport,

4:03and in the TCP/IP protocol stack,

4:05we actually have a layer four that's also called transport.

4:08And then for the best news is that these three layers of the OSA reference

4:12model,

4:13application, presentation, session,

4:15they've all been lumped together in one layer in the TCP/IP protocol stack

4:19called the application layer, and that's actually what we call it today.

4:22We call it the application layer, and nobody calls it layer five.

4:26We just call it the application layer.

4:27So going forward, as we take a look at the individual details

4:30that a computer has to do as it communicates across the network,

4:33we're going to be using this column right here,

4:36which is a representation of the TCP/IP protocol stack that is a real protocol,

4:41and we're going to borrow some of the layer numbers and labels

4:45that were in the original OSI reference model.

4:47So going forward, just to be clear,

4:49we're not going to be talking about details of the OSI reference model,

4:52other than just memorizing the layer names with things like,

4:55"Please do not throw sausage pizza away."

4:57And also, as we talk about TCP/IP and use it,

4:59we're not going to be actually referring to the network access layer,

5:02but instead, we'll be talking about layer one physical layer

5:06and layer two data link layer as a representation of the individual components

5:10happening in the network access layer in the TCP/IP protocol suite.

5:13So in short, our winner is right here and going forward,

5:17and for the balance of the entire course and everything I talk about

5:20from this point forward, when we talk about layers and names of layers

5:24and individual ingredients in the recipe of getting a computer network to

5:28operate,

5:28we're going to be using these representations with layers one, two, three, and

5:33four,

5:33physical data link network transport, and then up here,

5:36representing what was in the OSI reference model,

5:39the top three layers, we're just going to call it the application layer.

5:42So to really dig in and understand now the TCP/IP protocol stack

5:46or the suite of protocols in the TCP/IP protocol suite,

5:49using the numberings and the labels that we just described,

5:52in the next video, I'd like to take each individual component,

5:55like one recipe ingredient at a time and give you a real world example

6:00of what they do, how they work,

6:02and then as we build layer by layer by layer,

6:04it'll help fill in the gaps and show us a behind-the-scenes tour

6:07of what's happening when computers on a network are talking with each other.

6:11So we're going to start at the top with the application layer,

6:14and we're going to do that in the very next video,

6:16so I'll see you there in just a moment.

0:00Now, as promised to better understand logically what has to happen at a client,

0:05for example,

0:05right here, when it's communicating with the server right here and when it

0:08makes a request

0:09and the other gives a response or an answer to that request, we're going to be

0:13using the

0:13TCP/AP protocol stack as we discussed in the previous video and we're going to

0:17break it

0:18down one section at a time.

0:19It's like taking a recipe and breaking it down into one ingredient at a time

0:24and then

0:24we'll take a look at their relationship to each other.

0:27So we're going to start with the application layer.

0:28Now, what exactly does that mean, the application layer?

0:32And sometimes it's referred to as a service, like an application layer service.

0:36Now, what is an example of an application layer service?

0:38It's pretty much what you want from the network.

0:41For example, if this client right here opens up a browser and they go to www.

0:47server.com,

0:49I'd like to ask the question, what is it that the client's expecting to have

0:52happen as

0:53a result of opening a browser and going to www.server.com?

0:58Well, the answer is, of course, they want a response back.

1:01They want to go ahead and have their web page fill in with the response from

1:05that server.

1:05So what the client is actually requesting in this example would be an example

1:08of a web

1:09service like HTTP is an example of an application layer service.

1:14So HTTP stands for Hypertext Transfer Protocol and there's a secure flavor

1:18called HTTPS.

1:19But think of it like an example of an application layer service.

1:23That's why I'm putting it here in green.

1:24I'm going to jot down HTTP.

1:26And then I'm going to put it in a web like a web page.

1:28Now, in current networks, we're moving a lot more to things like HTTPS.

1:33That's a secure flavor of web services.

1:35But for now, I just want to provide a single example here of HTTP as an example

1:40of an

1:40application layer service.

1:41Now, what does an application layer service like HTTP look like?

1:45Let's get real.

1:46Let me show you.

1:47Let's go to client and I for a moment.

1:48I'll demonstrate this for us.

1:49We'll go to client and we'll open up a browser and we'll ask to see the content

1:54at server

1:55one.

1:56That's server one.nuggetlab.com, which is here in a lab environment.

2:00So here is my little client nug computer.

2:03And if we open up a browser, I've got a shortcut here on the taskbar for it.

2:06I'm going to click on Chrome there and I'm going to go to this URL.

2:09It's a fancy way of saying the name of the site you want to go to and it's HTTP

2:13colon

2:13slash slash server one.nuggetlab.com.

2:16So I'll click on that and that's my web request and now I got a web response

2:20because I specify

2:21that I wanted to use HTTP.

2:23That's the application layer service that used.

2:25So that's one example of an application layer service is HTTP that's being used

2:29to serve

2:30up web pages.

2:31Now, a long, long time ago in a galaxy far, far away, there used to be a thing

2:35called a

2:36phone look where you could actually look up somebody's name and then find out,

2:39for example,

2:40what their phone number was.

2:41I know we can look it up online now, but behind the scenes, this computer right

2:44here, client

2:45nug, if it wants to go out to server one.nuggetlab.com, that is an example of

2:49the name of that

2:51server or that service.

2:52However, behind the scenes, when computers communicate over an IP network, they

2:57are going

2:57to be using IP addresses.

2:59So here's an example of some IP addresses.

3:02We have one right here for a client.

3:03I think of that address.

3:05That's an example of what's called an IPV for address.

3:07We'll have future videos and skills regarding that, but an IP address,

3:10basically think of

3:11it like a street name and a house number.

3:14And so the client has a house number on a given street and so does the server.

3:18So the server is up here.

3:20So on the client, it's like 10, 10, zero.

3:22Think of that like a street name and 50 would be the house address on that

3:26street for this

3:27client computer.

3:28And in the server, we can think of 10, 40, zero.

3:30Think of that like a street name and think of dot 100 as the house number, if

3:34you will,

3:35on that street.

3:36And it will take a closer look later at those details.

3:38But the important part here is that if this computer right here, client nug

3:41wants to communicate

3:42with the server, it needs to know what that IP address is.

3:45So if we as a user put in the URL of http colon slash slash server one that nug

3:52getlab.com

3:53somehow this computer needs to know what the actual IP address is for that

3:58computer.

3:59So it's going to use yet another application layer service called DNS to make

4:03that request.

4:04So DNS stands for domain name system.

4:06Think of it like a lookup for IP addresses.

4:10So behind the scenes, the computer, it wants to know the IP address of server

4:14one dot nuggetlab.com.

4:15We can see right here in my lab environment, it's 10, 40, zero, 100, but the

4:19client doesn't

4:19know that yet.

4:20So it would use the client behind scenes would use DNS to make that request to

4:25find out what

4:25the actual address is.

4:27So as an example of another application layer service, I'm going to put DNS

4:30right here.

4:31And below it, I'll just write name lookup because that's what that service is

4:34providing.

4:35So one of the questions might be, well, who are we going to ask if we're using

4:38DNS?

4:38Who are we going to ask?

4:39So perhaps this client here in their local network has a DNS server that can

4:44interact

4:44with the internet or perhaps the client is connected to a DNS server out on the

4:49internet.

4:50So in this example, if we're connecting to a server inside of our company, it's

4:53very likely

4:53we also have a DNS server sitting inside of our company as well.

4:57So the computer would reach out to its DNS server and say, hey, I need the IP

5:01address

5:01for server one dot nuggetlab.com.

5:04And the server would respond back to the client.

5:06And then with that information, the client could continue his processing to

5:09forward a

5:09packet out to the actual IP address of that server.

5:12This example is 10 dot 40 dot 0 dot 100.

5:14And as an example of DNS, let's go back to this client machine and then we

5:17demonstrate

5:18DNS in action where this client is making a request to determine the IP address

5:23of the

5:23server.

5:24So here is our client.

5:25Let me go ahead and close that Chrome window.

5:27And let's go to a command prompt.

5:29And on a Windows computer, if we use the command IP config, it'll show us our

5:33information regarding

5:34our IP address.

5:35Again, we'll come back to that later.

5:37And if we type in IP config space slash all, it'll also tell us who are DNS

5:42servers.

5:42And right here, it's indicating who are DNS servers.

5:45If we made a request, for example, if I did a ping to server one dot nuggetlab.

5:50com and

5:51press dinner, before I press center, ping is just a connectivity testing tool

5:54just to

5:55verify we can reach it.

5:56So behind the scenes, even though as a user, I'm just typing ping behind the

5:59scenes, this

6:00computer is going to, if it doesn't already know, it's going to have to make a

6:03request

6:04to its DNS server say, Hey, what is the actual IP address behind server one dot

6:08nuggetlab.com

6:09cell press enter.

6:10And all of that just happens in the background in a flash before it starts to

6:15the ping to

6:15this IP address.

6:17And on a Windows computer, we can use the command IP config space slash display

6:23DNS

6:23to show the local DNS cache on this computer.

6:26So when the computer makes a request, it can store that information for a short

6:29period

6:30of time.

6:31And that way, if it's going to the server over and over and over again, it didn

6:32't have

6:33to make the DNS request over and over again.

6:35So this is the cache on the local computer.

6:37So we wanted to go to server one dot nuggetlab.com.

6:40We made a DNS request for that to happen.

6:42And the response we got back, the answer we got back was, Hey, it's at 10 dot

6:4640 dot

6:46zero dot 100.

6:48So these are examples of two application layer services.

6:51One where we're asking for web content, we want to see it.

6:54And behind the scenes, what we also just demonstrated was another application

6:57layer

6:57service being used called DNS, which is doing name lookup, where it converted

7:02and found

7:02out for us from a DNS server, what the actual IP address was that it needed

7:06based on the

7:07name of the server we're trying to go to.

7:09Now one other thing I really enjoyed doing, especially with the fundamentals of

7:13networking

7:14is let me go ahead and clean this up just a little bit.

7:16And let's talk about proving because it's always nice to hear a concept like,

7:21Oh, here's

7:21what happens.

7:22And here's what happens.

7:23But it's also really important periodically to validate and prove that what we

7:28think is

7:28happening is happening.

7:30So I'm going to go ahead and share with you a little tool called a packet

7:34capture, more

7:35specifically, it could be called packet capture software.

7:38And one of those out there that's super popular and it's free is called wire

7:42shark.

7:42So what we could do is we could run a wire shark right here on this local

7:46computer.

7:47And what it would do, it would capture all the packets and traffic.

7:50They're going in and out of this interface.

7:53And then put them in a nice interface so we can actually see the actual packets

7:56and

7:56traffic that's going in and out.

7:58So I'd like to share with you a packet capture with wire shark and just confirm

8:04that HTTP

8:05and DNS are both being used.

8:07So to do that, let's go down to client one and we'll start a packet capture.

8:11So here at client one, I'm going to go ahead and close the command prompt and

8:14to start

8:14a packet capture here, I have a shortcut on the desktop of client nug right

8:18here, a

8:18little fin of a shark and that is the taskbar shortcut for wire shark.

8:24And then I'm just going to tell it to go ahead and take a look at my network

8:26card that I

8:27have connected to this lab network.

8:29And now it's capturing traffic as it sees it off the network.

8:32So I go ahead and minimize that and let's generate some traffic.

8:35So let's go ahead and do a few things.

8:37Let's go to a command prompt here and I'm going to clear the DNS cache.

8:41So earlier we did the command IP config space slash display DNS.

8:46So we've already learned what the answer is about the IP address for our server

8:51.

8:51I want to go ahead and clear that and make it happen again.

8:54So we're actually sending out another DNS request.

8:56So we'll type in IP config slash DNS.

9:00That flushes the cache.

9:01We'll hit the upper key a few times.

9:02Do an IP config display DNS and just to confirm there's nothing currently in

9:06the cache like

9:06the temporary saved location on this computer.

9:09So at the moment, it doesn't know this little windows computer doesn't know

9:13what the actual

9:13IP address is behind server one.nuggetlab.

9:16So if we did a ping over to server one.nuggetlab.com and press enter behind the

9:21scenes, it had

9:22to do a DNS request to relearn the IP address of 1040 0 100.

9:27We can verify that with or if you're on a Windows 11 machine, you can also use

9:30a dash,

9:31although the slash has been used for decades.

9:33And there's the answer that happened in via DNS.

9:35And so if we then go to a browser and we want to capture some HTTP traffic,

9:39another application

9:41layer service, we can use this shortcut right here to go to HTTP server one.nug

9:45getlab.com

9:46and I'll hit refresh a couple of times just to make sure we're not just playing

9:49it from

9:49the cache.

9:50Now that we have done a DNS request, we've also done an HTTP request and our

9:55packet

9:55captures running, let's go ahead and take a look at the results.

9:59So I'm going to open up the packet capture here.

10:01I'm going to stop it and then I'm going to go ahead and do something called a

10:03display

10:04filter just to filter out some of the traffic.

10:06So when I type in DNS press enter and this shows us just the DNS traffic.

10:10So there's a whole bunch of DNS requests.

10:13I'm going to scroll down until I see the one that's the DNS request and I'm

10:17looking

10:17over here on the right hand side.

10:19I'm looking for the DNS request for server one.nuggetlab.com and there it is

10:23right there.

10:24So if you look at the details for this and again, my goal right here is to help

10:28us be

10:28experts at Wireshark.

10:30But I just want to confirm that in this DNS request and oops, this is the

10:34response.

10:35Go one up.

10:36Here is the request.

10:37So here's the DNS, the domain name system query where the client is saying, hey

10:40, I really

10:41would love to know the IP address for server one.nuggetlab.com.

10:44Think of it like you want to go to your friend's house and your friend's name,

10:48but you don't

10:48know their address.

10:49Think of it like asking somebody, hey, for Steve or Bob or Ali or whoever it is

10:53, what

10:54is the actual address for them?

10:56That's a lot like a DNS request where we know the name of the server we want to

10:58go to,

10:59but we don't have the address and so we make a request.

11:01So here's a request and at the application layer here, this is the DNS that's

11:05being

11:06used.

11:07And then for the packet right below it, that is a response coming back and the

11:10response

11:10that came back said, hey, that server is at this IP address and we'll open up

11:15the answer

11:15to see that.

11:16So here's the address right there, 1040, 0100.

11:20So before we get too wrapped up in the individual details regarding Wireshark,

11:24the main purpose

11:25of that demonstration was to help reinforce two examples of application layer

11:29services,

11:30what we want.

11:31For an HTTP, we want a webpage effectively.

11:34For DNS, we want the information regarding the address for a server like server

11:38one.nuggetlab.com.

11:40And those are two examples of application layer services.

11:42But not the only two, there are hundreds of different application layer

11:46services, but

11:47these are two great examples of application layer services.

11:50Now just like building a house with a foundation and then first floor and

11:54second floor and

11:55third floor, et cetera, each of those layers depends on the one below it.

11:59So even though we have these application layer services, we have other

12:02functions that we need

12:03to call upon and use to actually make the request able to go from this client

12:08up to the

12:08server.

12:09So in this video, I'd like to take it the next logical step, still using HTTP

12:13and DNS as

12:13an example and talk about some of the protocols that are used, some of the

12:16rules that are

12:17used in the TCP/AP protocol stack at layer four.

12:21And that'll help us better understand the logical process that has to happen at

12:24layer

12:24four to support the application layer services.

12:27So I'll see you in the next video as we take a closer look at the transport

12:31layer, layer

0:00We are going to continue using this as an example of a client who's accessing a

0:04server

0:05up here and that's server one.

0:06In the previous video, we took a look at two application layer services.

0:10One was HTTP, which think of it like web services, getting a web page.

0:14And the other we looked at was DNS, an acronym for domain name system, which is

0:19the way to

0:20look up the actual address like the street name and the house number for a

0:23computer or

0:24system you want to go to.

0:26But you don't know that yet, so you make a DNS request and say, hey, for this

0:29server

0:29one.nuggetlab.com, what is the actual address behind it?

0:33Again, these are two examples of application layer services.

0:36So I'm going to go ahead and put those in green and that way they match our

0:39color coding

0:40here for the application layer.

0:42So let's go back to this computer here, client nug, as we continue our

0:45discussion.

0:46Now the application layer is just one component of what this computer needs to

0:50put together

0:50before making that request.

0:52There's also going to be as part of the TCPP protocol stack.

0:56There's also layer four information that needs to be included.

0:58And that's because these application layer services have specific layer four

1:02protocols

1:03that they're built or designed to use.

1:06And so as part of making a request, the computer would not only specify the

1:09protocol at the

1:10application layer they want to use for the request, but they would also specify

1:13the layer

1:14four transport protocol needs to be used in combination with that application

1:17layer service.

1:18So for the transport layer, let me go ahead and try to match that color here.

1:22So I'm going to go ahead and put a little arrow that represents layer four, the

1:25transport

1:26layer.

1:27And this top one is the application layer.

1:29I'll put app for short.

1:30And our two examples are HTTP and DNS as application layer services.

1:34And let's start with the DNS request.

1:35When we type in the name of the server we want to go to, behind the scenes, if

1:39our computer

1:40doesn't already know what the address is for that server, it's going to make a

1:44DNS request.

1:45And at layer four, for the original flavor of DNS, it's going to use a layer

1:48four protocol

1:49called UDP.

1:52And that stands for user data gram protocol, but we don't really need to memor

1:55ize the actual

1:56full name, we can just call it UDP.

1:58And UDP is a layer four transport protocol that's used with the original DNS.

2:03Now there are some varieties and other flavors, but we're going to stick to the

2:06basics here

2:06and just say that DNS, the application layer service, uses the layer four

2:10transport layer

2:11protocol of UDP.

2:13And let me explain the logic of how UDP works.

2:15UDP has the opinion of not really caring or checking to see whether something

2:21arrives.

2:22So let's imagine we have ourselves.

2:24So this will be you and I, I'll call it us, to here and we'll have our neighbor

2:28over here.

2:29And we'll go ahead and identify that we're both happy.

2:32And this right here is going to represent a wall between us.

2:35So with UDP, here's the attitude.

2:38We're going to take some data and we're just going to send it over to our

2:41neighbor, but

2:42we're not going to know whether or not that neighbor got it.

2:44Think of it like throwing a brick or something over the wall and you assume it

2:47's going to

2:48land, you hope it's going to land, but you just don't know for sure whether it

2:51's going

2:51to land or not.

2:52That's the attitude of the UDP protocol at the transport layer.

2:56It doesn't do anything on its own to verify or check to see whether it arrived

3:00or not.

3:01It's something that takes the data or the request is going to be made and ships

3:04it over

3:04and hopes for the best.

3:06Now in the event the neighbor sees it and responds back, that's a good

3:08indication that

3:09it works, but by itself user data gram protocol, therefore doesn't do any

3:12checking.

3:13Think of it like throwing a brick over the wall and hoping it lands.

3:16And that's the protocol at layer four associated with the original DNS.

3:19In fact, we have that protocol capture we just did.

3:22Let's go back and take a look.

3:23So here is our protocol capture and let's go ahead and take the query.

3:27Here's our request for server one.nuggetlab.com.

3:31And if we collapse the details down here, here's our DNS request.

3:36And then just below that, now in this protocol analyzer is showing the

3:38application layer

3:39information at the bottom and then the transport layer and then it goes down,

3:42down, down.

3:43So this represents the layer four transport protocol that's being used by DNS.

3:49So again, the DNS is an example of an application layer service.

3:52What we're trying to do, we're trying to resolve or find out the address for a

3:56server

3:56and then layer four it's using the user data gram protocol.

3:59And so behind the scenes, the client computer is adding that layer four

4:02information regarding

4:04the UDP header and that detail before it sends that request out on the network.

4:08Now not every application layer service is going to be using UDP.

4:11Another example of a layer four protocol that HTTP uses is TCP.

4:16Let me go ahead and put that in the same color here as our transport layer.

4:20So put TCP right here and TCP at the transport layer uses a different attitude

4:25rather than

4:25just sending the data and hope it arrives.

4:28So let me go ahead and clean up this little analogy here for UDP where we're

4:31just shipping

4:32it over and hoping it arrives and compare that with a reliable layer four

4:36transport protocol

4:38called TCP.

4:39So with TCP I like to think of it like two people that are going to have a

4:42discussion.

4:42Now one of the things that I've discovered and I've been on the planet for a

4:45while, one

4:46of the things I've discovered when two people communicate is that if we just

4:48shout something

4:49out immediately the receiver may or may not receive it or understand it

4:53correctly.

4:54So sometimes it deserves a little warm up conversation.

4:57So if we see our neighbor we might say something like, "Hey, beautiful day

5:01today."

5:02And then our neighbor might say, "Back, sure is."

5:04And then we might say, "Back, hey, have a great day."

5:06Now at that point we know we're talking to each other, we know we have a

5:10communication

5:11path between each other and as a result if we start communicating about sports

5:15or about

5:15something else we know back and forth that we have a reliable communication.

5:20So if we begin talking about sports or some other topic it's not like the

5:23neighbor is

5:24going to think, "Oh, he talking to me?"

5:25They know they're talking to each other because they already have that initial

5:28dialogue.

5:29And so in the world of TCP that's a lot like an initial warm up conversation

5:33before we

5:34start talking about sports or some other topic between the client, in this case

5:39the neighbor

5:39on the left and the server and example that be our neighbor.

5:43So again here in our real example we have our client here and our server here.

5:46So for application layer services that use TCP they have a little warm up

5:50session before

5:51we start making a request.

5:52So a TCP is called a three way handshake where the client sends a little

5:56request out a synchronization

5:57request that's called saying, "Hey, I'd love to chat with you."

6:00And the server then sends a response back and that's called an ACK.

6:03So I'll put the client here on the left and the server here on the right.

6:06And the ACK is short for an acknowledgement.

6:08And the server is also going to want to make sure that from its perspective the

6:12client's

6:12willing to talk to it.

6:13So in addition to that acknowledgement it'll also send its own synchronization

6:16request

6:17and they call that a CINAC.

6:18It's sent to actually one packet with both those elements included and then if

6:22the client

6:22wants to continue that conversation it'll go ahead and send its own

6:25acknowledgement back.

6:26So think of this little TCP three way conversation like the little warm up

6:31conversation between

6:32two neighbors before they start talking about sports.

6:35In this case that little warm up session with TCP is called a three way

6:39handshake.

6:40And assuming that that three way handshake goes well we've just confirmed that

6:44the client

6:44and server can talk to each other, they're willing to go ahead and communicate.

6:47And then once that three way handshake happens with TCP they can start

6:51negotiating and setting

6:52up the actual request for the application layer services.

6:55Now the cool thing is because we already from the client went to the server for

6:59our web request

7:00with HTTP and because I still have that capture open we should be able to find

7:05that TCP three

7:06way handshake as part of the HTTP session.

7:10So let's go take a look and verify that what we think might happen at layer

7:14four with the

7:15TCP protocol being used to support HTTP let's verify that it is.

7:19So back to the packet cap for we go and I currently have a little filter here

7:22saying

7:22only show DNS on that type of HTTP press center and here's our HTTP session and

7:27just

7:28for ease of use I'm going to right click on one of these and say please follow

7:32the HTTP

7:33stream which is going to include the TCP and here it is right here.

7:37So there's the HTTP conversation I'm going to go ahead and close that because

7:41what that

7:41also is going to do you put that filter in for us we can also see here the

7:45three way

7:46handshake that happened just before the HTTP so here's the actual HTTP request

7:52and

7:52at layer four it's using TCP but before it actually made that request it had

7:56that warm

7:56up conversation and this is an example of the three way handshake from the

8:00client saying

8:00hey I'd like to go ahead and communicate with you and they call that a send

8:04request

8:05as shown right here the server responds back with an acknowledgement and its

8:08own send

8:08request again send a search for synchronization and then we have the final

8:12acknowledgement

8:13from the client going back to the server so our three way handshake is right

8:17here and

8:18then presuming that went well which it did we didn't have the client making an

8:21HTTP request

8:22so again just to confirm that TCP uses a three way handshake it also uses

8:27confirmations

8:28and acknowledgments periodically just to make sure that all the data that's

8:31being sent back

8:32and forth has been received and processed correctly so that's why periodically

8:36here after our

8:37request for the website we also have a TCP acknowledgement right here just

8:41validating

8:42that the data was received and it'll continue on periodically again until that

8:46TCP session

8:46is closed so what is the takeaway from this the takeaway is that at the

8:50application layer

8:51we have services that we want to have happen or receive for example web

8:55services or name

8:56resolution with DNS and at layer four each of those application layer services

9:01have a

9:01predetermined layer four protocol that they are going to use to assist with

9:06those requests

9:06in the case of HTTP it uses TCP which has a three way handshake it's considered

9:11a connection

9:12oriented and reliable protocol because of the checks and balances that happen

9:16for the

9:16TCP session and then the original flavor of DNS domain name system is an

9:20application

9:21layer service used to request the IP address or address for a server and behind

9:26the scenes

9:26at layer four it's using UDP and again UDP is like throwing a brick over the

9:30wall there's

9:31nothing specifically at layer four that's going to guarantee that the request

9:35that we

9:36send for DNS is going to make it or not hopefully we get a response and then we

9:40're good to go

9:41so a typical client if it makes a DNS request with UDP there's a problem with

9:45the network

9:46and the client times out in the background it's very likely just to go ahead

9:49and make

9:50another DNS request and another until it gives up and again most of that is

9:54transparent

9:55to the user unless there's a failure and it actually never gets a DNS response

9:59which

9:59would cause a failure for us to identify what the IP address is of the server

10:03and we would

10:03never get there so let me clean that up just a little bit and let's talk about

10:07yet another

10:07challenge when this client is attempting to go to this server and let's imagine

10:11it's already

10:11done the DNS request so it knows exactly the IP address needs to send that

10:15traffic to

10:16not only does this client need to know what that IP address is but it also

10:19needs to include

10:19that information in the traffic in the packet before it sends it out and that

10:23my friend is

10:24one of the primary responsibilities of this layer of the TCP/IP protocol stack

10:29the network

10:30layer that's also the layer of the protocol stack that we're going to look at

10:33in close

10:34detail in the very next video so when you're ready I'll see you there in just a

10:38moment.

0:00In the previous video, we identified that HTTP at the application layer uses

0:05the services of TCP at

0:07layer 4 and the TCP is connection oriented meaning it's checking and validating

0:11that the connection

0:11state is good and the receiver received all the data. For example, the client

0:15went and sent a request,

0:16it did the three way handshake, validated it, it could communicate with the

0:19server and then

0:20once that three way handshake was done, it then was able to make the HTTP

0:23request and get the

0:24content on the screen of this client computer. And then periodically with TCP,

0:28it's going to validate

0:29that all the data that was sent received actually made it to the other side and

0:33was acknowledged by

0:33the other side. One in the case of the original favorite of DNS, the main name

0:37system, when it

0:38makes a DNS request, that request doesn't use all of that overhead at layer 4

0:42because it's using a

0:44different layer 4 protocol, in this case UDP, which is like throwing a brick

0:47over the wall. So if

0:49that request never makes it, it's just going to time out and DNS is going to

0:52think, well, I guess it

0:53didn't make it, maybe I do it again. Because at layer 4, there's no

0:56synchronization or testing or

0:57validation that the actual request ever made it. So with that in mind, as we

1:02work our way down the

1:03protocol stack, we're now going to focus on the network layer and what is

1:07included at the client

1:08machine in that network layer information before it actually sends that traffic

1:12out on the network.

1:12So I'll go ahead and make this new section here called the network layer. I'll

1:16put a little arrow

1:17there to represent. That's what we're talking about right here. I've also color

1:20coded it. And

1:20there's one primary thing that's going to be included at the network layer and

1:25those are addresses.

1:27Specifically IP or internet protocol addresses. Again, for right now, let's

1:31just think of an IP

1:31address like the street name and the house number. And on a computer network

1:36with IP,

1:36the street name is called the network and the house number is called a hosted

1:40rest. But for

1:40now, we'll just use the analogy of a street name and house number. So this

1:44client computer needs to

1:46include that information before it sends that traffic on the network so that

1:49the network knows

1:50who to deliver the traffic to. And that's what layer three is all about. So in

1:53this example,

1:54where client nugged down here is a client at 10 dot 10 dot 0 dot 50, that's its

2:00address. And

2:01that's the source address of the client who's making the request and the

2:04servers address,

2:05which we'll call the destination address for this request, that destination

2:08address will be 10

2:0940 0 100. So the client before it's going to even send the data out on the

2:13network, it needs to

2:14include that information about what IP address is this coming from my address

2:19as the client computer.

2:20And what is the IP address that we want to send it to, which is the IP address

2:24of the server. And

2:25all that information is included at the network layer. Now in the world of IP

2:29in a protocol,

2:30there's IP v4, there's also IP v6. And these addresses you see here and this

2:36topology and right here

2:37and here, those are examples of IP v4 addresses. And we'll have further

2:41discussions in great detail

2:43about both IP v4 and IP v6. But for now, those are the addresses that need to

2:47be included in the

2:48headers. Now, good news. When we did our initial requests with HTTP and with

2:53DNS, and we captured

2:54it, we should also be able to see at layer three for the HTTP request, we

2:59should see at layer three,

3:00the source address of client nugge and the destination address of the server.

3:04And for DNS,

3:05we'd be able to see the source address of the client and the IP address of

3:09whoever the DNS

3:10server is this client had been configured to use. So to reinforce that, let's

3:13take a peek at that

3:14same packet capture for the HTTP. We'll verify once again that it's using TCP

3:20at layer four,

3:21and we'll also verify at layer three, the IP address information, which is

3:24right there. So let's go

3:25back to that same packet capture and take a look. So back to the packet capture

3:29we go. And here's

3:30our HTTP request. So here we have at the application layer, it's HTTP, that's

3:35an acronym for the Hypertext

3:36Transfer Protocol at layer four, just reconfirming that we're using TCP, the

3:41Transmission Control

3:42Protocol, and then at layer three, if we take a look at that, right here, it

3:47includes at layer three,

3:48the source address, that's the client 10, 10, 0, 50's address, and the

3:51destination 10, 40, 0, 100.

3:54So that's the primary function of layer three is to include the IP address

4:00information. Also

4:02referred to as the layer three address, because at the end of the day, an IP

4:06address at layer three

4:07is really a layer three IP address. So either way, it's the IP address that's

4:11associated with layer three

4:13of the TCP/AP protocol stack. So in the capture, we were able to identify that

4:19at layer three,

4:19it had the source address of the client at 10, 10, 0, 50, and the destination

4:24address of the actual

4:25server at 10, 40, 0, 100. I also had a point out and remind you that all this

4:29information that's

4:30currently happening is being done by our computers in the background just by us

4:34making a few simple

4:35requests. So in the background, it's identified what the layer four protocol

4:39needs to be based on the

4:40application layer service that's being used. And then furthermore, based on the

4:43IP addresses involved,

4:45it includes the source and the station IP address in the layer three component

4:49or compartment or

4:50layer of the protocol stack. And if a client doesn't know, for example, what

4:54the IP address is of a

4:56server like server one.nuggetlab.com, it will simply make a DNS request, get

5:01that IP address,

5:01and once it has the IP address of the server, it can then include it in the

5:05request for HTTP

5:06services. At that point, use HTTP for the web service request, which is using

5:11TCP. And then at

5:12layer three, as we go down, it had the information regarding the source and

5:15destination IP addresses

5:17as we just identified in the packet capture. Now, after all this work that's

5:21been done right

5:21here in the brain, if you will, of this client computer who wants to make this

5:25HTTP request,

5:25are we done? And the answer is no, we're not done yet because we have two more

5:30layers of

5:31detail that we want to break apart and identify. So in the next video, we're

5:35going to leverage

5:36our existing HTTP session that's using TCP layer four, and at layer three has

5:41the IP address

5:41information. And we're going to take a look at what else is added and needed at

5:46layer two in the

5:47TCP protocol suite. So we'll discuss that in the next video. And I look forward

5:51to seeing you there

0:00So as we continue our discussion, let's focus in on our HTTP session.

0:04Think of it like our web request that we're going to be making in order to

0:06server one.

0:07That's an example of an application layer service.

0:10And as we discussed in our previous videos,

0:12HTTP at the transport layer uses a protocol called TCP.

0:16Now, who gets to choose that?

0:18Like, do we as a user say, "Hey, I want to use TCP or UDP?"

0:22The answer is no, we don't get to choose that because those are coded or

0:25planned on.

0:26When the application layer services are set up, they already have identified

0:29which layer four protocols are going to use.

0:31And then our computer just does all that background work

0:33to include all the right information to make the request.

0:36So at layer four, our computer is logically adding the correct protocol

0:39information for the request.

0:41And in HTTP, it's going to be using TCP.

0:43And then at layer three, it's going to be adding the information about the

0:46addresses.

0:47Again, think of an address like a street name and a house number of how to get

0:50somewhere.

0:51On the case of an IP network, the source IPV4 address here of 10, 10, 0, 50,

0:56and the destination IP address here of 10, 40, 0, 100.

0:59And so I'm going to put IP addresses.

1:01And I'm also going to put S and D, just to remind us that's going to include at

1:04layer three,

1:04the source and the destination IP address.

1:07And that's important because if the client makes a request up to the server,

1:09and the server wants to respond, it needs to know who to send the response to,

1:13based on the IP address.

1:15So next, let's focus our attention on the data link layer.

1:18Also referred to as layer two of our TCP/PP protocol stack.

1:22And at the data link layer, we are also going to be including addresses,

1:25but these are what we refer to as physical addresses.

1:28You might say physical addresses, what do you mean?

1:30And we talk about physical addresses.

1:32Let me give you an analogy that's going to help.

1:34Now, in many communities that I've lived in over my lifetime, we have a street.

1:38So let's imagine these are the houses.

1:40So if this is Elm Street, and this is house 101, and this is 103, and 104,

1:46and this is 102, and 105, let's imagine we want to deliver some mail to one of

1:52these houses.

1:52Now, if we had mailboxes at every single house, that'd be great,

1:55but in many communities I've lived in, they have a group mailbox with just slot

1:58number.

1:59So let's imagine we have slot one, and two, and three, and four, and five, and

2:04six,

2:04and seven, and eight, and nine, and ten, and eleven, and twelve, and thirteen,

2:08and fourteen.

2:09And I just realized I have way more mail slots that I need.

2:12So I'll call this our community mailbox.

2:15So if the mail person received a piece of mail, and they need to put in the

2:18right box,

2:19we'd have to have some way of knowing, okay, for house number 101, which

2:23mailbox number you have,

2:24or for 105, which mailbox number do you have?

2:27Let's also add house 100 here as well.

2:29So let's imagine for our discussion that house number 100 is using mailbox 13.

2:36So there have to be some correlation or knowledge between the actual house

2:39number,

2:40like the address on the Elm Street, and which mailbox number that mail should

2:44go to for that house.

2:46Now, how is this applicable in a network? Each network device, like this

2:49computer right here,

2:50with this network interface card, and this little computer here with this

2:52network interface card,

2:54and this wireless computer with this network interface card for the wireless

2:57network,

2:58each of those have their own burned in from the manufacturer a hardware address

3:03, a physical address.

3:05And that's associated with their network interface card.

3:08So if you see the term "NIC", if we're not talking about a person named "NIC",

3:11a NIC refers to an acronym network interface card.

3:14It's the actual component on the computer that lets it communicate on the

3:17network.

3:18So each network interface card has its own unique physical address that's

3:22burned in

3:23from the manufacturer who made that either that computer with network adapter,

3:26or who made that network adapter.

3:28Now, this physical address, good and bad, it has many different names.

3:32So it could be called a physical address, think of it like because it's part of

3:35the physical card,

3:36whether it's a wireless physical card or a physical network adapter.

3:39It also can be called the "Layer 2 Address" because its address,

3:43that physical address is associated with "Layer 2" and the "Protocol Stack".

3:46It also could be called the "Mac Address" and not "Mac" as in Apple products,

3:51but "Mac stands for Media Access Control". So if you see a "Mac Address",

3:55they're talking about the burned in address on these network interface cards.

3:59And because it's burned in, sometimes you'll see it as the "BIA" for burned in

4:03address.

4:03And I've also seen it referred to as the "hardware Address".

4:07And that's because it's the address that's given to that specific network

4:09interface card,

4:10that physical piece of hardware, for example, that you're using on your

4:13computer to communicate on the network.

4:15So basically we have five names for the same type of address.

4:19Physical address, "Layer 2 Address", "Mac Address", "Burned in Address", "Hard

4:24ware Address".

4:25They're all referring to that address that's given to the network interface

4:27card.

4:28So, for example, if we took a look at this interface right here on ClientNug,

4:32and if we took a look at this address here on this network interface card on

4:35the router,

4:35and that router interface right there is "GIG" for "GIG-A-bit Ethernet",

4:39and that happens to be in this topology 2/0,

4:42if we were to take a look at those two interfaces,

4:44we could actually see the special physical address, or a layer two address,

4:48or "Mac Address", or "Burned Address", or "Hardware Address",

4:50whatever you want to call it that's been given to that network adapter.

4:53And that is 12 characters long.

4:56And it's implemented in what's called "hexadecimal".

4:58So you and I, in our dating dealings, we deal with "decimal".

5:02decimal. Let's zero through nine then you get past nine and you carry the one

5:05and

5:05start over; with hexadecimal it's zero through fifteen except for those last

5:11characters it goes like this zero, one two three all the way through nine and

5:16then because there's 16 different characters for the ten it goes to A

5:19and then B and C and D and E and F; for a total of 16 characters one, two,

5:27three,

5:27four, five, six, seven, eight, nine, ten, eleven, twelve, thirteen, fourteen,

5:30fifteen, sixteen.

5:31So the burned-in address, the physical address is twelve characters long, it is

5:34allowed to have some A, B, C, etc. in it up to F as well as zero through nine

5:39and

5:40those are all valid characters that can be used by the manufacturer as they

5:43assign

5:44and address a layer two address to an interface and as reinforcement of that

5:48let's go over to our client and egg machine and take a look, we'll also take

5:51a look at our router's interface here just to verify that no matter what type

5:54of

5:55network card or who the manufacturer is all of them are going to have this 12

5:59hexadecimal character long MAC address associated with them. So if we go back

6:03to

6:04our client this is client nug, we'll go back to a command prompt here and we

6:06did

6:06some IP config earlier so let's go ahead and let's do an IP config all by

6:10itself

6:10and press enter so IP config that command on a Windows computer will show us

6:15the

6:16IP address that we currently have and if we use the command IP config space

6:20slash all or dash all it works on the current flavor of Windows it'll show us

6:24more information including this information right here. So this is an

6:27example of our physical address our layer two address our hardware address our

6:31burned and address on this specific Windows 11 computer and it's zero zero

6:36fifteen five D zero zero zero zero zero zero eight. So I'm just remember this

6:40Windows computer ends in zero four zero eight. So back in our topology and let

6:45's

6:45take a look at this interface right here on this router. So in my little

6:48lab environment which I'll put you on a little bit later in this set of videos

6:51on

6:52this interface right here which is gig two slash zero on the Cisco router it

6:56also has a layer two address based on that network interface card that's right

7:00there. So let me show you that as well. So here we are at what's called the CLI

7:04the command line interface for a network device this is a router from Cisco

7:09systems and most routers are gonna have some way of looking at the details

7:12whether it's a command line or a graphical interface or both. So here if we

7:16do a show interface and also gigabit two slash zero those show us the physical

7:21interface characteristics for that specific interface. So if we press enter

7:25there there's a lot of output here but the part I want to get to is this right

7:28here. This is the layer two or hardware address or burned in address that's

7:32being

7:32used on this Cisco router ending in zero zero three eight. So some vendors will

7:37have four characters in a period on our Windows computer if we go back there it

7:42was using two characters in a dash and two characters but at the end of the day

7:45we're looking at a total of 12 hexasimal characters. So in this case there's

7:49four

7:49there's four more for a total of eight and four more for a total of 12. So on

7:54the

7:54router it's ending with zero zero three eight. So as we go back to our

7:58topology and let me clean this up a little bit we now know based on what we

8:01just looked at that this client and I got its network interface card its layer

8:05two address its physical address its Mac address its burned in address its

8:08hardware address ends and I wrote this down in zero four zero eight the little

8:14dots in front of it and this router on its interface which is interface gig two

8:18zero on that same local network its layer two address its Mac address its

8:22physical address its burned in address ends in zero zero three eight. So put

8:27three

8:27dots there zero zero three eight. So when this computer right here client

8:31that needs to send a frame of data some data over to its default gateway to the

8:35router at layer two the data link layer it's going to include the information

8:40about the source layer two address which is ending in zero four zero eight and

8:44the

8:44destination address of the router here at zero zero three eight and that way

8:49the

8:49network in this case a switch can make a forwarding decision and make sure that

8:53data gets from the client to its default gateway here which is router one. Now

8:58to

8:58help us in verifying that the good news is that we have a capture from earlier

9:02where this client was actually trying to communicate with a server and behind

9:05the scenes when a client needs to send traffic to a different network. They're

9:09gonna like the client lives on 10 10 zero street and the server lives on 10

9:1240 zero street a different street in that case the client is going to forward

9:16it

9:16at layer two to its default gateway so the gateway think of it like a router

9:20can make a decision and forward it on its way. So all of our captures that we

9:25did

9:25that involve traffic where this client was actually using its default gateway

9:29should at layer two have the source address of zero four zero eight and the

9:33destination address at layer two of zero zero three eight because that's what

9:37the

9:37client computer would need to include at layer two to make sure that traffic

9:40got forwarded to the right next device in this case is default gateway. So let

9:44's

9:44go back to our packet capture and look for zero four zero eight as a source and

9:49zero zero three eight as a destination. So let's go back to the right computer

9:53and here we go this is our client and add computer woman to my zat and we'll

9:57go back to our capture that we made earlier and let's go ahead and we can

10:01use pretty much any of these packets. So let's go ahead and take our HTTP

10:04request right here. So the application layer here's our HTTP request at layer

10:09four. There's the TCP protocol that was being used at layer three. We have the

10:13IP

10:13address information for source and destination and layer two. Let's go ahead

10:17and expand that. We had the layer two information primarily including the

10:20source

10:21layer two address and this is the one from the client ending in zero four zero

10:24eight and then look at the notes that's the right source address going to the

10:28layer two address of that client's default gateway which ends in zero zero

10:32three eight. So that's the purpose or the function of the layer two information

10:37also called the layer two header is to include the layer two address

10:40information. So if we look at the big picture when we simply go to this client

10:44and we open up a browser and we say we want to go to for example server one

10:49dot nuggetlab.com in the background is very likely if it has already learned

10:53the

10:53IP address or the destination address of that server it will behind the scenes

10:57to

10:57a DNS request to find out that information from a local or internet

11:01DNS server and then once it has the IP address it'll then turn around the

11:04client will and the computer will make that HTTP request which is using TCP

11:09at layer three it'll have the source IP address and destination address for

11:13that traffic flow it'll also have the physical addresses for the client and the

11:17default gateway. Now if the server was on the same street leave like this if

11:21the

11:21client was right here on Elm Street since our client and the server was on

11:25that same street Elm Street the client would need to forward the traffic to a

11:28router to forward it out to some other destination the client and server could

11:32talk locally on the same network however because most of our traffic is not on

11:37the same exact local network as we are most of the time our traffic is going to

11:41go to the default gateway or to a router who can then make a routing

11:44decision and send that traffic on its way. So at layer three we're going to

11:48include the IP addresses the source and destination and at layer two we're

11:51going

11:52to include the physical addresses that are involved in this case the client nug

11:55source physical address it's hardware address ending with 0408 and the

12:00destination layer two address of its default gateway at 038 and then the last

12:05step is to get going already and send it so the physical layer represents the

12:10physical connections the digital and electrical signals that are being sent

12:14over the network including wireless signals that are being sent and the

12:18standards regarding those. So in wireless we have something called Wi-Fi with a

12:22few different flavors and standards for Wi-Fi and the protocols are used there

12:25and for Ethernet we have different standards for various types of Ethernet

12:29including 100 megabit ethernet which is called fast ethernet and 1000

12:34megabits per second which is called gigabit ethernet and we also have 10

12:38gig or to gig and so at the physical layer we're talking about those physical

12:41components the electrical signals and the standards allowing that data to flow

12:45over the networks and the cool thing is this computer is doing most of that

12:49work

12:49in the background force all we did was you know go to a browser say we want to

12:54go to this web server and in the background it was doing all the work of

12:57identifying what the application layer services is going to be and the layer

13:01four protocols the source and destination IP addresses the source and

13:05destination

13:05physical addresses and then spitting that data out on the network and that

13:09process where this computer is taking all these components first of all the

13:13HTTP and then adding on the TCP information and then adding on the IP

13:17address information and adding on the physical layer information for the layer

13:20two addresses that process is called encapsulation and think of encapsulation

13:25like simply adding on and adding on and adding on the individual components

13:29that

13:29are part of the TCP/P protocol stack and so when we're starting at the

13:32application layer and we're adding on the individual components for each layer

13:35that's called encapsulation and when that traffic is received at the server

13:40guess what it's going to do it's going to go ahead and start the process of

13:43de-encapsulation as it looks at the individual components involved in that

13:47request coming from the client now to help reinforce the concept of encaps

13:51ulation

13:52I have some little tools I'd like to use and they are known as cups so we can

13:55think of you know one cup for example being the application layer and then

13:59putting that inside of another cup and that would represent the transport layer

14:02and then putting that in yet another cup which represents adding the additional

14:05information for the network layer the IP addresses and then putting that in

14:08another cup which adds on top of all that information regarding the layer two

14:11addresses and then finally that data is going to be sent over the network as a

14:14stream of bits and it's up to the network to correctly move that data in the

14:18correct direction towards the server who can receive it and de-encapsulate it

14:22and

14:22to help reinforce the concept of encapsulation I've got a little exercise

14:25with literal physical cups that I think you'll love and that's in the next

14:29video

14:29so we'll see you there in just a moment

0:00To help reinforce the idea that this computer is going through all the work to

0:05make that HTTP

0:06request for us, including adding the data at each of these layers that needs to

0:09be there,

0:10I'd like to go ahead and use an analogy with some cups. And the overall picture

0:13is this,

0:13when we have an application that you're a service like HTTP, the computer

0:16before making that request

0:18is going to add the additional transport information. Again, this is called

0:21encapsulation. So think of

0:22encapsulation like adding onto, it takes that HTTP request as the appropriate

0:26layer for protocol,

0:28which in the case of HTTP is TCP, then it'll add on the appropriate information

0:32regarding the IP

0:32addresses. Again, this is just adding an additional component or layer with

0:37that information,

0:38and then it'll add on the appropriate layer two address information, that's the

0:42physical

0:42addresses or MAC addresses that go by both names. And it's up to the network to

0:46deliver that request

0:47that the client's making over to the server. So to help reinforce this, let me

0:50go ahead and show

0:51you an example of this using cups. So earlier we had a computer that was

0:55physically connected

0:56to the network with this physical patch cable. So I'm going to move those to

1:00the side just for a moment.

1:02And let's talk about the process of encapsulations. Let's imagine sitting at

1:06this computer, the client

1:08does an HTTP request to get access to a web server. So that's an example of an

1:13application

1:13layer service. So what comes next? I'm likely to think with me for an

1:17application layer service like

1:18HTTP, which is an example of an application layer service, or sometimes

1:22referred to just as a network

1:24app, there's a layer for protocol associated with HTTP. Now, in addition to

1:28having the HTTP

1:29request here, we also need to include before the computer sends it out, we also

1:32need to have that

1:33computer include the layer for protocol associated with the application layer

1:37service. So HTTP,

1:38the application layer service called HTTP, uses that layer for it uses the

1:42transport protocol called

1:44TCP. So the computer would go ahead and add the appropriate information, and

1:48that's called

1:49encapsulation. So we have the original HTTP request, it's now included the

1:53transport or layer for

1:54information in the case of HTTP that's TCP. And then we need to add on the

1:58layer three information.

1:59And that layer three is referred to as the network layer. And that's going to

2:03include the IP addresses,

2:04the source IP address of this computer and the destination address of the

2:08server. Also,

2:10before the traffic is actually sent from this computer out the network, it also

2:13needs to include

2:14the appropriate layer two information. And that layer two information would be

2:17added. And that's

2:18the data link layer. And as we discussed that data link layer information would

2:21include the

2:22layer two address information, both the source, which would be the source layer

2:26two or MAC address

2:27or burn in address on this computer, its network interface card right here, as

2:31well as the next

2:32top in the path. So if we were forwarding traffic to our default gateway, so we

2:36could forward that

2:37packet out to the actual server, the destination layer two address would be the

2:41layer two address

2:42of our router. Just like we talked about in the demonstration with Wireshark

2:44with our computer,

2:46its source MAC address ending in 0408 and the client's default gateway on that

2:51same local network,

2:52where its layer two address ended in 0038. And then last but not least, once

2:56all this

2:56encapsulation has been done here inside the mind, if you will, of this little

3:00computer,

3:01the client PC, it'll then go ahead and shoot that information out the network.

3:06So whether it has a

3:06wireless network adapter or it has in this case a physical network adapter, in

3:10both cases it's

3:11referred to as the physical layer. Think of it like FedEx. If FedEx is

3:14delivering a package, they've got

3:16trucks that deliver it. So what they're delivering are packages and they have

3:19all kinds of addresses

3:20involved. But at the end of the day, it's the truck that's actually moving it.

3:22So think of the truck

3:23like the actual physical components and electrical signals that are being used

3:27to actually send that

3:29information over the network. So this encapsulated data, including the HTTP,

3:33the application layer,

3:34and in the case of HTTP, the transport layer, layer four using TCP and the

3:39network layer layer three,

3:40which includes the source and destination IP addresses and the data link layer,

3:43including the source

3:44and destination layer two addresses, all that's included and encapsulated

3:47before shipping that

3:48data out on the network. And this, my friend, represents the five basic

3:53components involved in today's

3:55TCP/AP protocol suite. I also want to point out at this point why we call this

3:59the TCP/AP protocol

4:00suite. It's because of the two major protocols that are being used at layer

4:04four. One of the

4:05protocols there, as we discussed, is TCP. That's part of the name, the TCP/AP

4:09protocol suite.

4:10And another big part of the protocol stack is the IP addressing itself, which

4:14is included at layer

4:15three. And so they took the term TCP from layer four and IP from layer three.

4:20And that's what we

4:21call the TCP/AP protocol stack or the TCP/AP protocol suite. And these cups can

4:25help you remember that

4:27we're doing encapsulation or adding of the individual components. And most of

4:31that work is done right

4:32here in the brain of the client before ever sending that data out of its

4:35network interface card.

4:37So to help reinforce even further the topics that we've talked about in this

4:40set of videos regarding

4:41reference models and now the TCP/AP protocol stack, in the next video, I'd like

4:44to put you on a hands

4:45on labs so that you can get up close and personal with TCP/AP and help

4:49reinforce the idea that using

4:51a model to logically, you know, separate each of the components is just an

4:56easier way of helping

4:57identify the whole process instead of calling it all magic. Because now we know

5:01that we have

5:02five specific layers, layer one, two, three, and four and the application layer

5:06. And by breaking it

5:07down and understanding what goes into each part is going to help us better

5:10understand how the

5:11network operates as a whole. So when you're ready, I'll see you in the next

5:14video for a hands on lab.

0:00To help reinforce a few of the concepts that we've discussed regarding the TCP

0:03AP protocol stack,

0:04here's the hands-on lab I'd like you to do. I like you to take a moment, you

0:07can do it right

0:08now if you'd like. If you're watching this on a computer, there's a link just

0:12below with a link

0:13for the hands-on lab. And on the hands-on lab, I'd like you to open up ClientN

0:16ug. And because this

0:17may be the first lab you've done with me, let me make sure you know exactly

0:20where to go in the lab

0:22to open the interface for that Windows 11 ClientNug computer. So here is the

0:26lab environment that's

0:28already launched and running. And right here is a picture of the lab topology,

0:32going to bring that

0:32up just as a reference. And here's the client-nug computer that we're sitting

0:36at right here. And

0:37there's the server that we're going to go ahead and access. So to get to Client

0:41Nug, once you have

0:42the lab open, you're simply going to go ahead and double-click on the icon

0:45right here for ClientNug.

0:47You'll double-click and it'll open up a window for that little virtual machine,

0:51that Windows 11

0:52computer. So having said that, let me go ahead and double-click here on ClientN

0:55ug and that'll bring

0:56it up. That'll take just a moment or two. And it looks like it's here it comes.

1:00And I'll go ahead

1:00and click to make sure it's active in that window. And on the ClientNug

1:02computer, like you'd open up

1:04Chrome. There's a little shortcut for it on the taskbar on the very bottom of

1:07that Windows computer,

1:08or you can go ahead and launch it from the desktop. There's an icon there. And

1:11once you launch Chrome

1:13on ClientNug, then go ahead and go to this URL. Http colon slash slash server1.

1:18nug@lab.com in the

1:19lab environment. You can also just click on the bookmark if you want. That goes

1:23exactly that URL.

1:24And then once you've done that behind the scenes, what that would have done, if

1:27it didn't already

1:27know the IP address of server1, it would have made a DNS request. And then

1:31secondly, after

1:32knows the IP address via the DNS request, it would then make the HTTP request

1:36over to the server.

1:37So I'd like you to go ahead and do that to experience it. And then after you're

1:41done with that,

1:42I have as a convenience put on the desktop of our ClientNug computer, I have a

1:46file called DNS and

1:48HTTP capture. In fact, let's take a moment and verify that it's actually called

1:52that. And it's

1:52seeing there on the desktop of our ClientNug computer. So here on the ClientNug

1:56computer,

1:57on the desktop, here's that file of DNS plus HTTP capture. And I captured this

2:02earlier. So that

2:02way when we do the walkthrough, we'll have exactly the same information. So I'm

2:06going to go ahead and

2:07open that up. And I also limited the output to just show four packets packets

2:11one, two, three, and four,

2:12just to make it really clear on a couple of the sessions, the DNS request right

2:17here,

2:17and the HTTP request right here. And then below each one, I have the DNS

2:21response,

2:22and then the HTTP response. So when you click on these packets down below,

2:26it shows the details, including the application layer information and the layer

2:31four information

2:31and so forth for each of those packets. So what I'd like you to do regarding

2:34that packet

2:35capture is look at it and answer the following questions based on that capture.

2:39Regarding packet

2:40number one and packet number three, what are the application layer services

2:44involved for packet one

2:45and for packet three, and then for packet one three, what layer for transport

2:49protocols are being

2:50used? Again, that'd be for those two packets. And then looking at layer three

2:54information,

2:54that's the IP address information. What are the IP addresses involved with

2:58packets one and two,

2:59and that'd be for the source, as well as the destination IP addresses. And then

3:04finally,

3:05the layer two information, which would be the MAC addresses, sometimes called

3:09physical addresses

3:10or hardware addresses. Again, that would include the source and the destination

3:13. And just to confirm

3:15how to look at those components in wire shark, let me go ahead and show you

3:18that as well. So here

3:19in the packet capture, for example, you go to packet number one, and then here,

3:24the way the wire

3:24shark is showing this is the application layer information is at the bottom,

3:29and then it's going

3:30to layer four, and then layer three and layer two. So if we look at another

3:34packet like packet

3:35number three, at the bottom here, it's showing the application layer service,

3:38and then the layer

3:40four protocols using, and then the layer three protocol information, and then

3:43the layer two

3:44information. So that's how you can see the details regarding those, some of you

3:47are going to the

3:47packet in question, and sorting through it. Again, application layer is going

3:52to be at the very bottom.

3:53So with that in mind, have some fun with this hands on lab, and when you are

3:57done, and you'd like

3:57to do a walk through together, join me in the following video, and we'll do

4:01exactly that.

0:00So my objective for us in these labs is to give you the hands-on practice help

0:04reinforce

0:05and validate the concepts that we learned in the set of videos prior to the lab

0:09.

0:09So hopefully you've done the lab and now in this video they do a walkthrough of

0:13these lab tasks with you.

0:14So we're going to launch the lab, we'll go to the client-nug computer,

0:18we'll go ahead and do an HTTP request to server1.nuggetlab.com.

0:23And then we'll look at the pre-captured file called DNS and HTTP capture

0:27and answer the following questions regarding packet number one and packet

0:30number three

0:31basically asking what is the application layer service, what is the layer four

0:35transport protocol being used,

0:36what are the layer three addresses involved, the IP addresses if you will that

0:39are kept at layer three,

0:41and an IP header is another way of saying the information that's included at

0:44layer three

0:45and then also what's included at layer two, which would be the layer two

0:48addresses,

0:49the burn-in addresses, the MAC addresses, the hardware addresses based on the

0:52vendor using

0:53and what they choose to call them. So with that in mind, let's head back to the

0:56lab environment

0:56and let's do this walkthrough together. So back in the lab environment, I

0:59clicked on reset

1:00to go ahead and reset the lab back to square one. Also, as we go through these

1:04sets of videos

1:05and future videos together, if you want to reset the lab and start over, it's

1:08really easy to do,

1:09just use that reset option right here, give it a few minutes and then once it's

1:14reset,

1:14you click on start, it'll go ahead and launch and then you can go ahead and

1:17start fresh.

1:17So you don't need to worry about breaking anything or doing the wrong thing

1:20because you can just reset the lab

1:22anytime you need to to give it another go. Alright, so here we go in the lab

1:25environment,

1:26we'll go ahead and double click here on client nug, to go ahead and launch that

1:30,

1:30give that just a moment to initialize and here it comes and that looks like a

1:34black screen there.

1:35So I'm going to click once here on client nug and that brings the interface up,

1:38fantastic.

1:39And our first task is to go ahead and open up Chrome so we can launch it here

1:43from the desktop.

1:44We also have a shortcut here down in the taskbar so we'll go ahead and launch

1:47Chrome, there it comes.

1:49And then I have a bookmark right here for HTTP colon slash slash server one dot

1:52nuggetlab.com,

1:54which is here in the lab environment and we are good to go.

1:57So behind the scenes, if this computer had not yet learned through DNS what the

2:01IP address was from server one dot nuggetlab.com,

2:04before it made the HTTP request, it would also have gone out to a DNS server

2:08and asked for,

2:09hey, what is the actual IP address of server one dot nuggetlab.com and then

2:12come back and then start using the HTTP services to make the request.

2:16Alright, so now we've done that, let's minimize that.

2:18So now we've done that, I'll close that browser window and next let's open up

2:21this pre captured file that represents a DNS and an HTTP request by double

2:27clicking right here on DNS plus HTTP capture right there.

2:30And here it is. So the question is regarding packets one and three.

2:34So let's go ahead and select packet one here and then down below it shows the

2:37details.

2:38So as far as packet number one, the application layer protocol is DNS as shown

2:43right here.

2:44So it's a DNS request and we dig into it, you can actually see what we're

2:47requesting the client was asking for.

2:50Hey, what is the IP address of server one dot nugget lab.com.

2:54Alright, so that's the first question regarding packet number one and that one

2:59and I was the layer for protocol.

3:02So if we go to the next layer right here, which is layer four.

3:04Now they could have wire shark is just an example of a protocol analyzer that

3:08lets you see the details for the packets they're going back and forth.

3:12They could have, you know, shown the application layer on top, but what they

3:15chose to do is order it in this direction.

3:18So here's the DNS request and then that's been encapsulated with a UDP header

3:23that includes the UDP information.

3:26So the layer for transport protocol is UDP and then that got encapsulated like

3:30the cups into an IP header, which adds the additional information regarding the

3:34source and destination IP addresses.

3:36So the destination IP address is 1040 0 10 for packet number one and the source

3:40is the client's address at 10 10 0 50.

3:43And then the last question is what is the layer two source address.

3:47So if we click here on the layer two information, the source address, we could

3:50either see it here where it says source or we could go ahead and double click

3:55and open it and highlight this.

3:56And that's the source address ending in 0408.

3:59And that is the hardware address of the client who's sending out this

4:02information onto the network.

4:05So that's for packet number one.

4:07And the other question was about packet number three.

4:09So we'll click on packet number three and of the application layer, it's HTTP,

4:14the hypertext transfer protocol, and then at layer four, it's using TCP, the

4:17transmission control protocol, and then at layer three, it's using the internet

4:22protocol and includes the source and destination IP addresses

4:26and the source address is 10 10 0 50 as client and the destination is 1040 0

4:30100, which is the IP address of the server trying to reach.

4:34And then at layer two, it has the layer two addresses and the layer two

4:37information layer two header here, which includes the layer two addresses.

4:41Those layer two addresses have many different names.

4:44They can be called the hardware address.

4:45So the question was, what is the layer two source address.

4:48The source address is the source address ending in 0408.

4:58That's actually the layer two address of the computer in our case client night

5:01that sent this request.

5:03So those layer two addresses could be called hardware addresses or the physical

5:06address or the MAC address, MAC meaning capital, MAC, not nothing to do with

5:08Apple, but rather media access control address or the layer two address.

5:09We could just call it that or we could call it the burned in address.

5:12Those all referring to this layer two address that's burned into the network

5:15interface cards.

5:16And the case of this client saying the traffic to its default gateway so that

5:19router can forward it on.

5:21There is the layer two address for the destination, which is the layer two

5:24address of the client's default gateway.

5:27So let's take a look at our tasks and make sure we got all of them.

5:29We went through the packet capture.

5:31We identified from packet one and packet three, the application layer services

5:35and those were DNS and HTTP respectively.

5:38So for packet one and three, the application layer services were DNS for packet

5:43one and HTTP for packet three.

5:45The layer four protocols where the protocols are associated with those

5:48application services.

5:49So DNS was using UDP and HTTP was using TCP at layer four.

5:54And for both packets one and three, the source address was the client.

5:58That's its IP address.

5:59Think of it like the street name and the house number where that client is and

6:03the destination address was the server.

6:05And that was true for packet one and three.

6:07So the DNS request because the actual server server one is the DNS server and

6:12we had the IP address for our DNS server.

6:14That's why the DNS request went to that server as well.

6:17So the source IP address is the client's IP address for both packets one and

6:20three.

6:21And the destination was the server's IP address.

6:23And then for the layer two address, because the client and the server on

6:26different networks, the source address was the client's address,

6:29meaning the client's layer two address.

6:31And the destination was the client's default gateway on each of those subnets.

6:36And because the HTTP request and packet three and the DNS request and packet

6:39number one,

6:40we're both going to a server off the local network, the client was using its

6:43own source layer two address.

6:45And for both those packets being forwarded to the servers, the destination

6:47address would be the layer two address of the default gateway.

6:51And that's what we saw inside the packet captures.

6:53And I have very much enjoyed our time together in a set of videos regarding

6:56using a reference model.

6:58I also love it when I can tell the truth about the OSI reference model and how

7:03it's just a model.

7:04And it's not literally any protocol that we use today.

7:07It's just a reference model, but we leverage pieces and parts of that to better

7:10understand the protocol stack that we do use today,

7:14which is the TCPP protocol suite.

7:16Also sometimes referred to as the TCPP protocol stack, or if somebody just says

7:19what protocol are you using and they say IP,

7:22they're also generally just referring to the entire TCPP protocol stack, which

7:26includes at layer three IP addresses.

7:30So thanks again for joining me for this set of videos for this hands-on lab and

7:33this walkthrough.

7:34And I look forward to seeing you, my friend, as we continue this journey

7:37together in the next set of videos.

7:39Until then, I hope this has been informative and I'd like to thank you for

7:43viewing.