Metldr dump entra y sirvete

al-elnavajas escribió:
Gonzakpo escribió:¿Alguien tiene una PS3 para donar? Necesito probar unas cosas (intentar dumpear la RAM durante el proceso de booteo).

No necesito que funcione la PS3. Cómo requisito básico necesitaría que llegue al menu aunque sea. Pero despues puede sobrecalentar o tirar luz amarilla. No importa realmente, solo me interesa el contenido de la RAM durante el booteo.[/quot

si estas por Andalucia más ceca de Granada yo mismo....


Jaja. Lamentablemente no. Estoy en Argentina. :)
El twitter de @RealPsDev pone ha 6 horas un pastie muy largo http://t.co/3B3Z3Wmc
EDITADO: When the bootldr decryptes the lv0 if you use a pulse gen (about 49ns) before it runs on ppu you can dump the decrypted lv0
Vamos que se habla del cell reset hack es decir darle un pulso de tantos ns (Segun math eran 60 aunque ahora este tio dice que son 49 ?) y al darle ese pulso la ps3 se reiniciara sin limpiar la ram y volvera a cargar el fw asi que se debia modificar el lv1 de ese fw para que busque dumpear la ram con los loaders descifrados a un usb o al disco duro.
CFW-Prophet escribió:Vamos que se habla del cell reset hack es decir darle un pulso de tantos ns (Segun math eran 60 aunque ahora este tio dice que son 49 ?) y al darle ese pulso la ps3 se reiniciara sin limpiar la ram y volvera a cargar el fw asi que se debia modificar el lv1 de ese fw para que busque dumpear la ram con los loaders descifrados a un usb o al disco duro.

Buenas,en teoria entonces el Lv0 se puede descifrar no? con el Lv0 descifrado,se observan todas las keys necesarias para firmar?
Gracias y saludos.
CFW-Prophet escribió:Vamos que se habla del cell reset hack es decir darle un pulso de tantos ns (Segun math eran 60 aunque ahora este tio dice que son 49 ?) y al darle ese pulso la ps3 se reiniciara sin limpiar la ram y volvera a cargar el fw asi que se debia modificar el lv1 de ese fw para que busque dumpear la ram con los loaders descifrados a un usb o al disco duro.

lo malo es que todas las pruebas se realizan en consolas donde podemos acceder a ellas a través de linux y unas herramientas , llamemosles así consolas vulnerables metldr ,
el problemas persiste en que esto no lo podemos sacar ahora en consolas que vienen de fabrica con el metdlr2 , ya que están vinculadas a la cell , otra cosa seria que se pudiera instalar un cfw , que se esta trabajando , para instalar pkg , y a su vez herramientas que nos ayuden por que lo de cargar copias olvidaros de momento , en estas consolas , todo lo que baya a salir se debera instalar desde firmwares salidos de fabrica 3.55 o inferiores , me refiero a los famosos cfw 3.73 en adelante (kakaroto) o como es el caso de JFW MA3.56
peivol2002 escribió:El twitter de @RealPsDev pone ha 6 horas un pastie muy largo http://t.co/3B3Z3Wmc
EDITADO: When the bootldr decryptes the lv0 if you use a pulse gen (about 49ns) before it runs on ppu you can dump the decrypted lv0


Pues no se que demuestra esto, yo tengo uno casi igual :

