Beiträge von cottton

Erst delete, edit und create.

Dann den aktuellen Stand laden (und ausgeben).

=)

// pseudo code
isDelete = /*f.e.$_POST[action] === delete*/
isEdit = /*f.e.$_POST[action] === edit*/
isCreate /*f.e. $_POST[action] === create */

if isDelete
    if /*have id to delete and is valid*/
        if entityExists(/*id*/)
            deleteEntity(id)

else if isEdit
    if /*have id to edit and is valid*/
        if entityExists(/*id*/)
            editEntity(id, /*data ...*/)

else if isCreate
    if /*have id to create and is valid*/
        if entityExists(/*id*/)
            createEntity(/*data ...*/)

// and NOW load current data 
entities = loadEntities()
foreach entities as entity
    // ...

Kann nicht sein. Du kannst hundert oder kein Leerzeichen nutzen, Tabs und new line ...

Evtl hast Du beim Kopieren irgendein Zeichen kopiert, das wie ein Leerzeichen aussah, aber keins war.

Und beim entfernen des Leerzeichens hast Du das Zeichen entfernt.

Ich hatte mal das Problem, als ich mal Code aus dem Teamspeak Chat kopiert hatte.

BTW; immernoch offen für SQL injection,

Du hast entweder das LIKE vergessen, oder %% an den Wert angehangen.

Zitat

Jetzt habe ich wieder was falsch gemacht.Jetzt hat der bei allen 800 Einträgen die Zahl geändert.Oh man ich dreh noch am Rad

Naja, ne WHERE -Bedingung musst Du schon dran hängen.

Du kannst das wieder rückgängig machen.

Wenn Du das Script zB 3 mal ausgeführt hast, dann kannst Du bei allen wieder 3 abziehen:

UPDATE `besucher` SET `zahler` = `zahler` - 3;

Übrigens bestätigt der Vorfall das, was scatello gerade geschrieben hat

Nicht nur kopieren, sondern auch verstehen.

UPDATE `besucher` SET `zahler` = `zahler` + 1;
-- bedeuted:
-- update besucher setze {das was in zahler ist} = {das was in zahler ist} + 1

Das sollte das tun, was Du vorhast. Eigentlich recht einfach. Man muss es aber kennen|mal gesehen haben.

Das rechnen wird hier also dem SQL server überlassen.

Das Ganze hat auch einen großen Vorteil: wenn 2 oder mehr Scripte darauf zugreifen, dann setzten die sich die Werte nicht "kaputt".

Bsp:

Wert in db ist 1.

Script 1 lädt Wert.

Script 2 lädt Wert.

Beide haben den Wert 1.

Script 1 zählt 2 dazu - Wert im Script 1 (PHP seitig) ist nun 3.

Script 2 zählt 1 dazu - Wert im Script 2 (PHP seitig) ist nun 2.

Script 1 updated db: update ... wert = 3

Script 2 updated db: update ... wert = 2

Und hier ham wir den Salat. Beide sollten|wollten hochzählen, haben sich aber gegenseitig überschrieben.

Wird es dem SQL server überlassen:

Script 1 updated db: update ... wert = wert + 2

Wert in db jetzt 3

Script 2 updated db: update ... wert = wert + 1

Wert in db jetzt 4

---

SQL injection ist viel im Netz zu finden.

Du solltest Dich erstmal für eine Sache (mysqli oder PDO, wobei PDO mMn besser ist) entscheiden.

Das dann genauer ansehen und Du wirst feststellen, dass Du immer ::prepare nutzen wirst und (so gut wie) nie eine PHP Variable in die SQl Query schreiben wirst.

Keine Ahnung was Du vor hast. Aber wieder Vars in der Query. (sql injection)

REPLACE ersetzt doch in "zahler" den Wert $zahlalt (wenn gefunden) mit $zahlneu.

Das ergibt für mich keinen Sinn. Da sollte doch sicherlich eine Zahl drin stehen?

PLatzhalter (mysqli) ? statt $var! (sql injection)

Was für ein Quelltext? Was für ein Link?

Du suchst doch im Bsp WHERE seite LIKE ?

also wo das gesuchte Wort in der Spalte `seite` vorkommt.

Wenn Du noch in zusätzlichen Spalten suchen willst (zB `link`)

dann brauchst Du ein or

SELECT
 `id`, `seite`, `datum`, `prov`, `suche`,`wann`, `von`, `gestern`, `Zukunft`, `update`
