Formato .PKG

Archivado
Hola, esto estaba empezado en el hilo del exploit pero ya se sale un poco de la tematica de ese hilo y por eso he decidido hacer este nuevo para ver si asi prospera.

En el otro hilo aparece una informacion de ps3hax con parte del header de los archivos PKG y con esa informacion he preparado esta estructura pero me falta informacion para poder crear la aplicacion asiq os pego aki la estructura para que compareis e investigueis y si quereis os paso tb el codigo fuente en C de lo que yebo hecho (apenas nada porque he empezado hace una hora escasa con esto).

FORMATO .PKG:
-------------------

typedef struct PKG_header{
   unsigned char start[4];               // ".PKG"
   unsigned __int32 unk1;               // siempre "0x8000 0001"
   unsigned __int32 sec3_Offset;         // Section 3 offset "0xC0"
   unsigned __int32 unk2;               // ??? Valores "0x4","0x5","0x7" solamente (por ahora)
   unsigned __int32 sec2_Offset;         // Section 2 offset "0x80","0xA0"
   unsigned __int32 num_files_sec;         // Posiblemente numero de archivos en la seccion
   unsigned __int32 unk3;               // siempre "0x0"
   unsigned __int32 filesize;            // Tamaño del PKG
   unsigned __int32 unk4;               // siempre "0x0"
   unsigned __int32 data_sec_Offset;      // Seccion Datos offset
   unsigned __int32 unk5;               // siempre "0x0"
   unsigned __int32 size_data;            // tamaño de la seccion de datos
   unsigned char internal_name[48];      // nombre interno del archivo ej. ("EP0001-BLES00158_00-ASSASSINPATCH001............");
   unsigned char section1[32];            // Seccion 1
   unsigned char section2[64];            // Seccion 2
   typedef struct section3{
      unsigned __int32 sec1_unk1;         // valores "0x1"               por ahora
      unsigned __int32 sec1_unk2;         // valores "0x4"               por ahora
      unsigned __int32 sec1_unk3;         // valores "0x2" "0x3" "0x4" "0x5"   por ahora
      unsigned __int32 sec1_unk4;         // valores "0x2"               por ahora
      unsigned __int32 sec1_unk5;         // valores "0x4"               por ahora
      unsigned __int32 sec1_unk6;         // valores "0x1" "0x4" "0x5"      por ahora
      unsigned __int32 sec1_unk7;         // valores "0x3"               por ahora
      unsigned __int32 sec1_unk8;         // valores "0x4"               por ahora
      unsigned __int32 sec1_unk9;         // valores "0x0" "0x5A"            por ahora
      unsigned __int32 sec1_unk10;      // valores "0x4"               por ahora
      unsigned __int32 sec1_unk11;      // valores "0x8"               por ahora
      unsigned __int32 sec1_unk12;      // valores "0x0"               por ahora
      unsigned __int32 sec1_size_data;   // tamaño de la seccion de datos
      unsigned __int32 sec1_unk13;      // valores "0x0" "0x5"            por ahora
      unsigned __int32 sec1_unk14;      // valores "0x0" "0x4"            por ahora
      unsigned __int32 sec1_unk15;      // valores "0x0" "0x0960 0100" "0x0960 0101" "0x0960 0200" "0x1203 0110" por ahora
   } section3;
   unsigned char section4[64];            // Seccion 4 (PSP/PS1 archivos con lincencia tienen aqui los mismos datos)
   unsigned char section5[64];            // Seccion 5
   unsigned char SHA_1[20];            // SHA-1 del PKG (desde offset 0x0 hasta el final de la seccion 5)
   unsigned char EOF[12];               // Fin de archivo (reyeno de 0x0)
} PKG_header;



Espero que alguien se apunte, y si tiene conocimientos de C o de compresion o ficheros en hexadecimal mejor [tomaaa]

Fuente: http://www.ps3hax.net/showthread.php?t=2461
ostia como mola :P
Nunca sabre pq a a partir del hexadecimal la gente se puede imaginar que tipo de de estructura de datos tiene un archivo ^^U
Como sacais el struct?
Probando, vas cojiendo de 4bytes en 4bytes y miras a ver si lo que dicen concuerda con algo como el tamaño del fichero o algun offset donde empieze algo, y a base de mirar varios pkg vas contrastanto asta que mas o menos descubres que significa cada trocito de la cabecera.
Yo me apunto a ayudarte, voy a bajar un paquete para hacer pruebas. Por cierto, hay un programa que es editor hexadecimal, el AXE, al que tu le das una estructura de datos y te la rellena con los datos de un fichero, puede ser util para ir verificando distintos paquetes. Ahi queda eso.
Aqui os pongo la structura de datos para el Hex Workshop que es el q uso yo.