0x000034E0    0x00000013    sys.lv1.emuioif0irq
0x00003508    0x0000000E    lv1.ram.tkm_cr
0x00003530    0x0000000E    sys.lv1.be_ras
0x00003558    0x0000001A    sys.lv1.iosys.errorhandler
0x00003580    0x00000010    sys.lv0.revision
0x000035A8    0x0000000E    lv1.ram.tkm_pr
0x00003670    0x0000000B    be.0.tb_clk
0x000036C0    0x00000010    be.0.spu.faultbm
0x000036E8    0x00000011    sys.platform.mode
0x000037B0    0x00000010    sys.cellos.flags
0x00003800    0x00000013    sys.lv1.iosys.pciex
0x000038C8    0x0000001B    lv1.ram.ioc_ioif0_quethshld
0x000038F0    0x0000001B    lv1.ram.ioc_ioif1_quethshld
0x00003918    0x0000000F    sys.lv0.version
0x00003940    0x00000017    sys.lv1.iosys.pci.retry
0x00003968    0x00000016    lv1.ram.biu_modesetup1
0x00003990    0x00000009    sys.ac.sd
0x000039B8    0x00000016    lv1.ram.biu_modesetup2
0x00003A80    0x00000013    sys.lc.polling.time
0x00003AA8    0x0000000C    sys.ac.misc2
0x00003AD0    0x00000011    lv1.ram.spe_ragid
0x00003B98    0x00000014    lv1.ram.tkm_ioif0_ar
0x00003BC0    0x00000014    lv1.ram.tkm_ioif1_ar
0x00003BE8    0x0000001A    lv1.ram.mic_tm_threshold_0
0x00003C10    0x00000013    sys.lv1console.mode
0x00003C38    0x0000001A    lv1.ram.mic_tm_threshold_1
0x00003DA0    0x0000000F    be.0.fir.mic_f0
0x00003DC8    0x0000000F    be.0.fir.mic_f1
0x00003DF0    0x0000000F    pme.memory.size
0x00003E18    0x0000000F    be.0.ioif0.addr
0x00003E40    0x0000000F    be.0.ioif1.addr
0x00003E68    0x00000015    sys.hw.config_version
0x00003E90    0x0000000E    sys.sata.param
0x00003EB8    0x00000014    sys.hw.model_emulate
0x00003EE0    0x00000010    be.0.fir.spu0_ee
0x00003F08    0x00000010    be.0.fir.spu1_ee
0x00003F30    0x00000010    be.0.fir.spu2_ee
0x00003F58    0x00000009    be.0.nclk
0x00003F80    0x00000010    be.0.fir.spu0_em
0x00003FA8    0x0000000E    sys.flash.boot
0x00003FD0    0x0000000D    sys.qaf.qafen
0x00003FF8    0x00000010    be.0.fir.spu1_em
0x00004425    0x00000014       0000000000000 0 0
0x000044E2    0x0000000B    000  00 0 0
0x0000454F    0x00000008    000000 
0x000045FD    0x00000009    000 0 000
0x0000460A    0x0000000C    0 0    0   0
0x00004634    0x0000000A    00 0 0000
0x000046AC    0x0000000A     000000   
0x00004796    0x00000020     00 0 00000 000   0 000 0 8 0   
0x000047BF    0x0000000C    00 0 000000
0x00004823    0x0000000A      0000 0 0
0x0000497C    0x00000008    00000020
0x000049E5    0x00000009    00 00 000
0x000049F5    0x00000009    0000000 0
0x00004B05    0x00000008    0 00   0
0x00004B37    0x0000000B    00  0000 00
0x00004BA4    0x00000018    0 000     000 000 00 0 0
0x00004DAC    0x00000009       00 00
0x0001F7AF    0x00000022    (0000 0 00000000000000 01000000 00
0x0001F856    0x0000000D    0 00000000000
0x0001F873    0x00000012    00000 0 0 00000000
0x0001F89E    0x00000013    0000000 0 00000 000
0x0001F939    0x0000000D    0000 00 00 00
0x0001F981    0x0000000A    0000000000
0x0001F98C    0x0000000F     000000 0000000
0x0001FB1B    0x00000008    0000 000
0x0001FB5E    0x0000000B     0000000 0
0x0001FC35    0x00000013    000 0 000000 000000
0x0001FCDF    0x0000000E    000000  00000
0x0001FD56    0x00000008    000000 0
0x0001FD80    0x0000000A    0000 00010
0x0001FDEC    0x00000011    00000 0000  0000
0x0001FE2C    0x00000024    0000000 00000p000000000 000000000 00
0x0001FEB9    0x0000000B    00000000000
0x0001FF7A    0x00000019    00 00000000000000   00000
0x0001FFEE    0x00000015      000 00000000 000SCE
0x00067FEE    0x00000012    ???????;?????;????
0x0007FCBC    0x00000014    FFFFFFFFFFFFFFFFFFFF
0x0007FCDC    0x00000008    Un-initi
0x0007FCFC    0x00000028    SONY    PS-SYSTEM   302R               
0x0007FD2C    0x00000008    Un-initi
0x0007FD5C    0x00000008    4151   
0x00080598    0x0000001B     SLL:unload_gos: lpar_id:%d
0x00080A48    0x0000000B    /local_sys0
0x00080BE0    0x00000008    /flh/os/
0x00080C78    0x00000017    /proc/partitions/%d/mem
0x00081198    0x00000038    !!! dispatcher_mgr::pme_received : sanity check error #1
0x000819B8    0x0000003C    !!! vuart_pme::disconnect : destruct_virtual_uart, return=%u
0x00081A48    0x0000003A    !!! vuart_pme::connect : construct_virtual_uart, return=%u
0x00081A88    0x0000001C    /proc/partitions/%d/vuart/%d
0x00082FC8    0x00000025    In security_policy_manager::request:
0x00083010    0x00000024    security_policy_manager::initialize
0x00083150    0x0000002B    In security_policy_manager::register_rule:
0x000831F8    0x00000025    access_control_if::add_entry failed:
0x00083220    0x00000034    In security_policy_manager::load_additional_policy:
0x00083258    0x00000031    security_policy_manager::initialize is not called
0x00083290    0x00000011    SCE_CELLOS_SS_SPM
0x000832A8    0x0000002C    secure_profile_loader_if::get_contents_size
0x000832E8    0x00000027    secure_profile_loader_if::get_contents
0x00083330    0x00000042    In security_policy_manager::load_additional_policy: received acm:
0x00083380    0x0000001C    In security_policy_manager::
0x000833A0    0x00000018    load_additional_policy:
0x000833E0    0x00000022    access_control_if::cancel_changes
0x00083408    0x0000002A    access_control_if::commit_changes failed:
0x00083438    0x00000032    In security_policy_manager::load_internal_policy:
0x000834B0    0x00000026    access_control_if::initialize failed:
0x000834D8    0x00000016    load_internal_policy:
0x000834F0    0x00000016    register_rule failed,
0x00083508    0x00000022    access_control_if::commit_changes
0x00083530    0x00000028    In security_policy_manager::initialize:
0x00083580    0x0000002E    security_policy_manager::load_internal_policy
0x000837A8    0x00000008        name:    {
0x000837B8    0x00000008    0x%llx,
0x00083820    0x00000009        value:    {
0x00083880    0x00000024    In ss_init_repository::create_node:
0x000838E1    0x00000024    In ss_init_repository::create_node:
0x00083988    0x0000001C    In entry::remove_from_mngq:
0x00083A58    0x00000029    In access_control_if::get_acm_entry_num:
0x00083AB8    0x0000002A    In access_control_if::cleanup_rule_entry:
0x00083BA8    0x0000002E    In access_control_if::remove_rule_entry_list:
0x00083BD8    0x0000002F    object_entry::get_rule_entry_list_head failed:
0x00083C08    0x00000016    In access_control_if::
0x00083C20    0x00000018    remove_rule_entry_list:
0x00083C40    0x0000001E    entry::insert_to_mngq failed:
0x00083C60    0x00000030    In access_control_if::remove_object_rule_entry:
0x00083C98    0x00000032    access_control_if::remove_rule_entry_list failed:
0x00083CD0    0x00000030    In access_control_if::copy_all_rule_of_section:
0x00083D18    0x00000027    object_entry::get_rule_entry_list_head
0x00083D40    0x0000001F    In access_control_if::get_acm:
0x00083D60    0x0000002C    access_control_if::copy_all_rule_of_section
0x00083DB0    0x0000002A    nentry should be greater than or equal to
0x00083DE8    0x00000031    object_hashtable::get_first_object_entry failed:
0x00083E20    0x00000021    access_control_if::copy_all_rule
0x00083E48    0x00000028    object_hashtable::get_next_object_entry
0x00083E78    0x0000002B    In access_control_if::remove_object_entry:
0x00083EA8    0x0000002B    object_hashtable::get_object_entry failed:
0x00083F00    0x00000013    access_control_if::
0x00083F48    0x0000001E    In access_control_if::lookup:
0x00083F68    0x00000023    object_hashtable::get_object_entry
0x00083FB0    0x00000027    object_entry::match_rule_entry failed:
0x00083FD8    0x0000002C    In access_control_if::cleanup_object_entry:
0x00084008    0x0000002E    object_hashtable::remove_object_entry failed:
0x00084038    0x00000033    In access_control_if::register_new_rule: oe is NULL
0x00084070    0x00000033    In access_control_if::register_new_rule: new failed
0x000840A8    0x00000029    In access_control_if::register_new_rule:
0x00084148    0x0000002B    In access_control_if::register_new_object:
0x00084188    0x0000002A    object_hashtable::add_object_entry failed:
0x000841B8    0x00000021    In access_control_if::add_entry:
0x000841F8    0x0000001A    mask should not be {0, 0}
0x00084218    0x00000025    if the section is PRIMARY, SECONDARY
0x00084250    0x00000016    mask should be {0, 0}
0x00084288    0x00000027    access_control_if::register_new_object
0x000842E0    0x0000002D    access_control_if::register_new_rule failed:
0x00084310    0x00000022    In access_control_if::initialize:
0x00084378    0x00000025    object_hashtable::initialize failed:
0x00084400    0x00000024    In access_control_if::remove_entry:
0x00084500    0x00000030    In access_control_if::add_entry: section broken?
0x00084538    0x00000028    In access_control_if::remove_all_entry:
0x00084568    0x00000012    remove_all_entry:
0x00084580    0x00000021    remove_object_rule_entry failed:
0x000845C0    0x00000026    In access_control_if::commit_changes:
0x00084600    0x0000001C    invalid m_primary_mngq_num:
0x00084620    0x0000001E    invalid m_secondary_mngq_num:
0x00084640    0x0000001D    invalid m_tertiary_mngq_num:
0x00084660    0x0000001C    invalid m_default_mngq_num:
0x000846A8    0x00000026    In access_control_if::cancel_changes:
0x000846D0    0x0000002B    In object_entry::get_rule_entry_list_head:
0x00084700    0x00000021    In object_entry::add_rule_entry:
0x00084768    0x0000002D    In object_hashtable::get_first_object_entry:
0x00084798    0x00000027    In object_hashtable::get_object_entry:
0x000847C0    0x00000021    In object_hashtable::initialize:
0x00084820    0x0000002A    In object_hashtable::remove_object_entry:
0x00084898    0x0000002C    In object_hashtable::get_next_object_entry:
0x000848C8    0x00000027    In object_hashtable::add_object_entry:
0x000848F0    0x0000000B    DEFAULT.SPP
0x00084900    0x00000010    0123456789abcdef
0x00084918    0x00000010    0123456789ABCDEF
0x00086140    0x0000000B    /dev/rflash
0x00086150    0x0000000B    /dev/eflash
0x00086160    0x0000000F    /_init_storage/
0x00086170    0x0000000E    /dev/flash_num
0x00096320    0x0000001B    /proc/partitions/2/vuart/10
0x000A6AC2    0x00000008    P*|    %.9)
0x000A9B98    0x00000011    Invalid Operation
0x000A9BB0    0x0000000E    Divide By Zero
0x000A9BC0    0x00000008    Overflow
0x000A9BCC    0x00000009    Underflow
0x000A9BD8    0x0000000E    Inexact Result
0x000A9BE8    0x00000017    : Heap memory corrupted
0x000A9C00    0x0000000E    Unknown signal
0x000A9C6C    0x00000014    Abnormal termination
0x000A9C83    0x00000016    Arithmetic exception:
0x000A9C9A    0x00000013    Illegal instruction
0x000A9CB1    0x00000012    Interrupt received
0x000A9CF3    0x00000013    Termination request
0x000A9D0A    0x0000000E    Stack overflow
0x000A9D21    0x00000016    Redirect: can't open:
0x000A9D38    0x00000012    Out of heap memory
0x000A9D4F    0x00000015    User-defined signal 1
0x000A9D66    0x00000015    User-defined signal 2
0x000A9D7D    0x00000016    Pure virtual fn called
0x000A9D94    0x00000015    C++ library exception
0x000B7B86    0x0000000B    raa)m1=@lox
0x000BA9C8    0x0000000B    e)ucaJdeekm
0x000C6694    0x0000000F    e)leeJonektfa)d
0x000C814F    0x00000012    l= pa=`baa)raaknk<
0x000C81B8    0x00000019    = pa=`ba=@rva)raaknkaJkp<
0x000C8227    0x0000001A    p= pa=`ba=@rva)raaknkaJkp<
0x000C940C    0x0000000B    e)ucaJdeekm
0x000C9AC8    0x00000009    }kCx})[x|
0x000C9C7C    0x00000009    }kCx})[x|
0x000CB874    0x00000009    }kCx})[x|
0x000CBE3C    0x00000009    }kCx})[x|
0x000D1010    0x00000023    ss_init_if::notify_failure failed:
0x000D1038    0x00000021    ss_init_if::notify_ready failed:
0x000D1580    0x00000013    aim_spu_module.self
0x000D1770    0x0000000B    DEFAULT.SPP
0x000D1780    0x0000001B    SCE_CELLOS_SS_INDI_INFO_EID
0x000D1960    0x00000018    SCE_CELLOS_SS_SECURE_RTC
0x000D1A28    0x0000002B    SPL: laid or paid check error: laid:%lx %lx
0x000D1CC8    0x00000015    SCE_CELLOS_SYSTEM_MGR
0x000D1E90    0x0000000E    emer_init.self
0x000D1EA0    0x0000000D    hdd_copy.self
0x000D2390    0x00000012    PM:stored spp:%s,
0x000D23E8    0x00000022    get_repository_node_value failed:
0x000D2450    0x00000019    /flh/os/spp_verifier.self
0x000D2470    0x00000010    /rmt/default.spp
0x000D2488    0x00000013    /flh/os/default.spp
0x000D2620    0x00000008    /flh/os/
0x000D2678    0x0000000B    /local_sys0
0x000D26A8    0x00000017    /proc/partitions/%d/mem
0x000D3750    0x0000000B    sc_iso.self
0x000D37C0    0x00000013    sc_iso_factory.self
0x000D49D8    0x00000015    sc_proxy_if::sendrecv
0x000D49F0    0x00000013    (%d, 0x%x, %d, %d,
0x000D4A18    0x0000001A    In sc_proxy_if::sendrecv:
0x000D4AC0    0x00000024    buf_size should not be smaller than
0x000D4B00    0x00000008    /dev/sc3
0x000D4F10    0x0000000E    asecure_loader
0x000D4F38    0x00000008    trvk_prg
0x000D4F48    0x00000008    trvk_pkg
0x000D4F68    0x0000000B    nand_update
0x000D4F78    0x0000000A    lsp_update
0x000D4F88    0x0000000D    bdit_firmware
0x000D4F98    0x00000012    bdpt_301r_firmware
0x000D4FB0    0x00000012    bdpt_302r_firmware
0x000D4FC8    0x00000012    bdpt_303r_firmware
0x000D4FE0    0x00000009    trvk_prg0
0x000D4FF0    0x00000009    trvk_prg1
0x000D5000    0x00000009    trvk_pkg0
0x000D5010    0x00000009    trvk_pkg1
0x000D5020    0x00000012    bdpt_304r_firmware
0x000D5038    0x0000000D    END_OF_REGION
0x000D5E68    0x00000008        name:    {
0x000D5E78    0x00000008    0x%llx,
0x000D5EC8    0x00000009        value:    {
0x000D5F28    0x00000024    In ss_init_repository::create_node:
0x000D5F89    0x00000024    In ss_init_repository::create_node:
0x000D5FD0    0x00000010    0123456789abcdef
0x000D5FE8    0x00000010    0123456789ABCDEF
0x000D8199    0x00000012    flh/os/default.spp
0x000D82A0    0x0000000B    /dev/rflash
0x000D82B0    0x0000000B    /dev/eflash
0x000D82C0    0x0000000F    /_init_storage/
0x000D82D0    0x0000000E    /dev/flash_num
0x000F0060    0x0000000B    32'' TFT-TV
0x000F01C4    0x0000000B    32'' TFT-TV
0x000F1A77    0x0000000D    `partitions/2
0x000FBABA    0x0000000B    3x}9Kx}WSxH
0x0011232B    0x00000009    000000000
0x00112396    0x00000008    00000000
0x001123D3    0x00000018    000000000000000000004000
0x0011247D    0x00000008    0 01000
0x0011256B    0x00000008    000000 0
0x00112616    0x00000013    00 00000 00000000 0
0x00112759    0x0000000A    0000000000
0x0011279D    0x00000010    0000000000 000 0
0x00112838    0x0000000A    0 00000000
0x00112871    0x0000001C    0000000000 00000000000000 00
0x00112894    0x0000000A    0  00000 0
0x001128D1    0x0000000C     00000 00000
0x001128DE    0x00000018    000000 0080000000000 00
0x00112968    0x0000001E    00000 00 000000 00000 000000 0
0x0011299F    0x00000012    00000 000000000000
0x001129BC    0x00000009    000000000
0x001129C6    0x00000009    000 00000
0x00112A7D    0x00000008    000000 
0x00112B33    0x00000011    0000000000000000
0x00112C62    0x00000009     000 0000
0x00112D41    0x00000024    00 0000 0 0 000000000000000000000000
0x00112E0A    0x00000010    0000000000 0 0 0
0x00112E2D    0x00000017    00000000 000 00 000 0 0
0x00112EDB    0x00000009    00 020000
0x00112F4B    0x00000008    0000 000
0x00113112    0x0000000A    0 0 00000
0x0011311D    0x0000000D    000000 00 00
0x00113193    0x00000012    00000000000 00000
0x00113253    0x0000000A    0000000000
0x0011325E    0x0000000E    000  000000000
0x001132EF    0x0000000F    00 0  0000 0000
0x001134C4    0x0000000A    000080000
0x001135C6    0x0000000E    000000 00 0 0
0x001135E6    0x0000000B     000000000
0x00113675    0x0000000A     000000000
0x00117F48    0x00000009    U)8>UJ8>8
0x00124310    0x00000008    iso_enbl
0x00124388    0x0000000F    boot_dataddress
0x00124408    0x0000000C    boot_datsize
0x00126378    0x00000010    ??/???7?????????
0x0012A0A0    0x00000008    PS3_LPAR
0x0012A0C0    0x00000017    /flh/os/lv2_kernel.self
0x0012A1C0    0x00000015    SCE_CELLOS_SYSTEM_MGR
0x0012A2A0    0x0000000B    PS2_SW_LPAR
0x0012A2C0    0x00000023    /local_sys0/ps2emu/ps2_softemu.self


