<script type="text/javascript">
      window.onload = function() {
          CKEDITOR.replace('ckEditor', {
            skin: 'office2003',
            filebrowserUploadUrl: '<%=Url.Action("UploadImage") %>'
      });
  };

</script>

Wichtig ist hier der Parameter “filebrowserUploadUrl”. Dies ist der Pfad, wohin das Bild beim Upload gesendet wird.
Im Controller wird das ganze nun verarbeitet:

        [AcceptVerbs(HttpVerbs.Post)]
        public string UploadImage()
        {
            // Datei speichern
            var identifier = Guid.NewGuid();
            string[] fileExt = Request.Files[0].FileName.Split('.');
            string safeFile = identifier + "." + fileExt[fileExt.Length - 1];
            Request.Files[0].SaveAs(Path.Combine(HostingEnvironment.MapPath("~/UploadedImages/"), safeFile));

            // Daten an CKEditor zurück geben
            string result = "<script type=\"text/javascript\">";
            result += "window.parent.CKEDITOR.tools.callFunction(" + Request.QueryString["CKEditorFuncNum"] + ", \"" +
                      Path.Combine(Url.Content("~/UploadedImages/"), safeFile) + "\",\"\");</script>";
            return result;
        }

Erst speicher ich das Bild irgendwo und gebe dann den Pfad per Javascript zurück. Da ich nur das JS ausführen lassen muss, gebe ich kein komplettes View zurück. Die Url wird dann korrekt an CKEditor übergeben (siehe Screenshots). Der letzte Parameter des callFunction()-Aufrufes kann für Fehlermeldungen genutzt werden, Bild zu groß o.ä.
Mich hat dieser kleine Aufruf bestimmt eine Stunde gekostet!

Das Einbinden in die “web.config” erfolgt über folgenden Eintrag:

    <roleManager enabled="true" defaultProvider="MyPersonalRoleProvider">
      <providers>
        <clear />
        <add name="MyPersonalRoleProvider" type="MyApp.PersonalRoleProvider" connectionStringName="MSPConnString" />
      </providers>
   </roleManager>

Wichtig ist die erste Zeile. Standardmäßig steht “enabled” nämlich auf false!
Der RoleProvider ist nun fertig zum Einsatz! In eurem ASP.NET Projekt könnt ihr auf die Daten über die Standardmethoden wie etwa “Role.IsUserInRole()” etc. zugreifen. Mehr dazu steht in der MSDN.

Ich benutze bei einem Projekt etwa eine SQL-Datenbank und speicher bzw. lese die Daten per Stored-Procedures. Man könnte die Daten aber auch in einer XML-Datei speichern oder direkt hardcoded in der Klasse.

Als erstes erstellen wir ein neues Projekt in Visual Studio. Alternativ könnt ihr auch eine neue Klasse in einem bestehenden Projekt anlegen. Ich habe es als neues Projekt unterhalb meiner Projektmappe angelegt, der Übersicht halber.

Nun erstellen wir eine Klasse und leiten sie vom MembershipProvider ab:

using System;
using System.Configuration;
using System.Configuration.Provider;
using System.Data;
using System.Security.Cryptography;
using System.Text;
using System.Web.Security;
using System.Data.SqlClient;

namespace MyApp
{
    public class PersonalMembershipProvider : MembershipProvider
    {
        public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
        {
            throw new NotImplementedException();
        }

        public override bool ChangePassword(string username, string oldPassword, string newPassword)
        {
            throw new NotImplementedException();
        }

        public override bool ValidateUser(string username, string password)
        {
            throw new NotImplementedException();
        }

        public override MembershipUser GetUser(object providerUserKey, bool userIsOnline)
        {
            throw new NotImplementedException();
        }

        public override MembershipUser GetUser(string username, bool userIsOnline)
        {
            throw new NotImplementedException();
        }

        public override MembershipUserCollection GetAllUsers(int pageIndex, int pageSize, out int totalRecords)
        {
            throw new NotImplementedException();
        }

