Challenge Hand Shake Authentication Protocol on Packet Tracer (CHAP)

The Point-to-Point Protocol (PPP) is a data link protocol commonly used in establishing a direct connection between two networking nodes. It can provide connection authentication, transmission encryption and compression. PPP is used over many types of physical networks including serial cable, phone line,  trunk line, cellular telephone, specialized radio links, and fiber optic links etc. Internet service providers (ISPs) have used PPP for customer dial-up access to the Internet, since IP packets cannot be transmitted over a modem line on their own, without some data link protocol. PPP is commonly used as a data link layer protocol for connection over synchronous and asynchronous circuits, where it has largely superseded the older Serial Line Internet Protocol (SLIP) and telephone company mandated standards (such as Link Access Protocol, Balanced (LAPB).  

PPP was designed somewhat after the original HDLC specifications. The designers of PPP included many additional features that had been seen only in proprietary data-link protocols up to that time.

HDLC

HDLC provides both connection-oriented and connectionless service. HDLC can be used for point to multipoint connections, but is now used almost exclusively to connect one device to another, using what is known as Asynchronous Balanced Mode (ABM).

CHAP

CHAP provides protection against replay attacks by the peer through the use of an incrementally changing identifier and of a variable challenge-value. CHAP requires that both the client and server know the plaintext of the secret, although it is never sent over the network. The MS-CHAP variant does not require either peer to know the plaintext, but has been broken. Thus, CHAP provides better security as compared to Password Authentication Protocol (PAP).

CHAP Working

CHAP is an authentication scheme used by Point to Point Protocol (PPP) servers to validate the identity of remote clients. CHAP periodically verifies the identity of the client by using a three-way handshake. This happens at the time of establishing the initial link (LCP), and may happen again at any time afterwards. The verification is based on a shared secret (such as the client user's password).

1. After the completion of the link establishment phase, the authenticator sends a "challenge" message to the peer.
2. The peer responds with a value calculated using a one-way hash function on the challenge and the secret combined.
3. The authenticator checks the response against its own calculation of the expected hash value. If the values match, the authenticator acknowledges the authentication; otherwise it should terminate the connection.
4. At random intervals the authenticator sends a new challenge to the peer and repeats steps 1 through 3.
   
   Another feature of CHAP is that it doesn't only require the client to authenticate itself at startup time, but sends challenges at regular intervals to make sure the client hasn't been replaced by an intruder, for instance by just switching phone lines.

Let us apply PPP on packet tracer. Consider the following simpler topology.

 

Let us apply IP addresses on the interfaces and change the state of the interface from down to UP. So that they can communicate.

 

Similarly, for serial interface.

And IP configuration on PC.

The IP configuration on other router.

Serial Interface setting.

Now, we know that PCs that are attached cannot communicate until we apply a routing mechanism. In this case we are applying the RIP V2 protocol. Apply the following set of commands on both routers. We have also set the hostname of the router which will be useful to us later.

Now, let us set the commands on the second router as well.

Now, both PCs can communicate.

 

Now, we will set the authentication, In this tutorial we are going to apply CHAP(Challenge Handshake Authentication Protocol).

As we set the authentication on one router the communication is disabled.

 

Let us set it on other router as well.

Now, the communication is enabled.

 

Technorati Tags: packet tracer tutorial,pt tutorial,pap on packet tracer,ppp on packet tracer,password authentication protocol on packet tracer,password authentication protocol on pt,password authentication protocol,point to point protocol on packet tracer,point to point protocol tutorial,point to point protocol

CDP: Cisco Discovery Protocol

 

Cisco Discovery Protocol (CDP) is primarily used to obtain protocol addresses of neighboring devices and discover the platform of those devices. CDP can also be used to show information about the interfaces your router uses. CDP is media- and protocol-independent, and runs on all Cisco-manufactured equipment including routers, bridges, access servers, and switches.

Explanation:

CDP runs on all media that support Subnetwork Access Protocol (SNAP), including local-area network (LAN), Frame Relay, and Asynchronous Transfer Mode (ATM) physical media. CDP runs over the data link layer only. Therefore, two systems that support different network-layer protocols can learn about each other.

Each device configured for CDP sends periodic messages, known as advertisements, to a multicast address. Each device advertises at least one address at which it can receive SNMP messages. The advertisements also contain time-to-live, or holdtime, information, which indicates the length of time a receiving device should hold CDP information before discarding it. Each device also listens to the periodic CDP messages sent by others in order to learn about neighboring devices and determine when their interfaces to the media go up or down. 

CDP is a Cisco proprietary Layer 2 protocol that is media- and protocol-independent, and runs on all Cisco-manufactured equipment that includes:

• routers
• bridges
• access servers
• switches

A Cisco device enabled with CDP sends out periodic interface updates to a multicast address in order to make itself known to neighbors. Since it is a layer two protocol, these packets (frames) are not routed. Use of SNMP with the CDP MIB allows network management applications to learn the device type and the SNMP agent address of neighboring devices, and to send SNMP queries to those devices.

 

Let us apply CDP on packet tracer.

 

In the above topology, we have different devices attached with each other. So, if we want to look for the information of neighboring devices, we will apply the following command on Router enabled mode, “show cdp neighbors”.

And on Router 2 and 3 as well, as shown in figures below.

It can be seen clearly that it gives us the information of the neighboring devices. Note one thing here, that it gives us the information of the routers and switches that are directly attached to its ports. However, it does not gives us information about the hosts that are attached to it directly.

Technorati Tags: packet tracer tutorial,pt tutorial,cdp on packet tracer,cisco discovery protocol,cisco discovery protocol on packet tracer

Sticky MAC Addresses

Sticky MAC addresses are addresses that are dynamically learned once and remain stick to the port, we can adjust the max number of sticky MAC addresses to a single interface. the use of this feature is in large networks usually where we cant afford to waste time doing manual mac addresses to port mapping.

Let us apply this concept on packet tracer.

 

Let us set up a topology. Apply PCs with the IP addresses dynamically with the DHCP server set on the Server.

DHCP server setup on server.

 

Assigning IP to PCs.

 

Now, let us apply Sticky Mac address to the following interface of switch which is currently attach to PC1. It is interface fa 0/3.

The following commands will apply this concept.

 

Go to enable mode. Apply command,  show running-config.

Now, we do not have MAC address of PC here.

For this, remove the interface from PC1 attach it to another PC as shown in the figure below.

 

Request for DHCP.

Now. we have mac address and our port is sticky as shown in figure below.

MAC address of PC.

Now, re connect to PC1 and request for IP address. It has failed and it has also shutdown the interface because MAC address does not match with the MAC address of the port.

Technorati Tags: pt tutorial,packet tracer tutorial,sticky mac address,sticky mac address on packet tracer,sticky mac address on pt,port security switch,switch security

Wireless Communication in Packet Tracer

Let us create wireless topology on packet tracer. For this go to the wireless devices and select linksys wireless router, take some PCs and provide them with wireless linksys module so that they can communicate through router wirelessly. For that go to the PC physical mode as shown in the figures below.



Go to PC, and remove wired LAN and install wireless LAN module.


 


Now, its removed. Let us add wireless module.


 
NOw, PCs are connected.


Set the IP address.


 

As this wireless router provides us with the DHCP service, so we can obtain IP automatically by using this service for our PCs.


So now our PCs can communicate.



Now, let us apply authentication to our wireless router. For that, go to Config tab, click on Wireless. Provide it with the information as described below.


Go to PC desktop mode, Click on PC Wireless.


Click on connect. Select the device, you want to connect to, click connect.

Give correct password.


Now, we are done with it. We have successfully applied authentication.

Now, let us use Access point to connect to PCs wirelessly.
We can also connect wired router to access point in order to make our router wireless.


Apply IP addresses and put the status on.


We can also give authentication key to Access Point as well.


As in this figure below.

Technorati Tags: Packet tracer tutorial,pt tutorial,wireless on pt,wireless packet tracer,access point,wireless router packet tracer

Some Good Advices

There's some fine advice.

Give people more than they expect and do it cheerfully. 

Marry a man/woman you love to talk to. As you get older, their conversational skills will be as important as any other.. 

Don't believe all you hear, spend all you have or sleep all you want. 

When you say, "I love you," mean it. 

When you say, "I'm sorry," look the person in the eye. 

Be engaged at least six months before you get married. 

Believe in love at first sight. 

Never laugh at anyone's dream. People who don't have dreams don't have much. 

Love deeply and passionately. You might get hurt but it's the only way to live life completely. 

In disagreements, fight fairly. No name calling. 

Don't judge people by their relatives. 

Talk slowly but think quickly. 

When someone asks you a question you don't want to answer, smile and ask, "Why do you want to know?" 

Remember that great love and great achievements involve great risk. 

Say "God bless you" when you hear someone sneeze. 

When you lose, don't lose the lesson  

Remember the three R's: Respect for self; Respect for others; and responsibility for all your actions. 

Don't let a little dispute injure a great friendship. 

When you realize you've made a mistake, take immediate steps to correct it. 

Smile when picking up the phone. The caller will hear it in your voice.  Spend some time alone. Heavy rains remind us of challenges in life. Never ask for lighter rain.  Just pray for a  better umbrella. That is attitude. When flood comes, fish eat ants & when flood recedes, ants eat fish. Only time matters. Just hold on, God gives an opportunity to everyone! Life is not about finding the right person, but creating the right relationship, it is not how we care in the beginning, but how much we care till the end.  Some people always throw stones in your path. It depends on you what you make with them. Wall or Bridge?  Remember you are the architect of  your life. Every problem has (n+1) solutions, where n is the number of solutions that you have tried and 1 is that which you have not tried. That's life. Search a beautiful heart, but do not search for a beautiful face. Since beautiful things are not always good, but good things are always beautiful. It's not important to hold all the good cards in life. But it is important how well you play with the cards that you hold. Often when we lose all hope & think this is the end, God smiles from above and says: "relax dear its just a bend. Not the end". When you feel sad, to cheer up just go to the mirror and say: "Damn I am so cute" and you will overcome your sadness. But do not make this  a habit because liars go to hell :) One of the basic differences between God and human is, God gives, gives and forgives. But human gets, gets, gets and forgets.

Complete Binary Tree

We have earlier discussed the properties of the binary trees besides talking about the internal and external nodes’ theorem. Now we will discuss another property of binary trees that is related to its storage before dilating upon the complete binary tree and the heap abstract data type.

Here is the definition of a complete binary tree:

• A complete binary tree is a tree that is completely filled, with the possible exception of the bottom level.
• The bottom level is filled from left to right.

A binary tree T with n levels is complete if all levels except possibly the last are completely full,
and the last level has all its nodes to the left side.You may find the definition of complete binary tree in the books little bit different from this. A perfectly complete binary tree has all the leaf nodes. In the complete binary tree, all the nodes have left and right child nodes except the bottom level. At the bottom level, you will find the nodes from left to right. The bottom level may not be completely filled, depicting that the tree is not a perfectly complete one. Let’s see a complete binary tree in the figure below:

In the above tree, we have nodes as A, B, C, D, E, F, G, H, I, J. The node D has two children at the lowest level whereas node E has only left child at the lowest level that is J. The right child of the node E is missing. Similarly node F and G also lack child nodes. This is a complete binary tree according to the definition given above. At the lowest level, leaf nodes are present from left to right but all the inner nodes have both children. Let’s recap some of the properties of complete binary tree.

• A complete binary tree of height h has between 2^h to 2^h+1 –1 nodes.

• The height of such a tree is log₂N where N is the number of nodes in the tree.

• Because the tree is so regular, it can be stored in an array. No pointers are necessary.

We have taken the floor of the log₂ N. If the answer is not an integer, we will take the next smaller integer. So far, we have been using the pointers for the implementation of trees. The treeNode class has left and right pointers. We have pointers in the balance tree also. In the threaded trees, these pointers were used in a different way. But now we can say that an array can be stored in a complete binary tree without needing the help of any pointer.

Now we will try to remember the characteristics of the tree. 1) The data element can be numbers, strings, name or some other data type. The information is stored in the node. We may retrieve, change or delete it. 2) We link these nodes in a special way i.e. a node can have left or right subtree or both. Now we will see why the pointers are being used. We just started using these. If we have some other structure in which trees can be stored and information may be searched, then these may be used. There should be reason for choosing that structure or pointer for the manipulation of the trees. If we have a complete binary tree, it can be stored in an array easily.

