示例#1
0
        static byte[] Compute_NTLMv2(Type2Message type2, string username, string password)
        {
            var ntlm_hash = Compute_NTLM_Password(password);

            var ubytes = Encoding.Unicode.GetBytes(username.ToUpperInvariant());
            var tbytes = Encoding.Unicode.GetBytes(type2.TargetName.ToUpperInvariant());

            var bytes = new byte [ubytes.Length + tbytes.Length];

            ubytes.CopyTo(bytes, 0);
            Array.Copy(tbytes, 0, bytes, ubytes.Length, tbytes.Length);

            var md5          = new HMACMD5(ntlm_hash);
            var ntlm_v2_hash = md5.ComputeHash(bytes);

            Array.Clear(ntlm_hash, 0, ntlm_hash.Length);
            md5.Clear();

            var ntlm_v2_md5 = new HMACMD5(ntlm_v2_hash);

            var now       = DateTime.Now;
            var timestamp = now.Ticks - 504911232000000000;

            var nonce = new byte [8];
            var rng   = RandomNumberGenerator.Create();

            rng.GetBytes(nonce);

            byte[] blob = new byte [28 + type2.TargetInfo.Length];
            blob[0] = 0x01;
            blob[1] = 0x01;

            Buffer.BlockCopy(BitConverterLE.GetBytes(timestamp), 0, blob, 8, 8);

            Buffer.BlockCopy(nonce, 0, blob, 16, 8);
            Buffer.BlockCopy(type2.TargetInfo, 0, blob, 28, type2.TargetInfo.Length);

            var challenge = type2.Nonce;

            var hashInput = new byte [challenge.Length + blob.Length];

            challenge.CopyTo(hashInput, 0);
            blob.CopyTo(hashInput, challenge.Length);

            var blobHash = ntlm_v2_md5.ComputeHash(hashInput);

            var response = new byte [blob.Length + blobHash.Length];

            blobHash.CopyTo(response, 0);
            blob.CopyTo(response, blobHash.Length);

            Array.Clear(ntlm_v2_hash, 0, ntlm_v2_hash.Length);
            ntlm_v2_md5.Clear();
            Array.Clear(nonce, 0, nonce.Length);
            Array.Clear(blob, 0, blob.Length);
            Array.Clear(hashInput, 0, hashInput.Length);
            Array.Clear(blobHash, 0, blobHash.Length);

            return(response);
        }