        public override string ApplicationName
        {
            get { throw new NotImplementedException(); }
            set { throw new NotImplementedException(); }
        }

        public override MembershipPasswordFormat PasswordFormat
        {
            get { throw new NotImplementedException(); }
        }
    }
}

Oben sind nicht alle Methoden / Attribute aufgelistet, der Übersicht halber. Eine Methode wird standardmäßig nicht überschrieben, ist meiner Meinung aber sehr wichtig. Per “Initialize()” können Werte aus der “web.config” des Zielprojektes an den RoleProvider übergeben werden. Diese können etwa den SQL-ConnectionString etc. enthalten. Hierbei gibt es eigentlich keine Vorgaben.

        public override void Initialize(string name, NameValueCollection config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }
            if (string.IsNullOrEmpty(name))
            {
                name = "MyPersonalMembershipProvider";
            }
            base.Initialize(name, config);

            // ConnectionString auslesen
            ConnectionStringSettings connectionStringSettings = ConfigurationManager.ConnectionStrings[config["connectionStringName"]];

            if ((connectionStringSettings == null) || (connectionStringSettings.ConnectionString.Trim() == String.Empty))
            {
                throw new ProviderException("Connection string cannot be blank.");
            }
            this._connectionString = connectionStringSettings.ConnectionString;
        }

In diesem Beispiel wird etwa mit der Zeile “ConnectionStringSettings connectionStringSettings = ConfigurationManager.ConnectionStrings[config["connectionStringName"]];” der Connectionstring aus der “web.config” ausgelesen. Dazu wird der ConnectionStringName mit übergeben, wodurch über den ConfigurationManager der String ausgelesen werden kann. Weiterhin könnte man etwa übergeben, in welchem Format die Passwörter in der Datenbank gespeichert werden.

Nachdem ihr die Methoden entsprechend euren Bedürfnissen ausprogrammiert habt, wird es Zeit den MembershipProvider in eurem ASP.NET-Projekt einzubinden.
Dies geht relativ einfach. Für eine SQL-Verbindung benötigen wir einen entsprechenden ConnectionString. Sollte dieser noch nicht existieren oder die Benutzerdaten in einer anderen Datenbank liegen, legt einen entsprechenden Eintrag in der “web.config” an. Desweiteren müsst ihr unter <membership> einen Eintrag anlegen, der auf den eigenen MembershipProvider verweißt. Solltet ihr mehre MembershipProvider nutzen, so solltet ihr angeben, welches der Standardprovider ist (defaultProvider).

<configuration>
  <connectionStrings>
    <add name="MSPConnString" connectionString="Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|userdata.mdf;Integrated Security=True;User Instance=True" providerName="System.Data.SqlClient" />
  </connectionStrings>

  <system.web>
    <membership defaultProvider="MyPersonalMembershipProvider">
      <providers>
        <clear />
        <add name="MyPersonalMembershipProvider" type="MyApp.PersonalMembershipProvider" connectionStringName="MSPConnString" passwordFormat="Hashed" />
      </providers>
    </membership>
  </system.web>
</configuration>

Ich habe in dem Beispiel noch einen Wert mit übergeben. Der sagt aus, dass ich meine Passwörter in der Datenbank gehasht ablegen möchte.
Dies muss ich natürlich ausprogrammieren.
Der MembershipProvider ist nun einsatzbereit.

EntitySet 'UserInRole' kann nicht aktualisiert werden, denn es hat eine DefiningQuery, und im <ModificationFunctionMapping>-Element ist kein <InsertFunction>-Element zur Unterstützung des aktuellen Vorgangs vorhanden.

Eine Suche im Netz bring mich nicht wirklich weiter. Dort hieß es, ich soll für die m:m-Tabelle einen Primary-Key setzen. Habe ich über beide Felder getan, Ergebnis war das selbe.
Bei dem Beispiel kann ich es über den Role-Provider lösen, aber so richtig weiter bringt es mich dann an anderer Stelle nicht.
Ich werde weiter berichten.

