DEV Community: Taslim Arif

How to Enable Password Authentication in AWS ec2 Instances

Taslim Arif — Thu, 08 Jun 2023 04:54:25 +0000

The configuration to enable password authentication in AWS instance:-

Log in to the server using ssh client of your choice using
the private key.
```
ssh -i your-key.pem username@ip_address
```

Set up a password for the user using passwd command along
with the username.

sudo passwd ec2-user # If machine is Amazon Linux
sudo passwd ubuntu # If machine is Ubuntu

Open the sshd_config file.
```
sudo vi /etc/ssh/sshd_config
```
Find the Line containing "PasswordAuthentication" parameter

and change its value from "no" to "yes"
PasswordAuthentication yes
If you want to set up "root" login, find "PermitRootLogin"
parameter and change its value from prohibit-password
to "yes".
Now, restart the "sshd" service using the following
command.
```
sudo service sshd restart
```
Now you can log out and log in using the password you set
for the user.
```
ssh ec2-user@ip_address
# ssh ubuntu@15.1.25.40
```

Note: Although password will be encrypted while communicating with server but it is not recommended to enable the password authentication to connect with EC2 machines using ssh. Easy and common password can be guessed easily using brute force by some malicious user.

What the heck is SSH?

Taslim Arif — Mon, 05 Jun 2023 03:35:08 +0000

What Is SSH

SSH, or Secure Shell Protocol, is a remote administration protocol that allows users to access, control, and modify their remote servers over the internet
SSH service was created as a secure replacement for the unencrypted Telnet and uses cryptographic techniques to ensure that all communication to and from the remote server happens in an encrypted manner. It provides a mechanism for authenticating a remote user, transferring inputs from the client to the host, and relaying the output back to the client.
The SSH command consists of below distinct parts:
1. user:Account which you want to access
2. host: computer/server which you want to access (Provide IP Address or Domain name)
3. Private key if password authentication is not enabled
```
      ssh {user}@{host} # given that password policy is enabled
      ssh -i your_private-key.pem {user}@{host} # If password policy is not enabled then key is required
```

You can check my blog on how to enable password authentication for SSH with AWS EC2

Understanding Different Encryption Techniques

The significant advantage offered by SSH over telnet is the use of encryption to ensure a secure transfer of information between the host and the client. There are three different encryption technologies used by SSH:
1. Symmetrical encryption
2. Asymmetrical encryption
3. Hashing

For the sake this tutorial, we will not discuss One way Hashing for encryption.

Symmetrical Encryption

Symmetric encryption is a form of encryption where a secret key is used for both encryption and decryption of a message by both the client and the host. Effectively, anyone possessing the key can decrypt the message being transferred.
Symmetrical encryption is often called shared key or shared secret encryption. There is usually only one key that is used, or sometimes a pair of keys, where one key can easily be calculated using the other key.
Symmetric keys are used to encrypt the entire communication during an SSH session. Both the client and the server derive the secret key using an agreed method, and the resultant key is never disclosed to any third party.
Symmetric key is created using key exchange algorithm such as AES (Advanced Encryption Standard), CAST128, Blowfish.

Asymmetrical Encryption

Unlike symmetrical encryption, asymmetrical encryption uses two separate keys for encryption and decryption. These two keys are known as the public key and the private key. Together, both these keys form a public-private key pair.
A public key can be used by any individual to encrypt a message and can only be decrypted by the recipient who possesses their particular private key, and vice versa. These consist of extensive and seemingly random combinations of numbers and symbols, however, both public and private keys are paired using complex mathematical algorithms(RSA Algorithm).
Note that both encryption and decryption mechanisms are automatic processes – you don’t need to do anything manually.

Symmetrical Encryption Pros and Cons

Pros

Fast
Efficient for large Data

Cons

Hard to share the key(as key should be same at both client and server side, while sharing any hacker can steal the key information and access your data).

ASymmetrical Encryption Pros and Cons

Pros