FROM  `besucher`    
WHERE 
    `seite` LIKE ?
    OR `link` LIKE ?
;

Macht sich schlecht.

Wenn DU mehrere Zeilen zurückbekommst, dann hättest Du ja in jeder Zeile die Anzahl.

// ergebnis
id | seite | datum | ... | count
--------------------------------
1  | ...   | ...   | ... | 4
2  | ...   | ...   | ... | 4
3  | ...   | ...   | ... | 4
4  | ...   | ...   | ... | 4

Du kannst aber mysqli_num_rows nutzen.

$row_cnt = mysqli_num_rows($result);

> http://php.net/manual/de/mysq…m-rows-examples

Möglich, aber bissl unzuverlässig.

Angenommen, Du schreibst mit, wo sich der user gerade befindet:

$_SESSION['user']['current_page']

Dann könntest Du schon mal den Timer zurücksetzen, wenn Deine Scripte feststellen, dass current_page nicht mehr ".../User.php" ist.

if ($_SESSION['user']['current_page'] !== 'user.php') {
    $_SESSION['user']['timer'] = null;
}

Wenn der Benutzer wieder auf die User.php Seite kommt:

if (!isset($_SESSION['user']['timer'])) {
    // neuen timer anlegen
    $_SESSION['user']['timer'] = /*...*/;
} else {
    // timer "fortsetzen" (was auch immer hier passieren soll)
}

Du kannst allerdings NICHT feststellen, ob der Benutzer gerade Deine Seite schließt.

Das geht zB über Javascript. Aber auch nur, wenn es beim Benutzer aktiviert ist.

Zitat von Humbi

Sicherlich kann man auch alles auf einmal auslesen oder das Passwort direkt in der query prüfen.

Zitat von m.scatello

Was auch effektiver wäre.

NEIN. Kein PW in der SQL-query prüfen. Das würde mit md5 zB funktionieren. Aber md5 nimmt man NICHT.

Via password_hash werden immer unterschiedliche Hashes erstellt (liegt am Salt im Hash). Und die Prüfung ist nicht valide.

Zitat von Humbi

$sql="SELECT `id`, `passwort` FROM table WHERE `username` LIKE ?";

Never LIKE!

Du willst ganz sicher nicht einen User laden, der einen ähnlichen Namen hat.

Auch wenn hier die PLatzhalter % fehlen - LIKE gehört hier nicht hin.

Note: bei solchen Queries sollte man die Abfrage limitieren.

SELECT `id`, `passwort` FROM `table` WHERE `username` = :username LIMIT 1;

LIMIT 1 und abschließendes ;

Das LIMIT schließt von der Query her schon mal aus, dass Du (aus welchem Grund auch immer) Mehrere User mit dem gleichen Namen bekommst.

Name sollte ja sicherlich einzigartig sein. Sollte also aus irgend einem Grund ein zweiter User den gleichen Namen registrieren können, wird er ignoriert.

Denn wer zuerst kam, wird geladen (wenn default id ASC geladen wird).

Man könnte natürlich auch ohne LIMIT laden und per PHP prüfen, ob es mehrere im Ergebnis gibt - und dann Alarm schlagen. Aber das gehört denk ich nicht in den Login.

Zitat von m.scatello

$query = "Select
[...]
from
`users`
where
`user`='". mysqli_real_escape_string($mysqli, $_POST['user']) . "'";

$result = mysqli_query($mysqli, $query)

Alles anzeigen

Bitte keine Daten direkt in die Query schreiben.

Vergiss mysqli_real_escape_string.

http://php.net/manual/de/mysq…repare-examples

Zum Thema:

Eine Tabelle ist wirklich genug.

Von dem, was ich gesehen habe, kannst Du die zusammen legen.

Nur bei den Admins setzt Du dann (wir bereits erwähnt wurde) ein Feld isAdmin mit dem Wert 1.

Du könntest auch statt isAdmin ein Feld user_group_id hinzufügen.

Der Wert verweist dann auf eine Neue Tabelle user_group.

Bsp:

table user
id | name       | ... | user_group_id | ...
-------------------------------------------
1  | Frank      | ... | 1
2  | Hans       | ... | 3
3  | Steffen    | ... | 2
4  | Joe        | ... | 10

table user_group
id  | name              | description         | is_active | ...
-------------------------------------------------------
1   | Admin             | ...                 | 1
2   | Registered User   | ...                 | 1
3   | Pending User      | Not confirmed ...   | 1
...
10   | Moderator        | ...                 | 0