示例#2
0
        public byte[] ToByteArray()
        {
            byte[] array = new byte[16];
            int    num   = 0;

            byte[] bytes = BitConverterLE.GetBytes(this._a);
            for (int i = 0; i < 4; i++)
            {
                array[num++] = bytes[i];
            }
            bytes = BitConverterLE.GetBytes(this._b);
            for (int i = 0; i < 2; i++)
            {
                array[num++] = bytes[i];
            }
            bytes = BitConverterLE.GetBytes(this._c);
            for (int i = 0; i < 2; i++)
            {
                array[num++] = bytes[i];
            }
            array[8]  = this._d;
            array[9]  = this._e;
            array[10] = this._f;
            array[11] = this._g;
            array[12] = this._h;
            array[13] = this._i;
            array[14] = this._j;
            array[15] = this._k;
            return(array);
        }
 private bool Save(string fileName, byte[] asn)
 {
     File.Copy(fileName, fileName + ".bak", true);
     using (FileStream fileStream = File.Open(fileName, FileMode.Open, FileAccess.ReadWrite))
     {
         int num;
         if (base.SecurityOffset > 0)
         {
             num = base.SecurityOffset;
         }
         else if (base.CoffSymbolTableOffset > 0)
         {
             fileStream.Seek((long)(base.PEOffset + 12), SeekOrigin.Begin);
             for (int i = 0; i < 8; i++)
             {
                 fileStream.WriteByte(0);
             }
             num = base.CoffSymbolTableOffset;
         }
         else
         {
             num = (int)fileStream.Length;
         }
         int num2 = num & 7;
         if (num2 > 0)
         {
             num2 = 8 - num2;
         }
         byte[] bytes = BitConverterLE.GetBytes(num + num2);
         fileStream.Seek((long)(base.PEOffset + 152), SeekOrigin.Begin);
         fileStream.Write(bytes, 0, 4);
         int num3 = asn.Length + 8;
         int num4 = num3 & 7;
         if (num4 > 0)
         {
             num4 = 8 - num4;
         }
         bytes = BitConverterLE.GetBytes(num3 + num4);
         fileStream.Seek((long)(base.PEOffset + 156), SeekOrigin.Begin);
         fileStream.Write(bytes, 0, 4);
         fileStream.Seek((long)num, SeekOrigin.Begin);
         if (num2 > 0)
         {
             byte[] array = new byte[num2];
             fileStream.Write(array, 0, array.Length);
         }
         fileStream.Write(bytes, 0, bytes.Length);
         bytes = BitConverterLE.GetBytes(131584);
         fileStream.Write(bytes, 0, bytes.Length);
         fileStream.Write(asn, 0, asn.Length);
         if (num4 > 0)
         {
             byte[] array2 = new byte[num4];
             fileStream.Write(array2, 0, array2.Length);
         }
         fileStream.Close();
     }
     return(true);
 }
 private bool Save(string fileName, byte[] asn)
 {
     System.IO.File.Copy(fileName, fileName + ".bak", true);
     using (FileStream stream = System.IO.File.Open(fileName, FileMode.Open, FileAccess.ReadWrite))
     {
         int securityOffset;
         if (base.SecurityOffset > 0)
         {
             securityOffset = base.SecurityOffset;
         }
         else if (base.CoffSymbolTableOffset > 0)
         {
             stream.Seek((long)(base.PEOffset + 12), SeekOrigin.Begin);
             for (int i = 0; i < 8; i++)
             {
                 stream.WriteByte(0);
             }
             securityOffset = base.CoffSymbolTableOffset;
         }
         else
         {
             securityOffset = (int)stream.Length;
         }
         int num3 = securityOffset & 7;
         if (num3 > 0)
         {
             num3 = 8 - num3;
         }
         byte[] bytes = BitConverterLE.GetBytes((int)(securityOffset + num3));
         stream.Seek((long)(base.PEOffset + 0x98), SeekOrigin.Begin);
         stream.Write(bytes, 0, 4);
         int num4 = asn.Length + 8;
         int num5 = num4 & 7;
         if (num5 > 0)
         {
             num5 = 8 - num5;
         }
         bytes = BitConverterLE.GetBytes((int)(num4 + num5));
         stream.Seek((long)(base.PEOffset + 0x9c), SeekOrigin.Begin);
         stream.Write(bytes, 0, 4);
         stream.Seek((long)securityOffset, SeekOrigin.Begin);
         if (num3 > 0)
         {
             byte[] buffer = new byte[num3];
             stream.Write(buffer, 0, buffer.Length);
         }
         stream.Write(bytes, 0, bytes.Length);
         bytes = BitConverterLE.GetBytes(0x20200);
         stream.Write(bytes, 0, bytes.Length);
         stream.Write(asn, 0, asn.Length);
         if (num5 > 0)
         {
             byte[] buffer = new byte[num5];
             stream.Write(buffer, 0, buffer.Length);
         }
         stream.Close();
     }
     return(true);
 }
 /// <summary>Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes.</summary>
 /// <param name="value">The four-byte floating-point value to write. </param>
 /// <exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
 /// <exception cref="T:System.ObjectDisposedException">The stream is closed. </exception>
 /// <filterpriority>1</filterpriority>
 public virtual void Write(float value)
 {
     if (this.disposed)
     {
         throw new ObjectDisposedException("BinaryWriter", "Cannot write to a closed BinaryWriter");
     }
     this.OutStream.Write(BitConverterLE.GetBytes(value), 0, 4);
 }
