Vulnerabilidades del Sistema de Navegaci贸n

3/5

Aportes 13

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

El dolor que sent铆 al no poder usar private fields 馃槀

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 鈥渆ncapsulaci贸n鈥 o 鈥減rotecci贸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 鈥#鈥

undefined