Efficient for small Data
Security: Without both keys, a hacker can only access useless data.
Transparency: Public keys can be openly distributed, as losing them will not devolve into a security risk.

Cons

Speed : Systems need time for decryption. Users sending plenty of bulk files will have a long wait.
Vulnerabilities: Lose a private key, and anyone who finds it can read all messages, even if they're private. A lost key can result in a man-in-the-middle attack too.
Loss: If you lose your private key, you won't be able to decrypt messages sent to you.
Long-term sustainability: In the future, quantum computing will break most asymmetric and symmetric approaches.

If you see, the problem with symmetrical encryption is the threat to expose the key to some malicious user while sharing
the key info with server but at the same time it is fast and efficient for large data.
In real world, we use combination of best of both encryption algorithms.

How Does SSH Work With These Encryption Techniques

The way SSH works is by making use of a client-server model to allow for authentication of two remote systems and encryption of the data that passes between them.
The client must begin the SSH connection by initiating the TCP handshake with the server, ensuring a secured symmetric connection, verifying whether the identity displayed by the server match previous records (typically recorded in an RSA key store file), and presenting the required user credentials to authenticate the connection.
SSH operates on TCP port 22 by default (though SSH port can be changed if needed). The host (server) listens on port 22 (or any other SSH assigned port) for incoming connections. It organises the secure connection by authenticating the client and opening the correct shell environment if the verification is successful.

You can find the notion behind the mathematical algorithm for ASymmetrical Encryption Technique:

Session Encryption Negotiation

When a client tries to connect to the server via TCP, the server presents the encryption protocols and respective versions that it supports. If the client has a similar matching pair of a protocol and version, an agreement is reached and the connection is started with the accepted protocol. The server also uses an asymmetric public key which the client can use to verify the authenticity of the host.
Once this is established, the two parties use what is known as a Diffie-Hellman Key Exchange Algorithm to create a symmetrical key. This algorithm allows both the client and the server to arrive at a shared encryption key which will be used henceforth to encrypt the entire communication session.

Here is how the algorithm works at a very basic level:

Both the client and the server agree on a very large prime number, which of course does not have any factor in common. This prime number value is also known as the seed value.
Next, the two parties agree on a common encryption mechanism to generate another set of values by manipulating the seed values in a specific algorithmic manner. These mechanisms, also known as encryption generators, perform large operations on the seed. An example of such a generator is AES (Advanced Encryption Standard).
Both the parties independently generate another prime number. This is used as a secret private key for the interaction.
This newly generated private key, with the shared number and encryption algorithm (e.g. AES), is used to compute a public key which is distributed to the other computer.
The parties then use their personal private key, the other machine’s shared public key and the original prime number to create a final shared key. This key is independently computed by both computers but will create the same encryption key on both sides.
Now that both sides have a shared key, they can symmetrically encrypt the entire SSH session. The same key can be used to encrypt and decrypt messages (read: section on symmetrical encryption).

Now that the secured symmetrically encrypted session has been established, the user must be authenticated.

Authenticating the User

The final stage before the user is granted SSH access to the server is authenticating his/her credentials. For this, most SSH users use a password. The user is asked to enter the username, followed by the password.
These credentials securely pass through the symmetrically encrypted tunnel, so there is no chance of them being captured by a third party.
Although passwords are encrypted, it is still not recommended to use passwords for secure connections. This is because many bots can simply brute force easy or default passwords and gain secure shell access to your account. Instead, the recommended alternative is SSH Key Pairs.
These are a set of asymmetric keys used to authenticate the user without the need of inputting any password.

If you’re wondering how long it takes for a computer to calculate a hash and authenticate a user, well, it happens in
less than a second.
In fact, the maximum amount of time is spent in transferring data across the Internet.

Reasons behind bad Softwares (Technical Debts) and Refactoring

Taslim Arif — Sun, 26 Sep 2021 11:35:57 +0000

Bad code haunts everyone sooner or later troubling the one who wrote it along with whole team.