Lo que me extraña es que nadie se diera cuanta antes de lo que es... ¬_¬
LUCKYMAS escribió:
CFW-Prophet escribió:Vamos que se habla del cell reset hack es decir darle un pulso de tantos ns (Segun math eran 60 aunque ahora este tio dice que son 49 ?) y al darle ese pulso la ps3 se reiniciara sin limpiar la ram y volvera a cargar el fw asi que se debia modificar el lv1 de ese fw para que busque dumpear la ram con los loaders descifrados a un usb o al disco duro.

lo malo es que todas las pruebas se realizan en consolas donde podemos acceder a ellas a través de linux y unas herramientas , llamemosles así consolas vulnerables metldr ,
el problemas persiste en que esto no lo podemos sacar ahora en consolas que vienen de fabrica con el metdlr2 , ya que están vinculadas a la cell , otra cosa seria que se pudiera instalar un cfw , que se esta trabajando , para instalar pkg , y a su vez herramientas que nos ayuden por que lo de cargar copias olvidaros de momento , en estas consolas , todo lo que baya a salir se debera instalar desde firmwares salidos de fabrica 3.55 o inferiores , me refiero a los famosos cfw 3.73 en adelante (kakaroto) o como es el caso de JFW MA3.56


¿ Habra downgrade para los que tenga la ps3 con metdlr1 pero esten en un firmware superior a 3.55 ?
Hablo de hacer downgrade sin usar el progskeet o teensy , doy por echo de que el dongle sera necesario . En caso de que sea afirmativo,¿ habra un tutorial en referente a ello ? ( downgrade , instalacion linux ,etc..) . Ah se me olvidaba , enhorabuena .
Calantra escribió:
peivol2002 escribió:El twitter de @RealPsDev pone ha 6 horas un pastie muy largo http://t.co/3B3Z3Wmc
EDITADO: When the bootldr decryptes the lv0 if you use a pulse gen (about 49ns) before it runs on ppu you can dump the decrypted lv0


Pues no se que demuestra esto, yo tengo uno casi igual :

....


Lo que me extraña es que nadie se diera cuanta antes de lo que es... ¬_¬


Esta es tu respuesta:
it tell alot of events that happen at certain addresses like the lv0 app version is set at 0x10 ect
.

Lo que quiero decir es que, en realidad no tiene que ver nada con el dump del lv0...

Saludos [bye]
atarrabia escribió: ¿ Habra downgrade para los que tenga la ps3 con metdlr1 pero esten en un firmware superior a 3.55 ?
Hablo de hacer downgrade sin usar el progskeet o teensy , doy por echo de que el dongle sera necesario . En caso de que sea afirmativo,¿ habra un tutorial en referente a ello ? ( downgrade , instalacion linux ,etc..) . Ah se me olvidaba , enhorabuena .

depende de kakaroto y su cfw , si no dejara instalar pkg para instalar el QA Flags en esa version si nos deja aparte de su ya indicado reproductor multimedia ten por seguro que si y algo mas.
hjthebest escribió:Esta es tu respuesta:
it tell alot of events that happen at certain addresses like the lv0 app version is set at 0x10 ect
.

Lo que quiero decir es que, en realidad no tiene que ver nada con el dump del lv0...

Saludos [bye]


Todo eso son las cadenas extraídas de un volcado de la ram de la ps3(eso ya lo sabía, de ahí mi último comentario),bueno en parte, por que han cortado por donde les ha dao la gana, esta información ya se conoce desde hace un par de años, na menos [rtfm]. Y obviamente no han cortao debido a la falta de memoria, más bien a la falta de contenido, a buen entendedor... ein?

LUCKYMAS escribió:depende de kakaroto y su cfw


Oye una cosa, ¿donde dice Kakaroto que va a sacar un Custom? Iluminame porfavor, por que es la primera noticia que tengo... gracias.

Saludos.
no dice que lo va a sacar si no que lo tiene echo y ya probado desde la 4.00 , cuando este todo terminado se vera a la luz , hay un hilo en el eol sobre esto y sino buca con google
https://twitter.com/#!/KaKaRoToKS/statu ... 7154190337
Calantra escribió:
hjthebest escribió:Esta es tu respuesta:
it tell alot of events that happen at certain addresses like the lv0 app version is set at 0x10 ect
.

Lo que quiero decir es que, en realidad no tiene que ver nada con el dump del lv0...

Saludos [bye]


Todo eso son las cadenas extraídas de un volcado de la ram de la ps3(eso ya lo sabía, de ahí mi último comentario),bueno en parte, por que han cortado por donde les ha dao la gana, esta información ya se conoce desde hace un par de años, na menos [rtfm]. Y obviamente no han cortao debido a la falta de memoria, más bien a la falta de contenido, a buen entendedor... ein?

LUCKYMAS escribió:depende de kakaroto y su cfw


Oye una cosa, ¿donde dice Kakaroto que va a sacar un Custom? Iluminame porfavor, por que es la primera noticia que tengo... gracias.

Saludos.


Kakaroto no va a sacar un CFW. Lo que pasa es que a la gente le encanta tergiversar la información original. Kakaroto lo dejo bien claro. El va a proveer una forma de Jailbreakear la PS3 para poder instalar paquetes (lease homebrew). No va a proveer un CFW ya cocinado. Ni tampoco se van a poder correr Backup Managers (no hay Peek&Poke). Puedes leer más acá:

http://kakaroto.homelinux.net/2011/11/c ... jailbreak/
http://www.ps3devwiki.com/index.php?tit ... reak%C2%B4

P.D: Nadie tiene una PS3 para donar? No pido que funcione bien. Solo que cargue el menu principal!!! Es para desarmar e intentar dumpear la RAM y obtener lo que todos queremos. No creen que es mejor que tenerla tirada juntando polvo?
Gonzakpo
tu mismo te lo dices , y es mas lo he dicho yo anteriormente , para instalar un programa instalador hace falta un firmware no oficial eso se llama cfw , es decir necesitamos un firmware no oficial sony en la 4-00 con un paquete instalador , eso se llama cfw , el resto ya nos encargaremos los demás, solo me hace falta eso el instalador en un firmware no oficial ya que sony no lo va ha sacar [carcajad] [carcajad] [carcajad] [carcajad] .Lo que cargue y deje de cargar es cosa de nosotros.
LUCKYMAS escribió:Gonzakpo
tu mismo te lo dices , y es mas lo he dicho yo anteriormente , para instalar un programa instalador hace falta un firmware no oficial eso se llama cfw , es decir necesitamos un firmware no oficial sony en la 4-00 con un paquete instalador , eso se llama cfw , el resto ya nos encargaremos los demás, solo me hace falta eso el instalador en un firmware no oficial ya que sony no lo va ha sacar [carcajad] [carcajad] [carcajad] [carcajad] .Lo que cargue y deje de cargar es cosa de nosotros.

No hableis sin saber, no va a sacar ningun CFW, si no un metodo para instalar homebrew EN OFW, el mismo lo ha dejado claro muchas veces...
drake19 está baneado por "clon de usuario baneado"
LUCKYMAS escribió:Gonzakpo
tu mismo te lo dices , y es mas lo he dicho yo anteriormente , para instalar un programa instalador hace falta un firmware no oficial eso se llama cfw , es decir necesitamos un firmware no oficial sony en la 4-00 con un paquete instalador , eso se llama cfw , el resto ya nos encargaremos los demás, solo me hace falta eso el instalador en un firmware no oficial ya que sony no lo va ha sacar [carcajad] [carcajad] [carcajad] [carcajad] .Lo que cargue y deje de cargar es cosa de nosotros.


si pero si alguien consiguiere habilitar la carga de backups, o se intentase lograr el peek&poke asi si no?


PD: te envie otro mensaje sobre la wii.
el primero que saco un cfw fue el mismo kakaroto, y tampoco se cargaban manager [carcajad] [carcajad] [carcajad]
LUCKYMAS escribió:el primero que saco un cfw fue el mismo kakaroto, y tampoco se cargaban manager [carcajad] [carcajad] [carcajad]

Entonces si kakaroto saca algo en 3.73 como dijo y que va en 4.0 tambien,(supongo que en mtld2 incluso no?) a partir de su metodo se podria habilitar la carga de backups posteriormente el que entienda?
Saludoos.
Calantra escribió:Todo eso son las cadenas extraídas de un volcado de la ram de la ps3(eso ya lo sabía, de ahí mi último comentario),bueno en parte, por que han cortado por donde les ha dao la gana, esta información ya se conoce desde hace un par de años, na menos [rtfm]. Y obviamente no han cortao debido a la falta de memoria, más bien a la falta de contenido, a buen entendedor... ein?


Saludos.

Eso ya lo sabemos, (en parte porque lo dice el que publico esto) y entiendo que ese es el proposito de tu anterior comentario, pero lo que intento decir es que, que lo hayas sabido o que sea viejo, eso no interesa, el tipo solo esta dando datos (sean viejos o nuevos) que son interesantes o complementen/ayuden a la extraccion del las keys del lv0...

Bueno ya veo a que se referia Josep1723, anteriormente... :-|

Saludos [bye]
LittleMan escribió:
LUCKYMAS escribió:el primero que saco un cfw fue el mismo kakaroto, y tampoco se cargaban manager [carcajad] [carcajad] [carcajad]

Entonces si kakaroto saca algo en 3.73 como dijo y que va en 4.0 tambien,(supongo que en mtld2 incluso no?) a partir de su metodo se podria habilitar la carga de backups posteriormente el que entienda?
Saludoos.


Es posible pero no probable. No hasta que un desarrollador REAL se ponga a trabajar en ellos. Kakaroto dará el primer paso. Pero el resto solo lo puede llevar a cabo un desarrollador con conocimientos. Y hasta el momento, pareciera que los desarrolladores están invernando.
LUCKYMAS escribió:Gonzakpo
tu mismo te lo dices , y es mas lo he dicho yo anteriormente , para instalar un programa instalador hace falta un firmware no oficial eso se llama cfw , es decir necesitamos un firmware no oficial sony en la 4-00 con un paquete instalador , eso se llama cfw , el resto ya nos encargaremos los demás, solo me hace falta eso el instalador en un firmware no oficial ya que sony no lo va ha sacar [carcajad] [carcajad] [carcajad] [carcajad] .Lo que cargue y deje de cargar es cosa de nosotros.


Pero vamos a ver hombre , ¿que nos quieres vender?

Kakarotoks escribió:The third jail (modifying the firmware) is not possible with my method, this means that you will not have a “CFW”, you will run your homebrew applications and games on an official firmware. This also means that without peek&poke support, none of the backup managers will work. So, again, my solution is piracy-free, and as always, I do not plan on working on a way to enable piracy (or even legal backups).


