![](\"https://lh6.googleusercontent.com/ELzKfQlR5jHkRzeVW_9S0VxLD8vSfo2hJCvQxf37DZjwaod1Me05BzIs2Vk9unKneDda1PpI6TdmhvH7KnqFgCP0cRhIxORM9sfTn9RSTlTC40pwScwLLprVX2uu6sltu3kClQsc\")
In this blog, we’ll be implementing authentication with password hashing in a Node.js web application. For this, we’ll be using crypto, a package password hashing for Node.js.
\nThe Crypto module for Node JS helps developers to hash user passwords.
\nPre-requisites:
\nStep 1. First, create a directory structure as below :
\nhashApp
--model\n----user.js\n--route\n----user.js\n--server.jsStep 2. Create model/user.js file and add the following code :
\n// Importing modules \nconst mongoose = require('mongoose'); \nvar crypto = require('crypto'); \n \n// Creating user schema \nconst UserSchema = mongoose.Schema({ \n name : { \n type : String, \n required : true\n }, \n email : { \n type : String, \n required : true\n }, \n hash : String, \n salt : String \n}); \n \n// Method to set salt and hash the password for a user \nUserSchema.methods.setPassword = function(password) { \n \n // Creating a unique salt for a particular user \n this.salt = crypto.randomBytes(16).toString('hex'); \n \n // Hashing user's salt and password with 1000 iterations, \n \n this.hash = crypto.pbkdf2Sync(password, this.salt, \n 1000, 64, `sha512`).toString(`hex`); \n}; \n \n// Method to check the entered password is correct or not \nUserSchema.methods.validPassword = function(password) { \n var hash = crypto.pbkdf2Sync(password, \n this.salt, 1000, 64, `sha512`).toString(`hex`); \n return this.hash === hash; \n}; \n \n// Exporting module to allow it to be imported in other files \nconst User = module.exports = mongoose.model('User', UserSchema); Step 3. Create route/user.js file and add the following code:
\n// Importing modules \nconst express = require('express'); \nconst router = express.Router(); \n\n// Importing User Schema \nconst User = require('../model/user'); \n\n// User login api \nrouter.post('/login', (req, res) => { \n\n // Find user with requested email \n User.findOne({ email : req.body.email }, function(err, user) { \n if (user === null) { \n return res.status(400).send({ \n message : "User not found."\n }); \n } \n else { \n if (user.validPassword(req.body.password)) { \n return res.status(201).send({ \n message : "User Logged In", \n }) \n } \n else { \n return res.status(400).send({ \n message : "Wrong Password"\n }); \n } \n } \n }); \n}); \n\n// User signup api \nrouter.post('/signup', (req, res, next) => { \n\n\n// Creating empty user object \n let newUser = new User(); \n\n // Initialize newUser object with request data \n newUser.name = req.body.name, \n\n newUser.email = req.body.email,\n\n\n newUser.password=req.body.password\n\n // Call setPassword function to hash password \n newUser.setPassword(req.body.password); \n\n // Save newUser object to database \n newUser.save((err, User) => { \n if (err) { \n return res.status(400).send({ \n message : "Failed to add user."\n }); \n } \n else { \n return res.status(201).send({ \n message : "User added successfully."\n }); \n } \n }); \n}); \n// Export module to allow it to be imported in other files \nmodule.exports = router; Step 4. Create server.js file :
\n// Importing modules\nvar express = require('express');\nvar mongoose = require('mongoose');\nvar bodyparser = require('body-parser');\n \n// Initialize express app\nvar app = express();\n \n// Mongodb connection url\nvar MONGODB_URI = "mongodb://localhost:27017/hashAppDb";\n \n// Connect to MongoDB\nmongoose.connect(MONGODB_URI);\nmongoose.connection.on('connected', () => {\n console.log('Connected to MongoDB @ 27017');\n});\n \n// Using bodyparser to parse json data\napp.use(bodyparser.json());\n \n// Importing routes\nconst user = require('./route/user');\n \n// Use user route when url matches /api/user/\napp.use('/api/user', user);\n \n// Creating server\nconst port = 3000;\napp.listen(port, () => {\n console.log("Server ru\nnning at port: " + port);\n});Step 5. Run server.js file using command
\nnode server.jsStep 6. Open Postman and create a post request to localhost:3000/api/user/signup with following body parameter:
\n{\n"name" : "test".\n"email" : "test@test.com",\n"password" : "test1234"\n}Run the request and you will get a success response:
\n{\n"message" : "user added sucessfully"\n}User data is stored in the database as below:
\n "_id": {\n "$oid": "5ab71ef2afb6db0148052f6f"\n },\n "name": "test",\n "email": "test@test.com",\n "salt": "ddee18ef6a6804fbb919b25f790005e3",\n "hash": "bbf13ae4db87d475ca0ee5f97e397248a23509fc10c82f1e3cf110\n b352c3ca6cc057955ace9d541573929cd7a74a280a02e8cb549136b43df7704caaa555b38a",\n "__v": 0\n}If we have sensitive data or information that you need to be protected, ensuring it is secured correctly is important. With the above process, we can now successfully store our hashed password into our database with a bit of additional security.
\nYou can check the code on Github.
\n","frontmatter":{"date":"June 25, 2020","updated_date":null,"description":null,"title":"Password hashing with NodeJS","tags":["Security","NodeJs"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.4598540145985401,"src":"/static/3500f6f614e274d34fe0b6c1213a16a2/ee604/cover.png","srcSet":"/static/3500f6f614e274d34fe0b6c1213a16a2/69585/cover.png 200w,\n/static/3500f6f614e274d34fe0b6c1213a16a2/497c6/cover.png 400w,\n/static/3500f6f614e274d34fe0b6c1213a16a2/ee604/cover.png 800w,\n/static/3500f6f614e274d34fe0b6c1213a16a2/f3583/cover.png 1200w,\n/static/3500f6f614e274d34fe0b6c1213a16a2/3bf79/cover.png 1440w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Ashish Sharma","github":"ashish8947","avatar":null}}}},{"node":{"excerpt":"Idx-Auto-Tester is LoginRadius Identify Experience Automation Framework which refers to IEF Automation, is an open-source automation…","fields":{"slug":"/engineering/introduction-of-idx-auto-tester/"},"html":"Idx-Auto-Tester is LoginRadius Identify Experience Automation Framework which refers to IEF Automation, is an open-source automation framework built-in Nightwatch| Node.js tool with delivering all the standard authentication cases of LoginRadius Identity Experience.\nThis automation framework has been created for The LoginRadius Identity Experience Framework which is a ready-to-use solution that provides predefined layouts for all necessary authentication actions. It has all of the user accounts flows available, such as login, registration, forgotten password, and profile management.
\nWe used Nightwatch.js end-to-end testing framework to create our Idx-Auto-Tester. This framework relies on Selenium and provides several commands and assertions within the framework to perform operations on DOM elements. It internally uses the powerful W3C Webdriver API or the Selenium Webdriver and simplifies writing end-to-end automated tests in Node.js and effortlessly sets up for Continuous Integration.
\nNightwatch uses JavaScript language (Node.js) and CSS/XPath to identify an element. It has Built-in command-line test runner which can run the tests either sequentially or in parallel, together, by group, tags, or by single.
\nStep 1: Download and Install Java.
\nStep 2: Install Node.js.
\nStep 3: Install Nightwatch. In the command line, navigate to any directory and type
\n npm install -g nightwatch (here ‘g’ is for installing globally).Step 4: Create a folder structure as shown below where Project is the root.
\nStep 5. Now it is required to install selenium-server-standalone.jar and chromedriver.exe along with other dependencies to execute test cases.
\nAs all the dependencies are added in nightwatch.json, so by executing below command, these will be added in node_modules folder
\n npm installNow we have installed all the dependencies and configuration setup for the automation framework. Nightwatch.js offers an in-built test runner which expects a JSON configuration file to be passed. The default configuration file is nightwatch.json which should be present in the project’s root directory.
\nStep 6. In the root folder, create “nightwatch.js” file and place the following line:
\nrequire("nightwatch/bin/runner.js")Step 7. Now create nightwatch.json configuration file with the configurations mentioned as below code snippet for testing with Selenium and JavaScript.
{\n "src_folders": ["test"],\n "output_folder": "tests_output",\n "custom_commands_path": "helpers/custom-commands",\n "custom_assertions_path": "",\n "page_objects_path": "",\n "globals_path": "",\n "test_workers": {\n "enabled": false,\n "workers": 3\n },\n\n "selenium": {\n "start_process": true,\n "server_path": "node_modules/selenium-server-standalone-jar/jar/selenium-server-standalone-3.13.0.jar",\n "log_path": "",\n "host": "127.0.0.1",\n "port": 4444,\n "cli_args": {\n "webdriver.chrome.driver": "node_modules/chromedriver/lib/chromedriver/chromedriver.exe",\n "webdriver.ie.driver": ""\n }\n },\n\n "test_settings": {\n "default": {\n "skip_testcases_on_fail": false,\n "launch_url": "http://localhost",\n "selenium_port": 4444,\n "selenium_host": "127.0.0.1",\n "silent": true,\n "screenshots": {\n "enabled": true,\n "path": "screenshots"\n },\n "desiredCapabilities": {\n "browserName": "chrome",\n "javascriptEnabled": false,\n "acceptSslCerts": false,\n "chromeOptions": {\n "args": ["--headless-none"]\n }\n }\n },\n "firefox": {\n "desiredCapabilities": {\n "browserName": "firefox",\n "javascriptEnabled": true,\n "acceptSslCerts": true,\n "cli_args": {\n "globals": {\n "env": "fire fox"\n }\n }\n }\n },\n\n "ie": {\n "desiredCapabilities": {\n "browserName": "internet explorer",\n "javascriptEnabled": true,\n "acceptSslCerts": true,\n "cli_args": {\n "globals": {\n "env": "ie"\n }\n }\n }\n }\n }\n}Step 8. Now its time to design test case of any scenario, same as created in our Idx-Auto-Tester Framework under test folder named as TC01UserLogin
\nTo create functions/methods, we used nightwatch custom commands approach to create commands for all the required functions under custom-commands folder, like as there is command created for createUser.js which used to create the user and call it under test case.
\n\n\nNote: We are using 'Function-style commands' of Nightwatch to create command to resolve the asynchronous queueing system problem while running the test case.
\n
Step 9. The final thing we are required to do is to execute the tests from the base directory of the project using the command:
\nnpm test\n\nImportant Tip : A script has been added in package.json to define test execution command:
\n
"scripts":\n {\n "test": "node nightwatch.js --reporter html-reporter.js test"\n }This command will validate the tests and dependencies and then execute the test suite, which will open up the mentioned browser and execute the desired test steps.
\nIt is required to update the configuration to execute the tests in parallel by enabling the test_workers as true. This will enable parallel execution and execute all tests on a defined number of workers.
\n "test_workers": {\n "enabled": true,\n "workers": 3\n },In this framework design, we have covered various flows of LoginRadius Identity Experience Automation testing with Selenium Javascript. I hope we are now clear about the approach for an end-to-end automation testing with Selenium JavaScript using Nightwatch.js with the reference of Idx-Auto-Tester. We are aware of all the prerequisites required for setting up Nightwatch.js. It automates the entire test suite quickly with minimal configuration and is readable as well as easy to update. Our framework is also capable to use the best feature provided by Nightwatch.js framework which is the parallel testing of cases that proves to be time-efficient. The test results can directly be read from the terminal and also stored at a specified output folder.
\n","frontmatter":{"date":"June 22, 2020","updated_date":null,"description":null,"title":"Introduction of Idx-Auto-Tester","tags":["Automation","Idx-Auto-Tester"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/0081dfe350298b300d58aa44264cb5e8/ee604/idx-auto-tester.png","srcSet":"/static/0081dfe350298b300d58aa44264cb5e8/69585/idx-auto-tester.png 200w,\n/static/0081dfe350298b300d58aa44264cb5e8/497c6/idx-auto-tester.png 400w,\n/static/0081dfe350298b300d58aa44264cb5e8/ee604/idx-auto-tester.png 800w,\n/static/0081dfe350298b300d58aa44264cb5e8/f3583/idx-auto-tester.png 1200w,\n/static/0081dfe350298b300d58aa44264cb5e8/e4d72/idx-auto-tester.png 1280w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Himanshi Sharma","github":"Himanshi0512","avatar":null}}}},{"node":{"excerpt":"In this blog, we’ll be implementing authentication via Twitter in a Golang web application. For this, we’ll be using Goth, a social…","fields":{"slug":"/engineering/twitter-authentication-with-golang-and-goth/"},"html":"In this blog, we’ll be implementing authentication via Twitter in a Golang web application. For this, we’ll be using Goth, a social authentication middleware for Golang.
\nPre-requisites:
\nFirstly, We need to create a new Twitter App using its Application Management. Twitter does not seem to work nicely with it if \"localhost\" is given in the callback URL field. To overcome this limitation, you could use the special loopback address or \"127.0.0.1\" in place of \"localhost\".
\nStep 1. First, create a directory structure as below for your Go Application :
\nTwitterAuthenticationGoth\n-templates\n--index.html\n--success.html\n-main.goStep 2. Add the following code in index.html for creating LoginUI:
\n<!doctype html>\n<html>\n<head>\n <title>Twitter SignIn</title>\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bulma css -->\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n <style>\n body { padding-top:70px; }\n </style>\n</head>\n<body>\n<div class="container">\n <div class="jumbotron text-center text-success">\n <h1><span class="fa fa-lock"></span> Social Authentication</h1>\n <p>Login or Register with:</p>\n <a href="/auth/twitter" class="btn btn-danger"><span class="fa fa-twitter"></span> SignIn with Twitter</a>\n </div>\n</div>\n</body>\n</html> Step 3 Add the following code in success.html for creating ProfileUI:
\n<!doctype html>\n<html>\n <head>\n <title>Twitter SignIn</title>\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bulma css -->\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n <style>\n body { padding-top:70px; }\n </style>\n </head>\n <body>\n <div class="container">\n <div class="jumbotron">\n <h1 class="text-success text-center"><span class="fa fa-user"></span> Profile Information</h1>\n <div class="row">\n <div class="col-sm-6">\n <div class="well">\n <p>\n <strong>Id</strong>: {{.UserID}}<br>\n <strong>Email</strong>: {{.Email}}<br>\n <strong>Name</strong>: {{.Name}}\n </p>\n </div>\n </div>\n </div>\n </div>\n </div>\n </body>\n</html>Step 4. Add the following code in main.go for importing Goth and other packages :
\nimport (\n "fmt"\n "html/template"\n "log"\n "net/http"\n "sort"\n\n "github.com/gorilla/pat"\n "github.com/markbates/goth"\n "github.com/markbates/goth/gothic"\n "github.com/markbates/goth/providers/twitter"\n)Now we are ready to implement Twitter Authentication in our app
\nStep 5. Setup the twitter configuration by adding the following code in main.go :
\ngoth.UseProviders(\n twitter.New("TWITTER_KEY", "TWITTER_SECRET", "http://127.0.0.1:3000/auth/twitter/callback"),\n\n )Step 6. For adding all routes and functionality you just need to add following code in main.go :
\n type ProviderIndex struct {\n Providers[] string\n ProvidersMap map[string] string\n }\n\n func main() {\n goth.UseProviders(\n twitter.New("TWITTER_KEY", "TWITTER_SECRET", "http://127.0.0.1:3000/auth/twitter/callback"),\n // If you'd like to use authenticate instead of authorize in Twitter provider, use this instead.\n // twitter.NewAuthenticate(os.Getenv("TWITTER_KEY"), os.Getenv("TWITTER_SECRET"), "http://localhost:3000/auth/twitter/callback"),\n )\n\n m: = make(map[string] string)\n m["twitter"] = "Twitter"\n\n var keys[] string\n for k: = range m {\n keys = append(keys, k)\n }\n sort.Strings(keys)\n\n providerIndex: = & ProviderIndex {\n Providers: keys,\n ProvidersMap: m\n }\n\n p: = pat.New()\n p.Get("/auth/{provider}/callback", func(res http.ResponseWriter, req * http.Request) {\n\n user, err: = gothic.CompleteUserAuth(res, req)\n if err != nil {\n fmt.Fprintln(res, err)\n return\n }\n t, _: = template.ParseFiles("templates/success.html")\n t.Execute(res, user)\n })\n\n p.Get("/logout/{provider}", func(res http.ResponseWriter, req * http.Request) {\n gothic.Logout(res, req)\n res.Header().Set("Location", "/")\n res.WriteHeader(http.StatusTemporaryRedirect)\n })\n\n p.Get("/auth/{provider}", func(res http.ResponseWriter, req * http.Request) {\n // try to get the user without re-authenticating\n if gothUser, err: = gothic.CompleteUserAuth(res, req);\n err == nil {\n t, _: = template.ParseFiles("templates/success.html")\n t.Execute(res, gothUser)\n } else {\n gothic.BeginAuthHandler(res, req)\n }\n })\n\n p.Get("/", func(res http.ResponseWriter, req * http.Request) {\n t, _: = template.ParseFiles("templates/index.html")\n t.Execute(res, providerIndex)\n })\n log.Println("listening on localhost:3000")\n log.Fatal(http.ListenAndServe(":3000", p))\n }Now you just need to run the project by using the following command and try logging by using the Twitter button.
\nStep 7. Run the project :
\n go run main.goStep 8. Visit the browser with the URL http://127.0.0.1:3000.
After login with our twitter credentials, it will redirect back to our application and on the success page, we can see the details of the logged-in user and can save this detail in the database for future use also.
\nAs we have seen it is fairly easy to build a twitter social authentication system with Go and Goth, You can found the complete code used in this tutorial on our Github Repo
\n","frontmatter":{"date":"June 15, 2020","updated_date":null,"description":null,"title":"Twitter authentication with Go Language and Goth","tags":["Go","SocialLogin","Oauth"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/128533caa8a4ba717d200f38198342e4/14b42/cover.jpg","srcSet":"/static/128533caa8a4ba717d200f38198342e4/f836f/cover.jpg 200w,\n/static/128533caa8a4ba717d200f38198342e4/2244e/cover.jpg 400w,\n/static/128533caa8a4ba717d200f38198342e4/14b42/cover.jpg 800w,\n/static/128533caa8a4ba717d200f38198342e4/47498/cover.jpg 1200w,\n/static/128533caa8a4ba717d200f38198342e4/0e329/cover.jpg 1600w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Ashish Sharma","github":"ashish8947","avatar":null}}}},{"node":{"excerpt":"In this blog, we’ll be implementing authentication via Google in a Go web application. For this, we’ll be using Goth - Multi-Provider…","fields":{"slug":"/engineering/google-authentication-with-golang-and-goth/"},"html":"In this blog, we’ll be implementing authentication via Google in a Go web application. For this, we’ll be using Goth - Multi-Provider Authentication Package for Go
\nThis tutorial assumes you have:
\nWe can create a client ID and client secret using its Google API Console. You need to follow below steps once you open Google API Console
\nhttp://localhost:3000/auth/google/callbackNote: If Google doesn't support http://localhost:3000, then use http://127.0.0.1:3000
First in an empty folder run the below command
\ngo mod init googleauthgo mod init creates a new go.mod file and automatically imports dependencies when you will run go program
Create a file main.go in the root folder of your app and add the following code:
\nA small description for packages used in below code
\npackage main\n\nimport (\n "fmt"\n "html/template"\n "net/http"\n \n\n "log"\n\n "github.com/gorilla/pat"\n "github.com/markbates/goth"\n "github.com/markbates/goth/gothic"\n "github.com/markbates/goth/providers/google"\n "github.com/gorilla/sessions"\n)\n\n\nfunc main() {\n \n key := "Secret-session-key" // Replace with your SESSION_SECRET or similar\n maxAge := 86400 * 30 // 30 days\n isProd := false // Set to true when serving over https\n\n store := sessions.NewCookieStore([]byte(key))\n store.MaxAge(maxAge)\n store.Options.Path = "/"\n store.Options.HttpOnly = true // HttpOnly should always be enabled\n store.Options.Secure = isProd\n\n gothic.Store = store\n\n goth.UseProviders(\n google.New("our-google-client-id", "our-google-client-secret", "http://localhost:3000/auth/google/callback", "email", "profile"),\n )\n\n p := pat.New()\n p.Get("/auth/{provider}/callback", func(res http.ResponseWriter, req *http.Request) {\n\n user, err := gothic.CompleteUserAuth(res, req)\n if err != nil {\n fmt.Fprintln(res, err)\n return\n }\n t, _ := template.ParseFiles("templates/success.html")\n t.Execute(res, user)\n })\n\n p.Get("/auth/{provider}", func(res http.ResponseWriter, req *http.Request) {\n gothic.BeginAuthHandler(res, req)\n })\n\n p.Get("/", func(res http.ResponseWriter, req *http.Request) {\n t, _ := template.ParseFiles("templates/index.html")\n t.Execute(res, false)\n })\n log.Println("listening on localhost:3000")\n log.Fatal(http.ListenAndServe(":3000", p))\n}Note: The callback URL in google.New should be the same as used in the google app configuration.
If it is hard to understand the code, Here is the description of all the routes used in the code mentioned above
\ngothic.BeginAuthHandler will redirect you to google authentication URLCreate an html file under path templates/index.html, it will render into a nice looking social login page:
\n<!-- templates/index.html -->\n<!doctype html>\n<html>\n<head>\n <title>Google SignIn</title>\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bulma css -->\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n <style>\n body { padding-top:70px; }\n </style>\n</head>\n<body>\n<div class="container">\n <div class="jumbotron text-center text-success">\n <h1><span class="fa fa-lock"></span> Social Authentication</h1>\n <p>Login or Register with:</p>\n <a href="/auth/google" class="btn btn-danger"><span class="fa fa-google"></span> SignIn with Google</a>\n </div>\n</div>\n</body>\n</html> After it we will create an Html file under path templates/success.html, it will be used to show the user profile information we will get after authenticated by google
\n<!-- templates/success.html -->\n<!doctype html>\n<html>\n <head>\n <title>Google SignIn</title>\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bulma css -->\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n <style>\n body { padding-top:70px; }\n </style>\n </head>\n <body>\n <div class="container">\n <div class="jumbotron">\n <h1 class="text-success text-center"><span class="fa fa-user"></span> Profile Information</h1>\n <div class="row">\n <div class="col-sm-6">\n <div class="well">\n <p>\n <strong>Id</strong>: {{.UserID}}<br>\n <strong>Email</strong>: {{.Email}}<br>\n <strong>Name</strong>: {{.Name}}\n </p>\n </div>\n </div>\n </div>\n </div>\n </div>\n </body>\n</html>Note: Here we are also using bootstrap and font-awesome css to make our web pages look good.
\nWe have finished building our social login page, let's run the application by below command
\ngo run main.goOnce our server is running, we can see our social login page on http://localhost:3000/
We need to click on SignIn with Google button, which will redirect us to the google login page.
\nAfter login with our google credentials, it will redirect back to our application and on the success page, we can see the details of the logged-in user and can save this detail in a database for future use also.
\nProvide basic details about your app:
\nApp logo
\nauth tab in the navigation bar as shown below. You can now copy your secret and ID from here mkdir Linkedin-node-authenticationLinkedin-node-authentication/ cd Linkedin-node-authenticationpackage.json and copy the following code The dependencies, we are going to use in the projects are
\nexpress : Node web frameworkexpress-session Session managment of expresspassport Authentication middleware for Node.js passport-linkedin-oauth2 A simple passport strategy for LinkedIn OAuth2 passport linkedin oauth2ejs - Templating engine{\n "name": "linkedin-login-node",\n "version": "1.0.0",\n "description": "Basic application for setting up Linkedin login using node and passport",\n "main": "index.js",\n "scripts": {\n "test": "echo \\"Error: no test specified\\" && exit 1",\n "start": "node server.js"\n },\n "author": "LoginRadius",\n "license": "ISC",\n "dependencies": {\n "ejs": "^3.1.2",\n "express": "^4.17.1",\n "express-session": "^1.17.1",\n "passport": "^0.4.1",\n "passport-linkedin-oauth2": "^2.0.0"\n }\n}After this run the following command in the terminal
\nnpm installserver.js and paste the following code const express = require('express');\nconst app = express();\nconst session = require('express-session');\nconst passport = require('passport');\nconst LinkedInStrategy = require('passport-linkedin-oauth2').Strategy;\nconst routes = require('./routes.js');\nconst config = require('./config')\n\napp.set('view engine', 'ejs');\n\napp.use(session({\n resave: false,\n saveUninitialized: true,\n secret: 'SECRET'\n}));\n\napp.use(passport.initialize());\napp.use(passport.session());\n\npassport.serializeUser(function (user, cb) {\n cb(null, user);\n});\n\npassport.deserializeUser(function (obj, cb) {\n cb(null, obj);\n});\n\npassport.use(new LinkedInStrategy({\n clientID: config.linkedinAuth.clientID,\n clientSecret: config.linkedinAuth.clientSecret,\n callbackURL: config.linkedinAuth.callbackURL,\n scope: ['r_emailaddress', 'r_liteprofile'],\n}, function (token, tokenSecret, profile, done) {\n return done(null, profile);\n}\n));\n\napp.use('/', routes);\n\nconst port = 3000;\n\napp.listen(port, () => {\n console.log('App listening on port ' + port);\n});routes.js in the root directory and paste the following code const passport = require('passport');\nconst express = require('express');\nvar router = express.Router();\n\nrouter.get('/', function (req, res) {\n res.render('pages/index.ejs'); // load the index.ejs file\n});\n\nrouter.get('/profile', isLoggedIn, function (req, res) {\n res.render('pages/profile.ejs', {\n user: req.user // get the user out of session and pass to template\n });\n});\n\nrouter.get('/auth/linkedin', passport.authenticate('linkedin', {\n scope: ['r_emailaddress', 'r_liteprofile'],\n}));\n\nrouter.get('/auth/linkedin/callback',\n passport.authenticate('linkedin', {\n successRedirect: '/profile',\n failureRedirect: '/login'\n }));\n\nrouter.get('/logout', function (req, res) {\n req.logout();\n res.redirect('/');\n});\n\n\nfunction isLoggedIn(req, res, next) {\n if (req.isAuthenticated())\n return next();\n res.redirect('/');\n}\n\nmodule.exports = router;views and under this create a directory named pages. Under this folder create two pages named profile.ejs and index.ejs// index.ejs\n<!doctype html>\n<html>\n\n<head>\n <title>Linkedin Node Authentication</title>\n <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">\n <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">\n <link rel="stylesheet" type="text/css"\n href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.97.5/css/materialize.min.css">\n <style>\n .linkedin {\n background-color: #0073b1 !important;\n color: #fff !important;\n }\n .fa-linkedin-f:before,\n .fa-linkedin:before {\n content: "\\f0e1";\n }\n </style>\n</head>\n\n<body>\n <nav class="light-blue lighten-1" role="navigation">\n <div class="nav-wrapper container">\n <a id="logo-container" href="#" class="brand-logo">Node Authentication</a>\n </div>\n </nav>\n <div class="section no-pad-bot" id="index-banner">\n <div class="container">\n <br><br>\n <div class="row center">\n <div class="col s6 offset-s3">\n <div class="card">\n <div class="card-content">\n <span class="card-title">Linkedin Login using Node and passport</span>\n </div>\n <div class="card-action">\n <a href="/auth/linkedin" class="waves-effect waves-light btn social linkedin">\n <i class="fa fa-linkedin"></i> Sign in with Linkedin\n </a>\n </div>\n </div>\n </div>\n </div>\n </div>\n </div>\n</body>\n\n</html><!- profile.ejs->\n<!doctype html>\n<html>\n\n<head> \n <title>LinkedIn Node Authentication</title>\n <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">\n <link rel="stylesheet" type="text/css"\n href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.97.5/css/materialize.min.css">\n <style>\n .card:hover {\n box-shadow: 0 10px 20px rgba(0, 0, 0, 0.19), 0 6px 6px rgba(0, 0, 0, 0.23);\n margin-bottom: 54px;\n }\n </style>\n</head>\n\n<body>\n <nav class="light-blue lighten-1" role="navigation">\n <div class="nav-wrapper container">\n <a id="logo-container" href="#" class="brand-logo">Node Authentication</a>\n <a href="/logout" class="right">Logout</a>\n </div>\n </nav>\n <div class="section no-pad-bot" id="index-banner">\n <div class="container">\n <br><br>\n <div class="row center">\n <div class="col s12">\n <div class="card">\n <div class="card-content blue lighten-3">\n <span class="card-title white-text"><strong><i class="large material-icons">person</i>\n </strong></span>\n </div>\n <div class="card-action">\n <h5><b><%= user.displayName %></b></h5>\n <p><strong>Linkedin id</strong>: <%= user.id %></p>\n </div>\n </div>\n </div>\n </div>\n </div>\n </div>\n</body>\n\n</html>config.js file created in the root directory module.exports = {\n 'linkedinAuth': {\n 'clientID': '<CLIENT_ID>', // your App ID\n 'clientSecret': '<CLIENT_SECRET>', // your App Secret\n 'callbackURL': 'http://127.0.0.1:3000/auth/linkedin/callback'\n }\n}// Final directory structure\nLinkedin-node-authentication/\n --|node_modules\n --|views/\n |--|pages/\n |----|error.ejs\n |----|profile.ejs\n |----|index.ejs\n --|config.js\n --|package.json\n --|package-lock.json\n --|routes.js\n --|server.jsLinkedin-node-authentication/npm starthttp://localhost:3000
Click on the sign in button, and you will be asked to login through Linkedin. Once logged in you will be redirected to profile page as below:
\n
First, add a file called quotes.txt in the folder you want to run the Deno code, We will read these quotes with the help of Deno
\nDon't worry about what anybody else is going to do. The best way to predict the future is to invent it. - Alan Kay\nPremature optimization is the root of all evil in programming. - Donald Knuth\nClarity and brevity sometimes are at odds. When they are, I choose clarity. - Jacob Kaplan-Moss\nOptimism is an occupational hazard of programming; feedback is the treatment. - Kent Beck\nA lot of times, people don't know what they want until you show it to them. - Steve Jobs\nNine people can't make a baby in a month. - Fred Brooks\nA clever person solves a problem. A wise person avoids it. - Albert EinsteinAnd then create an index.ts file in which we will write Deno code, we can also write Deno code in javascript instead of Typescript, but as Deno is built on TypeScript we are using Typescript here
\nconst getQuotes = async (fileName: string): Promise<Array<string>> => {\n const decoder = new TextDecoder("utf-8");\n\n const text: string = decoder.decode(await Deno.readFile(fileName));\n return text.split("\\n");\n};\n\nconst quotesArr: Array<string> = await getQuotes("quotes.txt");\n\nconst randomQuote: string = quotesArr[Math.floor(Math.random() * quotesArr.length)];\nconsole.log(randomQuote);In the getQuotes function, we are using Deno.readFile #readfile to read the contents of a file as an array of bytes and using TextDecoder to convert the bytes to string and then splitting it in a string array and return
Then we are just picking a randomQuote with Math.random and console.log that on our screen
To run the above code we need to put --allow-read flag in our command as shown below because we need to access the local filesystem to read the file.
deno run --allow-read index.tsDeno is secure by default, with no file, network, or environment access unless explicitly enabled. You can run deno run --help to see all the available flags for different permissions
Once your program run initially you will see that Deno is compiling the index.ts file and printing a random quote from quotes.txt, if you run the programme again without changing the code it will not compile it again and will just show another random quote.
\ndeno run --allow-read index.ts\nCompile file:///C:/Users/PuneetSingh/Documents/deno_fs/index.ts\nPremature optimization is the root of all evil in programming. - Donald Knuth\n\n\ndeno run --allow-read index.ts\nA lot of times, people don't know what they want until you show it to them. - Steve JobsLet's create another TypeScript file write.ts and put the below code in it
\nimport { readLines } from "https://deno.land/std@v0.52.0/io/bufio.ts";\n\nconsole.log('Start typing...');\n\nconst encoder = new TextEncoder();\nawait Deno.writeFile("input.txt", new Uint8Array());\n\n// Listen to stdin input by readLines\nfor await(const line of readLines(Deno.stdin)) {\n const data = encoder.encode(line+"\\n");\n await Deno.writeFile("input.txt", data, {append: true});\n console.log("Wrote the above text in input.txt\\n") \n}In the above code we are using readLines to raed user input line by line, Every time we run the code Deno.writeFile(\"input.txt\", new Uint8Array()) will create an empty input.txt file in the folder.
Then const line of readLines(Deno.stdin) in a loop will wait for the user to input any text, as we will give any input Deno.writeFile with {append: true} is used to append data in input.txt
Let's run the program, Once we run it, whatever text we will give to the program through standard input will be written to input.txt
\ndeno run --allow-write write.ts\n\nStart typing...\nThis is a demo for Deno\nWrote the above text in input.txt\n\nIn this demo, we will write some text in a file\nWrote the above text in input.txtIf you check the input.txt file you will found the content which was given as input
\nThis is a demo for Deno\nIn this demo, we will write some text in a fileNow you know how to read from a text file and how to write in a text file with Deno, You can found the complete source code used in the above blog on our Github Repo
\n","frontmatter":{"date":"June 09, 2020","updated_date":null,"description":null,"title":"Read and Write in a local file with Deno","tags":["Deno"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.6666666666666667,"src":"/static/051c3d60bd1877dbdbc0c04965cdc4db/2a4de/deno_file_system.png","srcSet":"/static/051c3d60bd1877dbdbc0c04965cdc4db/69585/deno_file_system.png 200w,\n/static/051c3d60bd1877dbdbc0c04965cdc4db/497c6/deno_file_system.png 400w,\n/static/051c3d60bd1877dbdbc0c04965cdc4db/2a4de/deno_file_system.png 600w","sizes":"(max-width: 600px) 100vw, 600px"}}},"author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null}}}}]},"markdownRemark":{"excerpt":"Google has prepared a roadmap to restrict third-party cookies in Chrome. Since 04 January 2024, Chrome has rolled out third-party cookie…","fields":{"slug":"/engineering/identity-impact-of-google-chrome-thirdparty-cookie-restrictions/"},"html":"Google has prepared a roadmap to restrict third-party cookies in Chrome. Since 04 January 2024, Chrome has rolled out third-party cookie restrictions for 1% of stable clients and 20% of Canary, Dev, and Beta clients.
\nWhat does it mean for user authentication?
\nOn one hand, Google believes third-party cookies are widely used for cross-site tracking, greatly affecting user privacy. Hence, Google wants to phase out (or restrict) supporting third-party cookies in Chrome by early Q2 2025 (subject to regulatory processes).
\nOn the other hand, Google introduced Privacy Sandbox to support the use cases (other than cross-site tracking and advertising) previously implemented using third-party cookies.
\nIn this article, we’ll discuss:
\nThird-party cookie restrictions affect user authentication in three ways, as follows.
\nIf your website or app uses an external Identity Provider (IdP) — like LoginRadius, the IdP sets a third-party cookie when the user authenticates on your app.
\nIf you have multiple apps across domains within your organization and authentication is handled using an IdP (internal or external) with web SSO, you already use third-party cookies to facilitate seamless access for each user using a single set of credentials.
\nIf you have implemented web SSO with one primary domain and multiple sub-domains of the primary domain, third-party cookie restrictions may not apply. For now, Google doesn’t consider the cookies set by sub-domains as third-party cookies, although this stance may change in the future.
\nFor example, you have apps at example.com, travel.example.com, stay.example.com, and web SSO is handled by auth.example.com. In this case, third-party cookie restrictions don’t apply.
Federated SSO is similar to, albeit different from, web SSO. It can handle multiple IdPs and applications—aka., Service Providers (SPs)—spanning multiple organizations. It can also implement authentication scenarios that are usually implemented through web SSO.
\nUsually, authentication is handled on a separate pop-up or page when the user wants to authenticate rather than on the application or website a user visits.
\nFor example, you already use federated SSO if you facilitate authentication for a set of apps through multiple social identity providers as well as traditional usernames and passwords.
\n\n\nNote: It is also possible to store tokens locally, not within cookies. In this case, third-party cookie restrictions won’t affect token-based authentication. However, the restrictions still affect authentication where tokens are stored within third-party cookies (a common and secure method).
\n
Google has been developing alternative features and capabilities for Chrome to replace third-party cookies as part of its Privacy Sandbox for Web initiative.
\nSpecific to authentication, Google recommends the following:
\nCHIPS are a restricted way of setting third-party cookies on a top-level site without making them accessible on other top-level sites. Thus, they limit cross-site tracking and enable specific cross-site functionalities, such as maps, chat, and payment embeds.
\nFor example, a user visits a.com with a map embed from map-example.com, which can set a partitioned cookie that is only accessible on a.com.
If the user visits b.com with a map embed from map-example.com, it cannot access the partitioned cookie set on a.com. It has to create a separate partitioned cookie specific to b.com, thus blocking cross-site tracking yet allowing limited cross-site functionality.
You should specifically opt for partitioned cookies (CHIPS), which are set with partitioned and secure cookie attributes.
\nIf you’re using an external identity provider for your application, CHIPS is a good option to supplant third-party cookie restrictions.
\nHowever, CHIPS may not be ideal if you have a web SSO or federated SSO implementation. It creates separate partitioned cookies for each application with a separate domain, which can increase complexity and create compatibility issues.
\nWith Storage Access API, you can access the local storage in a third-party context through iframes, similar to when users visit it as a top-level site in a first-party context. That is, it gives access to unpartitioned cookies and storage.
\nStorage Access API requires explicit user approval to grant access, similar to locations, camera, and microphone permissions. If the user denies access, unpartitioned cookies and storage won’t be accessible in a third-party context.
\nIt is most suitable when loading cross-site resources and interactions, such as:
\nVerifying user sessions when allowing interactions on an embedded social post or providing personalization for an embedded video.\nEmbedded documents requiring user verification status to be accessible.
\nAs it requires explicit user approval, it is advisable to use Storage Access API when you can’t implement an identity use case with the other options.
\nWith Related Website Sets, you can declare a primary website and associatedSites for limited purposes to grant third-party cookie access and local storage for a limited number of sites.
Chrome automatically recognizes related website sets declared, accepted, and maintained in this open-source GitHub repository: Related Website Sets
\nIt provides access through Storage Access API directly without prompting for user approval, but only after the user interacts with the relevant iframe.
\nIt is important to declare a limited number of domains in related website sets that are meaningful and used for specific purposes. Google may block or suspend any exploitative use of this feature.
\nThe top-level site can also request approval for specific cross-site resources and scripts to Storage Access API using resuestStorageAccessFor() API.
If you’re using an external identity provider for your web application, you can declare the domain of the identity provider in the related set to ensure limited third-party cookies and storage access to the identity provider, thus ensuring seamless user authentication.
\nRelated Website Sets can also work to supplement third-party cookie restrictions in web SSO and federated SSO if the number of web applications (or domains) is limited.
\nFedCM API enables federated SSO without third-party cookies.
\nWith FedCM API, a user follows these steps for authentication:
\nYou can access a user demo of FedCM here: FedCM.
\nFor more information about implementing federated SSO with FedCM API, go through the FedCM developer guide.
\nFirstly, we’re committed to solving our customers' user identity pain points — and preparing for the third-party cookies phase-out is no different.
\nWe’ll implement the most relevant and widely useful solutions to facilitate a smooth transition for our customers.
\nPlease subscribe to our blog for more information. We’ll update you on how we help with the third-party cookie phase-out.
\nThe proposed changes to phase out third-party cookies and suggested alternatives are evolving as Google has been actively collaborating and discussing changes with the border community.
\nMoreover, browsers like Firefox, Safari, and Edge may approach restricting third-party cookies differently than Google does.
\nFrom LoginRadius, we’ll keep you updated on what we’re doing as a leading Customer Identity and Access Management (CIAM) vendor to prepare for the third-party cookie phase-out.
\nTop-level site: It is the primary site a user has visited.
\nFirst-party cookie: A cookie set by the top-level site.
\nThird-party cookie: A cookie set by a domain other than the top-level site. For example, let’s assume that a user has visited a.com, which might use an embed from loginradius.com to facilitate authentication. If loginradius.com sets a cookie when the user visits a.com, it is called a third-party cookie as the user hasn’t directly visited loginradius.com.