Dazu öffne ich das Modell im Visual Studio Designer und wähle oben die Tabelle aus. Unten wird mir nun das Fenster “Zuordnungsdetails” angezeigt (alternativ über Ansicht » Weitere Fenster). Hier wähle ich die Spalte durch anklicken aus, die ich bearbeiten möchte. Wichtig ist jetzt dass ich hier nicht das vordere MSSQL-Feld sondern den hinteren Bereich, also den C# Typen auswähle (siehe Markierung).

Im Eigenschaftsfenster könnt ihr nun die entsprechenden Werte ändern. In dem Fall setzen wir den Setter auf Private.

Wenn wir nun versuchen eine Id zu setzen, hagelt es Fehlermeldungen:

TestTable test = new TestTable();
test.Id = 3;

Fehlermeldung lautet:

Die Eigenschaft oder der Indexer "MvcApplication1.Models.TestTable.Id" kann in diesem Kontext nicht verwendet werden, da der set-Accessor nicht verfügbar ist.

Auf diesen Weg können wir auch noch andere Sachen ändern, z.B. den Getter verändern oder den Namen des Attributs ändern.

Ach sollte man ein Feld gar nicht im Modell haben wollen, so wählt man bei den Zuordnungdetails einfach “Löschen” aus.

Auf den Weg könnt ihr das Feld später auch wieder ins Modell reinholen.

Auch wenn man sich vorher Gedanken gemacht hat, kann es sein, dass sich die Struktur der Datenbank ändert. Ein neues Feld muss hinzugefügt werden als Beispiel. Wie in meinem Beispiel.

Nun möchte ich diese Änderungen natürlich auch möglichst einfach in mein Model bekommen, ohne dies neu anzulegen. Öffnet das Model in Visual Studio per Doppelklick, so dass ihr in den Designer kommt. Rechtsklickt dort irgendwo und wählt “Modell aus Datenbank aktualisieren”.

Wählt im folgenden Bildschirm den Reiter “Aktualisieren”. Hierbei sei erwähnt, dass nun alles aus der Datenbank aktualisiert wird! Also solltet ihr euch die Änderungen dann noch mal ansehen.

Zu guter letzt habt ihr nun das neue Feld in eurem Ado.Net Modell.

Ich habe bis jetzt zwar nur mal kurz durchgeblättert, aber es scheint recht interessant zu sein und einen kleinen Einblick ins innere zu geben.
Nun brauch ich nur noch ein ordentliches Buch über LINQ

md5(“test”) immer “098f6bcd4621d373cade4e832627b4f6″

Das Problem
Selbst wenn nun ein böser Hacker die Datenbank ausliest, kommt er so an das Passwort. Der einfachste Weg liegt dabei so nahe, dass man gar nicht drauf kommt. Gebt mal so einen Hash bei Google ein, man wird das Passwort herausfinden können. Und mittlerweile gibt es ganze Rainbow-Tabellen, so dass es immer einfacher wird, die Werte zu vergleichen.
Aufgrund des Einfallsreichtums mancher Menschen tippe ich mal darauf, dass man ca. 50% der Passwörter der Otto-Normal-Benutzer daher innerhalb weniger Minuten knacken könnte.

Eine mögliche Lösung
Eine sehr elegante Möglichkeit ist es daher, den Hash zu versalzen (engl. Salt).
Die Idee dahinter ist so simpel wie erfolgreich. Ein per Zufall (im Idealfall) erzeugter String, wird vor oder hinter das Passwort gehangen, dieser String dann gehashet. An diesen Hash wird wieder der per Zufall erzeugte String angehangen (oder davor). Das Ergebnis wäre dann:

SALTHASHEDPASSWORD

