Vulnerabilidades del Sistema de Navegación

El dolor que sentí al no poder usar private fields 😂

Clases que pueden ayudarte a solucionar este desafío:

• Lo más nuevo en JavaScript Orientado a Objetos
• Module Pattern y Namespaces: propiedades privadas en JavaScript

Para solucionar el problema de seguridad en la navegación de la nave espacial, debes abordar las vulnerabilidades identificadas. En el código proporcionado, hay dos vulnerabilidades principales:
.

1. Clonación de la llave de acceso desde la propiedad _spaceShipKey del Capitán DC.
2. Clonación de la llave de acceso desde la propiedad _key de la nave espacial.

.
Para abordar la primera vulnerabilidad, debes asegurarte de que la propiedad _spaceShipKey del Capitán DC no sea accesible para otros astronautas. Puedes lograrlo haciendo la siguiente modificación en el código:

export class Astronaut {
  constructor({ name }) {
    this.name = name;
    this._spaceShipKey = undefined;
  }

  setAccessKey(accessKey) {
    if (!this._spaceShipKey) {  // Agrega esta verificación para evitar reemplazar la llave existente
      this._spaceShipKey = accessKey;
    }
  }

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

Con esta modificación, el Capitán DC solo puede establecer su llave de acceso una vez. Si se intenta establecer nuevamente, se ignorará la nueva llave.
.
Para abordar la segunda vulnerabilidad, debes asegurarte de que no se pueda acceder ni modificar directamente la propiedad _key de la nave espacial. Puedes lograrlo mediante el uso de una técnica llamada “encapsulación” o “protección de acceso” en JavaScript. Modifica el constructor de la clase SpaceShip y define una función getKey() para acceder a la llave:

export class SpaceShip {
  constructor({ key }) {
    let _key = key; // Utiliza una variable local para almacenar la llave

    this.getKey = () => {
      return _key;
    };

    this._movements = [];
  }

  getAccessKey(astronaut) {
    const isAstronaut = astronaut instanceof Astronaut;

    if (isAstronaut) {
      astronaut.setAccessKey(this.getKey());
    }
  }

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

Con esta modificación, la propiedad _key de la nave espacial se vuelve inaccesible directamente desde fuera de la clase, y solo se puede obtener a través de la función getKey(). Esto evita la clonación no autorizada de la llave de acceso.
.
Una vez realizadas estas modificaciones, el código debería ser más seguro y las vulnerabilidades identificadas estarán mitigadas.

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

class Astronaut {
    #_spaceShipKey
    constructor({ name }) {
        this.name = name;
        this.#_spaceShipKey = undefined;
    }

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

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

class SpaceShip {
    #_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");
        }
    }
}

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

export class Astronaut {
  constructor({ name }) {
    this.name = name;
    this._spaceShipKey = undefined;
  }

  set spaceShipKey(key) {
    if (this._spaceShipKey === undefined) {
      this._spaceShipKey = key;
    }
  }

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

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

  get movements() {
    return this._movements;
  }

  get astronauts() {
    return this._astronauts;
  }

  addAstronaut(astronaut) {
    const isAstronaut = astronaut instanceof Astronaut;

    if (isAstronaut) {
      this._astronauts.push(astronaut);
    }
  }

  getAccessKey(astronaut) {
    const isAstronaut = astronaut instanceof Astronaut;

    if (isAstronaut) {
      astronaut.spaceShipKey = this._key;
      this.addAstronaut(astronaut); // Agregar astronauta a la lista de astronautas a bordo de la nave
    }
  }

  navigator(direction, { astronaut }) {
    const isAstronautAccessKeyValid = this._astronautAccessKeyValid(astronaut);

    if (isAstronautAccessKeyValid) {
      this._movements.push(direction);
    } else {
      this._movements.push("Incorrect Access Key");
    }
  }

  _astronautAccessKeyValid(astronaut) {
    return this._astronauts.some(a => a === astronaut && a._spaceShipKey === this._key);
  }
}

genial interesante, pero el capitán podrá mantener el rumbo

Ya esta!! y ahora?? jajaja no me deja seguir a la siguiente clase, es normal? lo van cargando de a poco??

Muy buena modalidad! me encantó!

Solución 😄…

.
.
.
.

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

export class Astronaut {
  constructor({ name }) {
    this.name = name;
    this.private = { _spaceShipKey: undefined };
  }

  setAccessKey(accessKey) {
    this.private["_spaceShipKey"] = accessKey;
  }

  navigate(spaceShip, direction) {
    spaceShip.navigator(direction, { accessKey: this.private["_spaceShipKey"] });
  }
}

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

    if (isAstronaut) {
      astronaut.setAccessKey(this.private["_key"]);
    }
  }

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

Estan buenos estos ejercicios!

Usando el método estático defineProperty

export class Astronaut {
  constructor({ name }) {
    this.name = name;
    let _spaceShipKey = undefined;
    Object.defineProperty(this, 'accessKey', {
      get(){return _spaceShipKey},
      set (accessKey){_spaceShipKey = accessKey}
    })
  }

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

Solución con namespaces:

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

export class Astronaut {
  constructor({ name }) {
    this.name = name;
    // this._spaceShipKey = undefined;
    this.private = { _spaceShipKey: undefined };
  }

  setAccessKey(accessKey) {
    this.private["_spaceShipKey"] = accessKey;
  }

  navigate(spaceShip, direction) {
    spaceShip.navigator(direction, {
      accessKey: this.private["_spaceShipKey"],
    });
  }
}

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

  getAccessKey(astronaut) {
    const isAstronaut = astronaut instanceof Astronaut;

    if (isAstronaut) {
      astronaut.setAccessKey(this.private["_key"]);
    }
  }
  get _movements() {
    return this.private["_movements"];
  }
  navigator(direction, { accessKey }) {
    if (this.private["_key"] == accessKey) {
      this.private["_movements"].push(direction);
    } else {
      this.private["_movements"].push("Incorrect Access Key");
    }
  }
}

Sistema de navegacion arreglado ahora a culpar a capitan DC porque el es el impostor jajaja

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

export class Astronaut {
  constructor({ name }) {
    this.name = name;
    this.private = {
      _spaceShipKey: undefined
    }
  }

  setAccessKey(accessKey) {
    this.private["_spaceShipKey"] = accessKey;
  }

  navigate(spaceShip, direction) {
    spaceShip.navigator(direction, { accessKey: this.private["_spaceShipKey"] });
  }
}

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

    if (isAstronaut) {
      astronaut.setAccessKey(this.private["_key"]);
    }
  }

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

el poder de un gato “#”