Validatie, authenticatie en autorisatie

Validatie, authenticatie en autorisatie

INTRODUCTIE

Installatie

Installeer bcrypt

npm install bcrypt

Installeer cookie-parser

npm install cookie-parser

Installeer express-validator

npm install express-validator

Installeer jsonwebtoken

npm install jsonwebtoken

Voorbereiding

  • Om cookies te kunnen lezen, hebben we de cookieParser nodig. Update je app.js.
app.use(cookieParser());
  • Vergeet niet om de body-parser te importeren
import cookieParser from "cookie-parser";

Voorbereiding

  • We hebben 3 pagina's in de startcode: home, register & login.

Validatie, authenticatie en autorisatie

MIDDLEWARE

Middleware functions are functions that have access to the request object ( req ), the response object ( res ), and the next function in the application's request-response cycle. The next function is a function in the Express router which, when invoked, executes the middleware succeeding the current middleware.

Middleware

Middleware

  • Eerder gebruikte middleware is o.a. bodyparser

request

response

body-parser

bodyparser kan o.a. de data die wordt meegegeven vanaf de client omzetten naar json.

Middleware

  • In deze les gebruiken we de cookie-parser en schrijven we eigen schakels in de middleware ketting.

Validatie, authenticatie en autorisatie

VALIDATIE

Validatie is het controleren van een waarde of een methode op geldigheid of juistheid. Meestal wordt deze werkwijze gebruikt bij het versturen van data met behulp van een formulier.

Validatie

  • Om er voor te zorgen dat de data die vanaf de client wordt verstuurd hetgeen is wat we verwachten, gebruiken we express-validator.
  • Voeg een post method toe om te registreren, aan te melden en af te melden in app.js.
app.post('/register', postRegister);
app.post('/login', postLogin);
app.post('/logout', logout);

Validatie

  • postRegister, postLogin en logout zijn controllers die we plaatsen in controllers/authentication.js.
  • Maak naast de bestaande functies ook deze functies aan.

express-validator

  • Om express validator te kunnen gebruiken, zullen we vlak vooraleer we de data doorgeven naar ons post-functie deze laten controleren door express-validator via middleware.

request

response

express-

validation

postRegister

register controller

express-validator

  • De express-validator middleware zal errors toevoegen aan de request van de client wanneer de body niet voldoet aan criteria.
  • Er is tal van ingebouwde criteria van express-validator.
  • Stel, je hebt in je body een email adres dat je wil valideren. Je gebruikt de ingebouwde validator als volgt:
body('email').isEmail()

express-validator

  • Wil je hier een gebruiksvriendelijke foutmelding aan toevoegen, dan gebruik je withMessage 
body('email')
  .isEmail()
  .withMessage('Onjuist e-mail adres');
  • Wil je controleren of je e-mail wel is ingevuld én of het ingevulde effectief een e-mail adres is, dan maak je nieuwe schakels in de ketting.
body('email')
  .notEmpty()
  .withMessage('E-mail is een verplicht veld.')
  .isEmail()
  .withMessage('Onjuist e-mail adres'),

express-validator

  • In bovenstaand voorbeeld zal de foutmelding de laatste boodschap zijn (Onjuist e-mail adres) TENZIJ je de ketting stopt met de bail functie.
body('email')
  .notEmpty()
  .withMessage('E-mail is een verplicht veld.')
  .bail()
  .isEmail()
  .withMessage('Onjuist e-mail adres'),

Authenticatie Validatie

  • We gaan extra middleware toevoegen met een array aan validatie die gebruikt wordt om de authenticatie-body te kunnen valideren. Ofwel, valideren of het e-mail adres en wachtwoord correct is.
  • Maak een folder middleware aan, met daarbinnen een folder validation en de file authentication.js

Authenticatie Validatie

  • Telkens wanneer we aanmelden of registeren, willen we de data controleren. Vul authentication.js aan met meerdere validators. 
import { body } from 'express-validator';

export default [
  body('email')
    .notEmpty()
    .withMessage('E-mail is een verplicht veld.')
    .bail()
    .isEmail()
    .withMessage('Onjuist e-mail adres'),
  body('password')
    .isLength({ min: 6 })
    .withMessage('Wachtwoord moet bestaan uit minstens zes tekens.'),
]

Authenticatie Validatie

  • Voeg nu de validators middleware(s) toe vlak voor we de controller postRegister ingaan.
app.post('/register', ...validationAuthentication, postRegister);
app.post('/login', ...validationAuthentication, postLogin);
  • Let op: zorg dat je de validationAuthentication ook importeert in app.js

postRegister

  • Eenmaal aangekomen in de postRegister controller kunnen we het resultaat van de validatie opvragen.
export const postRegister = async (req, res, next) => {
  try {
    const errors = validationResult(req);

    // if we have validation errors
    if (!errors.isEmpty()) {
      console.log("We\'ve got some errors, dude...");
    }
    
  } catch(e) {
    next(e.message);
  }
}

postRegister

  • Er zijn nu twee opties
    • De validatie loopt fout, dan moeten we opnieuw de de registratie pagina tonen via next()
    • De validatie loopt goed, dan registreren we de gebruiker en navigeren we naar de login-pagina
  • In het eerste geval gaan moeten we dus nog een extra schakel in de middleware toevoegen:
app.post('/register', ...validationAuthentication, postRegister, register);
app.post('/login', ...validationAuthentication, postLogin, login);

postRegister

  • We parsen de fouten en geven de foutmeldingen per input veld door naar de register route via de next() functie. 
// if we have validation errors
if (!errors.isEmpty()) {
  // errors on a field
  req.formErrorFields = {};
  errors.array().forEach(({ msg, param }) => { 
    req.formErrorFields[param] = msg 
  });

  // we have errors, so re-render the registration page
  return next();
}

