Stand #Codechange wir haben jeden Tag Verbesserungen auf (PH_AF3FD128) Sicherheit; erste Arbeit überhaupt war der Authentifizierungsdienst in der#Security Kapitel und dann haben wir die Fähigkeiten der Entwickler, exklusive Sicherheit für unsere Website zu schaffen verfeinert. Die Entwickler haben jedes Mal ein Update gemacht, wenn wir eine Art von Schwachstellen gefunden haben; dies ist äußerst nützlich, um Algorithmus-Fehler auf der Fliege zu machen, ist dies die Zeit, sich darauf zu konzentrieren, wie wir gesicherte Client-Seiten, die mit dem Server-Seite kommunizieren müssen (wie Ajax-Aufrufe und Post/Get-Updates). In der Tat haben wir die beiden Operationen unterteilt: GET (Daten, die durch Querystrings gesendet werden) und POST (Daten, die durch ein Formular gesendet werden).
Im ersten Fall (GET) muss der Benutzer diesen Punkten folgen, um die Seite erfolgreich zu anfordern:
- Authentifizierung (auf Anfrage)
- Header Check um sicher zu sein, dass es nur durch Javascript aufgerufen wird
- I/O Speichern Sie an einem sicheren Ort der Festplatte den Zeitstempel und die Informationen über den Benutzer, hashed mit SHA512; jedes Mal, wenn eine Client-Seite angefordert wird, kann das System zählen die Datumszeit und wie oft die Seite wird in einem bestimmten Zeitraum angefordert; Sie könnten vorübergehend verboten werden, wenn Sie die Seite zu viel Zeit in einem bestimmten Zeitraum von Sekunden anfordern
- Ein Token, das normalerweise durch Querystring gesendet wird und es ist der SHA1 oder SHA512 (abhängig davon, wie viel schneller die Anfrage sein muss) Hash der Benutzer-SessionID
- Dieses Token muss mit der ursprünglichen SessionID des Benutzers übereinstimmen, wenn der Benutzer irgendeine Server-Seitenanfrage macht
- Wenn das Token übereinstimmen, dann dürfen Sie eine einfache GET-Anfrage stellen
Als GET-Anfrage meinen wir jede Anfrage, die keine Datenbanken oder I/O der Festplatten berührt und von Abfragenstrings kommt.
Im zweiten Fall (POST) muss der Benutzer diesen Punkten folgen, um die Seite erfolgreich zu anfordern:
- Authentifizierung (auf Anfrage)
- Header Check um sicher zu sein, dass es nur durch Javascript aufgerufen wird
- I/O Speichern Sie an einem sicheren Ort der Festplatte den Zeitstempel und die Informationen über den Benutzer, hashed mit SHA512; jedes Mal, wenn eine Client-Seite angefordert wird, kann das System zählen die Datumszeit und wie oft die Seite wird in einem bestimmten Zeitraum angefordert; Sie könnten vorübergehend verboten werden, wenn Sie die Seite zu viel Zeit in einem bestimmten Zeitraum von Sekunden anfordern
- Ein erstes Token in der Regel von GET (Querystring) gesendet und es ist die SHA1 oder SHA512 Hash des Benutzers sessionID
- Ein zweites Token, das von POST (Form) gesendet wird und es ist die Aes256 Krypta des Hashs mit SHA1 oder SHA512 (abhängig davon, wie viel schneller die Anfrage sein muss) der BenutzersessionID, sowie zusätzliche Informationen wie Datumszeit und andere (verschlüsselt nur mit aes256 und Paket mit aller Anfrage)
- Diese beiden Token müssen mit der ursprünglichen SessionID des Benutzers übereinstimmen, und zusätzliche Informationen werden entschlüsselt
- Wenn das Token übereinstimmen, dann dürfen Sie eine einfache GET-Anfrage stellen
- Mit der zuvor verschlüsselten Datumszeit können wir die Interaktion der Nutzer jede Sekunde steuern und wir können bestimmte Aktionen genehmigen oder nicht, indem wir sie im Laufe der Zeit einschränken
- Wenn alles ausgepackt ist erfolgreich (Token und zusätzliche Informationen), brauchen Sie nur ein paar Sekunden, um eine normale Server-Seite Anfrage zu machen und dann wird dieser Zugriff für die Zukunft obfusziert
Als POST-Anfrage bedeuten wir jede Anfrage, die durch ein Formular und/oder Berührung irgendwelche Datenbanken oder I/O der Festplatten kommt.
Server-Seite Kopfzeilen überprüfen:
//Nur eingeschränkter Zugang ajax...
define('IS_AJAX', isset($_SERVER['HTTP_X_REQUESTED_WITH'])) &&& strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest');
if(!IS_AJAX) {
"Beschränkter Zugang";
}
$pos = strpos($_SERVER['HTTP_REFERER'],getenv(HTTP_HOST'));
if($pos===false)
"Beschränkter Zugang";
}Dies ist ein serverseitiger Code (PHP) gibt Ihnen eine Idee, wie die Header überprüft werden; dies ist eine zusätzliche Sicherheit, aber Header könnte leicht spooft werden, so dass wir eine weitere Schicht der Sicherheit wie unten implementieren müssen.
I/O Festplatte überprüfen
// Anzahl der erlaubten Seitenanfragen für den Benutzer
define("CONTROL_MAX_REQUESTSclientside," 1);
// Zeitintervall zum Zählen von Seitenanfragen (Sekunden)
define("CONTROL_REQ_TIMEOUTclientside," 1);
// Sekunden, um den Benutzer zu bestrafen, der bei den Anfragen überschritten hat
define("CONTROL_BAN_TIMEclientside," 10);
//user IP
if(empty($_SERVER["REMOTE_ADDR"])):
Definition ("USER_IPclientside," sanitizeUSERIPclientside(hash('sha512','clientside'.session_id()))));
andere:
define("USER_IPclientside," sanitizeUSERIPclientside(hash('sha512', 'clientside'.$_SERVER["REMOTE_ADDR"])));
Endif;
// schreibbares Verzeichnis, um Skriptdaten durch einen sicheren Ordner in der Festplatte ersetzen zu lassen
Definition ("SCRIPT_TMP_DIRclientside," "[Verzeichnis]");
define("CONTROL_DBclientside," "[Verzeichnis2]";
define("CONTROL_LOCK_DIRclientside," "[directory3]";
define("CONTROL_LOCK_FILEclientside," "[directory4]."sanitizeUSERIPclientside(hash('sha512', USER_IPclientside)));
@mkdir(CONTROL_LOCK_DIRclientside);
@mkdir(SCRIPT_TMP_DIRclientside);
//Zeigen Sie den Fehler, wenn ein Fehler vorhanden ist
wenn (file_exists(CONTROL_LOCK_FILEclientside)) {
if (time()-filemtime(CONTROL_LOCK_FILEclientside) > CONTROL_BAN_TIMEclientside) {
// dieser Benutzer hat seine Strafe abgeschlossen
unlink(CONTROL_LOCK_FILEclientside);
} sonst {
// zu viele Anfragen
Echo "Zu viele Anfragen";
Touch(CONTROL_LOCK_FILEclientside);
sterben;
}
}
Funktion antiflood_countaccessCLIENTSIDE() {
// Anfragen und letzte Zugriffszeit zählen
$control = Array();
wenn (file_exists(CONTROL_DBclientside))) {
$fh = fopen(CONTROL_DBclientside, "r");
$control = array_merge($control, (array)unserialize(fread($fh, filesize(CONTROL_DBclientside)))));
fclose($fh);
}
if (isset($control[USER_IPclientside])) {
if (time()-$control[USER_IPclientside]["t"] < CONTROL_REQ_TIMEOUTclientside) {
$control[USER_IPclientside]["c"]++;
} sonst {
$control[USER_IPclientside]["c"] = 1;
}
} sonst {
$control[USER_IPclientside]["c"] = 1;
}
$control[USER_IPclientside]["t"] = time();
if ($control[USER_IPclientside]["c"] > CONTROL_MAX_REQUESTSclientside) {
// dieser Benutzer hat zu viele Anfragen innerhalb kürzester Zeit gemacht
$fh = fopen(CONTROL_LOCK_FILEclientside, "w");
fwrite($fh, USER_IPclientside);
fclose($fh);
}
// aktualisierte Kontrolltabelle schreiben
$fh = fopen(CONTROL_DBclientside, "w");
fwrite($fh, serialize($control));
fclose($fh);
}
//Sanitisierung der Benutzer IP oder SessionID für den Namen der Datei auf der Festplatte zu schreiben
Funktion sanitisieren USERIPclientside($theuserIP) {
//sanitize ustrip oder session ID
$userIP = str_replace(array([\', \']'), '', $theuserIP);
$userIP = preg_replace('/\[.*\]/U', '', $userIP);
$userIP = preg_replace('/&(amp;)?#?[a-z0-9]+;/i', '-', $userIP);
$userIP = htmlentities($userIP, ENT_COMPAT, 'utf-8');
$userIP = preg_replace('/&([a-z])(acute|uml|circ|grave|ring|cedil|slash|tilde|caron|caron|quot|rsquo);/i', '\\1', $userIP );
$userIP = preg_replace(array('/[^a-z0-9]/i', '/[-]+/') , '-', $userIP);
Rückwärtsstromgeber ("trim($userIP, '-'));
}Dies ist ein serverseitiger Algorithmuscode (PHP) und schreibt an einem sicheren Ort der Festplatten die Anzahl der versendeten Zeiten, den Zeitstempel und einige einzigartige Informationen dieser Anfrage mit SHA512 (als Dateiname); wenn die Anzahl der Zeiten überschritten oder der Zeitstempel anders als der angegebene ist, wird die Anfrage fehlschlagen und ein Fehler wird angezeigt. Dieser Algorithmus ist etwas kompliziert und funktioniert allein, mit der gegebenen Anzahl von Sekunden und den richtigen Ordnern auf der Festplatte, ohne andere menschliche Eingriffe.
Tokens-Authentifizierung
$token1 = urlencode(sha1(session_id())); //mit AES256 CRYPT $token2 = AES256CRYPT(sha1(session_id())"),"[initialvectorkey]"; (WISSEN) //$token2 = sha1(session_id());
wir definieren den Wert der Token im obigen Beispiel.
Dies oben ist ein Beispiel für eine POST-Anfrage; in Kombination, wenn die POST-Anfrage gefeuert wird, wird auch eine GET-Anfrage (mit Javascript ajax) mit einer Abfragestring wie diese gefeuert:
// Feuern Sie die Anfrage auf /form.php ab (nicht wirklicher Pfad, nur zum Beispiel) Anfrage = $.ajax URL: "form.php?token1=" Typ: "Post," Daten: serialisiert Daten });
auf diese Weise werden die beiden Token vom Client an die serverseitigen Skripte gesendet, die zur Abstimmung bereit sind.
Passen Sie die Token
$token1GETVAR = urldecode($_GET['token1']);
//mit AES256 CRYPT
$token2POSTVAR = AES256DECRYPT($_POST['token2'], "[initialvectorkey]");
//ohne AES256 CRYPT
//$token2POSTVAR = $_POST['token2'];
$token1PHPVAR = sha1(session_id());
$token2PHPVAR = sha1(session_id());
if($token2POSTVAR != $token2PHPVAR $token1GETVAR != token1PHPVAR):
die(' ');
Endif;Die angeforderte Seite wird mit dem Matching der Token umgehen und alle zusätzlichen Informationen entschlüsseln, um sicherzustellen, dass die Anfrage von einer autorisierten Quelle stammt (im obigen Code sehen wir nur das Matching der Token).
Auf diese Weise haben wir eine vollständig kundenspezifisch und exklusiv Sicherheitspolitik für alle Anfragen aus nicht vertrauenswürdigen Quellen: Dies reduziert die Risiken von XSS oder anderen ähnlichen kundenseitigen Angriffen aus nicht vertrauenswürdigen Quellen drastisch. Bitte beachten Sie: Wie für Sicherheitszwecke können wir den Kryptocode enthüllen, der Informationen mit AES256 verschlüsselt und entschlüsselt; diese Codes befinden sich an einem sicheren Ort der Festplatten und außerhalb der Wurzel der Website. Die Verschlüsselung/Entschlüsselung mit AES256 ist eine Zusätzliche Praxis um sicher zu sein, dass die weitergegebenen Informationen vertrauenswürdig sind.
Dies ist kein ddos-Schutz, sondern ein Server-Seitenschutz, wenn Daten aus einer nicht vertrauten Quelle (wie Client-Seiten-Codes) gesendet werden. Alle Daten werden mit ssl 128 bit übertragen, so dass die sichere Übertragung von Daten eine Arbeit der Browser ist.
Dieser Sicherheitsfluss ist ein Ergebnis jahrelanger Studie und Anwendung; mit diesem System kann niemand, außer wer von der vorherigen Seite autorisiert ist, auf die clientseitigen Seiten zugreifen.
Die A.P.I. sind für den öffentlichen Zugang gebaut und sie implementieren nur einen kleinen Teil dieses Sicherheitssystems, das von allen ohne Einschränkungen zu erreichen ist. In der Anfang Januar 2018 wird die deprecated und nur einige Funktionen werden über sie verfügbar sein (keine weiteren Informationen über öffentliche Nutzer oder Informationen über öffentliche Inhalte); auf diese Weise werden öffentliche Endpunkte drastisch reduziert und Informationen werden am sichersten sein. Wir werden die (PH_AF3FD128) ohne sichtbare öffentliche Endpunkte.
Das ist alles, Leute! Alle Ihre Rückmeldungen werden geschätzt und danke, dass Sie das lesen und machen (PH_AF3FD128) immer besser, schneller und sicherer. Vielen Dank.
Bis bald, Leute!
