Author: saqibkhan

What is TLS/SSL

TLS stands for Transport Layer Security. It is the successor to Secure Sockets Layer (SSL). TLS along with SSL is used for cryptographic protocols to secure communication over the web.

TLS uses public-key cryptography to encrypt messages. It encrypts communication generally on the TCP layer.

What is public-key cryptography

In public-key cryptography, each client and each server has two keys: public key and private key. Public key is shared with everyone and private key is secured. To encrypt a message, a computer requires its private key and the recipient?s public key. On the other hand, to decrypt the message, the recipient requires its own

You have to use require(‘tls’) to access this module.

Syntax:

var tls = require('tls');  

The tls module uses OpenSSL to attain Transport Layer Security and Secure Socket Layer. TLS/SSL is a public/private key infrastructure. Each client and each server must have a private key.

A private key can be created like this:

openssl genrsa -out ryans-key.pem 1024   

All severs and some clients need to have a certificate. Certificates are public keys signed by a Certificate Authority or self-signed. To get certificate, you have to create a “Certificate Signing Request” (CSR) file.

A certificate can be created like this:

openssl req -new -key ryans-key.pem -out ryans-csr.pem   

To create a self-signed certificate with the CSR:

openssl x509 -req -in ryans-csr.pem -signkey ryans-key.pem -out ryans-cert.pem   

Node.js TLS client example

File: tls_client.js

tls = require('tls');  

function connected(stream) {  

    if (stream) {  

       // socket connected  

      stream.write("GET / HTTP/1.0\n\rHost: encrypted.google.com:443\n\r\n\r");    

    } else {  

      console.log("Connection failed");  

    }  

}  

 // needed to keep socket variable in scope  

var dummy = this;  

 // try to connect to the server  

dummy.socket = tls.connect(443, 'encrypted.google.com', function() {  

   // callback called only after successful socket connection  

   dummy.connected = true;  

   if (dummy.socket.authorized) {  

      // authorization successful  

      dummy.socket.setEncoding('utf-8');  

      connected(dummy.socket);  

   } else {  

      // authorization failed  

     console.log(dummy.socket.authorizationError);  

     connected(null);  

   }  

});  

 dummy.socket.addListener('data', function(data) {  

   // received data  

   console.log(data);  

});  

 dummy.socket.addListener('error', function(error) {  

   if (!dummy.connected) {  

     // socket was not connected, notify callback  

     connected(null);  

   }  

   console.log("FAIL");  

   console.log(error);  

});  

 dummy.socket.addListener('close', function() {  

 // do something  

});  

Output:

The Node.js Crypto module supports cryptography. It provides cryptographic functionality that includes a set of wrappers for open SSL’s hash HMAC, cipher, decipher, sign and verify functions.

What is Hash

A hash is a fixed-length string of bits i.e. procedurally and deterministically generated from some arbitrary block of source data.

What is HMAC

HMAC stands for Hash-based Message Authentication Code. It is a process for applying a hash algorithm to both data and a secret key that results in a single final hash.

Encryption Example using Hash and HMAC

File: crypto_example1.js

const crypto = require('crypto');  

const secret = 'abcdefg';  

const hash = crypto.createHmac('sha256', secret)  

                   .update('Welcome to JavaTpoint')  

                   .digest('hex');  

console.log(hash);  

Open Node.js command prompt and run the following code:

node crypto_example1.js  

Encryption example using Cipher

File: crypto_example2.js

const crypto = require('crypto');  

const cipher = crypto.createCipher('aes192', 'a password');  

var encrypted = cipher.update('Hello JavaTpoint', 'utf8', 'hex');  

encrypted += cipher.final('hex');  

console.log(encrypted);  

Open Node.js command prompt and run the following code:

node crypto_example2.js  

Decryption example using Decipher

File: crypto_example3.js

const crypto = require('crypto');  

const decipher = crypto.createDecipher('aes192', 'a password');  

var encrypted = '4ce3b761d58398aed30d5af898a0656a3174d9c7d7502e781e83cf6b9fb836d5';  

var decrypted = decipher.update(encrypted, 'hex', 'utf8');  

decrypted += decipher.final('utf8');  

console.log(decrypted);  

Open Node.js command prompt and run the following code:

node crypto_example3.js  

Node.js provides the ability to perform socket programming. We can create chat application or communicate client and server applications using socket programming in Node.js. The Node.js net module contains functions for creating both servers and clients.

Node.js Net Example

In this example, we are using two command prompts:

• Node.js command prompt for server.
• Window’s default command prompt for client.

server:

File: net_server.js

const net = require('net');  

var server = net.createServer((socket) => {  

  socket.end('goodbye\n');  

}).on('error', (err) => {  

  // handle errors here  

  throw err;  

});  

// grab a random port.  

server.listen(() => {  

  address = server.address();  

  console.log('opened server on %j', address);  

});  

Open Node.js command prompt and run the following code:

node net_server.js  

client:

File: net_client.js

const net = require('net');  

const client = net.connect({port: 50302}, () => {//use same port of server  

  console.log('connected to server!');  

  client.write('world!\r\n');  

});  

client.on('data', (data) => {  

  console.log(data.toString());  

  client.end();  

});  

client.on('end', () => {  

  console.log('disconnected from server');  

});  

Open Node.js command prompt and run the following code:

node net_client.js  

The Node.js DNS module contains methods to get information of given hostname. Let’s see the list of commonly used DNS functions:

• dns.getServers()
• dns.setServers(servers)
• dns.lookup(hostname[, options], callback)
• dns.lookupService(address, port, callback)
• dns.resolve(hostname[, rrtype], callback)
• dns.resolve4(hostname, callback)
• dns.resolve6(hostname, callback)
• dns.resolveCname(hostname, callback)
• dns.resolveMx(hostname, callback)
• dns.resolveNs(hostname, callback)
• dns.resolveSoa(hostname, callback)
• dns.resolveSrv(hostname, callback)
• dns.resolvePtr(hostname, callback)
• dns.resolveTxt(hostname, callback)
• dns.reverse(ip, callback)

Node.js DNS Example 1

Let’s see the example of dns.lookup() function.

File: dns_example1.js

const dns = require('dns');  

dns.lookup('www.javatpoint.com', (err, addresses, family) => {  

  console.log('addresses:', addresses);  

  console.log('family:',family);  

});  

Open Node.js command prompt and run the following code:

node dns_example1.js  

Node.js DNS Example 2

Let’s see the example of resolve4() and reverse() functions.

File: dns_example2.js

const dns = require('dns');  

dns.resolve4('www.javatpoint.com', (err, addresses) => {  

  if (err) throw err;  

  console.log(addresses: ${JSON.stringify(addresses)});  

  addresses.forEach((a) => {  

    dns.reverse(a, (err, hostnames) => {  

      if (err) {  

        throw err;  

      }  

      console.log(reverse for ${a}: ${JSON.stringify(hostnames)});  

    });  

  });  

});  

Open Node.js command prompt and run the following code:

node dns_example2.js  

Node.js DNS Example 3

Let’s take an example to print the localhost name using lookupService() function.

File: dns_example3.js

const dns = require('dns');  

dns.lookupService('127.0.0.1', 22, (err, hostname, service) => {  

  console.log(hostname, service);  

    // Prints: localhost  

}); 

Open Node.js command prompt and run the following code:

node dns_example3.js