2004-11-05 Sebastien Pouliot <sebastien@ximian.com>

	* AuthenticodeFormatter.cs: Now use BitConverterLE for explicit
	little-endian convertion.
	* PrivateKey.cs: Now use BitConverterLE for explicit little-endian
	convertion for PVK files.

svn path=/trunk/mcs/; revision=35703

diff --git a/mcs/class/Mono.Security/Mono.Security.Authenticode/AuthenticodeFormatter.cs b/mcs/class/Mono.Security/Mono.Security.Authenticode/AuthenticodeFormatter.cs
index 418f14483a5a2b556e37fdaa4811db28b54377a4..27e1d693920c29a95b847e0dff820599c9a6a6f0 100755 (executable)
--- a/mcs/class/Mono.Security/Mono.Security.Authenticode/AuthenticodeFormatter.cs
+++ b/mcs/class/Mono.Security/Mono.Security.Authenticode/AuthenticodeFormatter.cs
@@ -231,21 +231,21 @@ namespace Mono.Security.Authenticode {
                        }
 
                        // MZ - DOS header
-                       if (BitConverter.ToUInt16 (file, 0) != 0x5A4D)
+                       if (BitConverterLE.ToUInt16 (file, 0) != 0x5A4D)
                                return false;
 
                        // find offset of PE header
-                       int peOffset = BitConverter.ToInt32 (file, 60);
+                       int peOffset = BitConverterLE.ToInt32 (file, 60);
                        if (peOffset > file.Length)
                                return false;
 
                        // PE - NT header
-                       if (BitConverter.ToUInt16 (file, peOffset) != 0x4550)
+                       if (BitConverterLE.ToUInt16 (file, peOffset) != 0x4550)
                                return false;
 
                        // IMAGE_DIRECTORY_ENTRY_SECURITY