Den Salt brauchen wir an der Stelle wieder, um das Passwort wieder zu vergleichen. Anhand des Klartextpasswortes und des Salt können wir wieder den Hash erstellen und so die Werte vergleichen und der Benutzer kann sich einloggen oder wird halt ausgesperrt.

Vorteil des Versalzens
Nun wo liegt der Vorteil gegenüber der salzlosen Methode? Da der Salt per Zufall erzeugt wird, kommen am Ende bei selben Eingabewerten trotzdem unterschiedliche Hashes raus. Zwar kann man diese durch den ja bekannten Salt per BruteForce das Passwort knacken, was jedoch sehr Zeitaufwendig ist. Aber der einfache Vergleich mit Rainbow-Tables ist nicht mehr möglich, da die Wahrscheinlichkeit sehr gering ist, dass es Rainbow-Tables mit genau dem Passwort und dem Salt gibt.

Meine Salzstreuerklasse
Aber zurück zum Thema, ich wollte gerne genau so eine Salt Methode nutzen.
Jedoch fand ich auf Anhieb nichts fertiges in C#. Also habe ich ein wenig gegooglet und mir was eigenes programmiert, welches ich euch nicht vorenthalten möchte.

Die Verwendung ist simpel. Die Klasse sowie eine Demokonsolenanwendung findet ihr im Anhang.
Hier eine kurze Doku zur Erklärung.

        /// <summary>
        /// Gibt die Länge des Salt zurück, sofern eine vom Benutzer gesetzt wurde.
        /// Andernfalls wird eine Zufallslänge zurückgegeben.
        /// </summary>
        public int SaltLength

        /// <summary>
        /// Gibt einen Base64-Encoded String zurück, welcher nach dem DefaultHashAlgorithm gehashed wurde.
        /// </summary>
        /// <param name="password">Passwort</param>
        /// <param name="hashMethod">Die verwendete Hashmethode. Möglich: SHA1, SHA256, SHA384, SHA512, RIPEMD160, MD5</param>
        /// <param name="salt">Zu verendenen Salt.</param>
        /// <returns></returns>
        public string Hash(string password, string hashMethod, byte[] salt)

        /// <summary>
        /// Gibt einen Base64-Encoded String zurück, welcher nach dem DefaultHashAlgorithm gehashed wurde.
        /// </summary>
        /// <param name="password">Passwort</param>
        /// <returns></returns>
        public string Hash(string password)

        /// <summary>
        /// Gibt einen Base64-Encoded String zurück, welcher nach dem DefaultHashAlgorithm gehashed wurde.
        /// </summary>
        /// <param name="password">Passwort</param>
        /// <param name="hashMethod">Die verwendete Hashmethode. Möglich: SHA1, SHA256, SHA384, SHA512, RIPEMD160, MD5</param>
        /// <returns></returns>
        public string Hash(string password, string hashMethod)

        /// <summary>
        /// Gibt einen Base64-Encoded String zurück, welcher nach dem DefaultHashAlgorithm gehashed wurde.
        /// </summary>
        /// <param name="password">Passwort</param>
        /// <param name="salt">Zu verendenen Salt.</param>
        /// <returns></returns>
        public string Hash(string password, byte[] salt)

        /// <summary>
        /// Vergleicht ein Passwort mit einem Hash
        /// </summary>
        /// <param name="password"></param>
        /// <param name="hash"></param>
        /// <returns></returns>
        public bool VerifyHash(string password, string hash)

        /// <summary>
        /// Vergleicht ein Passwort mit einem Hash nach der angebenen Hashmethode.
        /// </summary>
        /// <param name="password"></param>
        /// <param name="hash"></param>
        /// <param name="hashMethod"></param>
        /// <returns></returns>
        public bool VerifyHash(string password, string hash, string hashMethod)

Viel Spaß damit!

Download
SaltHash.zip

