Автентифікація та авторизація

введений пароль → bcrypt.compare() → результат true або false

Authorization: Bearer <token>

npm init -y
npm install express bcryptjs jsonwebtoken

const express = require("express");
const bcrypt = require("bcryptjs");
const jwt = require("jsonwebtoken");

const app = express();
app.use(express.json());

const port = 3000;
const jwtSecret = process.env.JWT_SECRET;

if (!jwtSecret) {
  throw new Error("Задайте змінну середовища JWT_SECRET");
}

// У реальному застосунку користувачі зберігаються в базі даних.
let users = [];

function createToken(user) {
  return jwt.sign(
    {
      sub: user.id
    },
    jwtSecret,
    {
      expiresIn: "15m"
    }
  );
}

async function authenticate(req, res, next) {
  const authorization = req.headers.authorization;

  if (!authorization || !authorization.startsWith("Bearer ")) {
    return res.status(401).json({
      error: "Потрібен токен доступу"
    });
  }

  const token = authorization.slice("Bearer ".length);

  try {
    const payload = jwt.verify(token, jwtSecret);
    const user = users.find((item) => item.id === payload.sub);

    if (!user) {
      return res.status(401).json({
        error: "Користувача не знайдено"
      });
    }

    const { passwordHash, ...safeUser } = user;

    // Зберігаємо автентифікованого користувача для наступних middleware.
    req.user = safeUser;
    next();
  } catch (error) {
    return res.status(401).json({
      error: "Недійсний або прострочений токен"
    });
  }
}

function authorize({ roles = [], permissions = [] } = {}) {
  return (req, res, next) => {
    const user = req.user;

    const hasRequiredRole =
      roles.length === 0 ||
      roles.some((role) => user.roles.includes(role));

    const hasRequiredPermissions = permissions.every((permission) =>
      user.permissions.includes(permission)
    );

    if (!hasRequiredRole || !hasRequiredPermissions) {
      return res.status(403).json({
        error: "Недостатньо прав для виконання операції"
      });
    }

    next();
  };
}

app.post("/login", async (req, res) => {
  const { email, password } = req.body;

  if (typeof email !== "string" || typeof password !== "string") {
    return res.status(400).json({
      error: "Email і пароль є обов'язковими"
    });
  }

  const user = users.find((item) => item.email === email);

  // Не повідомляємо, чи існує такий email.
  if (!user || !(await bcrypt.compare(password, user.passwordHash))) {
    return res.status(401).json({
      error: "Невірний email або пароль"
    });
  }

  const token = createToken(user);

  res.json({
    token,
    user: {
      id: user.id,
      email: user.email,
      roles: user.roles,
      permissions: user.permissions
    }
  });
});

app.get("/profile", authenticate, (req, res) => {
  res.json({
    user: req.user
  });
});

app.get(
  "/articles",
  authenticate,
  authorize({ permissions: ["articles:read"] }),
  (req, res) => {
    res.json({
      articles: [
        { id: 1, title: "Вступ до Node.js" },
        { id: 2, title: "Middleware в Express" }
      ]
    });
  }
);

app.post(
  "/articles",
  authenticate,
  authorize({ permissions: ["articles:create"] }),
  (req, res) => {
    res.status(201).json({
      message: "Статтю створено",
      title: req.body.title
    });
  }
);

app.get(
  "/admin/users",
  authenticate,
  authorize({ roles: ["admin"] }),
  (req, res) => {
    res.json({
      users: users.map(({ passwordHash, ...user }) => user)
    });
  }
);

async function start() {
  users = [
    {
      id: "user-1",
      email: "user@example.com",
      passwordHash: await bcrypt.hash("user-password", 12),
      roles: ["user"],
      permissions: ["articles:read"]
    },
    {
      id: "editor-1",
      email: "editor@example.com",
      passwordHash: await bcrypt.hash("editor-password", 12),
      roles: ["editor"],
      permissions: ["articles:read", "articles:create"]
    },
    {
      id: "admin-1",
      email: "admin@example.com",
      passwordHash: await bcrypt.hash("admin-password", 12),
      roles: ["admin"],
      permissions: [
        "articles:read",
        "articles:create",
        "users:read"
      ]
    }
  ];

  app.listen(port, () => {
    console.log(`Сервер запущено на http://localhost:${port}`);
  });
}

start().catch((error) => {
  console.error("Не вдалося запустити сервер:", error);
  process.exit(1);
});

JWT_SECRET="дуже-довгий-випадковий-секрет" node server.js

$env:JWT_SECRET="дуже-довгий-випадковий-секрет"
node server.js

curl -X POST http://localhost:3000/login \
  -H "Content-Type: application/json" \
  -d '{"email":"editor@example.com","password":"editor-password"}'

{
  "token": "eyJ...",
  "user": {
    "id": "editor-1",
    "email": "editor@example.com",
    "roles": ["editor"],
    "permissions": ["articles:read", "articles:create"]
  }
}

curl http://localhost:3000/articles \
  -H "Authorization: Bearer eyJ..."

app.get(
  "/admin/users",
  authenticate,
  authorize({ roles: ["admin"] }),
  handler
);

authorize({
  permissions: ["articles:create"]
});

const hasRequiredPermissions = permissions.every((permission) =>
  user.permissions.includes(permission)
);

const hasAnyPermission =
  permissions.length === 0 ||
  permissions.some((permission) =>
    user.permissions.includes(permission)
  );

const jwtSecret = process.env.JWT_SECRET;

const { passwordHash, ...safeUser } = user;

expiresIn: "15m"

{
  "role": "admin"
}

app.get(
  "/admin/users",
  authenticate,
  authorize({ roles: ["admin"] }),
  handler
);

Невірний email або пароль