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....
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
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
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...
.it tell alot of events that happen at certain addresses like the lv0 app version is set at 0x10 ect
![[bye]](/images/smilies/nuevos2/adio.gif "adios")
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
![[rtfm]](/images/smilies/rtfm.gif "Lee!")
. Y obviamente no han cortao debido a la falta de memoria, más bien a la falta de contenido, a buen entendedor... 
LUCKYMAS escribió:depende de kakaroto y su cfw
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
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 menosLUCKYMAS 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.
![[carcajad]](/images/smilies/nuevos/risa_ani2.gif "carcajada")
.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
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
LUCKYMAS escribió:el primero que saco un cfw fue el mismo kakaroto, y tampoco se cargaban manager
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
Saludos.
LittleMan escribió:LUCKYMAS escribió:el primero que saco un cfw fue el mismo kakaroto, y tampoco se cargaban manager
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.
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
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).
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")...
![[qmparto]](/images/smilies/net_quemeparto.gif "Que me parto!")
: 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.
![[360º]](/images/smilies/nuevos/vueltas.gif "como la niña del exorcista")
)... 
R 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 R 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.. 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. paxama escribió:...como denomiais vosotros a un OFW con install packpage files y app home?
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).
. 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
Saludos.
![[+risas]](/images/smilies/nuevos/risa_ani3.gif "más 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
Saludos.
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
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!!
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
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
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.
.) 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. 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 
. 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
R 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í.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
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.
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.
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...
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).
/*
* 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");
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...