Ankündigung

Einklappen
Keine Ankündigung bisher.

[Erledigt] GET Parameter verschlüsseln

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • [Erledigt] GET Parameter verschlüsseln

    Moin zusammen.

    Ich habe ein kleines Problem. Ich möchte einen $_Get Parameter verschlüsseln und später wieder entschlüsseln. Beides funktioniert soweit auch. Allerdings wird mir beim entschlüsseln das Array im $_GET völlich verhauen.

    Ich benutze zum ver- und entschlüsseln folgende Klasse:

    PHP-Code:
    <?php
        
    class URLEncryption {
            
    /**
            *   @var string Enthält das Verschlüsselungspasswort
            */
            
    private $_key "Hier_Passwort";

            
    /**
            * Verschlüsselt einen String. 
            * @access private
            * @param string $pData Der zu verschlüsselne String
            * @return string Der verschlüsselte String, kodiert mittels einer URL-sicherem base64
            */
            
    private function encrypt($pData) {
                
    $passcrypt trim(mcrypt_encrypt(MCRYPT_RIJNDAEL_256$this->_key,
                                        
    trim($pData), MCRYPT_MODE_ECB));

                
    $encode $this->base64url_encode($passcrypt);
                return 
    $encode;
            }

            
    /**
            * Entschlüsselt einen String
            * @access private
            * @param string $pData Der verschlüsselte String
            * @return string Der entschlüsselte String
            */
            
    private function decrypt($pData) {   
                
    $decoded $this->base64url_decode($pData);

                
    $decrypted trim(mcrypt_decrypt(MCRYPT_RIJNDAEL_256$this->_keytrim($decoded),
                                        
    MCRYPT_MODE_ECB));
                return 
    $decrypted;
            }

            
    /**
            * Kodiert einen String mittels base64. Dabei wird auf eine gültige Verwendung in einer URL geachtet.
            * @access private
            * @param string $pData Der zu kodierende String
            * @return string Der base64-Kodierte String
            */
            
    private function base64url_encode($data) {
                return 
    rtrim(strtr(base64_encode($data), '+/''-_'), '=');
            }

            
    /**
            * Dekodiert einen String mittels base64. Dabei wird auf eine gültige Verwendung in einer URL geachtet.
            * @access private
            * @param string $pData Der zu dekodierende String
            * @return string Der dekodierte String
            */
            
    private function base64url_decode($data) {
                return 
    base64_decode(str_pad(strtr($data'-_''+/'), strlen($data) % 4'='STR_PAD_RIGHT));
            } 

            
    /**
            * Parst den verschlüsselten $_GET-String. 
            * @param $pData Der verschlüsselte $_GET-String.
            * @return void Es wird nichts zurück gegeben.
            */
            
    function parseEncryptedGET($pData) {
                
    parse_str($this->decrypt($pData), $_GET);
            }

            
    /**
            * Verschlüsselt einen $_GET-String (á la "foo=bar&bar=foo") 
            * @param string $pGETString Der GET-String
            * @return string Der verschlüsselte String.
            */
            
    function createEncryptedGET($pGETString) {
                return 
    $this->encrypt($pGETString);
            }

        }
    ?>
    Zum Verschlüsseln des Links nutze ich dann folgenden Code:

    PHP-Code:
    <?
    include "class/urlenc.class.php";
    $urlenc = new URLEncryption();

    echo ' - <a href="enc.php?data='.$urlenc->createEncryptedGET("$newdomain").'">Jetzt Registrieren</a>';
    ?>
    und Zum Entschlüsseln dann diesen Code:

    PHP-Code:

    <?
    echo "Codiert: ";
    print_r($_GET);
    echo "<br>";


    include "class/urlenc.class.php";
    $urlenc = new URLEncryption();


    if(isset($_GET["data"])) {
        $urlenc->parseEncryptedGET($_GET['data']);
           
     }

    echo "Decodiert: ";
    print_r($_GET);
    ?>
    Das Ergebniss sieht dann wie Folgt aus:

    Codiert: Array ( [data] => g5MCRSxLptIqYZtA8Yyqr3PSOnxEX7LRneCLAVviz9c )
    Decodiert: Array ( [deepzone-teile_de] => )

    Wie man sieht wird das Get Array nach dem entschlüsseln falsch aufgebaut so das ich mit dem GET Parameter eigentlich nichts mehr anfangen kann.
    Leider hab ich keine Ahnung wo genau der Fehler sitzt und Hoffe das ich hier vielleicht hiolfe bekommen könnte. Vielen Dank schonmal im Vorraus.

    Greetz Deep


  • #2
    - Wozu machst du das?

    - Woher ist die Klasse, kann es sein das die einfach nicht funktoniert. Finde die sieht tlw. seltsam aus bzw. hat die meines Erachtens einige Fehler drinnen.
    Debugging: Finde DEINE Fehler selbst! | Gegen Probleme beim E-Mail-Versand | Sicheres Passwort-Hashing | Includes niemals ohne __DIR__
    PHP.de Wissenssammlung | Kein Support per PN

    Kommentar


    • #3
      dito, wobei ein blick in die docu auch nicht schaden würde, wenn schon verschlüsseln.

      aber der sinn, parameter serverseiting zu ver- und entschlüsslen, mag mir auch nicht einleuchten. user wissen ja zumeist was sie klicken. zudem würde eine simple zuordnung mE die selben resultate liefern.

      Kommentar


      • #4
        Schade das nach Sinnhaftigkeit gefragt wird. Der Zweck ist rein der Daten und Systemschutz. Ein unverschlüsselter $_Get Parameter, und ich könnte Daten auslesen die mich nichts angehen möglicherweise.

        Beispiel:
        URL "www.domain.tld/index.php?daten=datensatz1"

        Ein Angreifer könnte nun "...daten=datensatz1" verändern um möglicherweise an Daten zu kommen die ihn nichts angehen. Dies möchte ich schlichtweg vermeiden. Sinn meiner Meinung nach 100% !

        Nun wollte ich hier nicht über die Sinnhaftigkeit meines Projektes Diskutieren sondern suche lediglich Hilfe zu meinem Problem.

        Handbücher, Internet etc. habe ich bereits durchsucht und gelesen. Halfen mir aber nicht bei der Lösung.

        Kommentar


        • #5
          Da gibt es einfach bessere Möglichkeiten -> Dem User technisch verbieten an Orte zu gehen die ihn nichts angehen, anstatt den Pfad zu vernebeln.
          ACL, Berechtigungssystem, Whitelist
          Davon abgesehen, suckt die nachträgliche Manipulation von Request-Daten doch.

          Zu deinem Beispielcode(verschlüsseln und entschlüsseln, nicht die Klasse), geh doch mal den Ablauf durch und hau nach jedem Schritt einen dump rein, das ist mir in den von dir geposteten Code-Ausschnitten zu durcheinander um wirklich erkennen zu können, was du da machst.
          Relax, you're doing fine.
          RTFM | php.de Wissenssammlung | Datenbankindizes | Dateien in der DB?

          Kommentar


          • #6
            Moin,

            es geht ja nicht um eine Art von Rechte System sondern vielmehr um den Schutz vor Angriffen durch Manipulieren der URL.

            Das Thema hat sich dann auch erledigt.
            Fehler lag einfach im Aufbau der URL.

            Bislang habe ich die URL die Verschlüsselt werden sollte im Quellcode so aufgebaut:

            ...enc.php?data=domain.tld


            Das Ergebniss: geht nicht.

            Nachdem ich nun die URL folgendermasse aufgabaut wird:

            ...enc.php?data=domain=domain.tld


            Funktioniert das ganze nun wie es soll.
            Unter der Nutzung der o.a. Klasse:

            PHP-Code:
            <?
            ini_set('display_errors',1);
            error_reporting(-1);  

            //Klasse includen 
            include "class/urlenc.class.php";
            $urlenc = new URLEncryption();

            // URL verschlüsseln 
            echo '<a href="enc.php?data='.$urlenc->createEncryptedGET('domain=domin.tld').'">...enc.php?data=domain=domain.tld</a>';
            echo "<br>";
            echo "<br>";
            echo "<br>";
            echo "<br>";

            // $_GET Parameter aus der URL anzeigen
            echo "Übergebenes $_GET aus der URL: ";
            print_r($_GET);
            echo "<br>";

            // URL wieder entschlüsseln
            if(isset($_GET["data"])) {
                $urlenc->parseEncryptedGET($_GET["data"]);
                   
             }


            // Ausgabedes $_GET Array
            echo "Ausgabedes des GET Array nach entschlüsselung: ";
            print_r($_GET);

            echo "<br>";

            // Wiederverwendung der $_GET Parameter
            echo "Parameter nach entschlüsselung: ";
            echo $_GET["domain"];

            ?>

            Kommentar


            • #7
              Ein Angreifer könnte nun "...daten=datensatz1" verändern um möglicherweise an Daten zu kommen die ihn nichts angehen. Dies möchte ich schlichtweg vermeiden. Sinn meiner Meinung nach 100% !
              jo wenn du meinst, fage mich allerdings, wieso dui das get mitsendest vom und zum server.

              Schade das nach Sinnhaftigkeit gefragt wird.
              sowas bringt mich zumeist weiter.

              egal, es macht das was es soll, scheinbar. der aufbau der url ist für mich jetzt noch weniger nachvollziehbar, das scheint aber ja ein seiteneffekt.

              dann klick mal auf erledigt.

              Kommentar


              • #8
                Hmmm.... Um Parameter ohne Formular an eine andere Seite zu übergeben bleibt mir doch garnichts anderes Übrig als $_GET zu nutzen. $_Post funktioniert doch ohne Formular garnicht. Damit diese Parameter aber sicher übertragen und nicht Manipuliert werden können müssten diese Daten aben Verschlüsselt werden.
                Wenn ihr hierzu eine passende bzw. bessere alt. habt dann immer her damit. Ich lass mich ja gern eines besseren belehren

                Kommentar


                • #9
                  Session. Fertig.
                  --

                  „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                  Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


                  --

                  Kommentar


                  • #10
                    Hallo!

                    Zitat von DeepZone Beitrag anzeigen
                    [...] sondern vielmehr um den Schutz vor Angriffen durch Manipulieren der URL [...]
                    Ich vermeide Manipulationen durch ein Array. Inhalte werden nur angezeigt wenn die eingegebene URL im Array steht, wenn nicht bekommt der Besucher eine passende Meldung. Seitdem ich das so mache ist meine error_log leer (die war vor der Umstellung immer voll). Ein 100%-iger Schutz ist das zwar auch nicht, scheint aber derzeit gut zu funktionieren.

                    Zudem nutze ich jetzt Clean-URLs ("www.domain.tld/daten/datensatz1"), umgesetzt auf "index.php?daten=datensatz1" wird per htaccess. Sieht so besser aus und reduziert Manipulationsversuche der URLs.

                    Gruß, René

                    Kommentar


                    • #11
                      Zitat von nikosch Beitrag anzeigen
                      Session. Fertig.
                      Sessions sind natürlich eine Möglichkeit. Auch das mit dem Array scheint ne Möglichkeit zu sein. Ich denke allerdings die Sessions würden schon reichen.

                      Greetz Deep

                      Kommentar


                      • #12
                        Ich hab sowas auf andere Art und Weise gemacht. Zum einen eine md5-Checksumme und eine SHA1-Checksumme von der Variablen machen, von beiden die ersten 5 Werte über lassen und vor und hinter den Parameter hängen. Function dazu: id_aus(). Im Gegenzug id_ein() arbeitet logischerweise umgekehrt. md5 vorne und sha1 hinten abschneiden, aus dem Rest den SHA1 und MD5 bilden und nur 5 Zeichen jeweils über lassen. Diese dann miteinander vergleichen. Stimmts, ist gut, stimmts nicht, hat jemand an der Variablen rummgepfuscht und das Ding wird gestoppt. Will man es jetzt noch verstecken, einfach base64 codieren.

                        Kommentar


                        • #13
                          Anmerkung:

                          Will man es jetzt noch verstecken, einfach base64 codieren
                          Also ob sich base64 zum "verstecken" eignet will ich bezweifeln. Meistens sieht man an dem codierten String schon das es Base64 ist, dh da ist dann ein decode schnell gemacht. Base64 ist halt nicht dazu da um Daten zu "verstecken", zweiter Absatz: http://de.wikipedia.org/wiki/Base64

                          Zum ersten Absatz sage ich nichts, da ich den genauen Anwendungsfall nicht kenne, aber das klingt auf den ersten "Blick" ziemlich abenteuerlich

                          LG
                          Debugging: Finde DEINE Fehler selbst! | Gegen Probleme beim E-Mail-Versand | Sicheres Passwort-Hashing | Includes niemals ohne __DIR__
                          PHP.de Wissenssammlung | Kein Support per PN

                          Kommentar


                          • #14
                            Es geht ja nur um Verschleierung. Letzten Endes zählt nur das Paket aus Variabler und Hash-Bruchstücke um ein verfälschen zu verhindern. Die Codierung ist eigentlich nur gut, um nicht jedes Script-Kiddie auf den Inhalt aufmerksam zu machen. Probieren werden es eh die Leute, die etwas davon verstehen. Also mal den Wert um 1 hochsetzen. Ist bei der Hash-Methode natürlich ein absolutes Nogo. Erstens kann man den Hash nicht zurück rechnen, weil nur zwei Bruchteile zweier Hashs verfügbar sind und zweitens erkennt man die Form der Hashes nicht, da es wie gesagt nur 5 Zeichen vorn und hinten sind. Ein Zeichen geändert, egal wo, und die eigentliche Variable passt nicht mehr zum Hash. Problem gelöst.

                            Will man es richtig effektiv machen, packt man noch das Datum dazu und man hat einen Wert, der nur über eine bestimmte Zeit gültig ist.

                            Kommentar


                            • #15
                              Erstens kann man den Hash nicht zurück rechnen, weil nur zwei Bruchteile zweier Hashs verfügbar sind und zweitens erkennt man die Form der Hashes nicht, da es wie gesagt nur 5 Zeichen vorn und hinten sind.
                              Einen Hash kann man generell nicht zurückrechnen, weil zB ein Aufsatz mit 2000 Zeichen bei md5() auch nur den 32 stelligen Hashwert (zB 3858f62230ac3c915f300c664312c63f) ergibt. Dh du wirst nie auf den "echten" Ausgangswert kommen, selbst wenn du das Verfahren kennst.

                              Beispiel:
                              Summe 10: Zeig mir welche Rechnung ich verwendet habe. Da gibt es 1+9, 2+8, 2x5, 20:2 etc...

                              Es würde dir aber reichen wenn du auf eine dieser Rechnungen kommst die eben die Summe 10 erzeugt.

                              LG
                              Debugging: Finde DEINE Fehler selbst! | Gegen Probleme beim E-Mail-Versand | Sicheres Passwort-Hashing | Includes niemals ohne __DIR__
                              PHP.de Wissenssammlung | Kein Support per PN

                              Kommentar

                              Lädt...
                              X