示例#6
0
        public virtual void Write(double value)
        {
            if (disposed)
            {
                throw new ObjectDisposedException("BinaryWriter", "Cannot write to a closed BinaryWriter");
            }

            OutStream.Write(BitConverterLE.GetBytes(value), 0, 8);
        }
        public void Save(string filename, string password)
        {
            if (filename == null)
            {
                throw new ArgumentNullException("filename");
            }

            byte[]     blob = null;
            FileStream fs   = File.Open(filename, FileMode.Create, FileAccess.Write);

            try
            {
                // header
                byte[] empty = new byte [4];
                byte[] data  = BitConverterLE.GetBytes(magic);
                fs.Write(data, 0, 4);   // magic
                fs.Write(empty, 0, 4);  // reserved
                data = BitConverterLE.GetBytes(keyType);
                fs.Write(data, 0, 4);   // key type

                encrypted = (password != null);
                blob      = CryptoConvert.ToCapiPrivateKeyBlob(rsa);
                if (encrypted)
                {
                    data = BitConverterLE.GetBytes(1);
                    fs.Write(data, 0, 4); // encrypted
                    data = BitConverterLE.GetBytes(16);
                    fs.Write(data, 0, 4); // saltlen
                    data = BitConverterLE.GetBytes(blob.Length);
                    fs.Write(data, 0, 4); // keylen

                    byte[] salt = new byte [16];
                    RC4    rc4  = RC4.Create();
                    byte[] key  = null;
                    try
                    {
                        // generate new salt (16 bytes)
                        RandomNumberGenerator rng = RandomNumberGenerator.Create();
                        rng.GetBytes(salt);
                        fs.Write(salt, 0, salt.Length);
                        key = DeriveKey(salt, password);
                        if (Weak)
                        {
                            Array.Clear(key, 5, 11);
                        }
                        ICryptoTransform enc = rc4.CreateEncryptor(key, null);
                        // we don't encrypt the header part of the BLOB
                        enc.TransformBlock(blob, 8, blob.Length - 8, blob, 8);
                    }
                    finally
                    {
                        Array.Clear(salt, 0, salt.Length);
                        Array.Clear(key, 0, key.Length);
                        rc4.Clear();
                    }
                }
                else
                {
                    fs.Write(empty, 0, 4); // encrypted
                    fs.Write(empty, 0, 4); // saltlen
                    data = BitConverterLE.GetBytes(blob.Length);
                    fs.Write(data, 0, 4);  // keylen
                }

                fs.Write(blob, 0, blob.Length);
            }
            finally
            {
                // BLOB may include an uncrypted keypair
                Array.Clear(blob, 0, blob.Length);
                fs.Close();
            }
        }
 // PKCS #1 v.2.1, Section 4.1
 // I2OSP converts a non-negative integer to an octet string of a specified length.
 public static byte[] I2OSP(int x, int size)
 {
     byte[] array = BitConverterLE.GetBytes(x);
     Array.Reverse(array, 0, array.Length);
     return(I2OSP(array, size));
 }
