Vulnerabilidades del Sistema de Navegación

¡Salva al Capitán DC!

Miguel Ángel Torres Vargas

Estudiante

Me dolio la cabeza pero hice 3 soluciones, la cual una de ellas me deja pensando en el proceso:

Segun los recursos podiamos encapsular este proceso utilizando sea atributos privados dentro de la clase, pero si usamos #_spaceShipKey; y los llamamos respectivamente this.#_spaceShipKey; Funciona PERO no funciona en el simulador de platzi, ya que desactivaron estas reglas.

export function simulador(astronaut, spaceShip, direction) {
  astronaut.navigate(spaceShip, direction);
  return spaceShip._movements;
}

export class Astronaut {
  // Private
  #_spaceShipKey;
  constructor({ name }) {
    this.name = name;
  }

  setAccessKey(accessKey) {
    this.#_spaceShipKey = accessKey;
  }

  navigate(spaceShip, direction) {
    spaceShip.navigator(direction, { accessKey: this.#_spaceShipKey });
  }
}

export class SpaceShip {
  // Private
  #_key;
  constructor({ key }) {
    this.#_key = key;
    this._movements = [];
  }
  
  getAccessKey(astronaut) {
    const isAstronaut = astronaut instanceof Astronaut;

    if (isAstronaut) {
      astronaut.setAccessKey(this.#_key);
    }
  }

  navigator(direction, { accessKey }) {
    if (this.#_key == accessKey) {
      this._movements.push(direction)
    } else {
      this._movements.push("Incorrect Access Key");
    }
  }
}

Utilizando ya algo un poco mas avanzado, similar a la solucion del problema, se reduce la clase a propios objetos privados con narrow function properties:

export class Astronaut {
  constructor({ name }) {
    this.name = name;
    let _spaceShipKey;
    this.setAccessKey = (accessKey) => _spaceShipKey = accessKey;
    this.getAccessKey = () => _spaceShipKey;
  }

  navigate(spaceShip, direction) {
    spaceShip.navigator(direction, this);
  }
}

export class SpaceShip {
  constructor({ key }) {
    this._key = key;
    this._movements = [];
  }

  getAccessKey(astronaut) {
    if (astronaut instanceof Astronaut) {
      astronaut.setAccessKey(this._key);
    }
  }

  navigator(direction, astronaut) {
    if (astronaut instanceof Astronaut && this._key === astronaut.getAccessKey()) {
      this._movements.push(direction)
    } else {
      this._movements.push("Incorrect Access Key");
    }
  }
}

export function simulador(astronaut, spaceShip, direction) {
  astronaut.navigate(spaceShip, direction);
  return spaceShip._movements;
}

Utilizando Object.defineProperty como se menciona en el rescurso de los comentarios se llega a definir la clase y sus atributos de una manera privada para que no se lea su contendio sino que se defina solo cuando es necesario

export class Astronaut {
  constructor({ name }) {
    this.name = name;
    this._spaceShipKey;
    Object.defineProperty(this, '_spaceShipKey', {
      value: undefined,
      writable: false,
      enumerable: false,
      configurable: false
    });
  }

  setAccessKey(accessKey) {
    this._spaceShipKey = accessKey;
  }

  navigate(spaceShip, direction) {
    spaceShip.navigator(direction, this);
  }
}

export class SpaceShip {
  constructor({ key }) {
    Object.defineProperty(this, '_key', {
      value: key,
      writable: false,
      enumerable: false,
      configurable: false
    });
    this._movements = [];
  }

  getAccessKey(astronaut) {
    if (astronaut instanceof Astronaut) {
      astronaut.setAccessKey(this._key);
    }
  }

  navigator(direction, astronaut) {
    if (astronaut instanceof Astronaut && this._key === astronaut._spaceShipKey) {
      this._movements.push(direction)
    } else {
      this._movements.push("Incorrect Access Key");
    }
  }
}

export function simulador(astronaut, spaceShip, direction) {
  astronaut.navigate(spaceShip, direction);
  return spaceShip._movements;
}

Pero (Y aqui viene la pregunta), Veo que si se define en el constructor o en el metodo el Object.defineProperty no aplicara en la gran mayoria de casos su funcion y hay que sacarlo para medio "hackiar", el proceso, pero aun asi siguien siendo largo el proceso, algo similar a:

...
...

export function simulador(astronaut, spaceShip, direction) {
  astronaut.navigate(spaceShip, direction);
  return spaceShip._movements;
}

Object.defineProperty(Astronaut.prototype, "_spaceShipKey", {
  writable: false,
  configurable: false,
  enumerable: false,
  value: undefined,
});
Object.defineProperty(Astronaut.prototype, "setAccessKey", {
  writable: false,
  configurable: false,
  enumerable: false,
  value: function (accessKey) {
    Object.defineProperty(this, "_spaceShipKey", {
      writable: true,
      configurable: false,
      enumerable: false,
      value: accessKey,
    });
  },
});

pero no aplica para key ya que adentro es diferente su funcion.

La pregunta despues de todo es:

Como usar Object.defineProperty para que funcione en todos los casos.

Igual (si llega a funcionar con Object.defineProperty, en platzi me deja el ultimo (Capitán Impostor) con la informacion correcta como si las pruebas no fueran unitarias de todo si no en conjunto), vease esto presionando varias veces los botones en Vista.

Gracias por su tiempo y disculpen la extensión del post.

Juan Castro

Profesor

Las 3 soluciones que propones están excelentes. Exactamente así imaginamos el código con el que se resolvería el problema.

En efecto, los private fields son muy divertidos y cómodos de usar, aunque todavía no tengan buen soporte.
Programar todo desde el constructor para trabajar con variables locales funciona, aunque todo el código quede un poco "apeñuscado".
Y defineProperty definitivamente es lo más parecido que tenemos a hackear JavaScript para evitar completamente el acceso y modificación a nuestras propiedades, aunque llega incluso a ser demasiada protección, a veces no es tan conveniente.

CRISTIAN DARIO AGUDELO PORRAS

Estudiante

Gracias por el aporte, ya que en el curso no se explico el uso del __ # __ para definir la privacidad usando la sintaxis de class , ya que intentando con .defineProperty y con get&set no me fue posible dar solucion al problema!!

¡Salva al Capitán DC!

JavaScript POO para rescate espacial

Recupera el Sistema de Comunicaciones

Vulnerabilidades del Sistema de Navegación

Historial de Cambios en el Motor

Aprendizado contínuo em cibersegurança