Aber das erstmal nur so eingeworfen. Ist im Moment evtl Overkill.

Zitat von DER

PS: keine Kritik zum login Script?

Von mir aus:

$takelogin = $connection -> prepare("SELECT * FROM `database` WHERE `email` = ?;"); // `` und anschließendes ;
// ...
if(
    is_array($emailCheck) // prüfen, ob is array
    and isset($emailCheck['hash_password']) // und offset existiert
    and password_verify($_POST['passwordLogin'], $emailCheck['hash_password'])
) {
    // ...
}

FInde nichts sicherheitsrelevantes.

Aber ich würde bei alles Abfragen (db ect) die Fehler abfangen und loggen.

Teste doch zB mal was passiert, wenn dein mysql Server down ist.

Oder wenn Du einen Fehler in der SQL query hast.

Du musst doch nicht den kompletten Link auf jedem User speichern.

Der Host ändert sich doch nicht. Evtl nur der Aufbau um den User auszugeben.

Bsp:

tbl user
id | ...
1  | joe
2  | steven

tbl user_connection
id | user_id | connection_id
1  | 2       | 22
1  | 1       | 11

tbl connection -- weiß gerade keien anderen namen
id | scheme | host         | port | path            | query   | fragment
1  | https  | facebook.com | null | null            | user=%s | null
2  | http   | mywebsite.de | null | path/to/user/%s | null    | null

scheme, host, port, .... see http://php.net/manual/de/func…rl-returnvalues

pseudo code - connections (url) zusammenbauen:

url = "{scheme}://{host}"
if port !== null
    url .= ":{port}"
if path !== null
    path = sprintf(path, user.connection_id)
    url .= "/" . trim(path, "/")
if query !== null
    query = sprintf(query, user.connection_id)
    url .= "?" . ltrim(query, "?")
if fragment !== null
    fragment = sprintf(fragment, user.connection_id)
    url .= "#" . ltrim(fragment, "#")

// user.id 2 und host facebook.com:
// https://facebook.com?user=22

// user.id 2 und host mywebsite.de:
// http://mywebsite.de/path/to/user/22

Ändert zB mywebsite.de den Pfad, dann kannst Du das global in der connection tbl fixen|anpassen.

Was Jav schrieb

Denn mit

`user.id`

gibst du ja ein Feld user.id an

was dann `user`.`user.id` ansprechen will, was ja nicht existiert,

Also

    SELECT
        -- `user.id`, wrong
        `user`.`id`
        -- ...
        -- `u_post.u_id`, wrong
        `u_post`.`u_id`,
        -- ...
    FROM `u_post`       
    LEFT JOIN `user` 
    -- ON `u_post.u_id` = `user.id` wrong
    ON `u_post`.`u_id` = `user`.`id`
    WHERE 
        `u_post.accept_find` = 1 
        -- AND `user.image` != '' wrong
        AND `user`.`image` != ''
    ;

websocket wäre eine Möglichkeit.

Ist aber nicht so einfach wie ajax.

Passieren kann da nichts.

Das Verketten erledigt der mysql server über CONTCAT,

und du setzt die Value für :name_like ja per Platzhalter in die Query.

Aber:

Bei LIKE würde ich Dir das hier empfehlen:

$sql = "SELECT * FROM `user` WHERE `username` LIKE :name_like AND `accept_find` = 1 AND `id` != :id;";
$params = ['name_like' => "%{$yourValueHere}%"];

LIKE :placeholder

Dadurch bleibt Dir die Möglichkeit offen, die Platzhalter % und _ über die Parameter zu steuern.

Beispiele:

$params = ['name_like' => "%{$yourValueHere}%"]; // f.e. %foo%
$params = ['name_like' => "{$yourValueHere}%"]; // f.e. foo%
$params = ['name_like' => "%{$yourValueHere}"]; // f.e. %foo
$params = ['name_like' => "_{$yourValueHere}"]; // f.e. _foo
// ...

INFO

`` bei Feldnamen und Tables nutzen.

Und Query immer mit ; abschließen.

Das erschwehrt SQL-injections (man weiß ja nie),

Fehler wie zB WHERE order = ... (order ist reserviert für order by. Passier nicht mit `order`)

und sieht besser aus :p

Und, auch wenn hier nicht relevant, UPDATE und DELETE Queries mit LIMIT 1; abschließen, wenn nur eine Zeile betroffen sein soll.