Adjuntos

pkg-file.rar (0 Bytes)

Esto te puede ayudar?

Adjuntos

1.jpg (0 Bytes)

En la cabecera de los ficheros tu crees k ira la clave publica de la store?
El nombre de los archivos es aleatorio o hara algun tipo de comprobacion con el nombre?
yo no se mucho C pero si puedo ayudar en algo ayudare
Interesante ^^ He creado una pequeña aplicacion que lee la cabecera del PKG y muestra la informacion. He modificado un poco la estructura.

http://rafb.net/p/GuLsEU92.html
Waninkoko escribió:Interesante ^^ He creado una pequeña aplicacion que lee la cabecera del PKG y muestra la informacion. He modificado un poco la estructura.

http://rafb.net/p/GuLsEU92.html


lo e compilado y no hace nada
Supongo que le estaras pasando como argumento el fichero PKG no?
Alguien me lo puede pasar compilado ? xD
Me apunto a lo que sea en programacion en C [oki]
e encontrado esto haber si es util :

The SHA hash functions are five cryptographic hash functions designed by the National Security Agency (NSA) and published by the NIST as a U.S. Federal Information Processing Standard. SHA stands for Secure Hash Algorithm.

SHA-1 Algorithm


Note: All variables are unsigned 32 bits and wrap modulo 232 when calculating

Initialize variables:
h0 = 0x67452301
h1 = 0xEFCDAB89
h2 = 0x98BADCFE
h3 = 0x10325476
h4 = 0xC3D2E1F0

Pre-processing:
append the bit '1' to the message
append k bits '0', where k is the minimum number ≥ 0 such that the resulting message
    length (in bits) is congruent to 448 (mod 512)
append length of message (before pre-processing), in bits, as 64-bit big-endian integer

Process the message in successive 512-bit chunks:
break message into 512-bit chunks
for each chunk
    break chunk into sixteen 32-bit big-endian words w[i], 0 <= i <= 15

    Extend the sixteen 32-bit words into eighty 32-bit words:
    for i from 16 to 79
        w[i] = (w[i-3] xor w[i-8] xor w[i-14] xor w[i-16]) leftrotate 1

    Initialize hash value for this chunk:
    a = h0
    b = h1
    c = h2
    d = h3
    e = h4

    Main loop:
    for i from 0 to 79
        if 0 ≤ i ≤ 19 then
            f = (b and c) or ((not b) and d)
            k = 0x5A827999
        else if 20 ≤ i ≤ 39
            f = b xor c xor d
            k = 0x6ED9EBA1
        else if 40 ≤ i ≤ 59
            f = (b and c) or (b and d) or (c and d)
            k = 0x8F1BBCDC
        else if 60 ≤ i ≤ 79
            f = b xor c xor d
            k = 0xCA62C1D6

        temp = (a leftrotate 5) + f + e + k + w[i]
        e = d
        d = c
        c = b leftrotate 30
        b = a
        a = temp

    Add this chunk's hash to result so far:
    h0 = h0 + a
    h1 = h1 + b
    h2 = h2 + c
    h3 = h3 + d
    h4 = h4 + e

Produce the final hash value (big-endian):
digest = hash = h0 append h1 append h2 append h3 append h4
Waninkoko puedes poner el programa compilado a descargar?

Gracias. [angelito]
Para el SHA-1 no hay problema el mismo editor hexadecimal que uso te lo calcula en un momento, asique no necesitamos el algoritmo de momento.

Esta noche me pondre a trastear un poko con el programa en C y os lo paso que de momento solo tene la estructura y poko mas.

Tahorass!
Nethunter escribió:Para el SHA-1 no hay problema el mismo editor hexadecimal que uso te lo calcula en un momento, asique no necesitamos el algoritmo de momento.

Esta noche me pondre a trastear un poko con el programa en C y os lo paso que de momento solo tene la estructura y poko mas.

Tahorass!


ok , pues ya veremos esta noche como ba la cosa xD
16 respuestas
Archivado
Volver a Scene