The following example can help understand this process. Consider the above tree again.

We have seen an array of size 15 in which the data elements A, B, C, D, E, F, G, H, I, J have been stored, starting from position 1. The question arises why we have stored the data element this way and what is justification of storing the element at the 1^st position of the array instead of 0^th position? You will get the answers of these very shortly.

The root node of this tree is A and the left and right children of A are B and C. Now look at the array. While storing elements in the array, we follow a rule given below:

• For any array element at position i, the left child is at 2i, the right child is at (2i +1) and the parent is at floor(i/2).

In the tree, we have links between the parent node and the children nodes. In case of having a node with left and right children, stored at position i in the array, the left child will be at position 2i and the right child will be at 2i+1 position. If the value of i is 2, the parent will be at position 2 and the left child will be at position 2i i.e. 4 .The right child will be at position 2i+1 i.e. 5. You must be aware that we have not started from the 0^th position. It is simply due to the fact if the position is 0, 2i will also become 0. So we will start from the 1^st position, ignoring the 0^th.

Lets see this formula on the above array. We have A at the first position and it has two children B and C. According to the formula the B will be at the 2i i.e. 2^nd position and C will be at 2i+1 i.e. 3^rd position. Take the 2^nd element i.e. B, it has two children D and E. The position of B is 2 i.e. the value of i is 2. Its left child D will be at positon 2i i.e. 4^th position and its right child E will be at position 2i+1 i.e. 5. This is shown in the figure below:

If we want to keep the tree’s data in the array, the children of B should be at the position 4 and 5. This is true. We can apply this formula on the remaining nodes also. Now you have understood how to store tree’s data in an array. In one respect, we are using pointers here. These are not C++ pointers. In other words, we have implicit pointers in the array. These pointers are hidden. With the help of the formula, we can obtain the left and right children of the nodes i.e. if the node is at the ith position, its children will be at 2i and 2i+1 position. Let’s see the position of other nodes in the array.

As the node C is at position 3, its children should be at 2*3 i.e. 6^th position and 2*3+1 i.e. 7^th position. The children of C are F and G which should be at 6^th and 7^th position. Look at the node D. It is at position 4. Its children should be at position 8 and 9. E is at position 5 so its children should be at 10 and 11 positions. All the nodes have been stored in the array. As the node E does not have a right child, the position 11 is empty in the array.

You can see that there is only one array going out of E. There is a link between the parent node and the child node. In this array, we can find the children of a node with the help of the formula i.e. if the parent node is at ith position, its children will be at 2i and 2i+1 position. Similarly there is a link between the child and the parent. A child can get its parent with the help of formula i.e. if a node is at ith position, its parent will be at floor(i/2) position. Let’s check this fact in our sample tree. See the diagram below:

Level Order Numbers & Array index