contact

export const register = async (req, res) => {
  // do we have errors?
  const formErrors = [];

  // input fields
  const inputs = [{
    name: 'email',
    label: 'E-mail',
    type: 'text',
    value: req.body?.email ? req.body.email : '',
    error: req.formErrorFields?.email ? req.formErrorFields['email'] : ''
  }, {
    name: 'password',
    label: 'Password',
    type: 'password',
    value: req.body?.password ? req.body.password : '',
    error: req.formErrorFields?.password ? req.formErrorFields['password'] : ''
  }]

  // render the register page
  res.render('register', {
    layout: 'authentication',
    inputs,
    formErrors,
  });
}

postRegister

  • Zijn alle velden correct, dan valideren we ook of de gebruiker al dan niet al bestaat.
[...]
else {
  // get the user repository
  const userRepository = getConnection().getRepository('User');

  // get a user with a specific e-mail address
  const user = await userRepository.findOne({ where: { email: req.body.email } });

  // validate if the user already exists
  if(user) {
    req.formErrors = [{ message: "Gebruiker bestaat al." }];
    return next();
  }

  // hash the password
  const hashedPassword = bcrypt.hashSync(req.body.password, 12);

  // create a new user
  await userRepository.save({ email: req.body.email, password: hashedPassword });

  // go to login page
  res.redirect('/login');
}
[...]

postRegister

  • We gebruiken ook de bcrypt bibliotheek om het ingevoerde wachtwoord te encrypteren.

Oefening

  • Zorg er nu voor dat ook je login formulier wordt voorzien van validatie door je login en postLogin controller verder aan te vullen.
  • Controleer of de gebruiker bestaat.

Validatie, authenticatie en autorisatie

AUTHENTICATIE

Authenticatie is het proces waarbij iemand nagaat of een gebruiker, een andere computer of applicatie daadwerkelijk is wie hij beweert te zijn.

JWT

  • Om ervoor te zorgen dat een user de homepagina te zien krijgt op voorwaarde dat deze is ingelogd, gebruiken we een zogenaamd JSON Web Token ofwel JWT.

Client
Aanmelden

Server
JWT

JWT

  • Een token wordt bewaard op de client als een http-only cookie, dat betekent dat ze niet door javascript kan worden onderschept (en dus ook niet door malafide scripts).
  • Bij elke request wordt de token verstuurd naar de server en kan de server er van uitgaan dat een gebruiker correct is aangemeld.

JWT

  • We maken een token met de jsonwebtoken module.
 // create the webtoken
const token = jwt.sign(
  { userId: user.id, email: user.email },
  process.env.TOKEN_SALT,
  { expiresIn: '1h' }
);

// add token to cookie in response
res.cookie('token', token, { httpOnly: true });

// redirect to home page
res.redirect('/');
  • We hebben salt nodig om er zeker van te zijn dat onze token moeilijker te kraken is.

jwtAuth middleware

  • We schrijven een nieuwe middleware functie die we plaatsen vooraleer we de controller aanspreken.

 

  • Maak een nieuwe file in de middleware folder, jwtAuth.js.
import jwt from 'jsonwebtoken';

export const jwtAuth = (req, res, next) => {
  const token = req.cookies.token;
  try {
    const user = jwt.verify(token, process.env.TOKEN_SALT);
    req.user = user;
    next();
  } catch(e) {
    res.clearCookie('token');
    return res.redirect('/login');
  }
}
app.get('/', jwtAuth, home);

jwtAuth middleware

  • We controleren of we correct zijn aangemeld
    • jwt.verify()
  • Zijn we correct aangemeld, dan kunnen we door naar de volgende schakel in de middleware ketting met next().
  • Indien de token expired is, dan komen we terecht in de catch blok.
    • We verwijderen de token op de client
    • We navigeren terug naar de login pagina

Validatie, authenticatie en autorisatie

AUTORISATIE

Autorisatie in de informatica is het proces waarmee een gebruiker rechten krijgt op het benaderen van een object. Je krijgt toegang via autorisatie, wat je mag bekijken of aanpassen hangt af van de rollen die de gebruiker kreeg.

Oefening

In deze oefening breid je je applicatie uit tot een forum achtige landingspagina met slecht één message board. Een gebruiker kan al dan niet berichten toevoegen of verwijderen naargelang de rol die hij/zij/hen heeft verkregen.

  • Je maakt een entity Message aan. Deze omvat
    • Een primary key: id
    • Tekst: text
    • De User ID, een één-op-één relatie met de User-entity: userId

Oefening

  • Je implementeert drie rollen:
    • admin: kan berichten maken én verwijderen
    • editor: kan berichten maken
    • reader: kan enkel berichten raadplegen
  • Een ingelogde user heeft één van de drie rollen
  • Maak een entity Role. Deze omvat:
    • Een primary key: id
    • Een label (admin, editor of reader): label
  • Breid User uit met een roleId, een één-op-één relatie met Role.

Oefening

  • Je breidt je jwtAuth middleware uit zodat je naast de userId en e-mail ook doorgeeft welke rol de aangemelde user heeft.
  • Vang de rol op in je home controller en render énkel hetgeen uit wat de ingelogde user mag zien, conform zijn/haar/hun rol.
    • Gebruik hiervoor Handlebars, schrijf eventueel een custom block helper.
  • Controleer bij elke POST/GET/PUT of de gebruiker toegang heeft om de HTTP method uit te voeren, indien niet, geef je de respectievelijke HTTP error code terug:
    • Bijv. 401: Niet geautoriseerd
    • Controleer deze lijst op specifiekere error codes.

Validatie, authenticatie & autorisatie

By timdpaep

Made with Slides.com

Validatie, authenticatie & autorisatie

  • 420

More from timdpaep