UPDATE `user` SET `name` = :name; -- OH NOOOO, WHERE bedingung vergessen und alle user sind im arsch :(
-- damit wäre nur 1 user betroffen:
UPDATE `user` SET `name` = :name LIMIT 1;

Kommt darauf an.

Wenn Du direkt anzeigen willst, woher User kommt, dann zB (gerade mal gegoogled)

http://ipinfodb.com/ip_location_api.php

(kenne die Seite auch noch nicht. Soll aber kostenlos sein)

Gefunden hier: https://stackoverflow.com/questions/5398…location-in-php

Oder Du nimmst die IP und erstellst einen Link der auf (zB) utrace.de verweist.

Bsp: http://www.utrace.de/?query=95.90.213.255

In JS wäre das ja manipulierbar

Wenn es um eine Zahl (PIN) geht, die wirklich unique sein soll,

dann kommst Du nicht drum herum, die PINs irgendwo hinzuschreiben.

Ablauf:

1. pin = erstelle PIN

2. exists = prüfe, ob PIN bereits existiert

3. if exists == TRUE then goto 1.

4. schreibe PIN

5. veröffenliche PIN

Die PINs würde ich ein eine mysql tabelle schreiben.

Bsp:

<?php 
$attempts = 10;
$length = 16;
for ($pin = null, $i = 0; $i < $attempts; $i++) {
    $pin = createPIN($length);
    if (PINExists($pin)) {
        $pin = null;
        continue;
    } else {
        break;
    }
}
if (!strlen($pin) === $length) {
    echo "Fehler: trotz {$attempts} Versuchen konnte keine einzigartige PIN erstellt werden.";
} else {
    echo "Erfolg: die neue PIN lautet: {$pin}.";
}

/**
 * Returns a new PIN.
 *
 * @param int $length
 *
 * @return string
 */
function createPIN($length)
{
    $pin = '';
    for ($i = 0; $i < $length; $i++) {
        $pin .= mt_rand(0, 9);
    }
    return $pin;
}

/**
 * Returns if the given PIN (already) exists.
 *
 * @param int $pin
 *
 * @return bool
 */
function PINExists($pin)
{
    // hier nutzt du dein db adapter (PDO, mysqli_, ...)
    $sql = "SELECT COUNT(*) FROM `table_name` WHERE `pin` = :pin LIMIT 1;";
    $params = [
        'pin' => $pin
    ];
    $db->execute($sql, $params);
    // ...
    // return true wenn pin gefunden wurde
}

Wenn Du dafür sorgen willst, dass alle eingehenden Daten sauber sind, machst Du Dir zu viel Arbeit.

Du brauchst einfach nur PDO oder mysqli_ mit Platzhaltern nutzen, und schon ist es egal, was der Nutzer schickt.

Dafür sind die "Dinger" ja da - die values werden sicher an die Stelle der Platzhalter gesetzt.

trim ist in Ordnung. Alles Andere (strip_tags ...) kannst Du vergessen.

PDO: http://php.net/manual/en/pdo.prepare.php

Und es ist egal, wo das Script ausgeführt werden soll.

Solange es nicht ein Testscript ist, ist es den kleinen Aufwand mehr wert.

Denn 3 Wochen später soll es doch öffentlich erreichbar sein.

Was dann?

1. Mhh. Mist, hätt ich doch gleich richtig machen sollen" --und gehst alles noch mal durch (wenn Du darfst und kannst)

oder

2. "Naja, wird schon schief gehen" --und gehst ein Risiko ein.

$insertSql = "UPDATE formular SET
    firstName = :firstName,
    lastName = :lastName,
    privateStatus = :privateStatus
    WHERE email = :email
    LIMIT 1; // limit 1 nutzt man, um sicher zu gehen, dass wirklich nur eine zeile geändert wird.
             // nur so neben bei :)
";
        $insertStmt = $dbConnection->prepare($insertSql);
        $insertResult = $insertStmt->execute(
                array(
                    ":firstName" => $first_name, 
                    ":lastName" => $last_name, 
                    ":privateStatus" => $about_your_private,
                    ":email" => $_SESSION['email']
                )
        );

Das sollte es sein, wenn ich mich nicht vertippt hab

Nur ne Anmerkung:

Das PDO Bsp könnte evtl verwirren.

Im Originalcode wurde ja mysli genutzt. Und Da ist der Ablauf etwas anders.