Nach einiger Sucherei konnten wir dies auf die <connectionStrings> in der web.config zurückführen.
Durch einen Kollegen stand dort folgende zwei Einträge drin:

    <add name="PersonalSettingsEntities"
    connectionString="metadata=res://*/Models.Personal.csdl|res://*/Models.Personal.ssdl|res://*/Models.Personal.msl;provider=System.Data.SqlClient;provider connection string=&quot;Data Source=WXPAPP02\SQLEXPRESS;Initial Catalog=IntranetDB;User ID=sa;Password=sa;Pooling=False;MultipleActiveResultSets=True&quot;"
    providerName="System.Data.EntityClient" />
    <add name="PersonalEntities"
    connectionString="metadata=res://*/Models.Home.csdl|res://*/Models.Home.ssdl|res://*/Models.Home.msl;provider=System.Data.SqlClient;provider connection string=&quot;Data Source=WXPAPP02\SQLEXPRESS;Initial Catalog=IntranetDB;User ID=sa;Password=sa;Pooling=False;MultipleActiveResultSets=True&quot;"
    providerName="System.Data.EntityClient" />

Der Unterschied zu den anderen Connectionstrings war, dass diese Einträge die Einträge “Pooling=False;” enthält, und den Eintrag “Persist Security Info=True;” war nicht enthalten.
Die Zeilen entsprechend abgeändert, schon ging es.
Werde nachher noch mal genaue Erklärung zu den beiden Parametern raussuchen.

using System.Web.Mvc;

namespace MyProject.CustomExtensions
{
    public static class MyHtmlHelperExtensions
    {
        public static string Encode(this HtmlHelper html, string text, bool convertNewLine)
        {
            if (convertNewLine)
            {
                return html.Encode(text).Replace("\n", "<br />");
            }
            return html.Encode(text);
        }

        public static string Encode(this HtmlHelper html, object text, bool convertNewLine)
        {
            if (convertNewLine)
            {
                return html.Encode(text).Replace("\n", "<br />");
            }
            return html.Encode(text);
        }
    }

}

Wann IEnumerable nutzen, wann ICollection und wieso überhaupt IList?

Gibt in dem Blog übrigens noch andere lesenswerte Beiträge!

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl<MyModel>" %>
<%= Html.ValidationSummary(); %>
<% using(Ajax.BeginForm("MyAction", new AjaxOptions { UpdateTargetId = "fromDiv" })) { %>
Benutzername: <%= Html.Textbox("username", Model.Username) %>
<input type="submit" value="Absenden" />
<% } %>

Hier mal als Beispiel. Das ganze wurde dann an den Server gesendet, validiert und bei Bedarf halt mit Fehlermeldung noch mal ausgegeben.

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult MyAction(string username) {
   if(this.UsernameExists(username)) {
      this.ModelState.AddModelError("errorUsername","Benutzername existiert schon!");
      MyModel user = new MyModel { Username = username + "1" };
      return PartialView("MyControl", user);
   }
   //...
}

So, angenommen wir geben nun einen Benutzername ein, welcher schon existiert. Dann sollte nun das Formular erscheinen, oben die ValidationSummery und als Benutzername vorgeblendet der von eben + 1. Möge man meinen, ist aber nicht so. Es erscheint zwar die ValidationSummary aber nicht die 1 hinter dem Namen.
Ich hab das gute Teil rauf und runter debugt, in div. Browsern, bei allen das selbe Ergebnis. Im Model steht der richtige Wert, er wird aber nicht angezeigt.
Eine Erklärung konnte ich nicht finden, aber eine Lösung.

Das Problem liegt an Html.Textbox(). Es scheint, als ob er das Objekt im Cache vorhält. Da werden ganz böse Erinnerungen an ViewState wach. Lösen konnte ich das Problem, in dem ich die Textbox manuell erstelle:

Benutzername: <input type="text" name="username" value="<%= Html.Encode(Model.Username) %/>" />

Aber auf so etwas muss man erstmal kommen. Löst ja eigentlich nicht das Problem sondern nur umgangen. Vielleicht find ich ja noch mal einen Beitrag dazu in der MSDN oder jemand hinterlässt mir einen schönen Link in den Kommentaren.

