Zuerst ein Einstieg in das Thema "Einwegverschlüsselung":
(Weiter unten kommen wir dann zum Thema "Mehrwegverschlüsselung" was dich, bezogen auf deine Frage, besonders interessiert. Zum Verständnis und als Grundlage solltest du den ersten Teil trotzdem überfliegen.)

Das einfache Speichern eines Passworts als MD5 gilt heutzutage als unsicher. Für den MD5-Algorithmus gibt es so genannte Rainbow-Tables in denen Millionen bis Millarden von Varianten bereits vorberechnet sind.

Grundsätzlich geht man heute dazu über die Cryp-Funktionen im Zusammenhang mit mechanismen wie "Salt" und "Runden" zu verwenden was Rainbow-Tables unmöglich macht und den Aufwand eines Brude-Force um den Faktor 100 bis 1000 erhöht.

"Salt"

Was "Salt" ist wurde im zugehörigen Wikipedia Artikel bereits sehr gut erklärt weshalb ich ihn hier zitiere:

Salt (deutsch Salz) bezeichnet in der Kryptographie eine zufällig gewählte Zeichenfolge, die an einen gegebenen Klartext vor der Verwendung als Eingabe einer Hashfunktion angehängt wird, um die Entropie der Eingabe zu erhöhen. Es wird häufig für Speicherung und Übermittlung von Computer-Passwörtern benutzt.

Wikipedia

Ein Beispiel:

string salt = "mySalt"
return hashFn(salt + "geheimnis")

"Runden"

Bei den "Runden" handelt es sich um nichts anderes als das Konzept einer Schleife die wir bereits alle aus der Programmierung kennen. Das Ergebnis der Hash-Funktion (ob MD5, AES, DES, SHA, etc. spielt dabei keine Rolle) wird als Eingangswert für einen weiteren Aufruf selbiger benutzt. Das ganze wird einige tausend mal wiederholt.
Ziel der Aktion ist es, die Laufzeit des Hash-Algorithmus zu erhöhen.
Dir als Anwender oder Programmerer ist es egal ob ein dein Passwort in 1 Millisekunden oder 100 Millisekunden gehashed wurde. Für einen Angreifer bedeutet das jedoch eine Steigerung des Aufwands um den Faktor 100 da er jetzt pro Sekunden nicht mehr 1000 Passwörter durchprobieren kann, sondern nurnoch 10.

Ein Beispiel:

string myHash = hashFn("geheimnis")
for(int i=0; i<(2^12); i++){ //2^12 = 4096 Runden
  myHash = hashFn(myHash)
}
return myHash

"Salt" + "Runden" Kombiniert

Kommen wir jetzt zum interessanten Teil. Der Kombination von Salt und Runden.
Wir bereits oben beschrieben ist der Salt ein einmal generierter zufällig String. Beispielsweise kann man alternativ auch ein Masterpasswort als Salt verwenden.
Im Normalfall ist der Salt nicht als geheim einzustufen und darf ruhig im Klartext gespeichert werden (in der Variante mit dem Masterpasswort natürlich nicht!, in diesem Fall darf der Salt nirgendwo gespeichert werden). Es haben sich Schreibweise für Hash etabliert in denen dem eigendlichen Hash der Salt, der Exponent der die Anzahl an Runden definiert und ein Index für den Algorithmus vorrangestellt sind:

//Beispiel:
//  1$12$MySALT$DerEigendlicheHash
//Erklärung:
//  Index für MD5$Anzahl Runden (2^12 = 4096)$Salt$Hash

Dadurch kann man den Salt für jedes einzelne Passwort das du speichern willst neu generieren was die Erstellung neuer Rainbow-Tables quasi unmöglich macht. Zusätzlich läßt sich das Verschlüsselungsverfahren nachträglich verändern (Index 2 könnte für AES stehen) und die Anzahl der Runden ließe sich erhöhen ohne das die bestehenden Passwörter entschlüsselt und neu berechnet werden müßten.

Praktische Anwendungen

Die einfachste Variante:

string salt = "mySalt"
string myHash = hashFn(salt + "geheimnis")
for(int i=0; i<(2^12); i++){
  myHash = hashFn(myHash)
}
return myHash

Die bessere Variante:

string salt = "mySalt"
string myHash = hashFn(salt + "geheimnis")
for(int i=0; i<(2^12); i++){
  myHash = hashFn(salt + myHash)
}
return myHash

