Editing Sealedkey / pfsSKKey

This key can be found on different places and will be used for eg. SaveGame or Trophy Data decryption and encryption.
==== Paths ====
{| class="wikitable"
|-
! Kind !! Path
|-
| Trophys || /user/home/[[User ID|user Id]]/trophy/data/[[sce_trop]]/sealedkey
|-
| SaveGames || /user/home/[[User ID|user Id]]/[[NP Title ID|title Id]]/[[save data directory]]/[[sce_sys]]/
|}

== Structure ==
- size always 96 bytes

{| class="wikitable"
|-
! From !! To !! Description
|-
| 00 || 07 || MAGIC ("pfsSKKey") (?playstation file system sealed key key?)
|-
| 08 || 0F || Category (game=1 or version ?)
|-
| 10 || 1F || IV (16 bytes)
|-
| 20 || 3F || Encrypted key (32 bytes)
|-
| 40 || 5F || SHA-256 (32 bytes)
|}

'''C'''
<source lang="c">
 typedef struct sealedkey {
     const unsigned char MAGIC[8];
     const unsigned char CAT[8];
     const unsigned char IV[16];
     const unsigned char KEY[32];
     const unsigned char SHA256[32];
 } selaedkey;
</source>

'''CSharp'''
<source lang="csharp">
 protected internal struct sealedkey {
     internal static byte[] MAGIC = new byte[8];
     internal static byte[] CAT = new byte[8];
     internal static byte[] IV = new byte[16];
     internal static byte[] KEY = new byte[32];
     internal static byte[] SHA256 = new byte[32];
 }
</source>

Note: You can't use a const byte[] defination in C#. It need to be a static byte[].

== De/En -Crypting ==
Can be decrypted by frindly asking the OS to do it for you. You will need kernel rights to be able to ask the PS4 for it.
<source lang="c">
 /* Decryption */ 
 #define foreach(item, array) \
     for (int keep = 1, \
              count = 0, \
              size = sizeof(array) / sizeof(*array); \
          keep && count != size; \
          keep = !keep, count++) \
         for (item = (array) + count; keep; keep = !keep)
 
 typedef unsigned char byte;              /* byte defination for c/c++ */
 const char USER1 = "10000000";
 const cahr usb0 = "/mnt/usb0/";
 const char usb1 = "/mnt/usb1/";
 const char pfs = "dec_pfsSK.Key";
 const char home = "/user/home/";
 const char tropkey = "/trophy/data/sce_trop/sealedkey";
 char usb_error = "[-] ERROR: Can't access usb0 nor usb1!\n[-] Will return now to caller.\n"
 char usb0path[(sizeof(usb0) + sizeof(pfs))];
 char usb1path[sizeof(usb0path)];
 byte pfsSKKey[96];
 
 /* Get's the encrypted sealed key based on user id */
 byte get_pfsSKKey(const char *userID, const char path) {
     char toOpen[(sizeof(home) + sizeof(userID) + sizeof(path))];
     FILE *pfskey = fopen(snprintf(toOpen, sizeof(toOpen), %s%s%s, home, userID, path), "rb"); 
     if (!pfskey) return NULL;
  
     byte pfsSKKey[96];
     fread(pfsSKKey, 96, 1, pfskey);
     fclose(pfskey);
     return pfsSKKey;
 }
 
 /* Dump the sealedkey. Send over tcp and save to file */
 int dumpDecryptedSealedKey(int to) {
     if (to != 0 || to != 1) return -2;
 
     byte enc_pfsSKKey;
     if (sizeof((enc_pfsSKKey = get_pfsSKKey(USER1, tropkey))) != 96) {
         printf("[-] Can not load the sealed key!\n");
         return -1;
     }
 
     /* Now decrpyt the key */
     byte dec_pfsSKKey[16];
     int i = kernel.sceSblSsDecryptSealedKey(enc_pfsSKKey, dec_pfsSKKey);
     printf("[+] sceSblSsDecryptSealedKey returned %d\n", i); 
 
     /* Sending over tcp */
     if (i) {
         if (!to) {
             printf("[+] Your decrypted sealedkey = ");
 
             foreach(byte *val, dec_pfsSKKey) {
                 printf("%02X", *val);
             }
             printf("\n");
             return 1;
         }
         else { /* Saving to file */
             printf("[+] Will try to save to file...");
	    
             snprintf(usb0path, sizeof(usb0path), %s%s, usb0, pfs);
             snprintf(usb1path, sizeof(usb1path), %s%s, usb1, pfs);
             FILE *dump = fopen(usb0path, "wb");
	  
             if (!dump) {
                 dump = fopen(usb1path, "wb");
                 if (!dump) {
                     printf("fail!\n" + usb_error);
                     return -3;
                 }
             }
             fwrite(dec_pfsSKKey, 16, 1, dump);
             printf("done!\n");
             fclose(dump);
             return 1;
         }
     }
     else printf("[+] Error!\n");
     return -1;
 }
</source>