Heute wollte ich anhand einer Datenbank eine <select>-Liste in einem ASP.NET MVC Projekt erstellen.
Dazu wollte ich die Html.DropDownList() verwenden, welche eine Liste des Typen “SelectListItem” verlangt. Dies wollte ich schnell mit Linq erstellen:

var daten = from datensatz in this.datenSet select new SelectListItem {
Value = datensatz.Id.ToString(),
Text = datensatz.Name
}

Das hat so nicht geklappt, Fehlermeldung lautete:

‘LINQ to Entities’ erkennt die Methode ‘System.String ToString()’ nicht, und diese Methode kann nicht in einen Speicherausdruck übersetzt werden.

Zudem wurde mir als fehlerauslösende Zeile die Html.DropDownList() angezeigt. Das Problem liegt an dem “datensatz.Id.ToString()”, obwohl es vom Visual Studio direkt vorgeschlagen wird. Auch andere casting Methoden ((string) vorschreiben, Convert.ToString()) waren nicht erfolgreich.
Per Google kam ich auf diesem Beitrag, welcher die Lösung enthielt. Ich schaufel die Daten vorher in ein Dictionary und gebe sie von dort aus, da das Dictionary die ToString() Methode kennt.

var foo = from datensatz in this.datenSet.ToDictionary(i => i.Id, i => i.Name)
          select new SelectListItem
                     {
                         Text = datensatz.Value,
                         Value = datensatz.Key.ToString()
                     };

Diese Lösung klappt hier nun ganz gut, da wir wirklich nur einen Key und ein Value haben. Spätestens bei drei Werten kann man nicht über ein Dictionary gehen. Da müssen die Daten dann vorher in eine “Dummy”-Klasse gepumpt werden, welche die Wertetypen so annimmt. Nicht die schönste Weg, aber ein besserer fällt mir spontan nicht ein.

Nun wollte ich alle Einträge aus Tabelle B, welche keine Verknüpfung zu Tabelle A haben, sprich in der Spalte den Wert “NULL” besitzen.
Leider ist es nicht möglich, die Spalte im Code anzusteuern.

Die Lösung ist hier eigentlich ganz einfach, meine erste Idee war auch richtig, hat aber nicht “geklappt”, da ich mir die falsche Variable ausgeben lassen habe.
Da durch die 0..1 –> * Beziehung im “AdressbuchUser”-Objekt automatisch ein (in dem Fall) “AdressbuchFirmen”-Objekt angelegt wird, welches die Daten aus der anderen Tabelle enthält, braucht man dies nur auf null zu prüfen, schon funktioniert die ganze Geschichte.

Weitere Informationen zu dem Thema findet ihr hier.

Einige habe ich auf codeville.net gefunden.
Ausprobiert habe ich selber nur “Option 2″. Dazu änderte ich in der Global.asax die Default-MapRoute:

routes.MapRoute(
    "Default",                                                           // Route name
    "{controller}.aspx/{action}/{id}",                           // URL with parameters
    new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
);

Sofern im Projekt die Links über z.B. Html.ActionLink() erstellt werden, läuft das Projekt nun ohne weitere Probleme. Die Urls sehen nun so aus: http://localhost/Home.aspx/Index/123
Ist zwar nicht so der Hit, aber die einfachste Möglichkeit ohne viel gefrickel.

Aber etwas solltet ihr beachten. Sofern ihr die Authentifizierung nutzt, sollte ihr in der Web.config den Pfad zur Loginurl ändern:

<forms loginUrl="~/Account.aspx/LogOn" timeout="2880" />

Dann klappt es auch mit dem Nachbarn

Von nun an könnt ihr in Visual Studio, wenn ihr ein neues Projekt startet unter “Visual C#” –> “Web” ein ASP.NET MVC Projekt starten.

Das wars eigentlich schon