Consider the node J at position is 10. According to the formula, its parent should be at floor(10/2) i.e. 5 which is true. As the node I is at position 9, its parent should be at floor(9/2) i.e. 4. The result of 9/2 is 4.5. But due to the floor, we will round it down and the result will be 4. We can see that the parent of I is D which is at position 4. Similarly the parent of H will be at floor(8/2). It means that it will be at 4. Thus we see that D is its parent. The links shown in the figure depict that D has two children H and I. We can easily prove this formula for the other nodes.

From the above discussion we note three things. 1) We have a complete binary tree, which stores some information. It may or may not be a binary search tree. This tree can be stored in an array. We use 2i and 2i+1 indexing scheme to put the nodes in the array. Now we can apply the algorithms of tree structure on this array structure, if needed.

Now let’s talk about the usage of pointers and array. We have read that while implementing data structures, the use of array makes it easy and fast to add and remove data from arrays. In an array, we can directly locate a required position with the help of a single index, where we want to add or remove data. Array is so important that it is a part of the language. Whereas the data structures like tree, stack and queue are not the part of C or C++ language as a language construct. However we can write our classes for these data structures. As these data structures are not a part of the language, a programmer can not declare them directly. We can not declare a tree or a stack in a program. Whereas we can declare an array directly as int x []; The array data type is so efficient and is of so common use that most of the languages support it. The compiler of a language handles the array and the programmer has to do nothing for declaring and using an array.

We have built the binary trees with pointers. The use of pointers in the memory requires some time. In compilers or operating system course, we will read that when a program is stored in the memory and becomes a process, the executable code does not come in the memory. There is a term paging or virtual memory. When a program executes, some part of it comes in the memory. If we are using pointers to go to different parts of the program, some part of the code of program will be coming (loading) to memory while some other may be removed (unloading) from the memory. This loading and unloading of program code is executed by a mechanism, called paging. In Windows operating system, for this virtual memory (paging mechanism), a file is used, called page file. With the use of pointers, this process of paging may increase. Due to this, the program may execute slowly. In the course of Operating System and Compilers, you will read in detail that the usage of pointers can cause many problems.