示例#9
0
        private bool Save(string fileName, byte[] asn)
        {
#if DEBUG
            using (FileStream fs = File.Open(fileName + ".sig", FileMode.Create, FileAccess.Write)) {
                fs.Write(asn, 0, asn.Length);
                fs.Close();
            }
#endif
            // someday I may be sure enough to move this into DEBUG ;-)
            File.Copy(fileName, fileName + ".bak", true);

            using (FileStream fs = File.Open(fileName, FileMode.Open, FileAccess.ReadWrite)) {
                int filesize;
                if (SecurityOffset > 0)
                {
                    // FIXME Does it fit? Is it always the same size?
                    // file was already signed, we'll reuse the position for the updated signature
                    filesize = SecurityOffset;
                }
                else if (CoffSymbolTableOffset > 0)
                {
                    // FIXME This is not documented as something to remove.
                    // However some documentation says to remove after the last
                    // section, and some does not, and this might be there,
                    // or it might not.
                    // strip (deprecated) COFF symbol table
                    fs.Seek(PEOffset + 12, SeekOrigin.Begin);
                    for (int i = 0; i < 8; i++)
                    {
                        fs.WriteByte(0);
                    }
                    // we'll put the Authenticode signature at this same place (just after the last section)
                    filesize = CoffSymbolTableOffset;
                }
                else
                {
                    // file was never signed, nor does it contains (deprecated) COFF symbols
                    filesize = (int)fs.Length;
                }
                // must be a multiple of 8 bytes
                int addsize = (filesize & 7);
                if (addsize > 0)
                {
                    addsize = 8 - addsize;
                }

                // IMAGE_DIRECTORY_ENTRY_SECURITY (offset, size)
                byte[] data = BitConverterLE.GetBytes(filesize + addsize);
                if (PE64)
                {
                    fs.Seek(PEOffset + 168, SeekOrigin.Begin);
                }
                else
                {
                    fs.Seek(PEOffset + 152, SeekOrigin.Begin);
                }

                fs.Write(data, 0, 4);
                int size = asn.Length + 8;
                int addsize_signature = (size & 7);
                if (addsize_signature > 0)
                {
                    addsize_signature = 8 - addsize_signature;
                }
                data = BitConverterLE.GetBytes(size + addsize_signature);
                if (PE64)
                {
                    fs.Seek(PEOffset + 168 + 4, SeekOrigin.Begin);
                }
                else
                {
                    fs.Seek(PEOffset + 156, SeekOrigin.Begin);
                }

                fs.Write(data, 0, 4);
                fs.Seek(filesize, SeekOrigin.Begin);
                // align certificate entry to a multiple of 8 bytes
                if (addsize > 0)
                {
                    byte[] fillup = new byte[addsize];
                    fs.Write(fillup, 0, fillup.Length);
                }

                /*
                 * https://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/Authenticode_PE.docx
                 * The Authenticode signature is in a WIN_CERTIFICATE structure, which is declared in Wintrust.h as follows:
                 * typedef struct _WIN_CERTIFICATE
                 * {
                 *  DWORD       dwLength;
                 *  WORD        wRevision;
                 *  WORD        wCertificateType;
                 *  BYTE        bCertificate[ANYSIZE_ARRAY];
                 * } WIN_CERTIFICATE, *LPWIN_CERTIFICATE;
                 *
                 * The fields in WIN_CERTIFICATE are set to the following values:
                 * dwLength is set to the length of bCertificate.
                 * wRevision is set to the WIN_CERTIFICATE version number.
                 *
                 * wCertificateType is set to 0x0002 for Authenticode signatures.
                 * This value is defined in Wintrust.h as WIN_CERT_TYPE_PKCS_SIGNED_DATA.
                 * bCertificate is set to a variable-length binary array that contains the Authenticode PKCS #7 signedData.
                 * The PKCS #7 integrity is verified as described in ”PKCS #7: Cryptographic Message Syntax Standard.”
                 */
                // write WIN_CERTIFICATE.dwLength
                fs.Write(data, 0, data.Length);                                 // length (again)
                // write WIN_CERTIFICATE.wRevision = 0x0200 and wCertificateType = 2.
                // /usr/local/Cellar/mingw-w64/5.0.3/toolchain-x86_64/x86_64-w64-mingw32/include/wintrust.h
                // const short WIN_CERT_REVISION_1_0 = 0x0100;
                const short WIN_CERT_REVISION_2_0 = 0x0200;
                // const short WIN_CERT_TYPE_X509 = 0x0001;
                const short WIN_CERT_TYPE_PKCS_SIGNED_DATA = 0x0002;
                // const short WIN_CERT_TYPE_RESERVED_1 = 0x0003;
                // const short WIN_CERT_TYPE_TS_STACK_SIGNED = 0x0004;
                data = BitConverterLE.GetBytes(WIN_CERT_REVISION_2_0);
                fs.Write(data, 0, data.Length);
                data = BitConverterLE.GetBytes(WIN_CERT_TYPE_PKCS_SIGNED_DATA);
                fs.Write(data, 0, data.Length);
                fs.Write(asn, 0, asn.Length);
                if (addsize_signature > 0)
                {
                    byte[] fillup = new byte[addsize_signature];
                    fs.Write(fillup, 0, fillup.Length);
                }
                fs.Close();
            }
            return(true);
        }
示例#10
0
 public static byte[] I2OSP(int x, int size)
 {
     byte[] bytes = BitConverterLE.GetBytes(x);
     Array.Reverse((Array)bytes, 0, bytes.Length);
     return(PKCS1.I2OSP(bytes, size));
 }