Every developer in the world tries to write good and efficient code. I don't think that there is anyone who writes bad code deliberately.
Then why do we still get bad softwares? Let's look at few reasons for bad code going to production which is generally termed as Technical Debts.

Think of a scenario where you took money from someone on interest, for that time being it solves your problem, right.
But eventually, you have to repay that money to a person with interest. Sometimes, we delay so much in repaying money that the amount of interest gets higher than the actual money which we took from a person which makes it impossible for us to repay the money.

The same is the case with software development, you write bad code, and keep on shipping it to production and since you were not focusing on improving the code, there will be a time when it becomes impossible for you to refactor/improve your code.

Reasons of technical debt

Business Pressure

Sometimes business pressure forces us to ship unfinished code to production. To make it work, we do some patches here and there and hides them. But this will come back haunting us.
Don't do this, it is okay to get delayed sometimes instead of shipping bad code to production because in a long time it will cost more money and effort to improve it.

Developers not taking technical debts seriously or don't understand the importance of it

This is one of the most common cases, I have seen while working at various companies, many developers don't take these things seriously, for them working code is sufficient.
This becomes almost impossible to refactor and improve the code because your employer does not value it.

Lack of Documentation

Documentation is one of the most important aspects of software development. It doesn't matter how good code have you written, if other developers can't understand, contribute or use it. We must write a good documentation explaining every aspect of your code so that others feel, it is easy to use and they don't need to ask you everytime.

Incompetence

When the developer doesn’t know how to write decent code.

Lack of knowledge sharing among team members

When developers don't share their understanding of project with team members, it becomes almost impossible, specially for junior developers to work on it. They work in dark all the time and eventually create problems for themselve as well for whole team.

Lack of tests

The lack of immediate feedback encourages quick, but risky workarounds. In worst cases, these changes are implemented and deployed right into the production without any prior testing. The consequences can be catastrophic. For example, an innocent-looking hotfix might send a weird test email to thousands of customers or even worse, flush or corrupt an entire database.

Working in Isolation

This can lead to the accumulation of technical debt, which is then increased when changes are merged. The more changes made in isolation(in your respective branch), the greater the total technical debt because it can cause merge conflict, it is very hard to review it.

Lack of compliance monitoring

This happens when everyone working on the project writes code as they see fit. There must be a guideline to follow while writing, documenting, testing and deploying the code.

When to refactor your code

Follow rules of 3 for this.

When you are writing code for the 1st time, just get it done.
When you are doing something similar for the second time, keep refactoring thought in mind but anyways get it done.
when you are doing something similar for the third time, start refactoring it.

Adding new feature

While adding new feature into someone else dirty code, first refactor it and then add new features. It is very easy to understand clean code and add new features into it.

When fixing bugs

Clean your code, you will automatically find bugs.

During code review

This is last and probably the most important part of the refactoring process. After this your code will be going to production. It is always best to do code review in pairs, make sure author is present.

How to refactor

Make sure after refactoring your code should be cleaner than previous on and still all features are working. If code is not cleaner, you have just wasted your time.
Make sure you have a good understanding of the code you are refactoring.
Make sure while refactoring, no new functionality should be added in your code. Refactoring and adding new feature are two different things. Once you complete refactoring, then you can add new features.
Make sure all previous test cases are passing after refactoring.

Clean Code

Taslim Arif — Sun, 26 Sep 2021 08:24:15 +0000

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

– Martin Fowler

Writing clean, understandable, and maintainable code is a skill that is crucial for every developer to master.

When I say clean code I mean:

Proper variable name, function name, class name, proper indentation, proper spacing, proper comment, and proper/unique code style throughout the team.
Minimal number of lines of code, classes, functions, etc. Less code means less headache, fewer bugs, and less maintenance cost.
No duplication of code. Duplication in your software shows bad software and lack of knowledge.
It might seem contradictory to my previous point but too much abstraction is also bad. If your abstraction forces you to add more conditions and extra parameters in your method every time a new feature is introduced, it is a bad/wrong abstraction and you should follow the below things:
- Try to find a way so that every time you introduce a new feature, your abstraction should not be affected.
- Go back to duplication. You heard it right. Duplication is always better than wrong abstraction.