So we should use arrays where ever it can fulfill our requirements. The array is a very fast and efficient data structure and is supported by the compiler. There are some situations where the use of pointers is beneficial. The balancing of AVL tree is an example in this regard. Here pointers are more efficient. If we are using array, there will be need of moving a large data here and there to balance the tree.

From the discussion on use of pointers and array, we conclude that the use of array should be made whenever it is required. Now it is clear that binary tree is an important data structure. Now we see that whether we can store it in an array or not. We can surely use the array. The functions of tree are possible with help of array. Now consider the previous example of binary tree. In this tree, the order of the nodes that we maintained was for the indexing purpose of the array. Moreover we know the level-order traversal of the tree. We used queue for the level-order of a tree. If we do level-order traversal of the tree, the order of nodes visited is shown with numbers in the following figure.

In the above figure, we see that the number of node A is 1. The node B is on number 2 and C is on number 3. At the next level, the number of nodes D, E, F and G are 4, 5, 6 and 7 respectively. At the lowest level, the numbers 8, 9 and 10 are written with nodes H, I and J respectively. This is the level-order traversal. You must remember that in the example where we did the preorder, inorder and post order traversal with recursion by using stack. We can do the level-order traversal by using a queue. Now after the level-order traversal, let’s look at the array shown in the lower portion of the above figure. In this array, we see that the numbers of A, B, C and other nodes are the same as in the level-order traversal. Thus, if we use the numbers of level-order traversal as index, the values are precisely stored at that numbers in the array. It is easy for us to store a given tree in an array. We simply traverse the tree by level-order and use the order number of nodes as index to store the values of nodes in the array. A programmer can do the level-order traversal with queue as we had carried out in an example before. We preserve the number of nodes in the queue before traversing the queue for nodes and putting the nodes in the array. We do not carry out this process, as it is unnecessarily long and very time consuming. However, we see that the level-order traversal directly gives us the index of the array depending upon which data can be stored.

Now the question arises if we can store the binary tree in an array, why there should be the use of pointers? It is very simple that an array is used when the tree is a complete binary tree. Array can also be used for the trees that are not complete binary trees. But there will be a problem in this case. The size of the array will be with respect to the deepest level of the tree according to the traversal order. Due to incomplete binary tree, there will be holes in the array that means that there will be some positions in the array with no value of data. We can understand it with a simple example. Look at the following figure where we store a complete binary tree in an array by using 2i and 2i+1 scheme. Here we stored the nodes from A to J in the array at index 1 to 10 respectively.

Suppose that this tree is not complete. In other words, B has no right subtree that means E and J are not there. Similarly we suppose that there is no right subtree of A. Now the tree will be in the form as shown in the following figure (29.2).

In this case, the effort to store this tree in the array will be of no use as the 2i and 2i+1 scheme cannot be applied to it. To store this tree, it may be supposed that there are nodes at the positions of C, F, G, E and J (that were there in previous figure). Thus we transform it into a complete binary tree. Now we store the tree in the array by using 2i and 2i +1 scheme. Afterwards, the data is removed from the array at the positions of the imaginary nodes (in this example, the nodes are C, F, G, E and J). Thus we notice that the nodes A, B and H etc are at the positions, depicting the presence of a complete binary tree. The locations of C, f, G, E and J in the array are empty as shown in the following figure.

Now imagine that an incomplete binary tree is very deep. We can store this tree in the array that needs to be of large size. There will be holes in the array. This is the wastage of memory. Due to this reason, it is thought that if a tree is not completely binary, it is not good to store it into an array. Rather, a programmer will prefer to use pointers for the storage.

Remember that two things are kept into view while constructing a data structure that is memory and time. There should such a data structure that could ensure the running of the programs in a fast manner. Secondly, a data structure should not use a lot of memory so that a large part of memory occupied by it does not go waste. To manage the memory in an efficient way, we use dynamic memory with the help of pointers. With the use of pointers only the required amount of memory is occupied.

We also use pointers for complex operations with data structure as witnessed in the deletion operation in AVL tree. One of the problems with arrays is that the memory becomes useless in case of too many empty positions in the array. We cannot free it and use in other programs as the memory of an array is contiguous. It is difficult to free the memory of locations from 50 to 100 in an array of 200 locations. To manage the memory in a better way, we have to use pointers.

Technorati Tags: ds tutorial,data structure tutorial,tree data structure,trees in data structure,tree ds,tree traversal data structure,tree types,types of trees,binary trees,binary search trees,bst,bst data structure,bst ds,complete binary search tree,non tree structure,linear tree,complete binary tree