Actualmente estoy trabajando en una aplicación de prueba. Cuando aparece una pregunta, los usuarios tienen 10 segundos para responderla, de lo contrario no obtienen los puntos por esa pregunta. Una vez que se acabe el tiempo, quiero pasar automáticamente a la siguiente pregunta. Actualmente estoy enfrentando problemas sobre cómo hacer que el cliente no pueda "hackear" el temporizador de cuenta regresiva de 10 segundos.

Mi idea inicial era usar algo similar a setTimeout() en el lado del cliente durante 10 segundos y, una vez que se completa el temporizador, pedirle al servidor que obtenga la siguiente pregunta. El problema con esto es que el temporizador del lado del cliente se puede piratear/modificar para que se ejecute durante más de 10 segundos, lo que podría dar a algunos usuarios más de 10 segundos para responder la pregunta.

 client <--- sends question --- server | start timer for 10 seconds (as this is client-side, it could easily be extended) | . 10 seconds later . V client --- ask for next question / send answer ---> server

Para mantenerlo imposible de piratear, pensé en mover la lógica de verificación de tiempo al lado del servidor. Esto implicaría mantener dos variables ( A y B ) en el lado del servidor por usuario conectado, una que representa la hora en que se envió la pregunta y la otra que representa la hora en que se dio la respuesta. El temporizador del lado del cliente aún se ejecutaría, excepto que el lado del servidor usa las marcas de tiempo para realizar alguna validación para verificar si la diferencia entre las marcas de tiempo A y B excede los 10 segundos:

 client <--- sends question --- server (send question at timestamp `A`) | start timer for 10 seconds (as this is client-side, it could easily be extended) | . 10 seconds later . V client --- ask for next question / send answer ---> server (receive request at timestamp `B`) | +-----------------------------------------------------+ v server logic: duration = B - A if(duration > 10 seconds) { // allocated time exceeded }

Sin embargo, veo algunos defectos potenciales con esto. El tiempo que tarda la pregunta en llegar al cliente desde el servidor y el tiempo entre el momento en que el servidor envió la pregunta (tiempo A ) y el momento en que se inicia el temporizador del lado del cliente no será instantáneo y dependerá del ping. / conexión que el usuario tiene con el servidor. Existen problemas de ping similares cuando el cliente solicita la siguiente pregunta. Además, me preocupa que si el temporizador del lado del cliente, que se supone que debe ejecutarse durante 10 segundos, se retrase un poco, también podría causar que falle la verificación del lado del servidor. Como resultado, verificar si la duración excedió los 10 segundos no es suficiente y requeriría un búfer adicional. Sin embargo, siento que codificar arbitrariamente el búfer a algo así como 1 o 2 segundos podría generar problemas y se siente como una solución alternativa que no es muy sólida.

Pregunta: Me pregunto si hay un enfoque diferente que me falta para mantener el temporizador del lado del cliente inviolable y preciso. También quiero tratar de evitar la creación de temporizadores separados con setTimeout() o similares para cada usuario conectado en el lado del servidor, ya que muchos usuarios podrían estar conectados en un momento dado, y tener tantos temporizadores en cola en el servidor se siente sin recursos También quiero tratar de mantener al mínimo la cantidad de mensajes que se envían entre el cliente y el servidor.