Well, I don't see this as a failure of abstraction. It's caused by some specific other failures.

   a. Failure of people to understand data modeling, and the 
      difference between interface and implementation. "A new 
      requirement appears for which the current abstraction 
      is almost perfect. Just because the code is the same 
      doesn't mean it should use the same abstraction. The 
      data model is wrong, not the abstraction.

   b. Failure of people to think of the entire system, when 
      making a change. The rookie mistake is to think that 
      adding one more conditional is always harmless, but, at 
      some point, you've got 3 tons of straw on that poor 
      camel's back. Adding just one more case may have been 
      the correct fix last week, but not this week.

No magic numbers (A magic number is direct usage of a number in the code). Magic numbers are bad, not readable, hard to maintain and not reusable.
Minimum/No hard coding. It is bad, not reusable, not testable, and not maintainable.
Code should pass 100% of test cases(even 99% shows that you are screwed).
Code is easy and cheap to maintain.
Mature programmers know that the idea that everything is an object is a myth. Sometimes you really want simple data structures with procedures for your task. So you have to carefully think what to implement also thinking about the future perspective that what will be easy to update.

Always write concise documentation of your code( classes, functions, properties, etc.)

Tips to write clean code

Variable, function, or class names should be descriptive. If it requires a comment to describe what the name does, it's a bad naming convention.

let s; // number of seconds ---> Bad naming convention

Good naming convention:
let numberOfSeconds, customerName, employeeName, mailMessage, mailFolder

Do not include any redundant information/ noise words in naming. Some of noise words:
- Data
- Object
- Info
- Information
- Variable
- String

Bad naming convention:

userInfo, userData, userVariable, userObject, accountInformation, employeeString etc.

Good naming convention:
user, employee, account etc.

Be consistent while naming variables of similar tasks. For example, while naming any variable which stores fetched data from an API call or Database use only one of these: get, retrieve, fetch. Don't use more than one as they do the same task.

 Say you decide to follow get convention:
getUser, getName, getFile, getAccount etc. ==> Good convention
getUser, retrieveAccount, fetchName ===> Bad convention

Don't use magic numbers(A magic number is a direct usage of a number in the code)

Bad convention:
   if(age>=18) "eligible for voting"

Good Convention:
   MINIMUM_AGE_FOR_VOTING=18;
   if(age>=MINIMUM_AGE_FOR_VOTING) "eligible for voting"

Avoid leaving code inside comments because it makes other developers scary to remove them as they don't know whether it is for comment purposes or left to use later.
Always follow the coding style defined by the programming language which you are using. Few conventions in Typescript:
- Variable name should be in the camel case.
- Function name should be in the camel case.
- Class name should be in pascal case.
Try to follow the DRY (Don't Repeat Yourself) principle.
Function name should be a verb.
Class and variable name should be a noun.
Prefer to use code formatters such as Prettier for better code arrangement.
People often ask me, what should be maximum length of variable, function or class name. Well my answer to them:

If there's a shorter, but yet descriptive way to name the function, variable or class then your current variable, class or function name is long.

Conclusion

The skill of writing clean code comes from using it again and again in software development. It is the least you should follow while writing a software code.

Circular Linked List:

Taslim Arif — Sun, 19 Sep 2021 16:24:55 +0000

If you are not familiar with the LinkedList, I would highly recommend having a look at my blog:

Introduction to Linked List

In this tutorial, we will learn circular linked list in-depth by dividing topics in the following manner:

Definition of circular linked list.
Types of Circular linked list
Basic Operations on circular linked list

a) Searching/Traversal
b) Insertion
c) Deletion
Singly linked list as a circular linked list.
Doubly linked list as a circular linked list.
Applications of circular linked list
Implementation of circular linked list.