Traducción libre al spanglish :
El tercer jail (se refiere a la liberación de la consola) (modificar el Firmware) NO ES POSIBLE con mi método, esto significa que tú no vas a tener un Custom Firm Ware (por mucho que te pese), podrás correr tus aplicaciones caseras y juegos en un FIRMWARE OFICIAL. Esto también significa que no habrá "Peek&poke" (if (!peek && !poke) party=NULL;") por lo que NO funcionará ningún gestor de copias. Lo vuelvo a repetir, mi solución no permite la piratería y como siempre, no está entre mis planes trabajar en esa dirección para permitir la pirateria (o lo que es lo mismo "copias de respaldo")...


fuente? su propio Blog [qmparto] :
http://kakaroto.homelinux.net/2011/11/clarifications-about-3-73-jailbreak/

Saludos.
Gonzakpo escribió:Es posible pero no probable. No hasta que un desarrollador REAL se ponga a trabajar en ellos. Kakaroto dará el primer paso. Pero el resto solo lo puede llevar a cabo un desarrollador con conocimientos. Y hasta el momento, pareciera que los desarrolladores están invernando.

Exacto, de hecho nada mas que leer su ultima info para darse cuenta de lo que realmente sera su trabajo y a eso no se le llamara CFW como muchos creen, solo para Scene real, nada de carga de Backups (a menos que otro por medio de su trabajo lo logre [360º] )...

Saludos [bye]
Calantra escribió:Pero vamos a ver hombre , ¿que nos quieres vender?


yo no vendo nada , lo doy todo gratis sin cobrar ,pero me temo que apartir de ahora por copmentarios asi mejor me voy a apartar del tema , cuando salga lo que tenga que salir ya entraremos en materia y te recordare algunas cosas , no me gusta que se llene el hilo de comentarios asi, suerte.
LUCKYMAS escribió:
Calantra escribió:Pero vamos a ver hombre , ¿que nos quieres vender?


yo no vendo nada , lo doy todo gratis sin cobrar ,pero me temo que apartir de ahora por copmentarios asi mejor me voy a apartar del tema , cuando salga lo que tenga que salir ya entraremos en materia y te recordare algunas cosas , no me gusta que se llene el hilo de comentarios asi, suerte.


No entiendo por qué te enojas. Simplemente Calandra y yo te indicamos que Kakaroto dijo que no iba a entregar un CFW. Lo puedes leer en su blog personal. Así y todo insistes en que habrá un CFW y te enojas cuando te indicamos lo contrario. Lo tuyo ya es irracional.
LUCKYMAS escribió:
Calantra escribió:Pero vamos a ver hombre , ¿que nos quieres vender?


yo no vendo nada , lo doy todo gratis sin cobrar ,pero me temo que apartir de ahora por copmentarios asi mejor me voy a apartar del tema , cuando salga lo que tenga que salir ya entraremos en materia y te recordare algunas cosas , no me gusta que se llene el hilo de comentarios asi, suerte.

Dejalos lyckymas el tiempo te dara la razon parece ke algunos teneis amnesia
Si kakaroto nos da el install packpage file y app home y la forma de ejecutarlo,ke no es un CFW pero tampoco un OFW,lo demas no tardara
En cambio si nos da un pup ya empaketado con las keys 3.7XX/4.XX tardara mas pero saldra
gonzakpo y kalandra,como denomiais vosotros a un OFW con install packpage files y app home?
Jur...

Comentarios como "saldrá esto" o "no lo saldrá esto" no llevan a nada.

Por pura casualidad alguien siempre acierta. Es como decir "muy pronto habrá novedades"... se lleva diciendo desde hace cinco años y por pura probabilidad alguien acaba colgándose medallas, aunque no supiera ni lo que iba a salir.

Por lo tanto, los futuribles dejadlos a un lado.

Os recuerdo que el hilo no va sobre lo que puede o no salir.

Un saludo.
Bueno, aprovecho y les comento lo que (potencialmente) tengo pensado hacer.

Si buscan en la wiki de PS3DEV, en la zona dedicada a la RAM, van a encontrar las hojas de datos del XDR clock generator. En el mismo hay un pin llamado "/bypass" que deshabilita el PLL del integrado y deja pasar el clock source directo a las salidas (que alimentan la parte de la RAM). Por ende, con tan solo poner ese pin a masa mediante una resistencia de pull-down (10k, 1k o algo similar) se puede bajar el clock de referencia de las memorias XDR de 400MHz a 100MHz (eso solo si mi hipótesis de que el oscilador de la PS3 genera un clock de 100MHz). En conclusión, al bajar la velocidad de trabajo de las memorias, es mucho más sencillo conectar un analizador lógico al bus de datos de la memoria y levantar todo el bootloader durante el booteo de la PS3 (se copia descifrado a la memoria RAM). No es lo mismo muestrear una señal a 400MHz que a 100MHz.

Mi idea es utilizar un kit FPGA para improvisar un analizador lógico y dumpear la RAM completamente (al menos la parte interesante).

Esto es todo especulación obviamente y mi problema principal radica en que no tengo PS3 [carcajad]. Realmente tengo ganas de probar esto. Yo creo que puede funcionar. Requiere mucho trabajo (sobretodo lo de improvisar un analizador lógico en el kit FPGA) pero creo que debería andar con cualquier consola. Es decir, poder conseguir las keys de las consolas viejas como las de la serie 3000.

Otra opción sería generar un clock aún más bajo que 100MHz e inyectarlo (cortando pistas). Pero no estoy seguro si las memorias trabajarán bien a esa velocidad.

En fin, esa es toda mi teoría y estoy casi seguro que funciona porque es muy simple. Mi problema es que no tengo una PS3 para descuartizar. Por eso es que en los mensajes anteriores pregunté si alguien tenía una PS3 rota pero que al menos cargue hasta el menu.

A mi me gusta el HW (el software también pero no es mi profesión) y mi enfoque para romper la seguridad de la PS3 es puramente de HW. Una vez que tenga el dump (hipotéticamente) seguramente necesitaré de alguien que lo sepa interpretar (aunque supongo que debería ser trivial).

Simplemente quería compartir mis pensamientos con ustedes. Para ver si alguien me puede ayudar y también a modo de "brainstorming". Quizás alguien que lea esto tenga todas las herramientas (no como yo que no tengo PS3) para llevarlo a cabo.

Saludos.

P.D: Maldito EOL. No se puede escribir la palabra "X D R" sin que te ponga esa carita feliz!!
Muchas gracias por la informacion Gonzakpo,alguien quizas pueda hacerlo.

Saludos
yo te podria conseguir una fat 60 gb luz amarilla, no se si te serviria, si tienes manera de resucitarla de alguna forma; es de un amigo, lo unico que cuando terminaras pues tendriamos que devolversela porque utiliza las piezas para cosas de hardware tambien.
kpass escribió:yo te podria conseguir una fat 60 gb luz amarilla, no se si te serviria, si tienes manera de resucitarla de alguna forma; es de un amigo, lo unico que cuando terminaras pues tendriamos que devolversela porque utiliza las piezas para cosas de hardware tambien.


Gracias. Mandame un PM y arreglamos por ahí a ver si podemos combinar.

Lo mismo va para cualquier propuesta de este tipo. Por PM así no ensuciamos el hilo.

P.D: Les recuerdo -> Soy de Argentina!
paxama escribió:...como denomiais vosotros a un OFW con install packpage files y app home?

Yo lo denomino "Firmware jailbreakeado" (¿Existe esa palabra?) tal y como sucedía con 3.41 con dongle. No era un CFW, simplemente era un exploit que habilitaba esas opciones en OFW.
Y lo que dices es muy cierto, con Install PKG y App home se hacen maravillas [360º]
[bye]
Gonzakpo escribió:A mi me gusta el HW (el software también pero no es mi profesión) y mi enfoque para romper la seguridad de la PS3 es puramente de HW. Una vez que tenga el dump (hipotéticamente) seguramente necesitaré de alguien que lo sepa interpretar (aunque supongo que debería ser trivial).


Llegado el momento, yo podría echarte una mano con la parte del software, analizando el volcado con IDA y además cuento con una utilidad muy interesante para localizar llaves AES de PS3 XD.

Saludos.
Calantra escribió:
Gonzakpo escribió:A mi me gusta el HW (el software también pero no es mi profesión) y mi enfoque para romper la seguridad de la PS3 es puramente de HW. Una vez que tenga el dump (hipotéticamente) seguramente necesitaré de alguien que lo sepa interpretar (aunque supongo que debería ser trivial).


Llegado el momento, yo podría echarte una mano con la parte del software, analizando el volcado con IDA y además cuento con una utilidad muy interesante para localizar llaves AES de PS3 XD.

Saludos.

No,si al final,ni kakaroto ni tutha ni leches en vinagre... Da gusto leeros jaja,vosotrois podeis hacer algo coño,mas quisiera yo saber lo que vosotros fieras! [+risas] Saludos.
Calantra escribió:
Gonzakpo escribió:A mi me gusta el HW (el software también pero no es mi profesión) y mi enfoque para romper la seguridad de la PS3 es puramente de HW. Una vez que tenga el dump (hipotéticamente) seguramente necesitaré de alguien que lo sepa interpretar (aunque supongo que debería ser trivial).


Llegado el momento, yo podría echarte una mano con la parte del software, analizando el volcado con IDA y además cuento con una utilidad muy interesante para localizar llaves AES de PS3 XD.

Saludos.


Dalo por hecho. De paso me enseñas a usar el IDA que me interesa mucho aprender. Sospecho que me servirá más de una vez.

Igual, todavía esto esta todo verde porque no tengo la PS3 para desarmar. Y como viene la mano, dudo que alguien me done una. Sobretodo porque nadie me conoce acá y encima el 80% de los que visitan este foro son españoles (por el envío digo yo).
¿Podemos imaginar que Darkvolt sigue liado con el tema?

Sabemos que los sceners son muy cabezotas y en estos temas es normal encallarse dias e incluso semanas. Pero, ¿alguien de su entorno puede contarnos algo?

Un saludo.
Mucho tiempo creo que ha pasado desde que habló Darkvolt por última vez.

Considero oportuno cerrar el hilo hasta nuevas novedades.
AnonRed CfwTeam escribió:Mucho tiempo creo que ha pasado desde que habló Darkvolt por última vez.

Considero oportuno cerrar el hilo hasta nuevas novedades.


+1000000
releon escribió:
AnonRed CfwTeam escribió:Mucho tiempo creo que ha pasado desde que habló Darkvolt por última vez.

Considero oportuno cerrar el hilo hasta nuevas novedades.


+1000000

igual
Gonzakpo escribió:Bueno, aprovecho y les comento lo que (potencialmente) tengo pensado hacer.

Si buscan en la wiki de PS3DEV, en la zona dedicada a la RAM, van a encontrar las hojas de datos del X DR clock generator. En el mismo hay un pin llamado "/bypass" que deshabilita el PLL del integrado y deja pasar el clock source directo a las salidas (que alimentan la parte de la RAM). Por ende, con tan solo poner ese pin a masa mediante una resistencia de pull-down (10k, 1k o algo similar) se puede bajar el clock de referencia de las memorias X DR de 400MHz a 100MHz (eso solo si mi hipótesis de que el oscilador de la PS3 genera un clock de 100MHz). En conclusión, al bajar la velocidad de trabajo de las memorias, es mucho más sencillo conectar un analizador lógico al bus de datos de la memoria y levantar todo el bootloader durante el booteo de la PS3 (se copia descifrado a la memoria RAM). No es lo mismo muestrear una señal a 400MHz que a 100MHz.

Mi idea es utilizar un kit FPGA para improvisar un analizador lógico y dumpear la RAM completamente (al menos la parte interesante).

Esto es todo especulación obviamente y mi problema principal radica en que no tengo PS3 [carcajad]. Realmente tengo ganas de probar esto. Yo creo que puede funcionar. Requiere mucho trabajo (sobretodo lo de improvisar un analizador lógico en el kit FPGA) pero creo que debería andar con cualquier consola. Es decir, poder conseguir las keys de las consolas viejas como las de la serie 3000.

Otra opción sería generar un clock aún más bajo que 100MHz e inyectarlo (cortando pistas). Pero no estoy seguro si las memorias trabajarán bien a esa velocidad.

En fin, esa es toda mi teoría y estoy casi seguro que funciona porque es muy simple. Mi problema es que no tengo una PS3 para descuartizar. Por eso es que en los mensajes anteriores pregunté si alguien tenía una PS3 rota pero que al menos cargue hasta el menu.

A mi me gusta el HW (el software también pero no es mi profesión) y mi enfoque para romper la seguridad de la PS3 es puramente de HW. Una vez que tenga el dump (hipotéticamente) seguramente necesitaré de alguien que lo sepa interpretar (aunque supongo que debería ser trivial).

Simplemente quería compartir mis pensamientos con ustedes. Para ver si alguien me puede ayudar y también a modo de "brainstorming". Quizás alguien que lea esto tenga todas las herramientas (no como yo que no tengo PS3) para llevarlo a cabo.

Saludos.

P.D: Maldito EOL. No se puede escribir la palabra "X D R" sin que te ponga esa carita feliz!!


Muy agudo, no se me habia ocurrido la idea de "bajar" la velocidad del clock a la ram...

Tomo nota del asunto, tengo una 40gb en estado terminal, a ver si me puedo hacer con el resto del hardware y me pongo a echar un ojo.

Un saludo

Edito:

Alguien ha visto esto?

http://pastie.org/2972917
darkvolt es el mismo que el mister egg de la pagina francesa?
Algesat escribió:
Gonzakpo escribió:Bueno, aprovecho y les comento lo que (potencialmente) tengo pensado hacer.

Si buscan en la wiki de PS3DEV, en la zona dedicada a la RAM, van a encontrar las hojas de datos del X DR clock generator. En el mismo hay un pin llamado "/bypass" que deshabilita el PLL del integrado y deja pasar el clock source directo a las salidas (que alimentan la parte de la RAM). Por ende, con tan solo poner ese pin a masa mediante una resistencia de pull-down (10k, 1k o algo similar) se puede bajar el clock de referencia de las memorias X DR de 400MHz a 100MHz (eso solo si mi hipótesis de que el oscilador de la PS3 genera un clock de 100MHz). En conclusión, al bajar la velocidad de trabajo de las memorias, es mucho más sencillo conectar un analizador lógico al bus de datos de la memoria y levantar todo el bootloader durante el booteo de la PS3 (se copia descifrado a la memoria RAM). No es lo mismo muestrear una señal a 400MHz que a 100MHz.

Mi idea es utilizar un kit FPGA para improvisar un analizador lógico y dumpear la RAM completamente (al menos la parte interesante).

Esto es todo especulación obviamente y mi problema principal radica en que no tengo PS3 [carcajad]. Realmente tengo ganas de probar esto. Yo creo que puede funcionar. Requiere mucho trabajo (sobretodo lo de improvisar un analizador lógico en el kit FPGA) pero creo que debería andar con cualquier consola. Es decir, poder conseguir las keys de las consolas viejas como las de la serie 3000.

Otra opción sería generar un clock aún más bajo que 100MHz e inyectarlo (cortando pistas). Pero no estoy seguro si las memorias trabajarán bien a esa velocidad.

En fin, esa es toda mi teoría y estoy casi seguro que funciona porque es muy simple. Mi problema es que no tengo una PS3 para descuartizar. Por eso es que en los mensajes anteriores pregunté si alguien tenía una PS3 rota pero que al menos cargue hasta el menu.

A mi me gusta el HW (el software también pero no es mi profesión) y mi enfoque para romper la seguridad de la PS3 es puramente de HW. Una vez que tenga el dump (hipotéticamente) seguramente necesitaré de alguien que lo sepa interpretar (aunque supongo que debería ser trivial).

Simplemente quería compartir mis pensamientos con ustedes. Para ver si alguien me puede ayudar y también a modo de "brainstorming". Quizás alguien que lea esto tenga todas las herramientas (no como yo que no tengo PS3) para llevarlo a cabo.

Saludos.

P.D: Maldito EOL. No se puede escribir la palabra "X D R" sin que te ponga esa carita feliz!!


Muy agudo, no se me habia ocurrido la idea de "bajar" la velocidad del clock a la ram...

Tomo nota del asunto, tengo una 40gb en estado terminal, a ver si me puedo hacer con el resto del hardware y me pongo a echar un ojo.

Un saludo


Yo ya no lo sé si es posible. Estuve hablando con una persona y me iluminó un poco más en el asunto. Dumpear la RAM es posible pero eso solo nos facilitará todas las keys pero públicas. Eso significa que tampoco podríamos crear un CFW porque no podríamos firmar sin la clave privada. La única posibilidad de calcular la clave privada es teniendo dos firmas lv0 descifradas. Y para obtener eso se necesita conseguir el bootloader descifrado pero este nunca llega a la RAM :S

En fin, hasta nuevo aviso, lo de dumpear la RAM solo sirve para conseguir claves publicas. Pero aún falta la clave privada para conseguir un CFW. Y el método para hacer esto por ahora es muy superior a mi entendimiento de la materia.
Gonzakpo escribió:Yo ya no lo sé si es posible. Estuve hablando con una persona y me iluminó un poco más en el asunto. Dumpear la RAM es posible pero eso solo nos facilitará todas las keys pero públicas. Eso significa que tampoco podríamos crear un CFW porque no podríamos firmar sin la clave privada. La única posibilidad de calcular la clave privada es teniendo dos firmas lv0 descifradas. Y para obtener eso se necesita conseguir el bootloader descifrado pero este nunca llega a la RAM :S

En fin, hasta nuevo aviso, lo de dumpear la RAM solo sirve para conseguir claves publicas. Pero aún falta la clave privada para conseguir un CFW. Y el método para hacer esto por ahora es muy superior a mi entendimiento de la materia.


Lo unico que dumpearas seran los loaders (.ELF) que van encapsulados dentro del lv0 sabemos que el bootldr en primer lugar va y descifra el lv0 con la pck 0 pero si queremos estar por encima de sony hasta la eternidad seria conveniente que tuviesemos esta pck 0 que usa el bootldr (Que es per console pero nos basta con que uno de nosotros descifre cada lv0 de sony hasta el fw 6.60, etc permitiendonos cfw y fixes para siempre ademas de acabar con la necesidad de hacer de nuevo un dump en cada fw que sony saque }:/ .) aunque como dices para obtener las privadas (Para hacer un custom 4.00 instalable en consolas en dicho fw) al menos necesitamos el lv0 descifrado cosa que solo se puede lograr con el exploit de math modificado tal como hizo darkvolt.

