Abou Chleih

{the magic lies between the brackets}

Menü Schließen

Monat: September 2013

[WordPress] Integrieren des WordPress-Blog in die eigene Homepage #1 Einstieg + Blog-Hauptseite

Eigentlich wollte ich einen eigenen WordPress-Blog aufziehen, ähnlich diesem hier.
Doch hatte ich schon eine Homepage mit komplettem Template fertig.
So stellte sich mir die Frage, ob ich

  • einen eigenen WordPress-Theme bauen
    oder
  • WordPress in die eigene Homepage integrieren soll.

Ich entschied mich für letzteres.
Wie fängt man, aber an ein fertiges Backend in eine eigene Homepage zu integrieren?
Wie frage ich alles ab?
Man benötigt dazu die Datei wp-blog-header.php, welche sich im Stammverzeichnis des WordPress-Ordners befindet.
Die Datei lädt die ganze Umgebung, d.h. alle benötigten Funktionen, also genau das, was wir wollen.

/**
* Loads the WordPress environment and template.
*
* @package WordPress
*/

Nun lädt man die Datei via php in die eigene Seite:

 <!?php include ('meinPfad/wp-blog-header.php'); ?> 

Dies tut man am besten, der Übersichtlichkeit wegen, vor dem HTML-Tag des Dokuments:

<?php include ('wordpress/wp-blog-header.php'); ?>
<!DOCTYPE html>
<html>
<head><meta charset="utf-8" />
<title>Blog</title>...

Nun zum eigentlichen Thema, dem Anzeigen von Posts.
In WordPress gibt es die sogenannte Loop.
Diese wird genutzt, um alle Posts mit einer Loop (while-Schleife) zu bekommen. Sie ist ganz einfach und sieht wie folgt aus:

 <?php if ( have_posts() ) : while ( have_posts() ) : the_post(); ?>
<?php //TO DO HERE ?>
<?php endwhile; else: ?>
<p><?php _e('Sorry, keine Posts gefunden'); ?></p>
<?php endif; ?> 

In dieser while-Schleife können nun alle Objekte der Funktion the_post(); ausgelesen werden.
Hier sind folgende für meine Belange wichtig gewesen:

  • Die Post-ID:  the_ID();
  • Der Titel des Posts: the_title();
  • Die Kategorien mit Namen und Category-ID (später)
  • Die Tags: the_tags(…);
  • Das Datum: the_date();
  • Der Autor: the_author();
  • Der Inhalt: the_content();

Diese Funktion ruft man einfach innerhalb der Loop auf. So wird automatisch der Autor, das Datum, … des entsprechenden Post ausgelesen:

 <?php if (have_posts()) : while (have_posts()) : the_post(); ?>
<?php the_ID(); ?>
<?php the_title(); ?>
<?php the_tags(__('Tags: '), ', ', ' — '); //Die Tags werden mit Komma getrennt ?>
<? the_date();?>
<?php the_author(); ?>
<?php the_content(); ?>
<?php endwhile; else: ?>
<?php _e('Sorry, bisher wurden keine Beiträge geschrieben. Nichts gefunden.'); ?>
<?php endif; ?>

Das einzige, kleine Problem, welches ich noch hatte, war das Auslesen der Kategorien mit Name.
Dies war aber im Endeffekt relativ einfach gelöst, indem man die Funktion get_the_category(); in einer foreach-Schleife ausführte und die Rückgaben ausliest und ausgibt.
Es sollte grob so aussehen (Achtung, etwas buggy mit dem Komma):

<?php _e("Kategorien: "); ?> <?php //the_category(',')
foreach((get_the_category()) as $category) {
    echo $category->cat_name . ', ';
}?>

Im Endeffekt sieht der ganze Code in etwa so aus, wenn man ein paar eigene divs mit einfließen lässt, um die Ausgabe etwas zu designen:

 <div  style="width:450px;min-height:749px;">