Definition of circular linked list

In a circular linked list, elements are stored in random memory locations.
Similar to a singly linked list, each node of a circular linked list (I meant singly circular linked list) contains two fields:

data stored at that particular address.
Pointer which contains the address of the next node.

Unlike, singly linked list in which the last node of the contains a pointer to null to represent the termination of a linked list, in circular linked list, last node of linked list will point to the first node of the linked list.

Types of Circular Linked List:

There are two types of Circular linked list. i.e. we can make a circular linked list by modifying the Singly linked list as well as Doubly linked list.

1. Singly circular linked list

The above diagram is an example of a singly linked list in which the last node(Tail) points to NULL to represent the termination of the linked list.
To make it a singly circular linked list, you just need to modify the link of the last node.
Instead of pointing it to NULL, We are going to link it with the first(head) node.

Now, one question which might come into your mind is, how do we get to know termination condition, right?
Because, if we don’t apply termination condition our program will run into an infinite loop. Confused? 😕 😕 😕 😕 😕

Well, one thing you might do is, keep a track of head node and whenever we encounter it again, we say that we have traversed our whole linked list and Now it is time to terminate.
You could have taken a temp=head->next and start traversing linked list and check for whether our temp is head or not.

if (temp==head) ===> We have traversed whole linked list.
Well, it was just a brief explanation, we will see it via code in detail, later in this tutorial.

2. Doubly circular linked list

The above diagram is an example of doubly linked list in which the prev of head points to NULL and last node(Tail) points to NULL to represent the termination of linked list.
To make it a Doubly Circular Linked List, you just need to modify the link of the last node.
Instead of pointing next of last node (lastNode->next) to NULL, We are going to link it with first(head) node.
Moreover, the prev of first node (head->prev) will point to the last node.

In this case, keep a track of head node and whenever we encounter it again, we say that we have traversed whole linked list and now it is time to terminate.

You could have taken a temp=head->next and start traversing linked list and check for whether our temp is head or not.
if temp==head -----> We have traversed whole linked list.

Operations on Circular linked list

A. Traversal

Traversal in Circular linked list is similiar to singly or doubly linked list, we just need to take care of termination condition. In this case termination condition would be, If we reach again to our head node.

To perform this task do the following:
Take a temp node and store head ->next into it, now run a loop untill temp!=head and search for given element.
If we reach head ===> (temp==head): terminate loop.

Node *temp=head->next;
while(temp!=head)
{
  if(temp->data==ElementToFind) {
    cout<<"Element found"<<endl;
    break;
  }
  temp=temp->next;
}

B. Insertion

Insertion in Circular linked list will be exactly same as in singly linked list except inseting node at front and at last position.

Inserting node in Between two nodes

Inserting node at front

To insert a node at front, We need to know about the last node of linked list.
Hence we will traverse the whole linked list and reach to end of it.

Create a new node and link it with exisiting list as mentioned below:

LastNode->next=newNode;
newNode->next=head;

After, linking nodes, we need to update the head of linked list as we are inserting at the front and front node represent the head of linked list.
In our case, newNode would be our new head now.

head=newNode;

Inserting node at last

It is similiar to inserting node at front. The only difference is that we don't need to update head in this case.

C. Deletion

Deleting in between node

To delete in between node, find prev and next node of the node which needs to be deleted.

curr = head;
while(curr!=nodetoDelete) { 
   prev = curr;
   curr = curr->next;
}
prev->next=curr->next;
delete curr;

Deleting node at front

To delete a Node from front, We need to know about the last node of linked list.
Hence we will traverse the whole linked list and reach to end of it.

ptr = head;  
while(ptr ->next != head) {  
       ptr = ptr->next;  
}  
temp = head;
ptr -> next = temp->next;
// update head node
head =head->next;
delete temp;

Deleting last node

It is similiar to deleting node at front. The only difference is that we won't be updating head in this case.