示例#11
0
文件: DSA.cs 项目: pmq20/mono_forked
        // note: using SecurityElement.ToXml wouldn't generate the same string as the MS implementation
        public override string ToXmlString(bool includePrivateParameters)
        {
            StringBuilder sb        = new StringBuilder();
            DSAParameters dsaParams = ExportParameters(includePrivateParameters);

            try {
                sb.Append("<DSAKeyValue>");

                sb.Append("<P>");
                sb.Append(Convert.ToBase64String(dsaParams.P));
                sb.Append("</P>");

                sb.Append("<Q>");
                sb.Append(Convert.ToBase64String(dsaParams.Q));
                sb.Append("</Q>");

                sb.Append("<G>");
                sb.Append(Convert.ToBase64String(dsaParams.G));
                sb.Append("</G>");

                sb.Append("<Y>");
                sb.Append(Convert.ToBase64String(dsaParams.Y));
                sb.Append("</Y>");

                if (dsaParams.J != null)
                {
                    // if J wasn't imported then it's not exported and neither
                    // is part of the XML output
                    sb.Append("<J>");
                    sb.Append(Convert.ToBase64String(dsaParams.J));
                    sb.Append("</J>");
                }

                if (dsaParams.Seed != null)
                {
                    sb.Append("<Seed>");
                    sb.Append(Convert.ToBase64String(dsaParams.Seed));
                    sb.Append("</Seed>");

                    sb.Append("<PgenCounter>");
                    // the number of bytes is important (no matter == 0x00)
                    if (dsaParams.Counter != 0)
                    {
                        byte[] inArr = BitConverterLE.GetBytes(dsaParams.Counter);
                        int    l     = inArr.Length;
                        while (inArr[l - 1] == 0x00)
                        {
                            l--;
                        }

                        sb.Append(Convert.ToBase64String(inArr, 0, l));
                    }
                    else
                    {
                        sb.Append("AA==");                              // base64 encoded 0
                    }
                    sb.Append("</PgenCounter>");
                }

                if (dsaParams.X != null)
                {
                    sb.Append("<X>");
                    sb.Append(Convert.ToBase64String(dsaParams.X));
                    sb.Append("</X>");
                }
                else if (includePrivateParameters)
                {
                    throw new ArgumentNullException("X");
                }

                sb.Append("</DSAKeyValue>");
            }
            catch {
                ZeroizePrivateKey(dsaParams);
                throw;
            }

            return(sb.ToString());
        }
