add vote uniqueness, public key caching, relative poll timeframe, auth/rate limiting, modern UI styling, and error handling
This commit is contained in:
@@ -1,4 +0,0 @@
|
||||
PORT=3000
|
||||
YJS_WS_PORT=1234
|
||||
NODE_ENV=development
|
||||
CORS_ORIGIN=http://localhost:5173
|
||||
5
server/.gitignore
vendored
5
server/.gitignore
vendored
@@ -1,5 +0,0 @@
|
||||
node_modules/
|
||||
dist/
|
||||
.env
|
||||
*.log
|
||||
.DS_Store
|
||||
94
server/api/polls/[id].ts
Normal file
94
server/api/polls/[id].ts
Normal file
@@ -0,0 +1,94 @@
|
||||
import * as Y from 'yjs';
|
||||
// server/api/polls/[id].ts
|
||||
export default defineEventHandler(async (event) => {
|
||||
const method = event.node.req.method;
|
||||
const pollId = getRouterParam(event, 'id');
|
||||
|
||||
// We use Nitro's built-in storage.
|
||||
// 'polls' is the storage namespace.
|
||||
const storage = useStorage('polls');
|
||||
|
||||
if (!pollId) {
|
||||
throw createError({ statusCode: 400, statusMessage: 'Poll ID required' });
|
||||
}
|
||||
|
||||
// GET: Fetch the saved Yjs document state
|
||||
if (method === 'GET') {
|
||||
const data = await storage.getItem(`poll:${pollId}`);
|
||||
|
||||
// Fetch all user public keys to include in response
|
||||
const userStorage = useStorage('users');
|
||||
const publicKeys: Record<string, string> = {};
|
||||
|
||||
// Get all user keys from storage
|
||||
const keys = await userStorage.getKeys();
|
||||
for (const key of keys) {
|
||||
if (key.startsWith('user:')) {
|
||||
const userId = key.replace('user:', '');
|
||||
const publicKey = await userStorage.getItem(key);
|
||||
if (publicKey) {
|
||||
publicKeys[userId] = String(publicKey);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Return the array of numbers (or null if it doesn't exist yet) along with public keys
|
||||
return { update: data || null, publicKeys };
|
||||
}
|
||||
|
||||
// POST: Save a new Yjs document state
|
||||
if (method === 'POST') {
|
||||
const body = await readBody(event);
|
||||
|
||||
if (body.update && Array.isArray(body.update)) {
|
||||
// create a temp Y.Doc to encode the Data
|
||||
const tempDoc = new Y.Doc();
|
||||
Y.applyUpdate(tempDoc, new Uint8Array(body.update));
|
||||
const yMap = tempDoc.getMap('shared-poll');
|
||||
const pollData = yMap.toJSON();
|
||||
|
||||
// verify pollData
|
||||
for(var option in pollData){
|
||||
const votes = pollData[option] || [];
|
||||
var pubKeys: CryptoKey[] = [];
|
||||
|
||||
const verifyAllVotesForOption = async (votes: SignedData<VoteData>[]) => {
|
||||
console.log("verifying votes for option " + option,votes);
|
||||
// check last votes first. if there is something wrong, its likely in the last vote.
|
||||
for (let i = votes.length-1; i >= 0 ; i--) {
|
||||
const userStorage = useStorage('users');
|
||||
const votePubKeyString = await userStorage.getItem(`user:${votes[i]?.data.userid}`);
|
||||
|
||||
// Check if public key exists for this user
|
||||
if (!votePubKeyString) {
|
||||
console.error(`Error! No public key found for user: ${votes[i]?.data.userid}`);
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: `Vote from unknown user: ${votes[i]?.data.userid}. User must be registered to vote.`
|
||||
});
|
||||
}
|
||||
|
||||
const votePubKey = await stringToCryptoKey(String(votePubKeyString),'public')
|
||||
const isValid = await verifyChainedVote(votes, i,votePubKey);
|
||||
if(!isValid){
|
||||
console.error("Error! Invalid Vote at: " + i,votes)
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
};
|
||||
const verified = await verifyAllVotesForOption(votes);
|
||||
if(!verified){
|
||||
console.error("Failed to verify option: "+option)
|
||||
throw createError({ statusCode: 400, statusMessage: 'PollData contains unverifyable content!' });
|
||||
}
|
||||
}
|
||||
|
||||
// Save the binary update (sent as an array of numbers) to storage
|
||||
await storage.setItem(`poll:${pollId}`, body.update);
|
||||
return { success: true };
|
||||
}
|
||||
|
||||
throw createError({ statusCode: 400, statusMessage: 'Invalid update payload' });
|
||||
}
|
||||
});
|
||||
15
server/api/polls/index.get.ts
Normal file
15
server/api/polls/index.get.ts
Normal file
@@ -0,0 +1,15 @@
|
||||
// server/api/polls/index.get.ts
|
||||
export default defineEventHandler(async () => {
|
||||
const storage = useStorage('polls');
|
||||
|
||||
// Get all keys in the 'polls' namespace
|
||||
const allKeys = await storage.getKeys();
|
||||
|
||||
// Filter for our specific poll prefix and strip it for the UI
|
||||
// poll:my-id -> my-id
|
||||
const polls = allKeys
|
||||
.filter(key => key.startsWith('poll:'))
|
||||
.map(key => key.replace('poll:', ''));
|
||||
|
||||
return { polls };
|
||||
});
|
||||
82
server/api/users/[id].ts
Normal file
82
server/api/users/[id].ts
Normal file
@@ -0,0 +1,82 @@
|
||||
// server/api/users/[id].ts
|
||||
|
||||
// Simple in-memory rate limiter
|
||||
const rateLimitMap = new Map<string, { count: number; resetTime: number }>();
|
||||
const RATE_LIMIT_WINDOW = 60000; // 1 minute
|
||||
const RATE_LIMIT_MAX = 10; // 10 requests per minute per admin
|
||||
|
||||
function checkRateLimit(adminToken: string): boolean {
|
||||
const now = Date.now();
|
||||
const limit = rateLimitMap.get(adminToken);
|
||||
|
||||
if (!limit || now > limit.resetTime) {
|
||||
rateLimitMap.set(adminToken, { count: 1, resetTime: now + RATE_LIMIT_WINDOW });
|
||||
return true;
|
||||
}
|
||||
|
||||
if (limit.count >= RATE_LIMIT_MAX) {
|
||||
return false;
|
||||
}
|
||||
|
||||
limit.count++;
|
||||
return true;
|
||||
}
|
||||
|
||||
export default defineEventHandler(async (event) => {
|
||||
const method = event.node.req.method;
|
||||
const userId = getRouterParam(event, 'id');
|
||||
|
||||
// We use Nitro's built-in storage.
|
||||
// 'polls' is the storage namespace.
|
||||
const storage = useStorage('users');
|
||||
|
||||
if (!userId) {
|
||||
throw createError({ statusCode: 400, statusMessage: 'User ID required' });
|
||||
}
|
||||
|
||||
// GET: Fetch the saved Yjs document state
|
||||
if (method === 'GET') {
|
||||
const data = await storage.getItem(`user:${userId}`);
|
||||
// Return the array of numbers (or null if it doesn't exist yet)
|
||||
return { public_key: data };
|
||||
}
|
||||
|
||||
// POST: Save a new Yjs document state
|
||||
if (method === 'POST') {
|
||||
// Check for authentication
|
||||
const authHeader = getHeader(event, 'authorization');
|
||||
const adminApiKey = process.env.ADMIN_API_KEY || 'default-admin-key-change-in-production';
|
||||
|
||||
if (!authHeader || !authHeader.startsWith('Bearer ')) {
|
||||
throw createError({ statusCode: 401, statusMessage: 'Authorization header required' });
|
||||
}
|
||||
|
||||
const token = authHeader.replace('Bearer ', '');
|
||||
if (token !== adminApiKey) {
|
||||
throw createError({ statusCode: 403, statusMessage: 'Invalid or expired token' });
|
||||
}
|
||||
|
||||
// Check rate limiting
|
||||
if (!checkRateLimit(token)) {
|
||||
throw createError({ statusCode: 429, statusMessage: 'Rate limit exceeded. Try again later.' });
|
||||
}
|
||||
|
||||
const body = await readBody(event);
|
||||
|
||||
if (body.public_key) {
|
||||
const data = await storage.getItem(`user:${userId}`);
|
||||
|
||||
if (data == undefined || data == null) {
|
||||
// Save the binary update (sent as an array of numbers) to storage
|
||||
await storage.setItem(`user:${userId}`, body.public_key);
|
||||
console.log("New User created: " + userId)
|
||||
console.log("Public Key: " + body.public_key);
|
||||
return { success: true };
|
||||
}
|
||||
|
||||
throw createError({ statusCode: 400, statusMessage: 'User already exists.' });
|
||||
}
|
||||
|
||||
throw createError({ statusCode: 400, statusMessage: 'Invalid update payload' });
|
||||
}
|
||||
});
|
||||
2112
server/package-lock.json
generated
2112
server/package-lock.json
generated
File diff suppressed because it is too large
Load Diff
@@ -1,36 +0,0 @@
|
||||
{
|
||||
"name": "p2p-poll-server",
|
||||
"version": "1.0.0",
|
||||
"description": "Backend server for P2P polling app with Yjs and WebRTC signaling",
|
||||
"main": "dist/index.js",
|
||||
"scripts": {
|
||||
"dev": "tsx watch src/index.ts",
|
||||
"build": "tsc",
|
||||
"start": "node dist/index.js"
|
||||
},
|
||||
"keywords": [
|
||||
"yjs",
|
||||
"websocket",
|
||||
"webrtc",
|
||||
"p2p"
|
||||
],
|
||||
"author": "",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"cors": "^2.8.5",
|
||||
"dotenv": "^16.3.1",
|
||||
"express": "^4.18.2",
|
||||
"ws": "^8.14.2",
|
||||
"y-websocket": "^1.5.0",
|
||||
"yjs": "^13.6.8",
|
||||
"zod": "^4.3.6"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/cors": "^2.8.15",
|
||||
"@types/express": "^4.17.20",
|
||||
"@types/node": "^20.9.0",
|
||||
"@types/ws": "^8.5.8",
|
||||
"tsx": "^4.6.2",
|
||||
"typescript": "^5.2.2"
|
||||
}
|
||||
}
|
||||
@@ -1,59 +0,0 @@
|
||||
import express from 'express';
|
||||
import http from 'http';
|
||||
import cors from 'cors';
|
||||
import dotenv from 'dotenv';
|
||||
import { createYjsServer } from './yjs-server';
|
||||
import { createSignalingServer } from './signaling-server';
|
||||
import { logger } from './utils/logger';
|
||||
|
||||
dotenv.config();
|
||||
|
||||
const app = express();
|
||||
const PORT = process.env.PORT || 5000;
|
||||
|
||||
app.use(cors({
|
||||
origin: process.env.CORS_ORIGIN || ['http://localhost:5173', 'http://localhost:5174', 'http://localhost:5175'],
|
||||
credentials: true
|
||||
}));
|
||||
|
||||
app.use(express.json());
|
||||
|
||||
app.get('/health', (req, res) => {
|
||||
res.json({
|
||||
status: 'ok',
|
||||
timestamp: new Date().toISOString(),
|
||||
services: {
|
||||
yjs: 'running',
|
||||
signaling: 'running'
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
app.get('/', (req, res) => {
|
||||
res.json({
|
||||
message: 'P2P Poll Server',
|
||||
endpoints: {
|
||||
health: '/health',
|
||||
yjs: 'ws://localhost:' + PORT + '/yjs',
|
||||
signaling: 'ws://localhost:' + PORT + '/signal'
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
const server = http.createServer(app);
|
||||
|
||||
createYjsServer(server, PORT as number);
|
||||
createSignalingServer(server);
|
||||
|
||||
server.listen(PORT, () => {
|
||||
logger.info(`Server running on port ${PORT}`);
|
||||
logger.info(`Yjs WebSocket: ws://localhost:${PORT}/yjs`);
|
||||
logger.info(`Signaling WebSocket: ws://localhost:${PORT}/signal`);
|
||||
});
|
||||
|
||||
process.on('SIGTERM', () => {
|
||||
logger.info('SIGTERM signal received: closing HTTP server');
|
||||
server.close(() => {
|
||||
logger.info('HTTP server closed');
|
||||
});
|
||||
});
|
||||
@@ -1,305 +0,0 @@
|
||||
import { WebSocketServer, WebSocket } from 'ws';
|
||||
import http from 'http';
|
||||
import { SignalingMessage, SignalingMessageSchema } from './types/poll.types';
|
||||
import { logger } from './utils/logger';
|
||||
|
||||
interface Client {
|
||||
id: string;
|
||||
ws: WebSocket;
|
||||
roomId: string;
|
||||
lastSeen: number;
|
||||
messageCount: number;
|
||||
lastMessageTime: number;
|
||||
}
|
||||
|
||||
export function createSignalingServer(server: http.Server) {
|
||||
const wss = new WebSocketServer({
|
||||
noServer: true
|
||||
});
|
||||
|
||||
// Handle upgrade requests for /signal path
|
||||
server.on('upgrade', (request, socket, head) => {
|
||||
const pathname = request.url || '';
|
||||
|
||||
if (pathname === '/signal' || pathname.startsWith('/signal?')) {
|
||||
logger.info(`[SIGNALING] Upgrade request for path: ${pathname}`);
|
||||
wss.handleUpgrade(request, socket, head, (ws) => {
|
||||
wss.emit('connection', ws, request);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
const clients = new Map<string, Client>();
|
||||
const rooms = new Map<string, Set<string>>();
|
||||
const roomPasswords = new Map<string, string>();
|
||||
const HEARTBEAT_INTERVAL = 30000;
|
||||
const CLIENT_TIMEOUT = 60000;
|
||||
const RATE_LIMIT_WINDOW = 1000;
|
||||
const RATE_LIMIT_MAX = 10;
|
||||
|
||||
const heartbeatInterval = setInterval(() => {
|
||||
const now = Date.now();
|
||||
clients.forEach((client, clientId) => {
|
||||
if (now - client.lastSeen > CLIENT_TIMEOUT) {
|
||||
logger.info(`Client ${clientId} timed out, removing...`);
|
||||
handleClientLeave(clientId);
|
||||
} else {
|
||||
client.ws.send(JSON.stringify({ type: 'ping' }));
|
||||
}
|
||||
});
|
||||
}, HEARTBEAT_INTERVAL);
|
||||
|
||||
wss.on('connection', (ws: WebSocket) => {
|
||||
let clientId: string | null = null;
|
||||
const tempClientId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
|
||||
logger.info(`[SIGNALING] New WebSocket connection (temp: ${tempClientId})`);
|
||||
|
||||
ws.on('message', (data: Buffer) => {
|
||||
try {
|
||||
const parsed = JSON.parse(data.toString());
|
||||
const validationResult = SignalingMessageSchema.safeParse(parsed);
|
||||
|
||||
if (!validationResult.success) {
|
||||
logger.error('Invalid signaling message:', validationResult.error);
|
||||
ws.send(JSON.stringify({
|
||||
type: 'error',
|
||||
message: 'Invalid message format',
|
||||
errors: validationResult.error.issues
|
||||
}));
|
||||
return;
|
||||
}
|
||||
|
||||
const message: SignalingMessage = validationResult.data;
|
||||
|
||||
if (clientId) {
|
||||
const client = clients.get(clientId);
|
||||
if (client) {
|
||||
const now = Date.now();
|
||||
if (now - client.lastMessageTime < RATE_LIMIT_WINDOW) {
|
||||
client.messageCount++;
|
||||
if (client.messageCount > RATE_LIMIT_MAX) {
|
||||
logger.warn(`Client ${clientId} exceeded rate limit`);
|
||||
ws.send(JSON.stringify({
|
||||
type: 'error',
|
||||
message: 'Rate limit exceeded'
|
||||
}));
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
client.messageCount = 1;
|
||||
client.lastMessageTime = now;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
switch (message.type) {
|
||||
case 'subscribe':
|
||||
// y-webrtc subscribe message - client wants to join topics
|
||||
if (message.topics) {
|
||||
message.topics.forEach((topic: string) => {
|
||||
if (!rooms.has(topic)) {
|
||||
rooms.set(topic, new Set());
|
||||
}
|
||||
const tempId = `sub-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
|
||||
clientId = tempId;
|
||||
rooms.get(topic)!.add(tempId);
|
||||
clients.set(tempId, {
|
||||
id: tempId,
|
||||
ws,
|
||||
roomId: topic,
|
||||
lastSeen: Date.now(),
|
||||
messageCount: 0,
|
||||
lastMessageTime: Date.now()
|
||||
});
|
||||
logger.info(`[SIGNALING] Client subscribed to topic: ${topic}`);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'unsubscribe':
|
||||
// y-webrtc unsubscribe message
|
||||
if (message.topics && clientId) {
|
||||
message.topics.forEach((topic: string) => {
|
||||
const room = rooms.get(topic);
|
||||
if (room && clientId) {
|
||||
room.delete(clientId);
|
||||
if (room.size === 0) {
|
||||
rooms.delete(topic);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'publish':
|
||||
// y-webrtc publish message - broadcast to all subscribers of a topic
|
||||
if (message.topic) {
|
||||
const topic = message.topic;
|
||||
const room = rooms.get(topic);
|
||||
if (room) {
|
||||
room.forEach((subscriberId) => {
|
||||
const subscriber = clients.get(subscriberId);
|
||||
if (subscriber && subscriber.ws !== ws && subscriber.ws.readyState === WebSocket.OPEN) {
|
||||
subscriber.ws.send(JSON.stringify({
|
||||
type: 'publish',
|
||||
topic: topic,
|
||||
data: message.data
|
||||
}));
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 'join':
|
||||
clientId = message.from || `client-${Date.now()}`;
|
||||
const roomId = message.roomId || 'default-room';
|
||||
|
||||
const roomPassword = roomPasswords.get(roomId);
|
||||
if (roomPassword && message.password !== roomPassword) {
|
||||
logger.warn(`Client ${clientId} failed password authentication for room ${roomId}`);
|
||||
ws.send(JSON.stringify({
|
||||
type: 'error',
|
||||
message: 'Invalid room password'
|
||||
}));
|
||||
return;
|
||||
}
|
||||
|
||||
clients.set(clientId, {
|
||||
id: clientId,
|
||||
ws,
|
||||
roomId,
|
||||
lastSeen: Date.now(),
|
||||
messageCount: 0,
|
||||
lastMessageTime: Date.now()
|
||||
});
|
||||
|
||||
if (!rooms.has(roomId)) {
|
||||
rooms.set(roomId, new Set());
|
||||
}
|
||||
rooms.get(roomId)!.add(clientId);
|
||||
|
||||
logger.info(`Client ${clientId} joined room ${roomId}`);
|
||||
|
||||
const roomClients = Array.from(rooms.get(roomId)!).filter(id => id !== clientId);
|
||||
ws.send(JSON.stringify({
|
||||
type: 'peers',
|
||||
peers: roomClients
|
||||
}));
|
||||
|
||||
roomClients.forEach(peerId => {
|
||||
const peer = clients.get(peerId);
|
||||
if (peer && peer.ws.readyState === WebSocket.OPEN) {
|
||||
peer.ws.send(JSON.stringify({
|
||||
type: 'peer-joined',
|
||||
peerId: clientId
|
||||
}));
|
||||
}
|
||||
});
|
||||
break;
|
||||
|
||||
case 'offer':
|
||||
case 'answer':
|
||||
case 'ice-candidate':
|
||||
if (message.to) {
|
||||
const targetClient = clients.get(message.to);
|
||||
if (targetClient && targetClient.ws.readyState === WebSocket.OPEN) {
|
||||
targetClient.ws.send(JSON.stringify({
|
||||
type: message.type,
|
||||
from: message.from,
|
||||
data: message.data
|
||||
}));
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 'leave':
|
||||
if (message.from) {
|
||||
handleClientLeave(message.from);
|
||||
}
|
||||
break;
|
||||
|
||||
case 'create-room':
|
||||
if (message.roomId && message.password) {
|
||||
roomPasswords.set(message.roomId, message.password);
|
||||
logger.info(`Room ${message.roomId} created with password protection`);
|
||||
ws.send(JSON.stringify({
|
||||
type: 'room-created',
|
||||
roomId: message.roomId
|
||||
}));
|
||||
}
|
||||
break;
|
||||
|
||||
case 'ping':
|
||||
if (clientId) {
|
||||
const client = clients.get(clientId);
|
||||
if (client) {
|
||||
client.lastSeen = Date.now();
|
||||
client.ws.send(JSON.stringify({ type: 'pong', from: 'server' }));
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 'pong':
|
||||
if (clientId) {
|
||||
const client = clients.get(clientId);
|
||||
if (client) {
|
||||
client.lastSeen = Date.now();
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error('Error processing signaling message:', error);
|
||||
}
|
||||
});
|
||||
|
||||
ws.on('close', () => {
|
||||
if (clientId) {
|
||||
handleClientLeave(clientId);
|
||||
}
|
||||
});
|
||||
|
||||
ws.on('error', (error) => {
|
||||
logger.error('WebSocket error:', error);
|
||||
});
|
||||
});
|
||||
|
||||
function handleClientLeave(clientId: string) {
|
||||
const client = clients.get(clientId);
|
||||
if (client) {
|
||||
const roomId = client.roomId;
|
||||
const room = rooms.get(roomId);
|
||||
|
||||
if (room) {
|
||||
room.delete(clientId);
|
||||
|
||||
room.forEach(peerId => {
|
||||
const peer = clients.get(peerId);
|
||||
if (peer && peer.ws.readyState === WebSocket.OPEN) {
|
||||
peer.ws.send(JSON.stringify({
|
||||
type: 'peer-left',
|
||||
peerId: clientId
|
||||
}));
|
||||
}
|
||||
});
|
||||
|
||||
if (room.size === 0) {
|
||||
rooms.delete(roomId);
|
||||
}
|
||||
}
|
||||
|
||||
clients.delete(clientId);
|
||||
logger.info(`Client ${clientId} left room ${roomId}`);
|
||||
}
|
||||
}
|
||||
|
||||
wss.on('close', () => {
|
||||
clearInterval(heartbeatInterval);
|
||||
logger.info('Signaling server closed');
|
||||
});
|
||||
|
||||
logger.info('Signaling server running at path /signal');
|
||||
|
||||
return wss;
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
import { z } from 'zod';
|
||||
|
||||
export interface PollOption {
|
||||
id: string;
|
||||
text: string;
|
||||
votes: number;
|
||||
votedBy: string[];
|
||||
createdBy: string;
|
||||
timestamp: number;
|
||||
}
|
||||
|
||||
export interface Poll {
|
||||
id: string;
|
||||
question: string;
|
||||
createdBy: string;
|
||||
timestamp: number;
|
||||
options: PollOption[];
|
||||
}
|
||||
|
||||
export const SignalingMessageSchema = z.object({
|
||||
type: z.enum(['offer', 'answer', 'ice-candidate', 'join', 'leave', 'ping', 'pong', 'create-room', 'subscribe', 'unsubscribe', 'publish', 'signal']),
|
||||
from: z.string().optional(),
|
||||
to: z.string().optional(),
|
||||
data: z.any().optional(),
|
||||
roomId: z.string().optional(),
|
||||
password: z.string().optional(),
|
||||
topics: z.array(z.string()).optional(),
|
||||
topic: z.string().optional()
|
||||
});
|
||||
|
||||
export interface SignalingMessage {
|
||||
type: 'offer' | 'answer' | 'ice-candidate' | 'join' | 'leave' | 'ping' | 'pong' | 'create-room' | 'subscribe' | 'unsubscribe' | 'publish' | 'signal';
|
||||
from?: string;
|
||||
to?: string;
|
||||
data?: any;
|
||||
roomId?: string;
|
||||
password?: string;
|
||||
topics?: string[];
|
||||
topic?: string;
|
||||
}
|
||||
@@ -1,115 +0,0 @@
|
||||
type LogLevel = 'info' | 'error' | 'warn' | 'debug';
|
||||
type LogContext = Record<string, any>;
|
||||
|
||||
interface LogEntry {
|
||||
timestamp: string;
|
||||
level: LogLevel;
|
||||
message: string;
|
||||
context?: LogContext;
|
||||
}
|
||||
|
||||
class Logger {
|
||||
private context: LogContext = {};
|
||||
private timers: Map<string, number> = new Map();
|
||||
|
||||
setContext(ctx: LogContext): void {
|
||||
this.context = { ...this.context, ...ctx };
|
||||
}
|
||||
|
||||
clearContext(): void {
|
||||
this.context = {};
|
||||
}
|
||||
|
||||
private formatLog(level: LogLevel, message: string, args: any[]): LogEntry {
|
||||
const entry: LogEntry = {
|
||||
timestamp: new Date().toISOString(),
|
||||
level,
|
||||
message,
|
||||
context: Object.keys(this.context).length > 0 ? { ...this.context } : undefined
|
||||
};
|
||||
|
||||
if (args.length > 0) {
|
||||
if (entry.context) {
|
||||
entry.context.args = args;
|
||||
} else {
|
||||
entry.context = { args };
|
||||
}
|
||||
}
|
||||
|
||||
return entry;
|
||||
}
|
||||
|
||||
private log(level: LogLevel, message: string, ...args: any[]): void {
|
||||
const entry = this.formatLog(level, message, args);
|
||||
const logString = JSON.stringify(entry);
|
||||
|
||||
switch (level) {
|
||||
case 'info':
|
||||
console.log(logString);
|
||||
break;
|
||||
case 'error':
|
||||
console.error(logString);
|
||||
break;
|
||||
case 'warn':
|
||||
console.warn(logString);
|
||||
break;
|
||||
case 'debug':
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
console.debug(logString);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
info(message: string, ...args: any[]): void {
|
||||
this.log('info', message, ...args);
|
||||
}
|
||||
|
||||
error(message: string, ...args: any[]): void {
|
||||
this.log('error', message, ...args);
|
||||
}
|
||||
|
||||
warn(message: string, ...args: any[]): void {
|
||||
this.log('warn', message, ...args);
|
||||
}
|
||||
|
||||
debug(message: string, ...args: any[]): void {
|
||||
this.log('debug', message, ...args);
|
||||
}
|
||||
|
||||
startTimer(label: string): void {
|
||||
this.timers.set(label, Date.now());
|
||||
}
|
||||
|
||||
endTimer(label: string): number {
|
||||
const startTime = this.timers.get(label);
|
||||
if (!startTime) {
|
||||
this.warn(`Timer '${label}' not found`);
|
||||
return 0;
|
||||
}
|
||||
const duration = Date.now() - startTime;
|
||||
this.timers.delete(label);
|
||||
this.debug(`Timer '${label}': ${duration}ms`);
|
||||
return duration;
|
||||
}
|
||||
|
||||
time<T>(label: string, fn: () => T): T {
|
||||
this.startTimer(label);
|
||||
try {
|
||||
return fn();
|
||||
} finally {
|
||||
this.endTimer(label);
|
||||
}
|
||||
}
|
||||
|
||||
async timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T> {
|
||||
this.startTimer(label);
|
||||
try {
|
||||
return await fn();
|
||||
} finally {
|
||||
this.endTimer(label);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export const logger = new Logger();
|
||||
@@ -1,51 +0,0 @@
|
||||
import { WebSocketServer } from 'ws';
|
||||
// @ts-ignore
|
||||
import { setupWSConnection } from 'y-websocket/bin/utils';
|
||||
import http from 'http';
|
||||
import { logger } from './utils/logger';
|
||||
|
||||
export function createYjsServer(server: http.Server, port: number) {
|
||||
const wss = new WebSocketServer({
|
||||
noServer: true
|
||||
});
|
||||
|
||||
// Handle upgrade requests for /yjs/* paths
|
||||
server.on('upgrade', (request, socket, head) => {
|
||||
const pathname = request.url || '';
|
||||
|
||||
if (pathname.startsWith('/yjs')) {
|
||||
logger.info(`[YJS] Upgrade request for path: ${pathname}`);
|
||||
wss.handleUpgrade(request, socket, head, (ws) => {
|
||||
wss.emit('connection', ws, request);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
wss.on('connection', (ws, req) => {
|
||||
const url = req.url || 'unknown';
|
||||
const remoteAddress = req.socket.remoteAddress || 'unknown';
|
||||
logger.info(`[YJS] New connection from ${remoteAddress}, URL: ${url}`);
|
||||
|
||||
// Log when connection closes
|
||||
ws.on('close', () => {
|
||||
logger.info(`[YJS] Connection closed from ${remoteAddress}`);
|
||||
});
|
||||
|
||||
ws.on('error', (error) => {
|
||||
logger.error(`[YJS] Connection error from ${remoteAddress}:`, error);
|
||||
});
|
||||
|
||||
// y-websocket automatically handles docName from the URL path
|
||||
// The room name is passed as part of the URL: /yjs/room-name
|
||||
// We don't need to manually extract it
|
||||
setupWSConnection(ws, req, { gc: true });
|
||||
});
|
||||
|
||||
wss.on('error', (error) => {
|
||||
logger.error('Yjs WebSocket server error:', error);
|
||||
});
|
||||
|
||||
logger.info(`Yjs WebSocket server running on port ${port} at path /yjs`);
|
||||
|
||||
return wss;
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "ES2020",
|
||||
"module": "commonjs",
|
||||
"lib": ["ES2020"],
|
||||
"outDir": "./dist",
|
||||
"rootDir": "./src",
|
||||
"strict": true,
|
||||
"esModuleInterop": true,
|
||||
"skipLibCheck": true,
|
||||
"forceConsistentCasingInFileNames": true,
|
||||
"resolveJsonModule": true,
|
||||
"moduleResolution": "node",
|
||||
"declaration": true,
|
||||
"declarationMap": true,
|
||||
"sourceMap": true
|
||||
},
|
||||
"include": ["src/**/*"],
|
||||
"exclude": ["node_modules", "dist"]
|
||||
}
|
||||
89
server/utils/crypto.ts
Normal file
89
server/utils/crypto.ts
Normal file
@@ -0,0 +1,89 @@
|
||||
import { SignedData, VoteData } from "./types";
|
||||
/**
|
||||
* Gets the WebCrypto API regardless of environment (Node vs Browser)
|
||||
*/
|
||||
const getCrypto = () => {
|
||||
return (globalThis as any).crypto;
|
||||
};
|
||||
|
||||
export const verifyVote = async (data: any, signatureStr: string, publicKey: CryptoKey) => {
|
||||
const encoder = new TextEncoder();
|
||||
const encodedData = encoder.encode(JSON.stringify(data));
|
||||
|
||||
// Convert Base64 back to Uint8Array
|
||||
const signature = Uint8Array.from(atob(signatureStr), c => c.charCodeAt(0));
|
||||
|
||||
return await getCrypto().subtle.verify(
|
||||
"RSASSA-PKCS1-v1_5",
|
||||
publicKey,
|
||||
signature,
|
||||
encodedData
|
||||
);
|
||||
};
|
||||
|
||||
/**
|
||||
* Verifies a specific vote within an array of votes by
|
||||
* reconstructing the "signed state" at that point in time.
|
||||
*/
|
||||
export const verifyChainedVote = async (
|
||||
voteData: SignedData<VoteData>[],
|
||||
index: number,
|
||||
pubKey: CryptoKey
|
||||
) => {
|
||||
const voteToVerify = voteData[index];
|
||||
console.log("Verifying vote: " + voteToVerify)
|
||||
if(voteToVerify) {
|
||||
|
||||
const historicalState = voteData.slice(0, index + 1).map((v, i) => {
|
||||
if (i === index) {
|
||||
// For the current vote, the signature must be empty string
|
||||
// because it wasn't signed yet when passed to signVote
|
||||
return { ...v, signature: "" };
|
||||
}
|
||||
return v;
|
||||
});
|
||||
|
||||
try {
|
||||
// 3. Verify: Does this historicalState match the signature?
|
||||
return await verifyVote(historicalState, voteToVerify.signature, pubKey);
|
||||
} catch (err) {
|
||||
console.error("Verification failed")
|
||||
console.error(err);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
console.error("Vote is undefined or null");
|
||||
return false;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Converts a Base64 string back into a usable CryptoKey object
|
||||
* @param keyStr The Base64 string (without PEM headers)
|
||||
* @param type 'public' or 'private'
|
||||
*/
|
||||
export const stringToCryptoKey = async (keyStr: string, type: 'public' | 'private'): Promise<CryptoKey> => {
|
||||
// 1. Convert Base64 string to a Uint8Array (binary)
|
||||
const binaryString = Buffer.from(keyStr, 'base64').toString('binary');
|
||||
const bytes = new Uint8Array(binaryString.length);
|
||||
for (let i = 0; i < binaryString.length; i++) {
|
||||
bytes[i] = binaryString.charCodeAt(i);
|
||||
}
|
||||
|
||||
// 2. Identify the format based on the key type
|
||||
// Public keys usually use 'spki', Private keys use 'pkcs8'
|
||||
const format = type === 'public' ? 'spki' : 'pkcs8';
|
||||
const usages: KeyUsage[] = type === 'public' ? ['verify'] : ['sign'];
|
||||
|
||||
// 3. Import the key
|
||||
return await getCrypto().subtle.importKey(
|
||||
format,
|
||||
bytes.buffer,
|
||||
{
|
||||
name: "RSASSA-PKCS1-v1_5",
|
||||
hash: "SHA-256",
|
||||
},
|
||||
true, // extractable (set to false if you want to lock it in memory)
|
||||
usages
|
||||
);
|
||||
};
|
||||
36
server/utils/types.ts
Normal file
36
server/utils/types.ts
Normal file
@@ -0,0 +1,36 @@
|
||||
export interface PollProps {
|
||||
userid: string | undefined,
|
||||
activePollId: string,
|
||||
pollData: PollData,
|
||||
addOption: (name: string) => void,
|
||||
vote: (optionName: string) => void
|
||||
}
|
||||
|
||||
export interface PollListProps {
|
||||
userid: string | undefined,
|
||||
}
|
||||
|
||||
export interface PollData extends Record<string, SignedData<VoteData>[]> {
|
||||
}
|
||||
|
||||
export interface SignedData<T> {
|
||||
data: T,
|
||||
signature: string
|
||||
}
|
||||
|
||||
export interface VoteData {
|
||||
userid: string,
|
||||
timestamp: string
|
||||
}
|
||||
|
||||
export interface OptionData {
|
||||
userid: string,
|
||||
timestamp: string,
|
||||
optionName: string
|
||||
}
|
||||
|
||||
export interface UserData {
|
||||
userid: string,
|
||||
private_key: CryptoKey | undefined,
|
||||
public_key: CryptoKey | undefined
|
||||
}
|
||||
Reference in New Issue
Block a user