1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:

namespace Test_1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            // Schlüssel erzeugen, einmalig!
            using (var rsa = new RSACryptoServiceProvider(2048))
            {
                var privateKey = rsa.ToXmlString(includePrivateParameters: true);
                var publicKey = rsa.ToXmlString(includePrivateParameters: false);

                File.WriteAllText(@"./private.xml", privateKey);
                File.WriteAllText(@"./public.xml", publicKey);
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            // Signieren, beliebig oft
            var filename = @"./nextUpdate.zip";

            var fileContent = File.ReadAllBytes(filename);
            var rsaKey = File.ReadAllText(@"./private.xml");
            byte[] signature;

            using (var rsa = new RSACryptoServiceProvider(2048))
            {
                rsa.FromXmlString(rsaKey);
                signature = rsa.SignData(fileContent, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
            }

            // Signatur anhängen
            using (var stream = new BinaryWriter(new FileStream(filename, FileMode.Append)))
            {
                stream.Write(signature);
                stream.Write(signature.Length);
            }
        }

        private void button3_Click(object sender, EventArgs e)
        {
            // Signatur prüfen

            var filename = @"./nextUpdate.zip";

            var fileContent = File.ReadAllBytes(filename);

            if (fileContent.Length < 260)
            {
                MessageBox.Show("Fehlende Signatur oder unbekannter Algorithmus!", "Signaturprüfung");
                return;
            }

            var rsaKey = File.ReadAllText(@"./public.xml"); // Hier wird nur der public-Key benötigt!
            byte[] signature = null;
            int signatureLength = 0;

            // Signatur auslesen, sie hängt hinten an der Datei
            using (var stream = new MemoryStream(fileContent))
            {
                using (var reader = new BinaryReader(stream))
                {
                    stream.Seek(-4, SeekOrigin.End);
                    signatureLength = reader.ReadInt32();
                    if (signatureLength != 256)
                    {
                        MessageBox.Show("Fehlende Signatur oder unbekannter Algorithmus!", "Signaturprüfung");
                        return;
                    }
                    else
                    {
                        stream.Seek(-4 - signatureLength, SeekOrigin.End);
                        signature = reader.ReadBytes(signatureLength);
                    }
                }
            }
            var contentLength = fileContent.Length - signatureLength - 4;

            // Signatur gegen den vorhergehenden Teil (= das zip Archiv) prüfen
            using (var rsa = new RSACryptoServiceProvider(2048))
            {
                rsa.FromXmlString(rsaKey);
                var result = rsa.VerifyData(fileContent, 0, contentLength, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
                if (result)
                    MessageBox.Show("Signatur erfolgreich verifiziert :-)", "Signaturprüfung");
                else
                    MessageBox.Show("Beschädigte oder fehlerhafte Signatur!", "Signaturprüfung");
            }
        }
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:

public void InstallNewUpdate()
        {
            try
            {
                WebClient client = new WebClient();
                Uri URL = new Uri(@"http://meineURL.com/meineDatei.zip");
                string LocalPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "NewUpdate.zip");

                client.DownloadFile(URL, LocalPath);
                MessageBox.Show("g");
                client.DownloadFileCompleted += DownloadCompleted;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void DownloadCompleted(object sender, AsyncCompletedEventArgs e)
        {
            try
            {
                string LocalPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "NewUpdate.zip");
                MessageBox.Show("hier 4");
                // Signatur prüfen
                var filename = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "NewUpdate.zip");
                var fileContent = File.ReadAllBytes(filename);

                if (fileContent.Length < 260)
                {
                    MessageBox.Show("Fehlende Signatur oder unbekannter Algorithmus!", "Signaturprüfung");
                }
                else
                {
                    MessageBox.Show("Hier 1");
                }

                var rsaKey = File.ReadAllText(@"./public.xml");
                byte[] signature = null;
                int signatureLength = 0;

                // Signatur auslesen, sie hängt hinten an der Datei
                using (var stream = new MemoryStream(fileContent))
                {
                    using (var reader = new BinaryReader(stream))
                    {
                        stream.Seek(-4, SeekOrigin.End);
                        signatureLength = reader.ReadInt32();
                        if (signatureLength != 256)
                        {
                            MessageBox.Show("Fehlende Signatur oder unbekannter Algorithmus!", "Signaturprüfung");
                            return;
                        }
                        else
                        {
                            stream.Seek(-4 - signatureLength, SeekOrigin.End);
                            signature = reader.ReadBytes(signatureLength);
                            MessageBox.Show("Hier 2");
                        }
                    }
                }
                var contentLength = fileContent.Length - signatureLength - 4;

                // Signatur gegen den vorhergehenden Teil (= das zip Archiv) prüfen
                using (var rsa = new RSACryptoServiceProvider(2048))
                {
                    rsa.FromXmlString(rsaKey);
                    var result = rsa.VerifyData(fileContent, 0, contentLength, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
                    if (result)
                    {
                        // Weitere Progeamminstallation
                        using (StreamReader reader = new StreamReader(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Mainlysoft", "mainlysoft_devassist")))
                        {
                            string InstallationsPfad = reader.ReadLine();
                            if (InstallationsPfad != "")
                            {
                                string[] files = Directory.GetFiles(InstallationsPfad);
                                foreach (var file in files)
                                    File.Delete(file);

                                MessageBox.Show("Hier");
                                ZipFile.ExtractToDirectory(LocalPath, InstallationsPfad);
                                File.Delete(LocalPath);
                                System.Diagnostics.Process.Start(Path.Combine(InstallationsPfad, "Entwicklungstool.exe"));
                                Application.Exit();
                            }
                            else
                            {
                                MessageBox.Show("Hier 3");

                            }
                        }
                    }
                    else
                    {
                        MessageBox.Show("Beschädigte oder fehlerhafte Signatur!\rDieser Ordner wurde nicht von dem Mainlysoft Team freigegeben. Es kann sich um Schadsoftware handeln.\rBitte löschen Sie diesen Ordner, oder wenden Sie sich an den Mainlysoft Support.", "Signaturprüfung");

                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            InstallNewUpdate();
        }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:

    public void LoadAndInstallNewUpdate() // Besserer Name
    {
      try
      {
        WebClient client = new WebClient();
        Uri URL = new Uri(@"http://meineURL.com/meineDatei.zip");
        string LocalPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "NewUpdate.zip");

        client.DownloadFile(URL, LocalPath);
        MessageBox.Show("g");
        // Nachfolgeoperationen einfach direkt aufrufen...
        // Alternativ korrekt asynchron und das Completed-Event möglichst früh zuweisen.
        if (HasValidSignature(LocalPath))
        {
          InstallUpdate(LocalPath);
        }        
        else
        {
          MessageBox.Show("Beschädigte oder fehlerhafte Signatur!\rDieser Ordner wurde nicht von dem Mainlysoft Team freigegeben. Es kann sich um Schadsoftware handeln.\rBitte löschen Sie diesen Ordner, oder wenden Sie sich an den Mainlysoft Support.", "Signaturprüfung");
        }
      }
      catch (Exception ex)
      {
        MessageBox.Show(ex.Message);
      }
    }
    
    // Signaturprüfung als eigene Aufgabe, die mit einem Parameter auskommt und einen einfachen Rückgabewert hat :-)
    private bool HasValidSignature(string filename)
    {
      var fileContent = File.ReadAllBytes(filename);

      if (fileContent.Length < 260)
      {
        MessageBox.Show("Fehlende Signatur oder unbekannter Algorithmus!", "Signaturprüfung"); // Je nach Anwendungsfall vll. eine Exception
        return false;
      }
      
      MessageBox.Show("Hier 1");

      byte[] signature = null;
      int signatureLength = 0;

      // Signatur auslesen, sie hängt hinten an der Datei
      using (var stream = new MemoryStream(fileContent))
      {
        using (var reader = new BinaryReader(stream))
        {
          stream.Seek(-4, SeekOrigin.End);
          signatureLength = reader.ReadInt32();
          if (signatureLength != 256)
          {
            MessageBox.Show("Fehlende Signatur oder unbekannter Algorithmus!", "Signaturprüfung"); // Je nach Anwendungsfall vll. eine Exception
            return false;
          }
          else
          {
            stream.Seek(-4 - signatureLength, SeekOrigin.End);
            signature = reader.ReadBytes(signatureLength);
            MessageBox.Show("Hier 2");
          }
        }
      }
      
      var contentLength = fileContent.Length - signatureLength - 4;
      var rsaKey = File.ReadAllText(@"./public.xml");
      
      // Signatur gegen den vorhergehenden Teil der Datei (= das zip Archiv) prüfen
      using (var rsa = new RSACryptoServiceProvider(2048))
      {
        rsa.FromXmlString(rsaKey);
        return rsa.VerifyData(fileContent, 0, contentLength, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
      }
    }

    // Installationsvorgang trennen
    private void InstallUpdate(string filename)
    {
      // Weitere Programminstallation
      using (StreamReader reader = new StreamReader(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Mainlysoft", "mainlysoft_devassist")))
      {
        string InstallationsPfad = reader.ReadLine();
        if (InstallationsPfad != "")
        {
          string[] files = Directory.GetFiles(InstallationsPfad);
          foreach (var file in files)
            File.Delete(file);

          MessageBox.Show("Hier");
          ZipFile.ExtractToDirectory(filename, InstallationsPfad);
          File.Delete(filename);
          System.Diagnostics.Process.Start(Path.Combine(InstallationsPfad, "Entwicklungstool.exe"));
          Application.Exit();
        }
        else
        {
          MessageBox.Show("Hier 3");
        }
      }
    }

    private void button1_Click(object sender, EventArgs e)
    {
      LoadAndInstallNewUpdate();
    }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:

public void LoadAndInstallNewUpdate()
        {
            try
            {
                WebClient client = new WebClient();
                Uri URL = new Uri(@"http://meineDaten.zip");
                string LocalPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "NewUpdate.zip");

                client.DownloadFile(URL, LocalPath);

                if (HasValidSignature(LocalPath) == 1)
                {
                    InstallUpdate(LocalPath);
                }
                if (HasValidSignature(LocalPath) == 0)
                {
                    Form2 f = new Form2();
                    f.ShowDialog();

                    if (f.Action == 1)
                    {
                        File.Delete(LocalPath);
                        Application.Exit();
                    }
                }
                if (HasValidSignature(LocalPath) == 2)
                {
                    MessageBox.Show("Bei der Prüfung der Signatur ist ein unbekannter Fehler aufgetreten.\rBitte versuchen Sie es erneut.", "unbekannter Fehler", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        private int HasValidSignature(string filename)
        {
            try
            {
                var fileContent = File.ReadAllBytes(filename);

                if (fileContent.Length < 260)
                {
                    return 0;
                }

                byte[] signature = null;
                int signatureLength = 0;

                // Signatur auslesen, sie hängt hinten an der Datei
                using (var stream = new MemoryStream(fileContent))
                {
                    using (var reader = new BinaryReader(stream))
                    {
                        stream.Seek(-4, SeekOrigin.End);
                        signatureLength = reader.ReadInt32();
                        if (signatureLength != 256)
                        {
                            return 0;
                        }
                        else
                        {
                            stream.Seek(-4 - signatureLength, SeekOrigin.End);
                            signature = reader.ReadBytes(signatureLength);
                        }
                    }
                }

                var updatePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Update");
                ZipFile.ExtractToDirectory(filename, updatePath);

                var contentLength = fileContent.Length - signatureLength - 4;
                var rsaKey = File.ReadAllText(Path.Combine(updatePath, "public.xml"));

                // Signatur gegen den vorhergehenden Teil der Datei (= das zip Archiv) prüfen
                using (var rsa = new RSACryptoServiceProvider(2048))
                {
                    rsa.FromXmlString(rsaKey);
                    if (rsa.VerifyData(fileContent, 0, contentLength, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1))
                        return 1;
                    else
                        return 0;
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show(ex.Message);
                return 2;
            }
        }
        private void InstallUpdate(string filename)
        {
            try
            {
                using (StreamReader reader = new StreamReader(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Mainlysoft", "mainlysoft_devassist.txt")))
                {
                    string InstallationsPfad = reader.ReadLine();
                    if (InstallationsPfad != "")
                    {
                        string[] files = Directory.GetFiles(InstallationsPfad);
                        foreach (var file in files)
                        {
                            MessageBox.Show(file);
                        }

                        MessageBox.Show(filename);
                        //File.Delete(filename);
                        System.Diagnostics.Process.Start(Path.Combine(InstallationsPfad, "Entwicklertool.exe"));
                        Application.Exit();
                    }
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        private void button1_Click(object sender, EventArgs e)
        {
            LoadAndInstallNewUpdate();
        }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

        private int HasValidSignature(string filename)
        {
            try
            {
                // Sehr viel Code
            }
            catch(Exception ex)
            {
                MessageBox.Show(ex.Message);
                return 2;
            }
        }                    

1:
2:
3:
4:
5:

                var updatePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Update");
                ZipFile.ExtractToDirectory(filename, updatePath);

                var contentLength = fileContent.Length - signatureLength - 4;
                var rsaKey = File.ReadAllText(Path.Combine(updatePath, "public.xml"));                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:

public void LoadAndInstallNewUpdate()
        {
            using (StreamReader reader = new StreamReader(file))
            {
                x1 = reader.ReadLine();
                c2 = reader.ReadLine();
                c3 = reader.ReadLine();

                if (reader.ReadLine() == "update")
                {
                    WebClient client = new WebClient();
                    Uri URL = new Uri(@".......zip");
                    string LocalPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "NewUpdate.zip");

                    client.DownloadFile(URL, LocalPath);
                    int HashValue = HasValidSignature(LocalPath);
                    MessageBox.Show("Hier 100000");

                    if (HashValue == 1)
                    {
                        MessageBox.Show("Begin installation");
                        InstallUpdate(LocalPath);
                    }
                    if (HashValue == 0)
                    {
                        Form2 f = new Form2();
                        f.ShowDialog();

                        if (f.Action == 1)
                        {
                            File.Delete(LocalPath);
                            Application.Exit();
                        }
                    }
                    if (HasValidSignature(LocalPath) == 2)
                    {
                        MessageBox.Show("Bei der Prüfung der Signatur ist ein unbekannter Fehler aufgetreten.\rBitte versuchen Sie es erneut.", "unbekannter Fehler", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);
                    }
                }
            }

        }
        private int HasValidSignature(string filename)
        {

            var fileContent = File.ReadAllBytes(filename);

            if (fileContent.Length < 260)
            {
                return 0;
            }

            byte[] signature = null;
            int signatureLength = 0;

            // Signatur auslesen, sie hängt hinten an der Datei
            using (var stream = new MemoryStream(fileContent))
            {
                using (var reader = new BinaryReader(stream))
                {
                    stream.Seek(-4, SeekOrigin.End);
                    signatureLength = reader.ReadInt32();
                    if (signatureLength != 256)
                    {
                        return 0;
                    }
                    else
                    {
                        stream.Seek(-4 - signatureLength, SeekOrigin.End);
                        signature = reader.ReadBytes(signatureLength);
                    }
                }
            }

            var contentLength = fileContent.Length - signatureLength - 4;
            var rsaKey = "...";

            // Signatur gegen den vorhergehenden Teil der Datei (= das zip Archiv) prüfen
            using (var rsa = new RSACryptoServiceProvider(2048))
            {
                rsa.FromXmlString(rsaKey);
                if (rsa.VerifyData(fileContent, 0, contentLength, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1))
                    return 1;
                else
                    return 0;
            }

        }
        private void InstallUpdate(string filename)
        {
            InstallationsPfad = "....";
            if (InstallationsPfad != x1)
            {
                // Alte Programmdaten löschen
                // Installationspfad: Dokumente -> Mainlysoft Devassist -> Programm DLL's, .exe's ...
                DeleteFiles(InstallationsPfad);

                // Neue Programmdaten aufspielen
                Directory.CreateDirectory(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "MSUpd"));
                ZipFile.ExtractToDirectory(filename, Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "MSUpd"));
                DirectoryCopy(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "MSUpd"), InstallationsPfad, true);

                // Installationsordner löschen
                if (File.Exists(filename))
                {
                    File.Delete(filename);
                    MessageBox.Show("Hier 3");
                }

                MessageBox.Show("HIer 1234");
            }

            using (StreamWriter writer = new StreamWriter(file))
            {
                writer.WriteLine(InstallationsPfad);
                writer.WriteLine(x1);
                writer.WriteLine(c2);
                writer.WriteLine("update installed");
                writer.Close();
            }

            System.Diagnostics.Process.Start(...);
            Application.Exit();                    

1:
2:
3:
4:
5:
6:
7:
8:

string x1 = streamReader.ReadLine();
string x2 = streamReader.ReadLine();

//.....

streamWriter.Write("");
streamWriter.WriteLine(x1);
streamWriter.WriteLine(x2);                    

1:

RSACryptoServiceProvider.SignData(Byte[], HashAlgorithmName, RSASignaturePadding)