ptr = head;  
while(ptr ->next != head) {  
       preptr=ptr;  
       ptr = ptr->next;  
}  
preptr->next = ptr -> next;

D. Advantages of Circular linked list

In a circular linked list, there is no requirement for a NULL assignment in the code. The good thing about a circular linked list is that It never points to a NULL pointer unless fully deallocated.
Circular linked lists are always good and advantageous for the end operations since the beginning and the end of circular linked list coincide with each other.
Many algorithms such as the Round Robin scheduling which uses queue can efficiently and easily eliminate processes that are queued in a circular way or fashion without encountering any dangling pointers or NULL-referential
pointers.
The biggest advantage with a circular linked list is that It also performs all regular functions of a singly/doubly linked list along with additional features.

E. Disadvantage of circular linked list

Insertion at all positions (first node, last node, and In-between) takes O(n) time while in singly linked list insertion at first node takes O(1) time.
Deletion at all positions (first Node, Last Node, and In-between) takes O(n) time while in singly linked list deletion at first node takes O(1) time.
If we don’t apply the termination condition properly, our code might lead to infinite loop.

F. Applications of Circular linked list

If I talk about the real-life application of a circular linked list, It would be none other than our personal computers, which are capable of running multiple applications at a time. Computers process all applications in this manner that all running applications are kept in a queue which is implemented using a circular linked list and the operating system gives a fixed time(could be an example of Round Robin CPU Scheduling Process) slot know as time quantum to all for running processes.
The operating system keeps on iterating over the
circular linked list and keeps executing processes and removing them from waiting for queue until all the applications are executed/completed successfully.
We can also take an example multiplayer games in which all the players are kept in a queue which is implemented via a circular linked list and the pointer keeps on moving forward as the chance of a particular player ends.
We can also take an example of the circular linked list which can also be used to create a circular queue.
The problem with a given queue is that we need to keep two pointers one for FRONT and another for REAR in memory all the time to implement a queue.
But with the help of a Circular linked list we can do this task easily and efficiently because, in a circular linked list, only one pointer is required.
Circular linked list is also used in token rings scheduling in computer networks.
Circular linked list is used to display units like shop boards that require continuous traversal of data.

G. Implementation

#include <bits/stdc++.h>
using namespace std;
class NodeTaslim {
  public:
  int data;
  NodeTaslim *next;
  NodeTaslim() { 
    data = 0;
    next = NULL;
  }
  NodeTaslim(int x) {
    data = x;
    next = NULL;
  }
};


class CircularLinkedList {
   public:
   NodeTaslim *head;

   /* Insert at front */
   int addAtFront(int value);

   /* check list is empty or not */
   int isEmpty();

   /* Insert at end */
   int addAtEnd(int value);

   /* Search for an element in list */
   NodeTaslim *search(int k);

   /* Delete a node */
   NodeTaslim *deleteNode(int x);

   CircularLinkedList() {
     head = NULL;
   }
};

/* Find last Node of Linked List */
NodeTaslim *getLastNode(NodeTaslim *head) {
   NodeTaslim *temp = head;
   while (temp->next != head) {
     temp = temp->next;
   }
   return temp;
}

/* Add a Node at Front */
int CircularLinkedList ::addAtFront(int value)
{
   int i = 0;
   NodeTaslim *n = new NodeTaslim(value);
   /* Check list is empty or not */
   if (head == NULL) {
       n->next = head;
       head = n;
       i++;
   }
   else {
      NodeTaslim *last = getLastNode(head);
      n->next = head;
      last->next = n;
      head = n;
      i++;
   }
   return i;
}

/* Add a Node at Last */
int CircularLinkedList ::addAtEnd(int value) {
   NodeTaslim *n = new NodeTaslim(value);
   if (head == NULL) {
       head = n;
       n->next = NULL;
   }
   else {
       NodeTaslim *last = getLastNode(head);
       last->next = n;
       n->next = head;
   }
}