<?php if (have_posts()) : while (have_posts()) : the_post(); _e("<br>");?>
<div class="post" id="post-<?php the_ID(); ?>">
<h1><?php the_title(); ?></h1>
<div class="meta"><?php _e("Kategorien: "); ?> <?php //the_category(',')
foreach((get_the_category()) as $category) {
    echo $category->cat_name . ', ';
}?> <br/>
<?php the_tags(__('Tags: '), ', ', ' — '); ?>
<?php _e("Geschrieben am: "); ?> <? the_date(); _e("<br>");?>
<?php _e("Geschrieben von: "); ?><?php the_author(); ?>
<?php edit_post_link(__('edit')); ?>
<?php _e("<hr/>"); ?>
</div>
<div class="storycontent">
<?php the_content(__('(weiterlesen...)')); ?>
</div>
</div>

<?php endwhile; else: ?>
<p><?php _e('Sorry, bisher wurden keine Beiträge geschrieben. Nichts gefunden.'); ?></p>
<?php endif; ?>
</div> 

Der Blog ist eingebunden.
Part 2 mit Suche, Part 3 mit Archiv für Kategorien, … folgen.

[C#/.NET] Verschiedene Authentifizierungsmöglichkeiten #2 – Verschlüsselung und SecureString

[C#/.NET] Verschiedene Authentifizierungsmöglichkeiten #1 – Plain

Im ersten Teil der Serie beschriebe ich, wie man eine einfach Authentifizierung mit hart-codierten oder im Klartext (Plain) gespeicherten Passwörtern erstellt. Nun möchte man das Passwort natürlich eher selten so offen und unsicher speichern. Im Folgenden geht es um das Verschlüsseln und Entschlüsseln, sowie das Sichern von Texten (Strings)

Verschlüsseln:

Als Paradebeispielt für eine unsichere Verschlüsselung gilt die Caesar-Verschlüsselung (hier ROT13), dabei wird ein Buchstabe einfach durch den 13 Stellen vor- oder hinter liegenden Buchstaben ersetzt.

    static class Rot13
    {
        ///
/// Verschiebe Buchstaben um 13 Stellen
        ///
        public static string Enrypt(string pString)
        {
            string rot13String = "";
            foreach (char c in pOrgString)
            {
                if (c >= 'a' && c <= 'm' || c >= 'A' && c <= 'M')//falls der Buchstabe zwischen a/A und m/M liegt (m/M da es sich um den 13. Buchstaben handelt)
                {
                    rot13String += ((char)((int)c + 13)); //dann füge dem verschlüsselten String den Buchstaben, welcher 13 Stellen hinter dem   originalen Buchstaben steht hinzu
                }
                else if (c >= 'n' && c <= 'z' || c >= 'N' && c <= 'Z') //falls der Buchstabe zwischen n/N und z/Z liegt (n/N da es sich um den 14. Buchstaben also den ersten rotierten handelt)
                {
                    rot13String += ((char)((int)c - 13)); // dann ziehe 13 Stellen ab und füge den neune Char hinzu
                }
                else //Sollte es sich um keinen Buchstaben im lateinischen Alphabet handeln,
                {
                    rot13String += c; //So füge ihn unverändert hinzu
                }
            }
            return rot13String;
        }
    }

Entschlüsselt wird es indem man selben Code nochmals mit dem ROT13-verschlüsselten String als Parameter ausführt

Für die Verschlüsselung eines Strings mit AES (Rijndael-Algorithmus) verweise ich auf: [C#] AES-Ver und Entschlüsselung mit Rijndael

SecureString

Die Idee hinter dem SecureString ist es, die Zeit in der sich das Passwort (bzw. der zu sichernde Text) als Typ String im System befindet auf ein Minimum zu reduzieren. Dazu wird der String in ein Binärobjekt gewandelt und im unmanaged Memory (nicht verwalteter Speicher) gespeichert. Das führt dazu, dass das Objekt nicht durch den Garbage Collector berührt wird. Der SecureString wird fest im RAM verankert, sodass er nicht Teil der virtuellen Speichers ist und so „geswappt“ wird (Swap kann Daten auf der Festplatte hinterlassen, welche auch nach Beenden der Applikation noch vorhanden sind).
Früher oder später wird es nötig sein die Daten als String zwischenzuspeichern (beispielsweise, wenn der User das Passwort eingeben muss oder es wieder angezeigt werden soll).

Nun aber zum Code:
1. Erstellen eines SecureStrings:
Das Erstellen eines SecureString geschieht in der Regel mit der Methode AppendChar(char c). Zusätzlich gibt es noch die Methoden InsertAt(int index, char c), RemoveAt(int index) und SetAt(int index, char c).

        public void ConvertCharArrayToSecureString(char[] CharArray)
        {
            foreach (char c in CharArray) //IEnumerable
            {
                secureStr.AppendChar(c); //Für jeden Buchstaben (char) in dem String(Text in der Textbox), fügen wir den aktuellen Buchstaben dem SecureString an
            }
        }

Sobald das Passwort in den SecureString gewandelt wurde, solltet ihr den String/die TextBox leeren und den SecureString mittels der Methode MakeReadOnly() als schreibgeschützt festlegen.

Rufen wir nun die ToString() des SecureStrings auf und geben den Rückgabewert per MessageBox aus, so wird uns lediglich der Typ des Objekts angezeigt
2013-09-16 13_39_42-

2. Wandeln eines SecureStrings in einen String

Nun möchte man möglicherweise den SecureString doch auslesen. Dies lässt sich mit folgender Methode bewerkstelligen:

        public string ConvertSecureStringToString()
        {
            IntPtr unmanagedString = IntPtr.Zero; //Erstellt einen Zeiger (zeigt bisher auf nichts)
            try
            {
                unmanagedString = Marshal.SecureStringToGlobalAllocUnicode(secureStr); //kopiert den SecureString in den nicht verwalteten Speicher (dient als Puffer)
                return Marshal.PtrToStringUni(unmanagedString); //Reserviert einen verwalteten String (unseren Rückgabetyp) und kopiert eine nicht verwaltete Zeichenfolge (unser SecureString) hinein.
            }
            finally //Der im Finally-Block befindliche Code wirk auf jeden Fall ausgeführt (auch bei einer Exception)!
            {
                Marshal.ZeroFreeGlobalAllocUnicode(unmanagedString); //Gibt den Zeiger, welcher mit SecureStringToGlobalAllocUnicode reserviert wurde, frei (Puffer wird befreit)
            }
        }

Bitte vergesst den Code im finally-Block nicht, denn ohne diesen entsteht eine Möglichkeit das Passwort auszulesen.

In unserem oberen Beispiel muss ich einen kompletten String bzw. ein komplettes CharArray übergeben, sodass es hier noch die Möglichkeit gibt, das komplette Passwort an einen Stück zu auszulesen, um dies noch weiter zu erschweren, kann man wie folgt vorgehen.

Man erstelle eine normale TextBox (in meinem Beispiel SecureString_SecurerTextBox_textBox genannt) und registriere einen Eventhandler für das KeyPress-Event. In der Methode des Events verwendet man dann folgenden Code:

private void SecureString_SecurerTextBox_textBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == '\b') //Falls die Rücktaste gedrückt wurde,
            {
                DeleteLastCharFromSecureString(); //soll der letzte Buchstabe des SecureStrings gelöscht werden
                if(SecureString_SecurerTextBox_textBox.Text.Length > 0) //Sowie der letzte Buchstabe des Textes in der TextBox, wenn dort noch mindestens ein Buchstabe vorhanden ist
                    SecureString_SecurerTextBox_textBox.Text = SecureString_SecurerTextBox_textBox.Text.Remove(SecureString_SecurerTextBox_textBox.Text.Length - 1, 1);
            }
            else //Sollte die Taste eines anderen Buchstaben gedrückt worden sein,
            {
                AddCharToSecureString(e.KeyChar); //rufe die Methode zum Anfügen des Buchstabens auf
                SecureString_SecurerTextBox_textBox.Text += "*"; //und füge dem Text der TextBox ein Sternchen an
            }
            e.Handled = true; //Bricht das KeyPress-Ereignis ab (es wird kein Buchstabe hinzugefügt)
        }

Folgende Methoden sind zusätzlich erforderlich:

        private void AddCharToSecureString(char c)
        {
            secureStr.AppendChar(c); //Fügt einen Buchstaben an letzter Stelle des SecureStrings an
        }

        private void DeleteCharFromSecureString()
        {
            if(secureStr.Length > 0)
                secureStr.RemoveAt(secureStr.Length - 1); //Löscht den letzten Buchstaben im SecureString
        }

Durch die Vorgehensweise wird der Buchstabe nur als Parameter übergeben und in der TextBox lediglich ein Sternchen (*) hinterlegt. Die Zeit in der sich das Passwort offen/komplett im Speicher liegt, ist stark reduziert. Leider leidet die Benutzerfreundlichkeit und die Übersichtlichkeit des Codes darunter.

Zu guter Letzt das Demo Projekt:

20130811_Verweis-Manager - OleDBTest_000034

ROT13 und SecureString

[C#/.NET] Verschiedene Authentifizierungsmöglichkeiten #1 – Plain

Im Klartext hinterlegte Passwörter sind natürlich in keinster Weise zu empfehlen, da sie leicht ausgelesen werden können. Dennoch sind die für kleinere Programme, welche unkritisch sind manchmal sinnvoll, da solch ein Passwortschutz schnell geschrieben ist und seinen Zweck allemal erfüllt.
Ein mir bekanntes Beispiel wäre ein Textticker, in welchem man den Pfad nur mittels Passworteingabe ändern kann (solch ein Programm ist sehr unkritisch und bedarf keines extra Schutzes. Zudem verhindert solch ein Passwort, dass unbedarfte Benutzer die Einstellungen (un)absichtlich verändern).

Hartcodiert

Ist wohl die einfachste Möglichkeit ein Passwortschutz zu integrieren.
Dazu benötigt man lediglich zwei Strings(Username/Passwort) und legt diese wie gewünscht fest. Bspw. Username:Root, Passwort:tooR
In der Credentialsabfrage vergleichen wir dann einfach die hinterlegten mit jenen, welche eingegeben wurden.
Folgender Code wird dafür benötigt:

        string login_user = "Root"; //Hartcodierter Eintrag des Users
        string login_pw = "tooR"; //Hartcodierter Eintrag für das Passwort

        public Form1()
        {
            InitializeComponent();
            auth_button.Click += new EventHandler(auth_button_Click); //Eventhandler für den Click auf den Authentifizierungbutton
        }

        private void auth_button_Click(object sender, EventArgs e)
        {
            if (authenticate() == true) //Aufruf der Methode zum Vergleich der eingetragenen Werte mit den hinterlegten
                MessageBox.Show("Erfolgreich authentifiziert");
            else
                MessageBox.Show("Anmeldung war nicht erfolgreich");
        }

        private bool authenticate() //Rückgabetyp boolean
        {
            if (user_textBox.Text == login_user && pw_textBox.Text == login_pw) //Überprüfung der Gleichheit der Werte
                return true; //Gibt true zurück, falls die Werte gleich sind
            else //Ansonsten false
                return false;
        }

In Datei klar gespeichert

Ist eigentlich das selbe Spiel, jedoch weisen wir den Strings nicht „sofort“ einen Werte zu, sondern lesen sie zuerst aus einer Datei aus und dann weisen wir sie zu.
Da sich dieser Variante nur durch das Auslesen unterscheidet, werde ich nur eben jenes beschreiben.

Zuerst fügen wir den Namespace System.IO; mittels:

using System.IO;

hinzu und rufen folgende Methode beim Starten des Programms(im Konstruktor der Main-Klasse) auf

        private void GetLoginValues()
        {
            int lineCount = 1; //Wird benötigt, um die aktuelle Zeile zu ermitteln
            StreamReader credValueReader = new StreamReader("credValue.txt"); //Hier wird das Objekt angelegt und der Pfad festgelegt
            //in diesem Fall muss die Datei im Verzeichnis des Programmes liegen
            while (!credValueReader.EndOfStream) //Solange nicht das Ende der Datei erreicht wurde
            {
                switch (lineCount)
                {
                    case 1:
                        login_user = credValueReader.ReadLine(); //Weißt dem Userstring den Wert der ersten Zeile zu
                        break;
                    case 2:
                        login_pw = credValueReader.ReadLine(); //Weißt dem Passwortstring den Wert aus der nächsten Zeile(2) zu
                        break;
                }
                lineCount++; //erhöht den Zeilenzähler
            }
            credValueReader.Close(); //Löst den Zugriff auf die Datei(ist sehr wichtig!)
        }

© 2018 Abou Chleih. Alle Rechte vorbehalten.

Thema von Anders Norén.