Claro que obtenemos las publicas debido a que en el dump encontrariamos el appldr descifrado y de ahi sacamos todos los keysets analizando el dump con ida pudiendo descifrar eboots de juegos nuevos ademas de tener la posibilidad de firmar un custom fw 4.00 con las keys privadas de 3.55 por lo que el custom solo seria instalable desde el fw 3.55 o con flasher similar al 3.56 que hay ahora pero esto solo beneficiaria por un momento a algunos (quizas los interesados en psn pero...) igual sony moveria ficha, me alegra saber que alguien cerca de mi XD tambien esta interesado en esto me gustaria ayudarte pero por el momento no puedo mucho mas que los demas solo te podria ayudar despues con ida en caso de ser necesario y en darte mas detallitos :o .

Ya que usarias hw extra fpga para hacer el dumpeo y necesitas underclockear el bus de la ram te conviene saber que existen otros puntos en la mobo que te podrian ayudar a hacer esto mas facil aun es decir podemos ralentizar el proceso en la ps3 ademas de el underclocking para hacer mas rapida la captura...
bueno al menos con las publicas se pueden descifrar los eboots y cifrarlos de nuevo con las keys privadas de 3.55 no?

Algo es algo
Lynzy escribió:bueno al menos con las publicas se pueden descifrar los eboots y cifrarlos de nuevo con las keys privadas de 3.55 no?

Algo es algo


Si. Es cierto, pero sinceramente realmente eso es lo que menos me interesa al momento. Yo estoy más preocupado por los pobres que se quedaron atrapados con las consolas nuevas. Teóricamente el método de Mathieulh funciona para cualquier consola. Pero realmente es muy difícil de llevar a cabo. Se necesitaría una guía paso a paso para poder entender completamente lo que hace Mathielh.

Por lo que estuve mirando (en el IRC) Mathieulh usa el bus SPI entre la syscon y la CPU para escribir en la XDR y poder ejecutar codigo en el PPU durante el booteo. Con ese código dumpea el bootldr descifrado que durante el booteo se encuentra en la memoria del SPU0 (según mi interpretación personal). Una cosa de locos!! Algunos lo criticarán, pero realmente es un genio. Ni en un millón de años se me hubiera ocurrido algo así.

Nuestro esfuerzo tiene que concentrarse en estudiar la secuencia de booteo e intentar conseguir el bootloader descifrado. Pero eso implica entender a la PERFECCIÓN la secuencia de booteo de la PS3 y el xploit de Mathielh para poder adecuarlo al bootloader. Realmente esto solo es una tarea que podría llevar varías semanas full-time. Nada sencillo.

El objetivo de la scene tiene que ser conseguir las claves privadas con las que firman el lv0 (que se consiguen a partir de las claves del bootloader que según Mathieulh con dos bootloader descifrados se puede calcular la clave privada). Una vez conseguido eso, tenemos acceso ilimitado y eterno a la PS3. Algo mucho más ambicioso que simplemente poder modificar los eboots.

Propongo algo para que entre todos intentemos llegar a idear una forma de dumpear el bootloader en base al xploit por SPI que comentó Mathieulh.

Básicamente hay dos tareas principales por hacer:

1) Estudiar el exploit de Mathieulh, entender cómo funciona e intentar modificarlo (si es que es necesario) para que pueda correr en el PPU durante el proceso de booteo para dumpear el bootloader. No tengo idea de cómo hacer esto. Pero supongo que alguno de ustedes quizás pueda entender lo que hizo Mathieulh con su exploit.

2) Estudiar el bus SPI del Cell para determinar cómo escribir en la memoria X.DR usando dicho bus. Teóricamente se puede (en base a lo dicho por Math) pero por ahora me está costando trabajo encontrar esta info.

Un muy buen lugar para empezar es http://www.ps3devwiki.com

Y un muy buen documento (tomado de ps3devwiki) es: http://www.capsl.udel.edu/~jmanzano/Cel ... ch2006.pdf

A ver si entre todos podemos idear algo. La idea es que sea un proyecto colaborativo. Sin secretismos. Compartir descubrimientos o ideas. Nada de que una sola persona realice todo el trabajo y los demás lo alienten. Y si nadie tiene nada que aportar, es preferible el silencio. Simplemente para no contaminar el hilo de "vamos que tu puedes!".

Obviamente que yo no prometo nada como otra gente. La posibilidad de no tener éxito siempre existirá. Pero cuanta más gente se prenda en esto, más rápido se podrá llegar a algo concreto.
Gonzakpo escribió:Si. Es cierto, pero sinceramente realmente eso es lo que menos me interesa al momento. Yo estoy más preocupado por los pobres que se quedaron atrapados con las consolas nuevas. Teóricamente el método de Mathieulh funciona para cualquier consola. Pero realmente es muy difícil de llevar a cabo. Se necesitaría una guía paso a paso para poder entender completamente lo que hace Mathielh.