/* Search an Element in List */
NodeTaslim *CircularLinkedList ::search(int x) {
     NodeTaslim *ptr = head;
     while (ptr != NULL && ptr->data != x) {
           ptr = ptr->next;
     }
     return ptr;
}

/* Remove Node from List */
NodeTaslim *CircularLinkedList ::deleteNode(int x) {
    NodeTaslim *n = search(x);
    NodeTaslim *ptr1 = head;
    if (ptr1 == NULL) {
      cout << "List is empty";
      return NULL;
    }
    /*Remove first node*/
    else if (ptr1 == n) {
      ptr1->next = n->next;
      return n;
    }
    else {
      while (ptr1->next != n) {
         ptr1 = ptr1->next;
      }
      ptr1->next = n->next;
      return n;
    }
}

An Introduction to Linked List

Taslim Arif — Sun, 19 Sep 2021 12:40:28 +0000

A Linked List is a linear data structure which consists of a group of nodes.
Unlike an array, In a linked list, elements are stored in random memory locations.

Each node contains two fields :

data stored at that particular address.
Pointer which contains the address of the next node.

The last node of the linked list contains a pointer to null to represent the termination of the linked list.
Generally, We call the first node as Head node and the last node as the Tail node in linked list.

Why linked list over array?

An array contains the following limitations:

The size of an array is fixed. We must know the size of the array at the time of its creation, hence it is impossible to change its size at runtime.
Inserting a new element in an array is expensive because we need to shift elements to create room for a new element to insert.
Deleting an element in an array is also expensive as it also takes the shifting of elements in an array.

Advantages of linked lists:

Insertion and deletion operations can be implemented very easily and these are not costly as they do not require shifting of elements.
They are dynamic in nature. Hence, we can change their size whenever required.
Stacks and queues can be implemented very easily using Linked Lists.

Disadvantages of linked lists:

Random access of an element is not possible in linked lists, we need to traverse linked list from starting to search an element into it.
It is relatively slow to process in comparision of an array.
Since node of a linked list conatins both data and pointer to next node, hence extra memory is required to store pointer of each node.

Types of linked lists:

There are 3 types of linked lists:

Singly linked list
Circular linked list
Doubly linked list

Singly linked list

Singly linked list contains a node that has both data part and pointer to the next node.
The last node of the singly linked list has a pointer to null to represent the end of the linked list.
Traversal to previous nodes is not possible in singly linked list i.e We can not traverse in the backward direction.

Circular linked list

Circular linked list is similar to singly linked list but the last node of circular linked list points to first node (head node) of linked list.

Doubly linked list

Doubly linked list contains a node that has three entries:

data
pointer to next node
pointer to the previous node

We can traverse in both forward and backward directions in doubly linked list.

Implementation of linked list:

I am implementing singly linked list below for the sake of understanding.

#include<iostream>
using namespace std;
/* Create a class which contains 2 properties data and pointer to next node */
class Node
{
  public:
  int data;
  Node *next;

  Node(int data)
  {
   this->data=data;
   this->next=NULL;
  }
};

/* Take Input from the user in Linked List  and Stop when a user enters data== -1 */

Node *takeInput()
{
  int data;
  cin>>data;
  /* Intially linked list is empty, hence both head and tail nodes are NULL */
  Node *head=NULL;
  Node *tail=NULL;

  while(data!=-1)
  {
    Node *newNode = new Node(data);
    /* Inserting first element in empty linked list */
    if(head==NULL)
    {
      head=newNode;
      tail=newNode;
    }
    /* List is not empty */
    else
    {
      tail->next=newNode;
      tail=tail->next;
    }
    cin>>data;
  }
  return head;
}

/* Printing elements of Linked List  1->2->3->4->5->NULL */
void printNode(Node *head)
{
  Node *temp=head;
  while(temp!=NULL)
  {
    cout<<temp->data<<" ";
    temp=temp->next;
  }
}
int main()
{
  Node *head=takeInput(); // Taking input
  printNode(head); // Printing data
}