Diese beiden Varianten dienen nur als Einsteig in das Konzept. Es gibt noch Varianten die den Abhängig von der aktuellen Runde nur Teile des Salts verwenden und/oder Salt und Hash mit XOR verknüpft werden, und und und.

Soviel von mir als kleiner praktischer Einstieg in das Thema "Einweg-Verschlüsselung for Dummys" :D
Um es nochmals zu erwähnen. Diese beiden Verfahren sowie ihre Kombination sind anerkannte Verfahren der Cryptographie welche unabhängig von Algorithmus eingesetzt werden sollten.
Im speziellen aber sollte man gerade bei MD5 für das Thema "Salt" angehen und bei AES aufgrund der Hardware-Beschleinigung von Crypt-Funktionen durch die neuen Intel-Prozessoren auf jeden Fall das Thema "Runden" angehen.

---------------------------------------------------------------------

Lesenswertes:

Die Rainbow Table (zu Deutsch: Regenbogentabelle) ist eine von Philippe Oechslin entwickelte Datenstruktur, die eine schnelle, probabilistische Suche nach einem Element des Urbilds (i. d. R. ein Passwort) eines gegebenen Hashwerts ermöglicht. Der sogenannte Time-Memory-Tradeoff gestattet die Suche nach fast allen Klartexten eines bestimmten Zeichenraums innerhalb einer erheblich kürzeren Zeit, als diesen komplett zu bruteforcen und ohne alle für diesen Zeichenraum möglichen Hashwerte speichern zu müssen.

Dieses funktioniert bei Hashfunktionen ohne Salt, wie es z. B. bei den Passwörtern für die Windows-Familie oder vielen Routern der Fall ist. Vergleichsweise umfangreiche Tabellen wurden für LM Hashes und MD5 berechnet und stehen aus diversen Quellen zur Verfügung.

Verwendung finden Rainbow Tables bei der Wiederherstellung von Passwörtern, innerhalb der IT-Forensik, bei Penetrationstests und beim illegitimen Passwortcracken.

Rainbow Table

---------------------------------------------------------------------

Und nun zum eigendlichen Thema "Mehrwegverschlüsselung":

Für symmetrische Verschlüsselung dh. das heißt, das eine Zeichenkette sowohl Ver- als Entschlüsselt werden kann bietet sich Algorithmen wie AES und Blowfish an.
Diese erlauben es ein eine Zeichenkette in zusammenhang mit einem Passwort zu verschlüsseln. Bei der Entschlüsselung ist das selbe Passwört von nöten.
In deinem Fall (bezgnehmend auf Punkt 1) bietet sich das nur an, wenn du mehrere Passwörter oder Context-Daten abspeichern möchtest.
Sinnvoll ist es vorallem nicht das von Nutzer gewählte Passwort als Passwort (folgend Key genannt) für den Cryp-Algorithmus zu verwenden, sondern selbiges mit den oben beschriebnen Verfahrfahren der Einwegverschlüsselung zu Verschlüsseln. In der Regel sind Nutzerpasswörter recht einfach gestrickt weshalb dieses im Schnitt eine Länge von 6-9 Zeichen aufweisen. Zu wenig um als sicherer Key für einen symetrischen Cryp-Algorithmus zu dienen. Ein MD5-Hash zum Beispiel hat dagegen 128-Bit und ist somit deutlich besser geeignet.
Der Key selbst darf natürlich nicht auf dem Gerät gespeichert werden sondern muss in Zusammenhang mit einem Salt aus dem Nutzerpasswort errechnet werden.
So kannst du sicherstellen, das ein Angreifer der die Verschlüsselte Datei entwendet diese nur unter großen Technischen Aufwand wieder entschlüsseln kann.
Das Konzept der Runden läßt sich übrigens auch bei symmetrische Verschlüsselungsverfahren anwenden. Hierzu ein Beispiel:

string runden = 2^12
string myKey = MD5("geheimnis", "salt", runden )
string[] keys = new string[){ myKey, "geheimnis", "salt" }
string myCryp = "meine super geheimen daten"
for(int i<0; i<runden; i++){
  myCryp = AES(myCryp, keys[i % 3]) //AES(string, key)
}
return myCryp

Zum entschlüsseln sollte es genügen die Schleife umzukehren.

---------------------------------------------------------------------

Ich hoffe meine Ausführungen helfen dir weiter und beantworten die meißten deiner Fragen. Sicherheit erkauft man sich letztlich immer durch Aufwand. Entweder durch Aufwand beim Benutzer oder durch Programmieraufwand / Rechenleistung.