API tools faq
paste
Advertisement
BaSs_HaXoR

PS3 PSID PATCH.PKG SOURCE

BaSs_HaXoR
Sep 22nd, 2014
544
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 13.28 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdarg.h>
  4. #include <assert.h>
  5. #include <string.h>
  6. #include <string>
  7. #include <dirent.h>
  8. #include <unistd.h>
  9. #include <fcntl.h>
  10. #include <time.h>
  11. #include <math.h>
  12. #include <stddef.h>
  13. #include <sys/process.h>
  14. #include <cell/cell_fs.h>
  15. #include <sys/ss_get_open_psid.h>
  16.  
  17. #include <sys/spu_initialize.h>
  18. #include <cell/dbgfont.h>
  19. #include <cell/sysmodule.h>
  20. #include <cell/pad/libpad.h>
  21. #include <sysutil/sysutil_sysparam.h>
  22. #include <PSGL/psglu.h>
  23.  
  24. #include "../common/gfxCommon.h"
  25. #include "../common/gfxObject.h"
  26.  
  27. #define BUTTON_SELECT       (1<<0)
  28. #define BUTTON_L3           (1<<1)
  29. #define BUTTON_R3           (1<<2)
  30. #define BUTTON_START        (1<<3)
  31. #define BUTTON_UP           (1<<4)
  32. #define BUTTON_RIGHT        (1<<5)
  33. #define BUTTON_DOWN         (1<<6)
  34. #define BUTTON_LEFT         (1<<7)
  35. #define BUTTON_L2           (1<<8)
  36. #define BUTTON_R2           (1<<9)
  37. #define BUTTON_L1           (1<<10)
  38. #define BUTTON_R1           (1<<11)
  39. #define BUTTON_TRIANGLE     (1<<12)
  40. #define BUTTON_CIRCLE       (1<<13)
  41. #define BUTTON_CROSS        (1<<14)
  42. #define BUTTON_SQUARE       (1<<15)
  43.  
  44. SYS_PROCESS_PARAM(1001, 0x10000)
  45. uint32_t new_pad;
  46. uint32_t old_pad;
  47. uint64_t psidoffset = 0x800000000045218CULL;
  48. uint64_t conidoffset = 0x80000000003C2EF0ULL;
  49. uint64_t conidoffset2 = 0x8000000000452174ULL;
  50. void systemCallbackCheck(const uint64_t status, const uint64_t param, void *userdata)
  51. {
  52.     (void)userdata;
  53.     (void)param;
  54.     switch (status)
  55.     {
  56.         case CELL_SYSUTIL_REQUEST_EXITGAME:
  57.             sys_process_exit(0);
  58.             break;
  59.         default:
  60.             break;
  61.     }
  62. }
  63.  
  64. int readPad( void )
  65. {
  66.     int ret;
  67.     uint32_t padd;
  68.     CellPadData databuf;
  69.     CellPadInfo2 infobuf;
  70.     static uint32_t old_info = 0;
  71.    
  72.     ret = cellPadGetInfo2( &infobuf );
  73.     if ( ret != 0 )
  74.         {
  75.         old_pad=new_pad = 0;
  76.         return 1;
  77.         }
  78.  
  79.     if ( infobuf.port_status[0] == CELL_PAD_STATUS_DISCONNECTED )
  80.         {
  81.         old_pad=new_pad = 0;
  82.         return 1;
  83.         }
  84.  
  85.     if((infobuf.system_info & CELL_PAD_INFO_INTERCEPTED) && (!(old_info & CELL_PAD_INFO_INTERCEPTED)))
  86.         {
  87.         old_info = infobuf.system_info;
  88.         }
  89.     else
  90.         if((!(infobuf.system_info & CELL_PAD_INFO_INTERCEPTED)) && (old_info & CELL_PAD_INFO_INTERCEPTED))
  91.             {
  92.             old_info = infobuf.system_info;
  93.             old_pad=new_pad = 0;
  94.             return 1;
  95.             }
  96.  
  97.     ret = cellPadGetData( 0, &databuf );
  98.  
  99.     if (ret != CELL_OK)
  100.         {
  101.         old_pad=new_pad = 0;
  102.         return 1;
  103.         }
  104.  
  105.     if (databuf.len == 0)
  106.         {
  107.         new_pad = 0;
  108.         return 1;
  109.         }
  110.  
  111.     padd = ( databuf.button[2] | ( databuf.button[3] << 8 ) );
  112.  
  113.     new_pad=padd & (~old_pad);
  114.     old_pad= padd;
  115.  
  116.     return 1;
  117. }
  118.  
  119. void clear()
  120. {
  121.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  122. }
  123.  
  124. static inline void poke( uint64_t addr, uint64_t val)
  125. {
  126.     system_call_2(7, addr, val);
  127. }
  128.  
  129. static inline uint64_t peek(uint64_t address)
  130. {
  131.     system_call_1(6, address);
  132.     return_to_user_prog(uint64_t);
  133. }
  134.  
  135. int mount(char *srcpath, char *dstpath)
  136. {
  137.     system_call_2(35, (uint64_t) srcpath, (uint64_t) dstpath);
  138.     return_to_user_prog(int);
  139. }
  140.  
  141. void dumpLV2(const char *path)
  142. {
  143.     FILE *output;
  144.     uint64_t temp;
  145.     uint64_t startpos;
  146.     uint64_t endpos;
  147.        
  148.     startpos = 0x8000000000000000ULL;
  149.     endpos = 0x80000000007FFFFFULL;
  150.     output = fopen (path, "wb");
  151.        
  152.     for (uint64_t i = startpos; i < endpos; i = i + sizeof(uint64_t))
  153.     {
  154.         temp = peek (i);
  155.         fwrite (&temp, sizeof(uint64_t), 1, output);
  156.     }
  157.        
  158.     fclose (output);
  159. }
  160.  
  161. uint64_t hexToULong(const char *chars)
  162. {
  163.     return strtoull (chars,NULL,16);
  164. }
  165.  
  166. int strLen(char *str)
  167. {
  168.   int count = 0;
  169.   while (*str++) count++;
  170.   return count;
  171. }
  172.  
  173. char *strToHexStr(char *str)
  174. {
  175.     char *newstr = new char[16];
  176.     memset(newstr, 0, 16);
  177.     int len = strLen(str);
  178.    
  179.     for(int i = 0; i < len; i++)
  180.     {
  181.         char *chrs = new char[2];
  182.         sprintf(chrs, "%02X", (char)str[i]);
  183.         strcat(newstr, chrs);
  184.     }
  185.    
  186.     for(int i = len; i < 8; i++)
  187.         strcat(newstr, "00");
  188.    
  189.     return(newstr);
  190. }
  191.  
  192. uint64_t strToULong(char *str)
  193. {
  194.     char *chars = strToHexStr(str);
  195.     return hexToULong(chars);
  196. }
  197. char* currentPSID = new char[32];
  198. char* currentCONID = new char[32];
  199. void refreshCONID()
  200. {
  201.     uint64_t part1 = peek(conidoffset);
  202.     uint64_t part2 = peek(conidoffset + 0x8);
  203.     uint64_t part3 = peek(conidoffset + 0x10);
  204.     uint64_t part4 = peek(conidoffset + 0x18);
  205.     currentCONID = new char[36];
  206.     sprintf(currentCONID, "%016llx\n%016llx\n%016llx\n%016llx", part1, part2, part3, part4);
  207. }
  208. void refreshPSID()
  209. {
  210.     CellSsOpenPSID psid;
  211.  
  212.     sys_ss_get_open_psid(&psid);
  213.     char* charshigh = new char[16];
  214.     sprintf(charshigh, "%016llx", psid.high);
  215.     char* charslow = new char[16];
  216.     sprintf(charslow, "%016llx", psid.low);
  217.     currentPSID = new char[32];
  218.     sprintf(currentPSID, "%s%s", charshigh, charslow);
  219.     refreshCONID();
  220. }
  221. int isMounted(const char *path)
  222. {
  223.     int i, err;
  224.     CellFsStat status;
  225.     for (i = 0; i < 2; i++) {
  226.         err = cellFsStat(path, &status);
  227.         if (err == CELL_FS_SUCCEEDED) {
  228.             return 1;
  229.         }
  230.        // sys_timer_sleep(1);
  231.     }
  232.     return 0;
  233. }
  234. int usb = 0;
  235. int main()
  236. {
  237.    
  238.     // Initialize 6 SPUs but reserve 1 SPU as a raw SPU for PSGL
  239.     sys_spu_initialize(6, 1);
  240.     cellSysutilRegisterCallback(0, systemCallbackCheck, NULL);
  241.     cellSysmoduleLoadModule(CELL_SYSMODULE_IO);
  242.     cellSysmoduleLoadModule(CELL_SYSMODULE_FS);
  243.     cellPadInit(1);
  244.     srand(time(0));
  245.     // init PSGL and get the current system width and height
  246.     gfxInitGraphics();
  247.     // initalize the dbgFonts
  248.     dbgFontInit();
  249.  
  250.     refreshPSID();
  251.    
  252.     while(1)
  253.     {
  254.         // check for exit
  255.         cellSysutilCheckCallback();
  256.        
  257.         clear();
  258.        
  259.         // read pad
  260.         readPad();
  261.        
  262.         // check if syscall works
  263.         if(peek(0x80000000003EE470ULL) == 0xffffffff80010003ULL)
  264.             break; // quit the loop
  265.            
  266.         if(new_pad & BUTTON_UP)
  267.             if(usb < 127)
  268.                 usb++;
  269.        
  270.         if(new_pad & BUTTON_DOWN)
  271.             if(usb > 0)
  272.                 usb--;
  273.                
  274.         if(new_pad & BUTTON_SELECT)
  275.         {
  276.             char device[12];
  277.             sprintf(device, "/dev_usb%03d", usb);
  278.             if(isMounted(device))
  279.             {
  280.                 char path[21];
  281.                 sprintf(path, "%s/Lv-2.bin", device);
  282.                 dumpLV2(path);
  283.                 cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "Lv-2 memory dumped to %s\nPress Start to continue.", path);
  284.                 cellDbgFontDraw();
  285.                 psglSwap();
  286.                 while(1)
  287.                 {
  288.                     readPad();
  289.                     if(old_pad & BUTTON_START)
  290.                         break;
  291.                 }
  292.             }
  293.             else
  294.             {
  295.                 cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "%s isn't mounted\nPress Start to continue.", device);
  296.                 cellDbgFontDraw();
  297.                 psglSwap();
  298.                 while(1)
  299.                 {
  300.                     readPad();
  301.                     if(old_pad & BUTTON_START)
  302.                         break;
  303.                 }
  304.             }
  305.         }
  306.         if(new_pad & BUTTON_L1)
  307.         {
  308.             int fd;
  309.             char part1[17];
  310.             char part2[17];
  311.             char part3[17];
  312.             char part4[17];
  313.             uint64_t nrw;
  314.             char device[12];
  315.             sprintf(device, "/dev_usb%03d", usb);
  316.             if(isMounted(device))
  317.             {
  318.                 char path[26];
  319.                 sprintf(path, "%s/consoleid.txt", device);
  320.                 CellFsErrno err = cellFsOpen(path,
  321.                          CELL_FS_O_RDONLY, &fd, NULL, 0);
  322.                 if(err == CELL_FS_SUCCEEDED)
  323.                 {
  324.                     //yay
  325.                     err = cellFsRead(fd, (void *)part1, (uint64_t)16, &nrw);
  326.                     if(err == CELL_FS_SUCCEEDED && nrw >= 16)
  327.                     {
  328.                         part1[16] = '\0';
  329.                         err = cellFsRead(fd, (void *)part2, (uint64_t)16, &nrw);
  330.                         if(err == CELL_FS_SUCCEEDED && nrw >= 16)
  331.                         {
  332.                             part2[16] = '\0';
  333.                             err = cellFsRead(fd, (void *)part3, (uint64_t)16, &nrw);
  334.                             if(err == CELL_FS_SUCCEEDED && nrw >= 16)
  335.                             {
  336.                                 part3[16] = '\0';
  337.                                 err = cellFsRead(fd, (void *)part4, (uint64_t)16, &nrw);
  338.                                 if(err == CELL_FS_SUCCEEDED && nrw >= 16)
  339.                                 {
  340.                                     part4[16] = '\0';
  341.                                     // write out the consoleid now
  342.                                     uint64_t part1u = hexToULong(part1);
  343.                                     uint64_t part2u = hexToULong(part2);
  344.                                     uint64_t part3u = hexToULong(part3);
  345.                                     uint64_t part4u = hexToULong(part4);
  346.                                     poke(conidoffset, part1u);
  347.                                     poke(conidoffset + 0x8, part2u); // 4 64-bit integers          
  348.                                     poke(conidoffset + 0x10, part3u);
  349.                                     poke(conidoffset + 0x18, part4u);
  350.                                     poke(conidoffset2, part1u);
  351.                                     poke(conidoffset2 + 0x8, part2u);
  352.                                 }
  353.                                 else
  354.                                 {
  355.                                     cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "Unable to read consoleid part 4\nPress Start to continue.");
  356.                                     cellDbgFontDraw();
  357.                                     psglSwap();
  358.                                     while(1)
  359.                                     {
  360.                                         readPad();
  361.                                         if(old_pad & BUTTON_START)
  362.                                             break;
  363.                                     }
  364.                                 }                      
  365.                             }
  366.                             else
  367.                             {
  368.                                 cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "Unable to read consoleid part 3\nPress Start to continue.");
  369.                                 cellDbgFontDraw();
  370.                                 psglSwap();
  371.                                 while(1)
  372.                                 {
  373.                                     readPad();
  374.                                     if(old_pad & BUTTON_START)
  375.                                         break;
  376.                                 }
  377.                             }                      
  378.                         }
  379.                         else
  380.                         {
  381.                             cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "Unable to read consoleid part 2\nPress Start to continue.");
  382.                             cellDbgFontDraw();
  383.                             psglSwap();
  384.                             while(1)
  385.                             {
  386.                                 readPad();
  387.                                 if(old_pad & BUTTON_START)
  388.                                     break;
  389.                             }
  390.                         }
  391.                     }
  392.                     else
  393.                     {
  394.                         cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "Unable to read consoleid part 1\nPress Start to continue.");
  395.                         cellDbgFontDraw();
  396.                         psglSwap();
  397.                         while(1)
  398.                         {
  399.                             readPad();
  400.                             if(old_pad & BUTTON_START)
  401.                                 break;
  402.                         }
  403.                     }
  404.                     err = cellFsClose(fd);
  405.                 }
  406.                 else
  407.                 {
  408.                     cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "Unable to read consoleid.txt\nPress Start to continue.");
  409.                     cellDbgFontDraw();
  410.                     psglSwap();
  411.                     while(1)
  412.                     {
  413.                         readPad();
  414.                         if(old_pad & BUTTON_START)
  415.                             break;
  416.                     }
  417.                 }
  418.             }
  419.             else
  420.             {
  421.                 cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "%s isn't mounted\nPress Start to continue.", device);
  422.                 cellDbgFontDraw();
  423.                 psglSwap();
  424.                 while(1)
  425.                 {
  426.                     readPad();
  427.                     if(old_pad & BUTTON_START)
  428.                         break;
  429.                 }
  430.             }
  431.             refreshPSID();
  432.         }
  433.         if(new_pad & BUTTON_R1)
  434.         {
  435.             int fd;
  436.             char part1[17];
  437.             char part2[17];
  438.             uint64_t nrw;
  439.             char device[12];
  440.             sprintf(device, "/dev_usb%03d", usb);
  441.             if(isMounted(device))
  442.             {
  443.                 char path[21];
  444.                 sprintf(path, "%s/psid.txt", device);
  445.                 CellFsErrno err = cellFsOpen(path,
  446.                          CELL_FS_O_RDONLY, &fd, NULL, 0);
  447.                 if(err == CELL_FS_SUCCEEDED)
  448.                 {
  449.                     //yay
  450.                     err = cellFsRead(fd, (void *)part1, (uint64_t)16, &nrw);
  451.                     if(err == CELL_FS_SUCCEEDED && nrw >= 16)
  452.                     {
  453.                         part1[16] = '\0';
  454.                         err = cellFsRead(fd, (void *)part2, (uint64_t)16, &nrw);
  455.                         if(err == CELL_FS_SUCCEEDED && nrw >= 16)
  456.                         {
  457.                             part2[16] = '\0';
  458.                             // write out the PSID now
  459.                             uint64_t part1u = hexToULong(part1);
  460.                             uint64_t part2u = hexToULong(part2);
  461.                             poke(psidoffset, part1u); // PSID starts at 0x800000000044A18C
  462.                             poke(psidoffset + 0x8ULL, part2u); //   2 64-bit integers                      
  463.                         }
  464.                         else
  465.                         {
  466.                             cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "Unable to read PSID part 2\nPress Start to continue.");
  467.                             cellDbgFontDraw();
  468.                             psglSwap();
  469.                             while(1)
  470.                             {
  471.                                 readPad();
  472.                                 if(old_pad & BUTTON_START)
  473.                                     break;
  474.                             }
  475.                         }
  476.                     }
  477.                     else
  478.                     {
  479.                         cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "Unable to read PSID part 1\nPress Start to continue.");
  480.                         cellDbgFontDraw();
  481.                         psglSwap();
  482.                         while(1)
  483.                         {
  484.                             readPad();
  485.                             if(old_pad & BUTTON_START)
  486.                                 break;
  487.                         }
  488.                     }
  489.                     err = cellFsClose(fd);
  490.                 }
  491.                 else
  492.                 {
  493.                     cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "Unable to read psid.txt\nPress Start to continue.");
  494.                     cellDbgFontDraw();
  495.                     psglSwap();
  496.                     while(1)
  497.                     {
  498.                         readPad();
  499.                         if(old_pad & BUTTON_START)
  500.                             break;
  501.                     }
  502.                 }
  503.             }
  504.             else
  505.             {
  506.                 cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "%s isn't mounted\nPress Start to continue.", device);
  507.                 cellDbgFontDraw();
  508.                 psglSwap();
  509.                 while(1)
  510.                 {
  511.                     readPad();
  512.                     if(old_pad & BUTTON_START)
  513.                         break;
  514.                 }
  515.             }
  516.             refreshPSID();
  517.         }
  518.        
  519.         if(new_pad & BUTTON_CROSS)
  520.         {
  521.             char *part1 = new char[17];
  522.             char *part2 = new char[17];
  523.            
  524.             sprintf(part1,"%08x%08x",rand(),rand());
  525.             sprintf(part2,"%08x%08x",rand(),rand());
  526.             uint64_t part1u = hexToULong(part1);
  527.             uint64_t part2u = hexToULong(part2);
  528.             poke(psidoffset, part1u); // PSID starts at 0x800000000044A18C
  529.             poke(psidoffset + 0x8ULL, part2u); //   2 64-bit integers
  530.             refreshPSID();         
  531.         }
  532.        
  533.         if(new_pad & BUTTON_SQUARE)
  534.         {
  535.             char *part1 = new char[17];
  536.            
  537.             sprintf(part1,"%08x%08x",rand(),rand());
  538.             uint64_t part1u = hexToULong(part1);
  539.             poke(conidoffset + 0x8, part1u);
  540.             poke(conidoffset2 + 0x8, part1u);
  541.             refreshPSID();         
  542.         }
  543.  
  544.         if(new_pad & BUTTON_TRIANGLE)
  545.             break;
  546.                        
  547.         // print help stuff
  548.         cellDbgFontPrintf( 0.06f, 0.1f, 1.15f, 0xff606060, "PSIDPatch 1.5 - by stoker25\nCurrent PSID: %s\n\nCross - Randomise PSID\nSquare - Randomise ConsoleID\nR1 - Change PSID to /dev_usb%03d/psid.txt\nL1 - Change ConsoleID to /consoleid.txt\nUp/Down - Change USB", currentPSID, usb);
  549.         cellDbgFontPrintf( 0.06f, 0.4f, 1.15f, 0xff606060, "Select - Dump Lv-2\nTriangle - Quit PSIDPatch");
  550.         cellDbgFontPrintf( 0.06f, 0.55f, 1.15f, 0xff606060, "Current Console ID:\n%s", currentCONID);
  551.         cellDbgFontDraw();
  552.  
  553.        
  554.         // swap PSGL buffers
  555.         psglSwap();
  556.         sys_timer_usleep(200000);
  557.     }
  558.    
  559.     sys_process_exit(0);
  560.     return 1;
  561. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!