-                       int dirSecurityOffset = BitConverter.ToInt32 (file, peOffset + 152);
-                       int dirSecuritySize = BitConverter.ToInt32 (file, peOffset + 156);
+                       int dirSecurityOffset = BitConverterLE.ToInt32 (file, peOffset + 152);
+                       int dirSecuritySize = BitConverterLE.ToInt32 (file, peOffset + 156);
 
                        if (dirSecuritySize > 8) {
                                entry = new byte [dirSecuritySize - 8];
@@ -285,20 +285,19 @@ namespace Mono.Security.Authenticode {
                        authenticode = sign.ASN1;
 
                        byte[] asn = authenticode.GetBytes ();
-                       // debug
-                       if (Environment.GetEnvironmentVariable ("MONO_DEBUG") != null) {
-                               using (FileStream fs = File.Open (fileName + ".sig", FileMode.Create, FileAccess.Write)) {
-                                       fs.Write (asn, 0, asn.Length);
-                                       fs.Close ();
-                               }
+#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.Create, FileAccess.Write)) {\r
                                int filesize = (dirSecurityOffset == 0) ? file.Length : dirSecurityOffset;\r
                                // IMAGE_DIRECTORY_ENTRY_SECURITY (offset, size)\r
-                               byte[] data = BitConverter.GetBytes (filesize);\r
+                               byte[] data = BitConverterLE.GetBytes (filesize);\r
                                file [peOffset + 152] = data [0];
                                file [peOffset + 153] = data [1];
                                file [peOffset + 154] = data [2];
@@ -309,14 +308,14 @@ namespace Mono.Security.Authenticode {
                                if (addsize > 0)
                                        addsize = 8 - addsize;
                                size += addsize;
-                               data = BitConverter.GetBytes (size);            // header
+                               data = BitConverterLE.GetBytes (size);          // header
                                file [peOffset + 156] = data [0];
                                file [peOffset + 157] = data [1];
                                file [peOffset + 158] = data [2];
                                file [peOffset + 159] = data [3];\r
                                fs.Write (file, 0, filesize);\r
                                fs.Write (data, 0, data.Length);                // length (again)
-                               data = BitConverter.GetBytes (0x00020200);      // magic
+                               data = BitConverterLE.GetBytes (0x00020200);    // magic
                                fs.Write (data, 0, data.Length);
                                fs.Write (asn, 0, asn.Length);
                                // fill up

diff --git a/mcs/class/Mono.Security/Mono.Security.Authenticode/ChangeLog b/mcs/class/Mono.Security/Mono.Security.Authenticode/ChangeLog
index 4867eb4eb8c040af89d75519e90c95f9124eccc1..8b4a378cd90bd29a87646ee5755456b0628c5229 100644 (file)
--- a/mcs/class/Mono.Security/Mono.Security.Authenticode/ChangeLog
+++ b/mcs/class/Mono.Security/Mono.Security.Authenticode/ChangeLog
@@ -1,3 +1,10 @@
+2004-11-05  Sebastien Pouliot  <sebastien@ximian.com>
+
+       * AuthenticodeFormatter.cs: Now use BitConverterLE for explicit 
+       little-endian convertion.
+       * PrivateKey.cs: Now use BitConverterLE for explicit little-endian
+       convertion for PVK files.
+
 2004-10-29  Sebastien Pouliot  <sebastien@ximian.com>
 
        * AuthenticodeFormatter.cs: Fixed spcSpOpusInfo attribute (it wasn't 

diff --git a/mcs/class/Mono.Security/Mono.Security.Authenticode/PrivateKey.cs b/mcs/class/Mono.Security/Mono.Security.Authenticode/PrivateKey.cs
index 4b094695f47e7c07b492fbd3804c42f7952b214e..a5646d804027928e1ad93b3dec331c69d0953fe4 100644 (file)
--- a/mcs/class/Mono.Security/Mono.Security.Authenticode/PrivateKey.cs
+++ b/mcs/class/Mono.Security/Mono.Security.Authenticode/PrivateKey.cs
@@ -100,19 +100,19 @@ namespace Mono.Security.Authenticode {
                private bool Decode (byte[] pvk, string password) 
                {
                        // DWORD magic
-                       if (BitConverter.ToUInt32 (pvk, 0) != magic)
+                       if (BitConverterLE.ToUInt32 (pvk, 0) != magic)
                                return false;
                        // DWORD reserved
-                       if (BitConverter.ToUInt32 (pvk, 4) != 0x0)
+                       if (BitConverterLE.ToUInt32 (pvk, 4) != 0x0)
                                return false;
                        // DWORD keytype
-                       keyType = BitConverter.ToInt32 (pvk, 8);
+                       keyType = BitConverterLE.ToInt32 (pvk, 8);
                        // DWORD encrypted
-                       encrypted = (BitConverter.ToUInt32 (pvk, 12) == 1);
+                       encrypted = (BitConverterLE.ToUInt32 (pvk, 12) == 1);
                        // DWORD saltlen
-                       int saltlen = BitConverter.ToInt32 (pvk, 16);
+                       int saltlen = BitConverterLE.ToInt32 (pvk, 16);
                        // DWORD keylen
-                       int keylen = BitConverter.ToInt32 (pvk, 20);
+                       int keylen = BitConverterLE.ToInt32 (pvk, 20);
                        byte[] keypair = new byte [keylen];
                        Buffer.BlockCopy (pvk, 24 + saltlen, keypair, 0, keylen);
                        // read salt (if present)
@@ -174,20 +174,20 @@ namespace Mono.Security.Authenticode {
                        try {
                                // header
                                byte[] empty = new byte [4];
-                               byte[] data = BitConverter.GetBytes (magic);
+                               byte[] data = BitConverterLE.GetBytes (magic);
                                fs.Write (data, 0, 4);  // magic
                                fs.Write (empty, 0, 4); // reserved
-                               data = BitConverter.GetBytes (keyType);
+                               data = BitConverterLE.GetBytes (keyType);
                                fs.Write (data, 0, 4);  // key type
 
                                encrypted = (password != null);
                                blob = CryptoConvert.ToCapiPrivateKeyBlob (rsa);
                                if (encrypted) {
-                                       data = BitConverter.GetBytes (1);
+                                       data = BitConverterLE.GetBytes (1);
                                        fs.Write (data, 0, 4);  // encrypted
-                                       data = BitConverter.GetBytes (16);
+                                       data = BitConverterLE.GetBytes (16);
                                        fs.Write (data, 0, 4);  // saltlen
-                                       data = BitConverter.GetBytes (blob.Length);
+                                       data = BitConverterLE.GetBytes (blob.Length);
                                        fs.Write (data, 0, 4);          // keylen
 
                                        byte[] salt = new byte [16];
@@ -214,7 +214,7 @@ namespace Mono.Security.Authenticode {
                                else {
                                        fs.Write (empty, 0, 4); // encrypted
                                        fs.Write (empty, 0, 4); // saltlen
-                                       data = BitConverter.GetBytes (blob.Length);
+                                       data = BitConverterLE.GetBytes (blob.Length);
                                        fs.Write (data, 0, 4);          // keylen
                                }