Por lo que estuve mirando (en el IRC) Mathieulh usa el bus SPI entre la syscon y la CPU para escribir en la XDR y poder ejecutar codigo en el PPU durante el booteo. Con ese código dumpea el bootldr descifrado que durante el booteo se encuentra en la memoria del SPU0 (según mi interpretación personal). Una cosa de locos!! Algunos lo criticarán, pero realmente es un genio. Ni en un millón de años se me hubiera ocurrido algo así.

Nuestro esfuerzo tiene que concentrarse en estudiar la secuencia de booteo e intentar conseguir el bootloader descifrado. Pero eso implica entender a la PERFECCIÓN la secuencia de booteo de la PS3 y el xploit de Mathielh para poder adecuarlo al bootloader. Realmente esto solo es una tarea que podría llevar varías semanas full-time. Nada sencillo.

El objetivo de la scene tiene que ser conseguir las claves privadas con las que firman el lv0 (que se consiguen a partir de las claves del bootloader que según Mathieulh con dos bootloader descifrados se puede calcular la clave privada). Una vez conseguido eso, tenemos acceso ilimitado y eterno a la PS3. Algo mucho más ambicioso que simplemente poder modificar los eboots.

Propongo algo para que entre todos intentemos llegar a idear una forma de dumpear el bootloader en base al xploit por SPI que comentó Mathieulh.

Básicamente hay dos tareas principales por hacer:

1) Estudiar el exploit de Mathieulh, entender cómo funciona e intentar modificarlo (si es que es necesario) para que pueda correr en el PPU durante el proceso de booteo para dumpear el bootloader. No tengo idea de cómo hacer esto. Pero supongo que alguno de ustedes quizás pueda entender lo que hizo Mathieulh con su exploit.

2) Estudiar el bus SPI del Cell para determinar cómo escribir en la memoria X.DR usando dicho bus. Teóricamente se puede (en base a lo dicho por Math) pero por ahora me está costando trabajo encontrar esta info.

Un muy buen lugar para empezar es http://www.ps3devwiki.com

Y un muy buen documento (tomado de ps3devwiki) es: http://www.capsl.udel.edu/~jmanzano/Cel ... ch2006.pdf

A ver si entre todos podemos idear algo. La idea es que sea un proyecto colaborativo. Sin secretismos. Compartir descubrimientos o ideas. Nada de que una sola persona realice todo el trabajo y los demás lo alienten. Y si nadie tiene nada que aportar, es preferible el silencio. Simplemente para no contaminar el hilo de "vamos que tu puedes!".

Obviamente que yo no prometo nada como otra gente. La posibilidad de no tener éxito siempre existirá. Pero cuanta más gente se prenda en esto, más rápido se podrá llegar a algo concreto.


Sabemos entonces que el bootldr es el primer codigo ppu en ejecutarse justo cuando enciende el cell.

Mathieulth escribió:The first one I published can be used in conjunction to a hardware hack to get the bootloader to decrypt lv0 for you, you can also calculate lv0's private key through this, this means you can decrypt lv0, encrypt lv0 using the existing decrypted metdata keys, and sign lv0, you just need to use a ps3 to go through the process of decrypting each lv0 revision though. Know that if you sign lv0 you can also use yet another exploit to gain code execution on the bootloader and dump the keys and be able to decrypt lv0 straight on pc.

El primero que publique puede ser usado en conjunto con un hack de hardware para obtener el bootloader y descifrar lv0, podemos calcular las claves privadas del lv0 por medio de esto, esto quiere decir que puedes descifrar lv0, cifrar lv0 usando las ya existentes metadata keys descifradas, y firmar lv0, solo necesitas una PS3 para hacer el proceso de descifrar cada revision del lv0. Debes saber que si firmas un LV0 podras usar otro exploit para obtener permisos de ejecucion de codigo en el bootldr y dumpear las keys (per console key 0) y poder descifrar el lv0 en tu PC.


En el primero puede referirse a lo que dijo darkvolt ya que seria cargar bootldr para descifrar el lv0 o el metadata de su header cada vez que tengamos que descifrar un nuevo lv0 de sony

Darkvolt escribió:el lv0 se puede descifrar si se arreglan los registers del exploit de math para cargar bootldr y descifrar el metadata del header del lv0 y con eso descifrar el resto de sus secciones con sus loaders...


Sabemos que en el boot se carga al bootldr y este se queda en la local store de un spe
Mathieulth escribió:El segundo exploit explicado en el paso 2 (y usado en los archivos filtrados) que yo llamo "Exploit de la Dona" se basa en usar cableado alrededor de la memoria para engañar al metldr en la carga de una seccion .self dentro de su propio codigo (Y OBTENER PERMISOS DE EJECUCION DE CODIGO), este exploit solo funciona en el METLDR y no en el metldr.2 debido a que requiere que se firme un loader. Aunque hay otro exploit de los loaders que funciona en metldr y metldr.2 y permite los mismos permisos del anterior pero se basa en una implementacion de hardware dificil de encontrar, debido a que no es un exploit de software (Aunque puede ser hecha totalmente por software a menos que tengas codigo ejecutandose en la ppu con privilegios del lv2).


El exploit al que te has referido al igual que mi persona debe de ser el primero es decir hacer que nuestro propio codigo ppu pueda copiarse en la memoria haciendo que el metldr lo cargue ganando la posibilidad de ejecutarse y hacer el dump del local store con el bootldr.

Obviamente el resultado final del exploit sera un .self basado en este codigo (Tenemos que modificarlo para dumpear el local store de un spu donde deberia estar el bootldr) que deberemos hacer que metdlr cargue en el boot:

