661 lines
23 KiB
JavaScript
661 lines
23 KiB
JavaScript
const express = require('express');
|
||
const router = express.Router();
|
||
const { ethers } = require('ethers');
|
||
const crypto = require('crypto');
|
||
const db = require('../db');
|
||
const logger = require('../utils/logger');
|
||
const helmet = require('helmet');
|
||
const rateLimit = require('express-rate-limit');
|
||
const { checkRole, requireAuth } = require('../middleware/auth');
|
||
const { pool } = require('../db');
|
||
const { verifySignature, checkAccess, findOrCreateUser } = require('../utils/auth');
|
||
const authService = require('../services/auth-service');
|
||
|
||
// Создайте лимитер для попыток аутентификации
|
||
const authLimiter = rateLimit({
|
||
windowMs: 15 * 60 * 1000, // 15 минут
|
||
max: 20, // Увеличьте лимит с 5 до 20
|
||
standardHeaders: true,
|
||
legacyHeaders: false,
|
||
message: { error: 'Слишком много попыток аутентификации. Попробуйте позже.' },
|
||
});
|
||
|
||
// Получение nonce для аутентификации
|
||
router.get('/nonce', async (req, res) => {
|
||
try {
|
||
const { address } = req.query;
|
||
if (!address) {
|
||
return res.status(400).json({ error: 'Address is required' });
|
||
}
|
||
|
||
// Генерируем случайный nonce
|
||
const nonce = crypto.randomBytes(16).toString('hex');
|
||
|
||
// Сохраняем nonce в сессии
|
||
req.session.authNonce = nonce;
|
||
req.session.pendingAddress = address;
|
||
|
||
// Важно: сохраняем сессию перед отправкой ответа
|
||
await new Promise((resolve, reject) => {
|
||
req.session.save(err => {
|
||
if (err) reject(err);
|
||
else resolve();
|
||
});
|
||
});
|
||
|
||
console.log('Сессия после генерации nonce:', req.session);
|
||
console.log('Сессия после сохранения:', req.session);
|
||
|
||
return res.json({ nonce });
|
||
} catch (error) {
|
||
console.error('Error generating nonce:', error);
|
||
return res.status(500).json({ error: 'Internal server error' });
|
||
}
|
||
});
|
||
|
||
// Функция для проверки роли пользователя
|
||
async function checkUserRole(address, req) {
|
||
try {
|
||
const lowerCaseAddress = address.toLowerCase();
|
||
|
||
// Проверяем наличие токена доступа в базе данных
|
||
const result = await db.query(
|
||
'SELECT role FROM access_tokens WHERE LOWER(wallet_address) = $1 AND expires_at > NOW()',
|
||
[lowerCaseAddress]
|
||
);
|
||
|
||
if (result.rows.length > 0) {
|
||
// Если есть активный токен, проверяем роль
|
||
const role = result.rows[0].role;
|
||
return role === 'ADMIN';
|
||
}
|
||
|
||
// Если нет токена, проверяем адрес администратора из переменных окружения
|
||
const adminAddresses = (process.env.ADMIN_ADDRESSES || '')
|
||
.split(',')
|
||
.map((a) => a.toLowerCase());
|
||
return adminAddresses.includes(lowerCaseAddress);
|
||
} catch (error) {
|
||
console.error('Ошибка при проверке роли пользователя:', error);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// Проверка подписи и аутентификация
|
||
router.post('/verify', async (req, res) => {
|
||
try {
|
||
const { address, signature, message } = req.body;
|
||
|
||
console.log('Verify request: address=' + address + ', signature=' + signature.substring(0, 10) + '...');
|
||
console.log('Session data: nonce=' + req.session.authNonce + ', pendingAddress=' + req.session.pendingAddress);
|
||
|
||
// Проверяем, что nonce и адрес совпадают с сохраненными в сессии
|
||
if (!req.session.authNonce || !req.session.pendingAddress || req.session.pendingAddress !== address) {
|
||
console.error(`Invalid session or address mismatch: nonce=${req.session.authNonce}, pendingAddress=${req.session.pendingAddress}, address=${address}`);
|
||
return res.status(401).json({ error: 'Invalid session or address mismatch' });
|
||
}
|
||
|
||
// Проверяем подпись
|
||
const isValid = await verifySignature(req.session.authNonce, signature, address);
|
||
console.log('Signature verification result:', isValid);
|
||
|
||
if (!isValid) {
|
||
return res.status(401).json({ error: 'Invalid signature' });
|
||
}
|
||
|
||
// Находим или создаем пользователя
|
||
console.log('Finding or creating user for address:', address);
|
||
const { userId, isAdmin } = await findOrCreateUser(address);
|
||
console.log('User found/created:', { userId, isAdmin });
|
||
|
||
// Очищаем nonce и pendingAddress из сессии
|
||
const nonce = req.session.authNonce;
|
||
req.session.authNonce = null;
|
||
req.session.pendingAddress = null;
|
||
|
||
// Устанавливаем пользователя в сессии
|
||
req.session.userId = userId;
|
||
req.session.address = address;
|
||
req.session.isAdmin = isAdmin;
|
||
req.session.authenticated = true;
|
||
|
||
// Сохраняем сессию
|
||
await new Promise((resolve, reject) => {
|
||
req.session.save(err => {
|
||
if (err) {
|
||
console.error('Error saving session:', err);
|
||
reject(err);
|
||
} else {
|
||
console.log('Session saved successfully');
|
||
resolve();
|
||
}
|
||
});
|
||
});
|
||
|
||
console.log('Authentication successful for user:', { userId, address, isAdmin });
|
||
|
||
return res.json({
|
||
authenticated: true,
|
||
userId,
|
||
address,
|
||
isAdmin,
|
||
authType: 'wallet'
|
||
});
|
||
} catch (error) {
|
||
console.error('Error verifying signature:', error);
|
||
return res.status(500).json({ error: 'Internal server error' });
|
||
}
|
||
});
|
||
|
||
// Аутентификация через Telegram
|
||
router.post('/telegram', async (req, res) => {
|
||
try {
|
||
const { telegramId, authData } = req.body;
|
||
|
||
// Здесь должна быть проверка данных от Telegram
|
||
|
||
// Получаем или создаем пользователя
|
||
let userId = await authService.getUserIdByIdentity('telegram', telegramId);
|
||
|
||
if (!userId) {
|
||
// Создаем нового пользователя
|
||
const userResult = await db.query(
|
||
'INSERT INTO users (created_at, role_id) VALUES (NOW(), (SELECT id FROM roles WHERE name = $1)) RETURNING id',
|
||
['user']
|
||
);
|
||
|
||
userId = userResult.rows[0].id;
|
||
|
||
// Добавляем идентификатор Telegram
|
||
await db.query(
|
||
'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
|
||
[userId, 'telegram', telegramId]
|
||
);
|
||
}
|
||
|
||
// Проверяем связанные аккаунты
|
||
const identities = await authService.getAllUserIdentities(userId);
|
||
|
||
// Если есть связанный кошелек, проверяем токены
|
||
if (identities.wallet) {
|
||
await authService.checkTokensAndUpdateRole(identities.wallet);
|
||
}
|
||
|
||
// Получаем текущую роль
|
||
const isAdmin = await authService.isAdmin(userId);
|
||
|
||
// Устанавливаем сессию
|
||
req.session.userId = userId;
|
||
req.session.telegramId = telegramId;
|
||
req.session.authType = 'telegram';
|
||
req.session.authenticated = true;
|
||
|
||
res.json({
|
||
authenticated: true,
|
||
userId,
|
||
isAdmin,
|
||
authType: 'telegram',
|
||
identities
|
||
});
|
||
} catch (error) {
|
||
logger.error(`Telegram auth error: ${error.message}`);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Аутентификация через Email
|
||
router.post('/email', async (req, res) => {
|
||
try {
|
||
const { email, verificationCode } = req.body;
|
||
|
||
// Здесь должна быть проверка кода подтверждения
|
||
|
||
// Получаем или создаем пользователя
|
||
let userId = await authService.getUserIdByIdentity('email', email);
|
||
|
||
if (!userId) {
|
||
// Создаем нового пользователя
|
||
const userResult = await db.query(
|
||
'INSERT INTO users (created_at, role_id) VALUES (NOW(), (SELECT id FROM roles WHERE name = $1)) RETURNING id',
|
||
['user']
|
||
);
|
||
|
||
userId = userResult.rows[0].id;
|
||
|
||
// Добавляем идентификатор Email
|
||
await db.query(
|
||
'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
|
||
[userId, 'email', email]
|
||
);
|
||
}
|
||
|
||
// Проверяем связанные аккаунты
|
||
const identities = await authService.getAllUserIdentities(userId);
|
||
|
||
// Если есть связанный кошелек, проверяем токены
|
||
if (identities.wallet) {
|
||
await authService.checkTokensAndUpdateRole(identities.wallet);
|
||
}
|
||
|
||
// Получаем текущую роль
|
||
const isAdmin = await authService.isAdmin(userId);
|
||
|
||
// Устанавливаем сессию
|
||
req.session.userId = userId;
|
||
req.session.email = email;
|
||
req.session.authType = 'email';
|
||
req.session.authenticated = true;
|
||
|
||
res.json({
|
||
authenticated: true,
|
||
userId,
|
||
isAdmin,
|
||
authType: 'email',
|
||
identities
|
||
});
|
||
} catch (error) {
|
||
logger.error(`Email auth error: ${error.message}`);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Связывание аккаунтов
|
||
router.post('/link-identity', async (req, res) => {
|
||
try {
|
||
if (!req.session || !req.session.userId) {
|
||
return res.status(401).json({ error: 'Требуется аутентификация' });
|
||
}
|
||
|
||
const { identityType, identityValue } = req.body;
|
||
|
||
// Проверяем, не привязан ли уже этот идентификатор к другому пользователю
|
||
const existingUserId = await authService.getUserIdByIdentity(identityType, identityValue);
|
||
|
||
if (existingUserId && existingUserId !== req.session.userId) {
|
||
return res.status(400).json({ error: 'Этот идентификатор уже привязан к другому аккаунту' });
|
||
}
|
||
|
||
// Добавляем новый идентификатор
|
||
if (!existingUserId) {
|
||
await db.query(
|
||
'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
|
||
[req.session.userId, identityType, identityValue]
|
||
);
|
||
}
|
||
|
||
// Если добавлен кошелек, проверяем токены
|
||
if (identityType === 'wallet') {
|
||
await authService.checkTokensAndUpdateRole(identityValue);
|
||
}
|
||
|
||
// Получаем все идентификаторы пользователя
|
||
const identities = await authService.getAllUserIdentities(req.session.userId);
|
||
|
||
// Получаем текущую роль
|
||
const isAdmin = await authService.isAdmin(req.session.userId);
|
||
|
||
res.json({
|
||
success: true,
|
||
identities,
|
||
isAdmin
|
||
});
|
||
} catch (error) {
|
||
logger.error(`Link identity error: ${error.message}`);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Проверка текущей сессии
|
||
router.get('/check', (req, res) => {
|
||
console.log('Сессия при проверке:', req.session);
|
||
|
||
// Если сессия существует и пользователь аутентифицирован
|
||
if (req.session && req.session.authenticated) {
|
||
res.json({
|
||
authenticated: true,
|
||
address: req.session.address,
|
||
isAdmin: req.session.isAdmin || false,
|
||
role: req.session.role || 'USER'
|
||
});
|
||
} else {
|
||
res.json({
|
||
authenticated: false,
|
||
address: null,
|
||
isAdmin: false,
|
||
authType: null
|
||
});
|
||
}
|
||
});
|
||
|
||
// Обработчик выхода из системы
|
||
router.post('/logout', (req, res) => {
|
||
try {
|
||
// Сохраняем sessionID перед удалением сессии
|
||
const sessionID = req.sessionID;
|
||
|
||
// Удаляем сессию из хранилища
|
||
req.session.destroy(async (err) => {
|
||
if (err) {
|
||
console.error('Ошибка при удалении сессии:', err);
|
||
return res.status(500).json({ error: 'Internal server error' });
|
||
}
|
||
|
||
try {
|
||
// Удаляем запись из базы данных
|
||
await db.query('DELETE FROM sessions WHERE sid = $1', [sessionID]);
|
||
console.log(`Сессия ${sessionID} удалена из базы данных`);
|
||
} catch (dbErr) {
|
||
console.error('Ошибка при удалении сессии из базы данных:', dbErr);
|
||
}
|
||
|
||
// Очищаем cookie
|
||
res.clearCookie('dapp.sid');
|
||
res.json({ success: true });
|
||
});
|
||
} catch (error) {
|
||
console.error('Logout error:', error);
|
||
res.status(500).json({ error: 'Internal server error' });
|
||
}
|
||
});
|
||
|
||
// Маршрут для авторизации через Telegram
|
||
router.get('/telegram', (req, res) => {
|
||
// Генерируем случайный токен для авторизации
|
||
const token = crypto.randomBytes(32).toString('hex');
|
||
|
||
// Сохраняем токен в сессии
|
||
req.session.telegramToken = token;
|
||
|
||
// Создаем URL для авторизации через Telegram
|
||
const botName = process.env.TELEGRAM_BOT_NAME || 'YourBotName';
|
||
const authUrl = `https://t.me/${botName}?start=${token}`;
|
||
|
||
res.json({ authUrl });
|
||
});
|
||
|
||
// Маршрут для авторизации через Email
|
||
router.post('/email', async (req, res) => {
|
||
try {
|
||
const { email } = req.body;
|
||
|
||
if (!email) {
|
||
return res.status(400).json({ error: 'Email is required' });
|
||
}
|
||
|
||
// Генерируем код подтверждения
|
||
const verificationCode = Math.floor(100000 + Math.random() * 900000).toString();
|
||
|
||
// Сохраняем код в сессии
|
||
req.session.emailVerificationCode = verificationCode;
|
||
req.session.pendingEmail = email;
|
||
|
||
// В реальном приложении здесь нужно отправить email с кодом подтверждения
|
||
// Удалите или закомментируйте эти логи
|
||
// console.log(`Verification code for ${email}: ${verificationCode}`);
|
||
|
||
res.json({ success: true, message: 'Verification code sent' });
|
||
} catch (error) {
|
||
// Удалите или закомментируйте эти логи
|
||
// console.error('Error sending verification code:', error);
|
||
logger.error('Error sending verification code:', error);
|
||
res.status(500).json({ error: 'Failed to send verification code' });
|
||
}
|
||
});
|
||
|
||
// Маршрут для проверки кода подтверждения Email
|
||
router.post('/email/verify', async (req, res) => {
|
||
try {
|
||
const { email, code } = req.body;
|
||
|
||
if (!email || !code) {
|
||
return res.status(400).json({ error: 'Email and code are required' });
|
||
}
|
||
|
||
// Получаем код из сессии
|
||
const verificationCode = req.session.emailVerificationCode;
|
||
const pendingEmail = req.session.pendingEmail;
|
||
|
||
if (!verificationCode || !pendingEmail) {
|
||
return res.status(400).json({ error: 'No pending verification' });
|
||
}
|
||
|
||
// Проверяем, что email совпадает с тем, для которого был сгенерирован код
|
||
if (pendingEmail !== email) {
|
||
return res.status(400).json({ error: 'Email mismatch' });
|
||
}
|
||
|
||
// Проверяем код
|
||
if (verificationCode !== code) {
|
||
return res.status(400).json({ error: 'Invalid verification code' });
|
||
}
|
||
|
||
// Проверяем, существует ли пользователь в базе данных
|
||
const user = await db.query('SELECT * FROM users WHERE email = $1', [email]);
|
||
|
||
let userId;
|
||
let isAdmin = false;
|
||
|
||
if (user.rows.length === 0) {
|
||
// Если пользователь не существует, создаем его
|
||
const newUser = await db.query(
|
||
'INSERT INTO users (email, created_at) VALUES ($1, NOW()) RETURNING id',
|
||
[email]
|
||
);
|
||
userId = newUser.rows[0].id;
|
||
} else {
|
||
userId = user.rows[0].id;
|
||
isAdmin = user.rows[0].is_admin || false;
|
||
}
|
||
|
||
// Устанавливаем состояние аутентификации в сессии
|
||
req.session.isAuthenticated = true;
|
||
req.session.authenticated = true;
|
||
req.session.address = email;
|
||
req.session.userId = userId;
|
||
req.session.isAdmin = isAdmin;
|
||
req.session.authType = 'email';
|
||
|
||
// Удаляем код из сессии
|
||
delete req.session.emailVerificationCode;
|
||
delete req.session.pendingEmail;
|
||
|
||
res.json({
|
||
authenticated: true,
|
||
address: email,
|
||
isAdmin,
|
||
authType: 'email',
|
||
});
|
||
} catch (error) {
|
||
// Удалите или закомментируйте эти логи
|
||
// console.error('Error verifying email code:', error);
|
||
logger.error('Error verifying email code:', error);
|
||
res.status(500).json({ error: 'Failed to verify email code' });
|
||
}
|
||
});
|
||
|
||
// Добавляем маршрут для проверки прав доступа
|
||
router.get('/check-access', requireAuth, (req, res) => {
|
||
try {
|
||
// Получаем информацию о пользователе
|
||
const userData = {
|
||
address: req.session.address,
|
||
isAdmin: req.session.isAdmin || false,
|
||
roles: req.session.roles || [],
|
||
authenticated: true,
|
||
};
|
||
|
||
// Проверяем доступ к различным разделам
|
||
const access = {
|
||
dashboard: true, // Все аутентифицированные пользователи имеют доступ к панели управления
|
||
admin: userData.isAdmin, // Только администраторы имеют доступ к админке
|
||
contracts: userData.roles.includes('CONTRACT_MANAGER') || userData.isAdmin,
|
||
users: userData.roles.includes('USER_MANAGER') || userData.isAdmin,
|
||
};
|
||
|
||
res.json({
|
||
user: userData,
|
||
access: access,
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка при проверке прав доступа:', error);
|
||
res.status(500).json({ error: 'Internal server error' });
|
||
}
|
||
});
|
||
|
||
// Добавьте этот маршрут в routes/auth.js
|
||
router.post('/refresh-session', async (req, res) => {
|
||
try {
|
||
const { address } = req.body;
|
||
|
||
if (!address) {
|
||
return res.status(400).json({ error: 'Address is required' });
|
||
}
|
||
|
||
logger.info(`Получен запрос на обновление сессии для адреса: ${address}`);
|
||
|
||
// Проверяем доступ пользователя
|
||
const accessInfo = await checkAccess(address);
|
||
|
||
if (!accessInfo.hasAccess) {
|
||
return res.status(401).json({ error: 'Unauthorized' });
|
||
}
|
||
|
||
// Устанавливаем данные сессии
|
||
req.session.authenticated = true;
|
||
req.session.address = address;
|
||
req.session.userId = accessInfo.userId;
|
||
req.session.isAdmin = accessInfo.isAdmin;
|
||
req.session.authType = 'wallet';
|
||
|
||
await req.session.save();
|
||
|
||
res.json({
|
||
authenticated: true,
|
||
address,
|
||
isAdmin: accessInfo.isAdmin,
|
||
authType: 'wallet'
|
||
});
|
||
} catch (error) {
|
||
logger.error(`Error refreshing session: ${error.message}`);
|
||
res.status(500).json({ error: 'Internal server error' });
|
||
}
|
||
});
|
||
|
||
// Маршрут для обновления статуса администратора
|
||
router.post('/update-admin-status', async (req, res) => {
|
||
try {
|
||
const { address, isAdmin } = req.body;
|
||
|
||
if (!address) {
|
||
return res.status(400).json({ error: 'Address is required' });
|
||
}
|
||
|
||
console.log(`Запрос на обновление статуса администратора для адреса ${address} на ${isAdmin}`);
|
||
|
||
// Проверяем, существует ли пользователь
|
||
const userResult = await db.query('SELECT * FROM users WHERE address = $1', [
|
||
address.toLowerCase(),
|
||
]);
|
||
|
||
if (userResult.rows.length === 0) {
|
||
// Если пользователь не найден, создаем его
|
||
await db.query('INSERT INTO users (address, is_admin, created_at) VALUES ($1, $2, NOW())', [
|
||
address.toLowerCase(),
|
||
isAdmin,
|
||
]);
|
||
|
||
console.log(
|
||
`Создан новый пользователь с адресом ${address} и статусом администратора ${isAdmin}`
|
||
);
|
||
} else {
|
||
// Если пользователь найден, обновляем его статус
|
||
await db.query('UPDATE users SET is_admin = $1 WHERE address = $2', [
|
||
isAdmin,
|
||
address.toLowerCase(),
|
||
]);
|
||
|
||
console.log(
|
||
`Обновлен статус администратора для пользователя с адресом ${address} на ${isAdmin}`
|
||
);
|
||
}
|
||
|
||
res.json({ success: true });
|
||
} catch (error) {
|
||
console.error('Ошибка при обновлении статуса администратора:', error);
|
||
res.status(500).json({ error: 'Internal server error' });
|
||
}
|
||
});
|
||
|
||
// Маршрут для проверки структуры таблицы users
|
||
router.get('/check-db-structure', async (req, res) => {
|
||
try {
|
||
// Получаем информацию о таблице users
|
||
const tableInfo = await pool.query(`
|
||
SELECT column_name, data_type
|
||
FROM information_schema.columns
|
||
WHERE table_name = 'users'
|
||
`);
|
||
|
||
res.json({
|
||
tableStructure: tableInfo.rows,
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка при получении структуры базы данных:', error);
|
||
res.status(500).json({ error: 'Internal server error' });
|
||
}
|
||
});
|
||
|
||
// Добавьте этот маршрут для отладки
|
||
router.get('/debug-session', (req, res) => {
|
||
res.json({
|
||
sessionID: req.sessionID,
|
||
session: req.session,
|
||
authenticated: req.session ? req.session.authenticated : undefined,
|
||
address: req.session ? req.session.address : undefined,
|
||
userId: req.session ? req.session.userId : undefined,
|
||
isAdmin: req.session ? req.session.isAdmin : undefined,
|
||
role: req.session ? req.session.role : undefined
|
||
});
|
||
});
|
||
|
||
// Маршрут для проверки сессии
|
||
router.get('/session-debug', (req, res) => {
|
||
console.log('Текущая сессия:', {
|
||
id: req.sessionID,
|
||
session: req.session,
|
||
cookie: req.session.cookie
|
||
});
|
||
|
||
res.json({
|
||
sessionID: req.sessionID,
|
||
authenticated: req.session.authenticated,
|
||
address: req.session.address,
|
||
userId: req.session.userId,
|
||
isAdmin: req.session.isAdmin,
|
||
role: req.session.role,
|
||
cookie: req.session.cookie
|
||
});
|
||
});
|
||
|
||
// Маршрут для проверки содержимого таблицы сессий
|
||
router.get('/check-sessions', async (req, res) => {
|
||
try {
|
||
const result = await pool.query('SELECT * FROM sessions');
|
||
res.json({
|
||
currentSessionID: req.sessionID,
|
||
sessions: result.rows
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка при получении сессий:', error);
|
||
res.status(500).json({ error: 'Internal server error' });
|
||
}
|
||
});
|
||
|
||
// Добавьте обработку ошибок
|
||
router.use((err, req, res, next) => {
|
||
console.error('Auth route error:', err);
|
||
res.status(500).json({ success: false, message: 'Ошибка сервера' });
|
||
});
|
||
|
||
module.exports = router;
|