示例#12
0
        public void Save(string filename, string password)
        {
            if (filename == null)
            {
                throw new ArgumentNullException(nameof(filename));
            }
            byte[]     numArray1  = (byte[])null;
            FileStream fileStream = File.Open(filename, FileMode.Create, FileAccess.Write);

            try
            {
                byte[] buffer = new byte[4];
                byte[] bytes1 = BitConverterLE.GetBytes(2964713758U);
                fileStream.Write(bytes1, 0, 4);
                fileStream.Write(buffer, 0, 4);
                byte[] bytes2 = BitConverterLE.GetBytes(this.keyType);
                fileStream.Write(bytes2, 0, 4);
                this.encrypted = password != null;
                numArray1      = CryptoConvert.ToCapiPrivateKeyBlob(this.rsa);
                if (this.encrypted)
                {
                    byte[] bytes3 = BitConverterLE.GetBytes(1);
                    fileStream.Write(bytes3, 0, 4);
                    byte[] bytes4 = BitConverterLE.GetBytes(16);
                    fileStream.Write(bytes4, 0, 4);
                    byte[] bytes5 = BitConverterLE.GetBytes(numArray1.Length);
                    fileStream.Write(bytes5, 0, 4);
                    byte[] numArray2 = new byte[16];
                    RC4    rc4       = RC4.Create();
                    byte[] rgbKey    = (byte[])null;
                    try
                    {
                        RandomNumberGenerator.Create().GetBytes(numArray2);
                        fileStream.Write(numArray2, 0, numArray2.Length);
                        rgbKey = this.DeriveKey(numArray2, password);
                        if (this.Weak)
                        {
                            Array.Clear((Array)rgbKey, 5, 11);
                        }
                        rc4.CreateEncryptor(rgbKey, (byte[])null).TransformBlock(numArray1, 8, numArray1.Length - 8, numArray1, 8);
                    }
                    finally
                    {
                        Array.Clear((Array)numArray2, 0, numArray2.Length);
                        Array.Clear((Array)rgbKey, 0, rgbKey.Length);
                        rc4.Clear();
                    }
                }
                else
                {
                    fileStream.Write(buffer, 0, 4);
                    fileStream.Write(buffer, 0, 4);
                    byte[] bytes3 = BitConverterLE.GetBytes(numArray1.Length);
                    fileStream.Write(bytes3, 0, 4);
                }
                fileStream.Write(numArray1, 0, numArray1.Length);
            }
            finally
            {
                Array.Clear((Array)numArray1, 0, numArray1.Length);
                fileStream.Close();
            }
        }
        private bool Save(string fileName, byte[] asn)
        {
#if DEBUG
            using (FileStream fs = File.Open(fileName + ".sig", FileMode.Create, FileAccess.Write))
            {
                fs.Write(asn, 0, asn.Length);
                fs.Close();
            }
#endif
            // someday I may be sure enough to move this into DEBUG ;-)
            File.Copy(fileName, fileName + ".bak", true);

            using (FileStream fs = File.Open(fileName, FileMode.Open, FileAccess.ReadWrite))
            {
                int filesize;
                if (SecurityOffset > 0)
                {
                    // file was already signed, we'll reuse the position for the updated signature
                    filesize = SecurityOffset;
                }
                else if (CoffSymbolTableOffset > 0)
                {
                    // strip (deprecated) COFF symbol table
                    fs.Seek(PEOffset + 12, SeekOrigin.Begin);
                    for (int i = 0; i < 8; i++)
                    {
                        fs.WriteByte(0);
                    }
                    // we'll put the Authenticode signature at this same place (just after the last section)
                    filesize = CoffSymbolTableOffset;
                }
                else
                {
                    // file was never signed, nor does it contains (deprecated) COFF symbols
                    filesize = (int)fs.Length;
                }
                // must be a multiple of 8 bytes
                int addsize = (filesize & 7);
                if (addsize > 0)
                {
                    addsize = 8 - addsize;
                }

                // IMAGE_DIRECTORY_ENTRY_SECURITY (offset, size)
                byte[] data = BitConverterLE.GetBytes(filesize + addsize);
                fs.Seek(PEOffset + 152, SeekOrigin.Begin);
                fs.Write(data, 0, 4);
                int size = asn.Length + 8;
                int addsize_signature = (size & 7);
                if (addsize_signature > 0)
                {
                    addsize_signature = 8 - addsize_signature;
                }
                data = BitConverterLE.GetBytes(size + addsize_signature);
                fs.Seek(PEOffset + 156, SeekOrigin.Begin);
                fs.Write(data, 0, 4);
                fs.Seek(filesize, SeekOrigin.Begin);
                // align certificate entry to a multiple of 8 bytes
                if (addsize > 0)
                {
                    byte[] fillup = new byte[addsize];
                    fs.Write(fillup, 0, fillup.Length);
                }
                fs.Write(data, 0, data.Length);             // length (again)
                data = BitConverterLE.GetBytes(0x00020200); // magic
                fs.Write(data, 0, data.Length);
                fs.Write(asn, 0, asn.Length);
                if (addsize_signature > 0)
                {
                    byte[] fillup = new byte[addsize_signature];
                    fs.Write(fillup, 0, fillup.Length);
                }
                fs.Close();
            }
            return(true);
        }