/*
* SPP verifier direct
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published
* by the Free Software Foundation; version 2 of the License.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/workqueue.h>
#include <linux/mmzone.h>
#include <linux/io.h>
#include <linux/mm.h>
#include <linux/fs.h>

#include <linux/buffer_head.h>

#include <asm/uaccess.h>
#include <asm/lv1call.h>

#include "spu.h"

#define PROC_ROOT      "metldrpwn"
#define PROC_METLDR      "metldr"
#define PROC_ISOLDR      "mathldr"
#define PROC_RVKPRG      "rvkprg"
#define PROC_EID0      "eid0"
#define PROC_SPU      "spu"
#define PROC_DEBUG      "debug"
#define PROC_RUN      "run"
#define PROC_PROFILE      "profile"
#define PROC_DUMP      "dump"

#define METLDR_PAGE_ORDER   4
#define ISOLDR_PAGE_ORDER   5
#define RVKPRG_PAGE_ORDER   0
#define EID0_PAGE_ORDER      0
#define SPU_PAGE_ORDER      5
#define PROFILE_PAGE_ORDER   2
#define LS_ARGS_PAGE_ORDER   0

#define DEBUG_SIZE      4096
#define DUMP_SIZE      0x80000

#define EID0_LS_ADDR      0x3e400
#define LDR_ARGS_LS_ADDR   0x3e800
#define RVK_PRG_LS_ADDR      0x3f000

/*
* DPRINTF
*/
#define DPRINTF(fmt, ...)                  \
do {                           \
   if (debug_size >= (DEBUG_SIZE / 2))            \
      debug_size = 0;                  \
                           \
   debug_size += sprintf(debug + debug_size, fmt, ## __VA_ARGS__);   \
} while (0)

struct ldr_args {
   u64 prog_auth_id;
   u64 lpar_auth_id;
   void *spu_module;
   void *spu_module_arg1;
   u64 spu_module_arg1_size;
   void *spu_module_arg2;
   u64 spu_module_arg2_size;
   u8 res1[16];
   u64 field48;
   u8 res2[16];
};

static struct proc_dir_entry *proc_root;
static struct proc_dir_entry *proc_metldr;
static struct proc_dir_entry *proc_isoldr;
static struct proc_dir_entry *proc_rvkprg;
static struct proc_dir_entry *proc_eid0;
static struct proc_dir_entry *proc_spu;
static struct proc_dir_entry *proc_debug;
static struct proc_dir_entry *proc_dump;
static struct proc_dir_entry *proc_run;
static struct proc_dir_entry *proc_profile;

static unsigned char *metldr;
static unsigned char *isoldr;
static unsigned char *rvkprg;
static unsigned char *eid0;
static unsigned char *spu;

static unsigned char *debug;
static unsigned long debug_size;
static unsigned char *dump_data;

static unsigned char *profile;

static unsigned char *ls_args;

static struct workqueue_struct *workqueue;
static struct work_struct work;

static int force_exit;

static u64 ls_0x3ec00[12] = { -1 };

static u64 ls_0x3e000[] =
   { 0xff00000000ull, 0 };


struct file* file_open(const char* path, int flags, int rights) {
    struct file* filp = NULL;
    mm_segment_t oldfs;
    int err = 0;

    oldfs = get_fs();
    set_fs(get_ds());
    filp = filp_open(path, flags, rights);
    set_fs(oldfs);
    if(IS_ERR(filp)) {
       err = PTR_ERR(filp);
       return NULL;
    }
    return filp;

}

void file_close(struct file* file) {
    filp_close(file, NULL);
}

int file_write(struct file* file, unsigned long long offset, unsigned char* data, unsigned int size) {
    mm_segment_t oldfs;
    int ret;

    oldfs = get_fs();
    set_fs(get_ds());

    ret = vfs_write(file, data, size, &offset);

    set_fs(oldfs);
    return ret;
}
/*
* proc_generic_open
*/
static int proc_generic_open(struct inode *inode, struct file *file)
{
   struct proc_dir_entry *proc = PDE(inode);

   file->private_data = proc;

   return 0;
}

/*
* proc_generic_release
*/
static int proc_generic_release(struct inode *inode, struct file *file)
{
   return 0;
}

/*
* proc_generic_read
*/
static ssize_t proc_generic_read(struct file *file, char __user *buffer, size_t len, loff_t *off)
{
   struct proc_dir_entry *proc = file->private_data;
   int pos;

   pos = *off;

   if ((pos >= proc->size) || !len)
      return 0;

   if ((pos + len) > proc->size)
      len = proc->size - pos;

   if (copy_to_user(buffer, (unsigned char *) proc->data + pos, len))
      return -EFAULT;

   *off += len;

   return len;
}

/*
* proc_generic_write
*/
static ssize_t proc_generic_write(struct file *file, const char __user *buffer, size_t len, loff_t *off)
{
   struct proc_dir_entry *proc = file->private_data;
   int pos;

   pos = *off;

   if ((pos >= proc->size) || !len)
      return 0;

   if ((pos + len) > proc->size)
      len = proc->size - pos;

   if (copy_from_user((unsigned char *) proc->data + pos, buffer, len))
      return -EFAULT;

   *off += len;

   return len;
}

/*
* work_function
*/
static void work_function(struct work_struct *work)
{
   u64 ppe_id, vas_id;
   u64 priv2_addr, problem_phys, local_store_phys, unused, shadow_addr, spe_id;
   struct spu_shadow *shadow = NULL;
   struct spu_problem *problem = NULL;
   struct spu_priv2 *priv2 = NULL;
   struct ldr_args *ldr_args;
   u64 esid, vsid, offset, size;
   u64 intr_status, out_intr_mbox;
   u32 out_mbox;
   u8 cmd_tag, *ptr;
   int res;
   int dump;
   
   memset(debug, 0, DEBUG_SIZE);

   debug_size = 0;

   lv1_get_logical_ppe_id(&ppe_id);
   lv1_get_virtual_address_space_id_of_ppe(ppe_id, &vas_id);

   DPRINTF("PPE id (0x%016llx) VAS id (0x%016llx)\n", ppe_id, vas_id);

   res = lv1_construct_logical_spe(PAGE_SHIFT, PAGE_SHIFT, PAGE_SHIFT, PAGE_SHIFT, PAGE_SHIFT,
      vas_id, 0 /* type */, &priv2_addr, &problem_phys, &local_store_phys,
      &unused, &shadow_addr, &spe_id);

   DPRINTF("lv1_construct_logical_spe (0x%08x)\n", res);

   if (res)
      return;

   DPRINTF("SPE id (0x%016llx)\n", spe_id);

   res = lv1_enable_logical_spe(spe_id, 6);

   DPRINTF("lv1_enable_logical_spe (0x%08x)\n", res);

   if (res)
      goto bad;

   res = lv1_set_spe_interrupt_mask(spe_id, 0, 0x7);

   DPRINTF("lv1_set_spe_interrupt_mask(0) (0x%08x)\n", res);

   if (res)
      goto bad;

   res = lv1_set_spe_interrupt_mask(spe_id, 1, 0xf);

   DPRINTF("lv1_set_spe_interrupt_mask(1) (0x%08x)\n", res);

   if (res)
      goto bad;

   res = lv1_set_spe_interrupt_mask(spe_id, 2, 0xf);

   DPRINTF("lv1_set_spe_interrupt_mask(2) (0x%08x)\n", res);

   if (res)
      goto bad;

   res = lv1_set_spe_privilege_state_area_1_register(spe_id, MFC_SR1, 0x10);

   DPRINTF("lv1_set_spe_privilege_state_area_1_register (0x%08x)\n", res);

   if (res)
      goto bad;

   shadow = __ioremap(shadow_addr, sizeof(*shadow), _PAGE_NO_CACHE | 3);
   if (!shadow)
      goto bad;

   problem = ioremap(problem_phys, sizeof(*problem));
   if (!problem)
      goto bad;

   priv2 = ioremap(priv2_addr, sizeof(*priv2));
   if (!priv2)
      goto bad;

   esid = (GET_ESID((unsigned long) metldr) << SID_SHIFT) | SLB_ESID_V;
   vsid = (get_kernel_vsid((unsigned long) metldr, MMU_SEGSIZE_256M) << SLB_VSID_SHIFT) |
      SLB_VSID_KP | SLB_VSID_L;

   DPRINTF("ea (0x%016llx) esid (0x%016llx) vsid (0x%016llx)\n", (unsigned long long) metldr, esid, vsid);

   spu_slb_invalidate_all(priv2);

   spu_slb_set_entry(priv2, 0, esid, vsid);

   priv2->spu_cfg = 0;

   eieio();

   spu_in_mbox_write_64(problem, (u64) isoldr);

   spu_sig_notify_1_2_write_64(problem, (u64) metldr);

   spu_iso_load_req_enable(priv2);

   spu_iso_load_req(problem);

   while (1) {
      if (force_exit) {
         DPRINTF("exiting\n");
         goto bad;
      }

      res = lv1_get_spe_interrupt_status(spe_id, 0, &intr_status);

      DPRINTF("lv1_get_spe_interrupt_status(0) (0x%08x)\n", res);

      if (res)
         goto bad;

      if (intr_status) {
         res = lv1_clear_spe_interrupt_status(spe_id, 0, intr_status, 0);

         DPRINTF("lv1_clear_spe_interrupt_status(0) (0x%08x)\n", res);

         if (res)
            goto bad;
      }

      res = lv1_get_spe_interrupt_status(spe_id, 1, &intr_status);

      DPRINTF("lv1_get_spe_interrupt_status(1) (0x%08x)\n", res);

      if (res)
         goto bad;

      if (intr_status) {
         res = lv1_clear_spe_interrupt_status(spe_id, 1, intr_status, 0);

         DPRINTF("lv1_clear_spe_interrupt_status(1) (0x%08x)\n", res);

         if (res)
            goto bad;
      }

      res = lv1_get_spe_interrupt_status(spe_id, 2, &intr_status);

      DPRINTF("lv1_get_spe_interrupt_status(2) (0x%08x)\n", res);

      if (res)
         goto bad;

      if (intr_status & 0x1) {
         /* mailbox interrupt */

         if (spu_mbox_stat_intr_out_mbox_count(problem))
         {
            out_intr_mbox = priv2->spu_out_intr_mbox;

            DPRINTF("out interrupt mbox (0x%016llx)\n", out_intr_mbox);

            res = lv1_clear_spe_interrupt_status(spe_id, 2, intr_status, 0);

            DPRINTF("lv1_clear_spe_interrupt_status(2) (0x%08x)\n", res);

            if (res)
               goto bad;

            if (out_intr_mbox == 1) {
               /* transfer EID0, ldr args and revoke list for programs into SPU LS */

               DPRINTF("transferring EID0, ldr args and revoke list to LS\n");

               ldr_args = (struct ldr_args *) ls_args;
               memset(ldr_args, 0, sizeof(*ldr_args));
               ldr_args->prog_auth_id = 0x1050000003000001ull;
               ldr_args->lpar_auth_id = 0x1070000002000001ull;
               ldr_args->spu_module = spu;
               ldr_args->spu_module_arg1 = profile;
               ldr_args->spu_module_arg1_size = (1 << PROFILE_PAGE_ORDER) << PAGE_SHIFT;
               ldr_args->field48 = 3;

               cmd_tag = 1;

               if (spu_mfc_cmd_exec(problem, EID0_LS_ADDR,
                  (u64) eid0, 0x400, cmd_tag, 0, MFC_CMD_GET))
                  goto bad;

               ptr = ls_args + 1024;
               memcpy(ptr, ls_0x3ec00, sizeof(ls_0x3ec00));

               if (spu_mfc_cmd_exec(problem, 0x3ec00,
                  (u64) ptr, sizeof(ls_0x3ec00),
                  cmd_tag, 0, MFC_CMD_GET))
                  goto bad;

               if (spu_mfc_cmd_exec(problem, LDR_ARGS_LS_ADDR,
                  (u64) ldr_args, sizeof(*ldr_args), cmd_tag, 0, MFC_CMD_GET))
                  goto bad;

               if (spu_mfc_cmd_exec(problem, RVK_PRG_LS_ADDR,
                  (u64) rvkprg, *(u64 *) (rvkprg + 0x10) + *(u64 *) (rvkprg + 0x18),
                  cmd_tag, 0, MFC_CMD_GET) != 0)
                  goto bad;

               ptr = ls_args + 2048;
               memcpy(ptr, ls_0x3e000, sizeof(ls_0x3e000));

               if (spu_mfc_cmd_exec(problem, 0x3e000,
                  (u64) ptr, sizeof(ls_0x3e000),
                  cmd_tag, 0, MFC_CMD_GET))
                  goto bad;

               /* wait until MFC transfers are finished */

               DPRINTF("waiting until MFC transfers are finished\n");

               while (!spu_mfc_cmd_tag_status(problem, cmd_tag)) {
                  if (force_exit) {
                     DPRINTF("exiting\n");
                     goto bad;
                  }

                  set_current_state(TASK_INTERRUPTIBLE);
                  schedule_timeout(100);
               }

               eieio();

               DPRINTF("MFC transfers done\n");

               if (!spu_mbox_stat_out_mbox_count(problem))
                  goto bad;

               out_mbox = problem->spu_out_mbox;

               DPRINTF("out mbox (0x%08x)\n", out_mbox);

               if (out_mbox != 1)
                   break;
                  
               dump=1;
            }
            else if (out_intr_mbox == 2) {
               out_mbox = problem->spu_out_mbox;

               DPRINTF("out mbox (0x%08x)\n", out_mbox);

               res = lv1_clear_spe_interrupt_status(spe_id, 2, intr_status, 0);

               DPRINTF("lv1_clear_spe_interrupt_status(2) (0x%08x)\n", res);

               if (res)
                  goto bad;

               if (out_mbox != 2)
                  goto bad;
            }
   
         }
         if (dump != 0)
         {
            offset = 0;
            size = 0;

            while (offset < DUMP_SIZE/2)
            {
               spu_in_mbox_write(problem, offset);

               while (spu_mbox_stat_out_mbox_count(problem) == 0)
                  ;

               *(u32 *)(dump_data + size) = problem->spu_out_mbox;
               eieio();
               *(u32 *)(dump_data + size + 4) = problem->spu_out_mbox;
               eieio();
               *(u32 *)(dump_data + size + 8) = problem->spu_out_mbox;
               eieio();
               *(u32 *)(dump_data + size + 12) = problem->spu_out_mbox;
               eieio();
               
               offset += 16;
               size += 16;

/*               if (size >= sizeof(buf))
               {
               */         
         
         /*      DPRINTF("%x %x %x %x",buf[0],buf[1],buf[2],buf[3]);
/*                  if (result != 0)
                     return result;
*/
               //size = 0;
               }
            }

/*            if (size > 0)
            {
               result = gelic_xmit_data(gelic_bcast_mac_addr, 0xBEEF, buf, size);
               if (result != 0)
                  return result;
            }
*/   
            break;
         }
      
      
      
      if (!(problem->spu_status & 0x1))
         break;

      DPRINTF("sleep\n");

      set_current_state(TASK_INTERRUPTIBLE);
      schedule_timeout(100);
   }

   DPRINTF("problem status (0x%08x)\n", problem->spu_status);

bad:

   if (shadow)
      iounmap(shadow);

   if (problem) {
      spu_stop_req(problem);
      iounmap(problem);
   }

   if (priv2)
      iounmap(priv2);

   res = lv1_destruct_logical_spe(spe_id);

   DPRINTF("lv1_destruct_logical_spe (0x%08x)\n", res);
}

/*
* proc_run_write
*/
static int proc_run_write(struct file *file, const char *page, unsigned long count, void *data)
{
   queue_work(workqueue, &work);

   return count;
}

static struct file_operations proc_generic_fops = {
   .owner   = THIS_MODULE,
   .open     = proc_generic_open,
   .release = proc_generic_release,
   .read     = proc_generic_read,
   .write     = proc_generic_write,
};

/*
* construct_proc
*/
static int construct_proc(void)
{
   proc_root = proc_mkdir(PROC_ROOT, NULL);
   if (!proc_root)
      return -ENOMEM;

   proc_metldr = create_proc_entry(PROC_METLDR, S_IFREG | S_IRUGO | S_IWUSR, proc_root);
   if (!proc_metldr)
      return -ENOMEM;

   proc_metldr->proc_fops = &proc_generic_fops;
   proc_metldr->mode = S_IFREG | S_IRUGO | S_IWUSR;
   proc_metldr->uid = 0;
   proc_metldr->gid = 0;
   proc_metldr->size = (1 << METLDR_PAGE_ORDER) << PAGE_SHIFT;
   proc_metldr->data = metldr;

   proc_isoldr = create_proc_entry(PROC_ISOLDR, S_IFREG | S_IRUGO | S_IWUSR, proc_root);
   if (!proc_isoldr)
      return -ENOMEM;

   proc_isoldr->proc_fops = &proc_generic_fops;
   proc_isoldr->mode = S_IFREG | S_IRUGO | S_IWUSR;
   proc_isoldr->uid = 0;
   proc_isoldr->gid = 0;
   proc_isoldr->size = (1 << ISOLDR_PAGE_ORDER) << PAGE_SHIFT;
   proc_isoldr->data = isoldr;

   proc_rvkprg = create_proc_entry(PROC_RVKPRG, S_IFREG | S_IRUGO | S_IWUSR, proc_root);
   if (!proc_rvkprg)
      return -ENOMEM;

   proc_rvkprg->proc_fops = &proc_generic_fops;
   proc_rvkprg->mode = S_IFREG | S_IRUGO | S_IWUSR;
   proc_rvkprg->uid = 0;
   proc_rvkprg->gid = 0;
   proc_rvkprg->size = (1 << RVKPRG_PAGE_ORDER) << PAGE_SHIFT;
   proc_rvkprg->data = rvkprg;
   
    proc_eid0 = create_proc_entry(PROC_EID0, S_IFREG | S_IRUGO | S_IWUSR, proc_root);
    if (!proc_eid0)
          return -ENOMEM;

         proc_eid0->proc_fops = &proc_generic_fops;
         proc_eid0->mode = S_IFREG | S_IRUGO | S_IWUSR;
         proc_eid0->uid = 0;
         proc_eid0->gid = 0;
         proc_eid0->size = (1 << EID0_PAGE_ORDER) << PAGE_SHIFT;
         proc_eid0->data = eid0;

   proc_debug = create_proc_entry(PROC_DEBUG, S_IFREG | S_IRUGO | S_IWUSR, proc_root);
   if (!proc_debug)
      return -ENOMEM;


   proc_debug->proc_fops = &proc_generic_fops;
   proc_debug->mode = S_IFREG | S_IRUGO | S_IWUSR;
   proc_debug->uid = 0;
   proc_debug->gid = 0;
   proc_debug->size = DEBUG_SIZE;
   proc_debug->data = debug;

   proc_dump = create_proc_entry(PROC_DUMP, S_IFREG | S_IRUGO | S_IWUSR, proc_root);
   if (!proc_dump)
      return -ENOMEM;


   proc_dump->proc_fops = &proc_generic_fops;
   proc_dump->mode = S_IFREG | S_IRUGO | S_IWUSR;
   proc_dump->uid = 0;
   proc_dump->gid = 0;
   proc_dump->size = DUMP_SIZE/2;
   proc_dump->data = dump_data;

   proc_run = create_proc_entry(PROC_RUN, S_IFREG | S_IRUGO | S_IWUSR, proc_root);
   if (!proc_run)
      return -ENOMEM;

   proc_run->write_proc = proc_run_write;

   return 0;
}

/*
* destruct_proc
*/
static void destruct_proc(void)
{

   if (proc_run)
      remove_proc_entry(PROC_RUN, proc_root);

   if (proc_debug)
      remove_proc_entry(PROC_DEBUG, proc_root);

   if (proc_dump)
      remove_proc_entry(PROC_DUMP, proc_root);
      
   if (proc_spu)
      remove_proc_entry(PROC_SPU, proc_root);

   if (proc_eid0)
      remove_proc_entry(PROC_EID0, proc_root);

   if (proc_rvkprg)
      remove_proc_entry(PROC_RVKPRG, proc_root);

   if (proc_isoldr)
      remove_proc_entry(PROC_ISOLDR, proc_root);

   if (proc_metldr)
      remove_proc_entry(PROC_METLDR, proc_root);

   remove_proc_entry(PROC_ROOT, NULL);
}

/*
* metldrpwn_init
*/
static int __init metldrpwn_init(void)
{
   int res;

   metldr = (unsigned char *) __get_free_pages(GFP_KERNEL, METLDR_PAGE_ORDER);
   if (!metldr) {
      res = -ENOMEM;
      goto bad1;
   }

   memset(metldr, 0, (1 << METLDR_PAGE_ORDER) << PAGE_SHIFT);

   isoldr = (unsigned char *) __get_free_pages(GFP_KERNEL, ISOLDR_PAGE_ORDER);
   if (!isoldr) {
      res = -ENOMEM;
      goto bad2;
   }

   memset(isoldr, 0, (1 << ISOLDR_PAGE_ORDER) << PAGE_SHIFT);

   rvkprg = (unsigned char *) __get_free_pages(GFP_KERNEL, RVKPRG_PAGE_ORDER);
   if (!rvkprg) {
      res = -ENOMEM;
      goto bad3;
   }

   memset(rvkprg, 0, (1 << RVKPRG_PAGE_ORDER) << PAGE_SHIFT);
   
   eid0 = (unsigned char *) __get_free_pages(GFP_KERNEL, EID0_PAGE_ORDER);
   if (!eid0) {
      res = -ENOMEM;
      goto bad4;
   }

   memset(eid0, 0, (1 << EID0_PAGE_ORDER) << PAGE_SHIFT);
   
   profile = (unsigned char *) __get_free_pages(GFP_KERNEL, PROFILE_PAGE_ORDER);
   if (!profile) {
      res = -ENOMEM;
      goto bad7;
   }
   proc_profile = create_proc_entry(PROC_PROFILE, S_IFREG | S_IRUGO | S_IWUSR, proc_root);
   if (!proc_profile)
      return -ENOMEM;

   proc_profile->proc_fops = &proc_generic_fops;
   proc_profile->mode = S_IFREG | S_IRUGO | S_IWUSR;
   proc_profile->uid = 0;
   proc_profile->gid = 0;
   proc_profile->size = (1 << PROFILE_PAGE_ORDER) << PAGE_SHIFT;
   proc_profile->data = profile;

   memset(profile, 0, (1 << PROFILE_PAGE_ORDER) << PAGE_SHIFT);
   


   dump_data = kzalloc(DUMP_SIZE, GFP_KERNEL);
   if (!dump_data) {
      res = -ENOMEM;
      goto bad6;
   }
   
   debug = kzalloc(DEBUG_SIZE, GFP_KERNEL);
   if (!debug) {
      res = -ENOMEM;
      goto bad6;
   }

   ls_args = (unsigned char *) __get_free_pages(GFP_KERNEL, LS_ARGS_PAGE_ORDER);
   if (!ls_args) {
      res = -ENOMEM;
      goto bad8;
   }

   memset(ls_args, 0, (1 << LS_ARGS_PAGE_ORDER) << PAGE_SHIFT);

   res = construct_proc();
   if (res)
      goto bad9;

   INIT_WORK(&work, work_function);

   workqueue = create_singlethread_workqueue("metldrpwn_wq");
   if (!workqueue) {
      res = -ENOMEM;
      goto bad9;
   }

   return 0;

bad9:

   destruct_proc();
   free_pages((unsigned long) ls_args, LS_ARGS_PAGE_ORDER);

bad8:



bad7:

   kfree(debug);

bad6:

   free_pages((unsigned long) spu, SPU_PAGE_ORDER);

bad5:

   free_pages((unsigned long) eid0, EID0_PAGE_ORDER);

bad4:

   free_pages((unsigned long) rvkprg, RVKPRG_PAGE_ORDER);

bad3:

   free_pages((unsigned long) isoldr, ISOLDR_PAGE_ORDER);

bad2:

   free_pages((unsigned long) metldr, METLDR_PAGE_ORDER);

bad1:

   return res;
}

/*
* metldrpwn_exit
*/
static void __exit metldrpwn_exit(void)
{
   force_exit = 1;

   destroy_workqueue(workqueue);

   destruct_proc();

   if (metldr)
      free_pages((unsigned long) metldr, METLDR_PAGE_ORDER);

   if (isoldr)
      free_pages((unsigned long) isoldr, ISOLDR_PAGE_ORDER);

   if (rvkprg)
      free_pages((unsigned long) rvkprg, RVKPRG_PAGE_ORDER);

   if (eid0)
      free_pages((unsigned long) eid0, EID0_PAGE_ORDER);

   if (spu)
      free_pages((unsigned long) spu, SPU_PAGE_ORDER);

   if (debug)
      kfree(debug);

   if (dump_data)
      kfree(dump_data);
      
   if (ls_args)
      free_pages((unsigned long) ls_args, LS_ARGS_PAGE_ORDER);
}

module_init(metldrpwn_init);
module_exit(metldrpwn_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("SPP verifier direct");
MODULE_AUTHOR("glevand");


Se ha dicho que podemos escribir en la x dr solo a traves del bus spi y se dice que esto es increiblemente facil XD pero la verdad no veo que se haya dicho mucho sobre esto anteriormente aunque para eso solo se necesitaria el hw y las conexiones y esto por ejemplo math lo ha probado teniendo el bus a 50mhz! esto seria el SPI Fail ya que parece que sirve para comunicarnos con la ram incluso en las serie 30000 y obviamente para exploitear el bootldr e incluso el metldr.2...

En el codigo segun darkvolt tenemos que modificarle los registros aunque de seguro algo mas en principio podemos hacer lo que has dicho y documentarlo para entender mas de el. Esperemos que el proyecto se te pueda lograr gonzakpo

Saludos
Jur...

Aunque lo repetimos una y vez (y muchas cosas son de sentido común), volveremos a repetirlo para aquellos que piden cierre de hilos y demás:

1- Los hilos en los que no hay movimiento/posteos cayendo en el foro, por lo que no es necesario cerrarlos.

2- Postear por postear o postear para cerrar hilos (bien para pedir su cierre o bien para "forzar" su cierre") no está permitido; si no os interesa la temática de los hilos o no hay nada que aportar al tema sobre el que trata, por favor no posteeis. El hilo acabará cayendo en actividad o bien sólo se mantendrá si hay mensajes que aporten algo.

Postear por postear o para cerrar hilos sólo puede suponer reflotes innecesarios, crear conflictos innecesarios, flood, etc, que pueden ser motivo de infracción.

Un saludo.
Alguien sabe algo de Darkvolt? porque desde hace 10 dias que se paso por aqui no tenemos noticias suyas. Lo ultimo que dijo es que estaba "muy cerca" por lo que es de suponer que, o ha conseguido lo que pretendia (creo que era el dump del LV0) o se debe haber encontrado con alguna dificultad o problema nuevo. A ver si se pasa por aqui y nos puede dar alguna info de como va la cosa.
Todo va viento en popa, son fechas críticas (fiestas y demás) y tiene vida aparte de la scene como entendereis, además, no se quiere crear falso hype ni nada, por eso estamos un poco ausentes del hilo.
Muchas garacias por la info, esta claro fechas como estas no son para estar 25 horas delante el PC.... Bueno pues suerte y con ganas de saber que nos espera el futuro.

Mientras esperaremos los que de verdad sabemos y respetamos a los sceners, a que llege el dia que lo tengais listo.

Salu2
Highwind escribió:Todo va viento en popa, son fechas críticas (fiestas y demás) y tiene vida aparte de la scene como entendereis, además, no se quiere crear falso hype ni nada, por eso estamos un poco ausentes del hilo.


Ok, gracias Highwind. La verdad es que es mejor que siga trabajando en la "sombra" y el dia que tenga algo importante lo de a conocer si quiere.
Mathieul es un puto genio pese a quien le pese mucho mas listo que geohot
1489 respuestas