C# DJsIO.ReadStream方法代码示例

 private void addImageToolStripMenuItem_Click(object sender, EventArgs e)
 {
     DJsIO xIO = new DJsIO(DJFileMode.Open, "Open a PNG", "PNG File|*.png", true);
     if (!xIO.Accessed)
         return;
     if (xIO.Length > 0x4000)
     {
         MessageBox.Show("Error: Image is too big");
         return;
     }
     byte[] x = xIO.ReadStream();
     try { Image y = x.BytesToImage(); pictureBox1.Image = y; }
     catch (Exception z) { MessageBox.Show(z.Message); return; }
     HeaderInfo.ContentImageBinary = x;
 }

 /// <summary>
 /// Writes header to the file
 /// </summary>
 /// <param name="xParams"></param>
 /// <returns></returns>
 internal bool xWriteHeader(RSAParams xParams)
 {
     if (!xParams.Valid)
         throw CryptoExcepts.ParamError;
     // Writes, hashes, and signs data to a temp file
     AddToLog("Writing Header values");
     DJsIO x = new DJsIO(true);
     if (!x.Accessed)
         return false;
     if (!xHeader.Write(ref x))
     {
         x.Close();
         return false;
     }
     xHeader.SetSize(xIO.Length - xSTFSStruct.BaseBlock);
     x.Position = 0x340;
     if (xSTFSStruct.ThisType == STFSType.Type0)
         x.Write((int)0xAD0E);
     else x.Write((int)0x971A);
     // Fills to bottom of header
     x.Position = x.Length;
     x.Write(new byte[(0x8E6 + (xSTFSStruct.BaseBlock - 0xA000))]);
     x.Position = 0x379;
     xWriteDescriptor(ref x);
     AddToLog("Writing Master hash");
     long xLocale = 0;
     if (xSTFSStruct.xBlockCount <= Constants.BlockLevel[0])
         xLocale = GenerateBaseOffset(0, TreeLevel.L0);
     else if (xSTFSStruct.xBlockCount <= Constants.BlockLevel[1])
         xLocale = GenerateBaseOffset(0, TreeLevel.L1);
     else xLocale = GenerateBaseOffset(0, TreeLevel.L2);
     XTakeHash(ref xIO, xLocale, 0x381, 0x1000, ref x);
     AddToLog("Writing Header hash");
     int xSize = 0;
     if (xSTFSStruct.BaseBlock == 0xA000)
         xSize = 0x9CBC;
     else xSize = 0xACBC; // b000
     XTakeHash(0x344, 0x32C, xSize, ref x);
     AddToLog("Signing Header");
     x.Position = 0x22C;
     byte[] xHash = SHA1Quick.ComputeHash(x.ReadBytes(0x118));
     x.Position = 4;
     if (xParams.Type == PackageMagic.CON)
     {
         x.Write(xParams.Certificate);
         x.Write(ScrambleMethods.StockScramble(RSAQuick.SignatureGenerate(xParams.RSAKeys, xHash), true));
     }
     else
     {
         x.Write(ScrambleMethods.DevScramble(RSAQuick.SignatureGenerate(xParams.RSAKeys, xHash)));
         x.Write(new byte[0x128]);
     }
     x.IsBigEndian = true;
     x.Position = 0;
     x.Write(((uint)xParams.Type));
     x.Flush();
     xHeader.xMagic = xParams.Type;
     // Writes header to Package just incase of a emergency close, the Package still attains original strucure
     AddToLog("Writing Header to Package");
     xIO.Position = 0;
     xIO.Write(x.ReadStream());
     xIO.Flush();
     // Flush all the unused blocks to say they are written and now perm wif the new STFS Descriptor
     /*switched0.Clear();
     switched1.Clear();
     switched2 = false;*/
     x.Close();
     VariousFunctions.DeleteFile(x.FileNameLong);
     return true;
 }

 internal bool xUpdate()
 {
     try
     {
         int xsize = xpairs.Count * 0x10;
         if (Size > xsize)
         {
             new FreeSpaceEntry(xRef, xOffset + xsize, Size - xsize);
             xRef.PatchFree();
         }
         else if (Size < xsize)
         {
             int off = xRef.AllocateData(xsize);
             if (off == -1)
                 return false;
             new FreeSpaceEntry(xRef, xOffset, Size);
             xRef.PatchFree();
             xOffset = off;
         }
         DJsIO xbuff = new DJsIO(new byte[xsize], true);
         xbuff.Position = 0;
         foreach (SyncPair x in xpairs)
         {
             xbuff.Write(x.ID);
             xbuff.Write(x.Sync);
         }
         xbuff.Flush();
         xRef.xIO.Position = Offset;
         xRef.xIO.Write(xbuff.ReadStream());
         xRef.xIO.Flush();
         if (xsize > xSize)
             xRef.UpdateHeader();
         xSize = xsize;
         return true;
     }
     catch { return false; }
 }

 bool xWriteHeader(RSAParams xParams)
 {
     try
     {
         DJsIO xio = new DJsIO(true);
         xHeaderData.Write(ref xio);
         xio.SetLength(0xB000);
         xio.Position = 0x340;
         xio.Write((uint)0xAD0E);
         xio.Position = 0x379;
         xio.Write(new byte[] { 0x24, 5, 5, 0x11 });
         IO.Position = 0x37D;
         xio.Write(IO.ReadBytes(20));
         xio.Write((byte)((xIsShifted ? 1 : 0) << 6));
         xio.WriteUInt24(xBlockCount);
         xio.Write(xDeviation);
         xio.Flush();
         xio.Position = 0x344;
         byte[] xHash = SHA1Quick.ComputeHash(xio.ReadBytes((int)(xio.Length - 0x344)));
         xio.Position = 0x32C;
         xio.Write(xHash);
         xio.Flush();
         xio.Position = 0x22C;
         xHash = SHA1Quick.ComputeHash(xio.ReadBytes(0x118));
         xio.Position = 4;
         if (xParams.Type == PackageMagic.CON)
         {
             xio.Write(xParams.Certificate);
             xio.Write(ScrambleMethods.StockScramble(RSAQuick.SignatureGenerate(xParams.RSAKeys, xHash), true));
         }
         else
         {
             xio.Write(ScrambleMethods.DevScramble(RSAQuick.SignatureGenerate(xParams.RSAKeys, xHash)));
             xio.Write(new byte[0x128]);
         }
         xio.IsBigEndian = true;
         xio.Position = 0;
         xio.Write(((uint)xParams.Type));
         xio.Flush();
         xHeaderData.xMagic = xParams.Type;
         IO.Position = 0;
         IO.Write(xio.ReadStream());
         IO.Flush();
         xio.Dispose();
         return true;
     }
     catch { return false; }
 }

 bool xEncrypt(ref DJsIO xNewPayload)
 {
     try
     {
         if (!xSuccess)
             return false;
         if (xIsLive)
         {
             byte[] xService = (ThisType == AccountType.Stock ?
                 new byte[] { 0x50, 0x52, 0x4F, 0x44 } : // PROD
                 new byte[] { 0x50, 0x41, 0x53, 0x54 }); // PART
             xNewPayload.Position = 0x34;
             xNewPayload.Write(xService);
             xNewPayload.Flush();
         }
         List<byte> xReturn = new List<byte>();
         byte[] xConfounder = xRC4.NewConfounder(8);
         byte[] NewPay = xNewPayload.ReadStream();
         xNewPayload.Dispose();
         byte[] xHeaderKey = xComputeHeaderKey(xConfounder, NewPay);
         xRC4.KeyBinary = xComputeRC4Key(xHeaderKey);
         xReturn.AddRange(xHeaderKey);
         xReturn.AddRange(xRC4.KerberosEncrypt(ref xConfounder, ref NewPay));
         IO.Position = 0;
         IO.Write(xReturn.ToArray());
         IO.Flush();
         return true;
     }
     catch { return false; }
 }

 /// <summary>
 /// Initializes an instance
 /// </summary>
 /// <param name="xAcc"></param>
 /// <param name="xType"></param>
 /// <param name="CreateBackup"></param>
 public UserAccount(DJsIO xAcc, AccountType xType, bool CreateBackup)
 {
     if (xAcc.Length != 404 || !Enum.IsDefined(typeof(AccountType), xType))
         return;
     IO = xAcc;
     xHS = new HMACSHA1();
     ThisType = xType;
     DJsIO xfill;
     if (xDecrypt(out xfill))
     {
         if (CreateBackup)
         {
             xBackup = new DJsIO(true);
             xBackup.Position = 0;
             xBackup.Write(IO.ReadStream());
         }
         xfill.Position = 0;
         if (((xfill.ReadByte() >> 5) & 1) == 1)
         {
             xIsLive = true;
             xfill.Position = 0x28;
             xXUID = xfill.ReadUInt64();
         }
         xSuccess = true;
     }
 }