示例#14
0
        public void Save(string filename, string password)
        {
            if (filename == null)
            {
                throw new ArgumentNullException("filename");
            }
            byte[]     array      = null;
            FileStream fileStream = File.Open(filename, FileMode.Create, FileAccess.Write);

            try
            {
                byte[] array2 = new byte[4];
                byte[] bytes  = BitConverterLE.GetBytes(2964713758u);
                fileStream.Write(bytes, 0, 4);
                fileStream.Write(array2, 0, 4);
                bytes = BitConverterLE.GetBytes(this.keyType);
                fileStream.Write(bytes, 0, 4);
                this.encrypted = (password != null);
                array          = CryptoConvert.ToCapiPrivateKeyBlob(this.rsa);
                if (this.encrypted)
                {
                    bytes = BitConverterLE.GetBytes(1);
                    fileStream.Write(bytes, 0, 4);
                    bytes = BitConverterLE.GetBytes(16);
                    fileStream.Write(bytes, 0, 4);
                    bytes = BitConverterLE.GetBytes(array.Length);
                    fileStream.Write(bytes, 0, 4);
                    byte[] array3 = new byte[16];
                    RC4    rc     = RC4.Create();
                    byte[] array4 = null;
                    try
                    {
                        RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create();
                        randomNumberGenerator.GetBytes(array3);
                        fileStream.Write(array3, 0, array3.Length);
                        array4 = this.DeriveKey(array3, password);
                        if (this.Weak)
                        {
                            Array.Clear(array4, 5, 11);
                        }
                        ICryptoTransform cryptoTransform = rc.CreateEncryptor(array4, null);
                        cryptoTransform.TransformBlock(array, 8, array.Length - 8, array, 8);
                    }
                    finally
                    {
                        Array.Clear(array3, 0, array3.Length);
                        Array.Clear(array4, 0, array4.Length);
                        rc.Clear();
                    }
                }
                else
                {
                    fileStream.Write(array2, 0, 4);
                    fileStream.Write(array2, 0, 4);
                    bytes = BitConverterLE.GetBytes(array.Length);
                    fileStream.Write(bytes, 0, 4);
                }
                fileStream.Write(array, 0, array.Length);
            }
            finally
            {
                Array.Clear(array, 0, array.Length);
                fileStream.Close();
            }
        }
示例#15
0
        /// <summary>Creates and returns an XML string representation of the current <see cref="T:System.Security.Cryptography.DSA" /> object.</summary>
        /// <returns>An XML string encoding of the current <see cref="T:System.Security.Cryptography.DSA" /> object.</returns>
        /// <param name="includePrivateParameters">true to include private parameters; otherwise, false. </param>
        public override string ToXmlString(bool includePrivateParameters)
        {
            StringBuilder stringBuilder = new StringBuilder();
            DSAParameters parameters    = this.ExportParameters(includePrivateParameters);

            try
            {
                stringBuilder.Append("<DSAKeyValue>");
                stringBuilder.Append("<P>");
                stringBuilder.Append(Convert.ToBase64String(parameters.P));
                stringBuilder.Append("</P>");
                stringBuilder.Append("<Q>");
                stringBuilder.Append(Convert.ToBase64String(parameters.Q));
                stringBuilder.Append("</Q>");
                stringBuilder.Append("<G>");
                stringBuilder.Append(Convert.ToBase64String(parameters.G));
                stringBuilder.Append("</G>");
                stringBuilder.Append("<Y>");
                stringBuilder.Append(Convert.ToBase64String(parameters.Y));
                stringBuilder.Append("</Y>");
                if (parameters.J != null)
                {
                    stringBuilder.Append("<J>");
                    stringBuilder.Append(Convert.ToBase64String(parameters.J));
                    stringBuilder.Append("</J>");
                }
                if (parameters.Seed != null)
                {
                    stringBuilder.Append("<Seed>");
                    stringBuilder.Append(Convert.ToBase64String(parameters.Seed));
                    stringBuilder.Append("</Seed>");
                    stringBuilder.Append("<PgenCounter>");
                    if (parameters.Counter != 0)
                    {
                        byte[] bytes = BitConverterLE.GetBytes(parameters.Counter);
                        int    num   = bytes.Length;
                        while (bytes[num - 1] == 0)
                        {
                            num--;
                        }
                        stringBuilder.Append(Convert.ToBase64String(bytes, 0, num));
                    }
                    else
                    {
                        stringBuilder.Append("AA==");
                    }
                    stringBuilder.Append("</PgenCounter>");
                }
                if (parameters.X != null)
                {
                    stringBuilder.Append("<X>");
                    stringBuilder.Append(Convert.ToBase64String(parameters.X));
                    stringBuilder.Append("</X>");
                }
                else if (includePrivateParameters)
                {
                    throw new ArgumentNullException("X");
                }
                stringBuilder.Append("</DSAKeyValue>");
            }
            catch
            {
                this.ZeroizePrivateKey(parameters);
                throw;
            }
            return(stringBuilder.ToString());
        }