Pengenalan pengguna tanpa cookie atau penyimpanan lokal

132

Saya sedang membangun alat analitik dan saat ini saya bisa mendapatkan alamat IP, browser, dan sistem operasi pengguna dari agen pengguna mereka.

Saya ingin tahu apakah ada kemungkinan untuk mendeteksi pengguna yang sama tanpa menggunakan cookie atau penyimpanan lokal? Saya tidak mengharapkan contoh kode di sini; hanya petunjuk sederhana dari mana harus mencari lebih jauh.

Lupa menyebutkan bahwa itu harus kompatibel lintas-browser jika itu komputer / perangkat yang sama. Pada dasarnya saya setelah pengenalan perangkat tidak benar-benar pengguna.

slash197
sumber
5
Tidak juga - setidaknya tidak dengan cara apa pun yang dapat Anda andalkan untuk menjadi akurat. Mungkin hash dari ketiganya digabungkan, namun jika lebih dari satu orang di sebuah rumah menggunakan browser dan OS yang sama, itu masih tidak akan berfungsi. Juga, sebagian besar ISP memberikan alamat IP Dinamis, yang berarti mereka sering berubah-ubah dan tidak akan dapat diandalkan untuk keperluan identifikasi juga.
Jon
2
Maka Anda tidak tahu sesi apa itu. Kasus penggunaan Anda persis untuk apa sesi dirancang. Sesi tidak ada hubungannya dengan masuk atau otentikasi. Server web Anda akan memberi tahu klien untuk mengirim cookie dengan pengidentifikasi sesi. Anda mengidentifikasi klien itu menggunakan id sesi yang mereka kirimkan kepada Anda.
Man Vs Code
4
Cookie masih akan bekerja? Mengapa Anda menghindari menggunakan cookie?
Baba
2
Ini sangat sederhana dan saya menggunakannya setiap saat, minta pengguna untuk memasukkan nama pengguna dan kata sandi !!!
Amit Kriplani
2
Berikut ini adalah solusi javascript minimal (non-browser dalam hal ini): github.com/carlo/jquery-browser-fingerprint Saya sebutkan, karena itu membawa saya pada gagasan bahwa banyak plugin diinstal cross-browser secara default, tanpa pilihan apa pun pada bagian pengguna. Menyortirnya dengan hati-hati (yang bukan tugas kecil, tapi masih ...) berpotensi menyebabkan properti agnostik peramban yang nyata dari sidik jari berbasis perangkat yang lebih besar.
hexalys

Jawaban:

389

pengantar

Jika saya memahami Anda dengan benar, Anda perlu mengidentifikasi pengguna yang Anda tidak memiliki Pengidentifikasi Unik, jadi Anda ingin mengetahui siapa mereka dengan mencocokkan Data Acak. Anda tidak dapat menyimpan identitas pengguna dengan andal karena:

  • Cookie Dapat dihapus
  • Alamat IP Dapat berubah
  • Browser Dapat Berubah
  • Tembolok Peramban dapat dihapus

Java Applet atau Com Object akan menjadi solusi mudah menggunakan hash informasi perangkat keras, tetapi saat ini orang-orang sangat memperhatikan keamanan sehingga akan sulit untuk membuat orang memasang program-program semacam ini pada sistem mereka. Ini membuat Anda terjebak dengan menggunakan Cookie dan alat-alat serupa lainnya.

Cookie dan alat serupa lainnya

Anda mungkin mempertimbangkan untuk membangun Profil Data, kemudian menggunakan tes Probabilitas untuk mengidentifikasi Pengguna yang Kemungkinan . Profil yang berguna untuk ini dapat dihasilkan oleh beberapa kombinasi berikut ini:

  1. Alamat IP
    • Alamat IP asli
    • Alamat IP Proksi (pengguna sering menggunakan proxy yang sama berulang kali)
  2. Kue
  3. Bug Web (kurang dapat diandalkan karena bug diperbaiki, tetapi masih bermanfaat)
    • Bug PDF
    • Bug Flash
    • Bug Jawa
  4. Browser
    • Klik Pelacakan (banyak pengguna mengunjungi seri halaman yang sama pada setiap kunjungan)
    • Browser Sidik Jari - Plugin yang Dipasang (orang-orang sering memiliki beragam, set plugin yang agak unik)
    • Gambar dalam cache (orang terkadang menghapus cookie mereka tetapi meninggalkan gambar dalam cache)
    • Menggunakan Blobs
    • URL (riwayat browser atau cookie dapat berisi id pengguna unik di URL, seperti https://stackoverflow.com/users/1226894 atau http://www.facebook.com/barackobama?fref=ts )
    • System Fonts Detection (ini adalah tanda kunci kunci yang sedikit diketahui tetapi seringkali unik)
  5. HTML5 & Javascript
    • HTML5 LocalStorage
    • API Geolokasi HTML5 dan Geocoding Terbalik
    • Arsitektur, Bahasa OS, Waktu Sistem, Resolusi Layar, dll.
    • API Informasi Jaringan
    • API Status Baterai

Item yang saya daftarkan, tentu saja, hanya beberapa cara yang memungkinkan pengguna dapat diidentifikasi secara unik. Masih banyak lagi.

Dengan kumpulan elemen Data Acak ini untuk membuat Profil Data, untuk apa selanjutnya?

Langkah selanjutnya adalah mengembangkan beberapa Logika Fuzzy , atau, lebih baik lagi, Jaringan Syaraf Tiruan (yang menggunakan logika fuzzy). Dalam kedua kasus tersebut, idenya adalah untuk melatih sistem Anda, dan kemudian menggabungkan pelatihannya dengan Bayesian Inference untuk meningkatkan akurasi hasil Anda.

Jaringan Saraf Tiruan

The NeuralMesh perpustakaan untuk PHP memungkinkan Anda untuk menghasilkan Artificial Neural Networks. Untuk menerapkan Bayesian Inference, periksa tautan berikut:

Pada titik ini, Anda mungkin berpikir:

Mengapa begitu banyak Matematika dan Logika untuk tugas yang tampaknya sederhana?

Pada dasarnya, karena itu bukan tugas yang mudah . Apa yang Anda coba capai sebenarnya adalah Probabilitas Murni . Misalnya, diberikan pengguna yang dikenal berikut:

User1 = A + B + C + D + G + K
User2 = C + D + I + J + K + F

Ketika Anda menerima data berikut:

B + C + E + G + F + K

Pertanyaan yang pada dasarnya Anda tanyakan adalah:

Berapa probabilitas bahwa data yang diterima (B + C + E + G + F + K) sebenarnya adalah User1 atau User2? Dan yang mana dari dua pertandingan yang paling mungkin?

Agar dapat menjawab pertanyaan ini secara efektif, Anda perlu memahami Format Frekuensi vs Probabilitas dan mengapa Kemungkinan Gabungan menjadi pendekatan yang lebih baik. Rinciannya terlalu banyak untuk masuk ke sini (itulah sebabnya saya memberi Anda tautan), tetapi contoh yang baik adalah Aplikasi Wisaya Diagnosis Medis , yang menggunakan kombinasi gejala untuk mengidentifikasi kemungkinan penyakit.

Pikirkan sejenak serangkaian titik data yang terdiri dari Profil Data Anda (B + C + E + G + F + K dalam contoh di atas) sebagai Gejala , dan Pengguna Tidak Dikenal sebagai Penyakit . Dengan mengidentifikasi penyakit, Anda dapat lebih lanjut mengidentifikasi pengobatan yang sesuai (memperlakukan pengguna ini sebagai User1).

Jelas, suatu Penyakit yang telah kami identifikasi lebih dari 1 Gejala lebih mudah untuk diidentifikasi. Faktanya, semakin banyak gejala yang dapat kita identifikasi, diagnosis kita semakin mudah dan akurat.

Apakah ada alternatif lain?

Tentu saja. Sebagai ukuran alternatif, Anda dapat membuat algoritme penilaian sederhana Anda sendiri, dan mendasarkannya pada pencocokan tepat. Ini tidak seefisien probabilitas, tetapi mungkin lebih mudah untuk Anda terapkan.

Sebagai contoh, perhatikan grafik skor sederhana ini:

+ ------------------------- + -------- + ------------ +
| Properti | Berat | Pentingnya |
+ ------------------------- + -------- + ------------ +
| Alamat IP asli | 60 | 5 |
| Alamat IP proxy yang digunakan | 40 | 4 |
| Cookie HTTP | 80 | 8 |
| Cookie Sesi | 80 | 6 |
| Cookies Pihak Ketiga | 60 | 4 |
| Cookie Flash | 90 | 7 |
| Bug PDF | 20 | 1 |
| Bug Flash | 20 | 1 |
| Bug Jawa | 20 | 1 |
| Halaman yang Sering | 40 | 1 |
| Browser Cetak Jari | 35 | 2 |
| Plugin Terpasang | 25 | 1 |
| Gambar dalam Cached | 40 | 3 |
| URL | 60 | 4 |
| Deteksi Font Sistem | 70 | 4 |
| Penyimpanan Lokal | 90 | 8 |
| Geolokasi | 70 | 6 |
| AOLTR | 70 | 4 |
| API Informasi Jaringan | 40 | 3 |
| API Status Baterai | 20 | 1 |
+ ------------------------- + -------- + ------------ +

Untuk setiap informasi yang dapat Anda kumpulkan berdasarkan permintaan yang diberikan, berikan skor terkait, kemudian gunakan Pentingnya untuk menyelesaikan konflik ketika skor sama.

Bukti dari konsep

Untuk bukti konsep yang sederhana, silakan lihat di Perceptron . Perceptron adalah Model RNA yang umumnya digunakan dalam aplikasi pengenalan pola. Bahkan ada Kelas PHP lama yang mengimplementasikannya dengan sempurna, tetapi Anda mungkin perlu memodifikasinya untuk tujuan Anda.

Meskipun menjadi alat yang hebat, Perceptron masih dapat mengembalikan beberapa hasil (kemungkinan pertandingan), jadi menggunakan perbandingan Skor dan Perbedaan masih berguna untuk mengidentifikasi yang terbaik dari pertandingan tersebut.

Asumsi

  • Simpan semua informasi yang mungkin tentang setiap pengguna (IP, cookie, dll.)
  • Jika hasilnya adalah pencocokan tepat, tambah skor dengan 1
  • Jika hasilnya tidak sama persis, kurangi skor sebesar 1

Harapan

  1. Buat label RNA
  2. Hasilkan pengguna acak yang meniru basis data
  3. Hasilkan satu pengguna Tidak Dikenal
  4. Hasilkan RNA dan Nilai pengguna yang tidak dikenal
  5. Sistem akan menggabungkan informasi RNA dan mengajarkan Perceptron
  6. Setelah melatih Perceptron, sistem akan memiliki seperangkat bobot
  7. Anda sekarang dapat menguji pola pengguna Tidak Dikenal dan Perceptron akan menghasilkan set hasil.
  8. Simpan semua kecocokan positif
  9. Sortir pertandingan terlebih dahulu dengan Skor, lalu oleh Perbedaan (seperti dijelaskan di atas)
  10. Keluarkan dua kecocokan terdekat, atau, jika tidak ada kecocokan yang ditemukan, hasilkan hasil kosong

Kode untuk Bukti Konsep

$features = array(
    'Real IP address' => .5,
    'Used proxy IP address' => .4,
    'HTTP Cookies' => .9,
    'Session Cookies' => .6,
    '3rd Party Cookies' => .6,
    'Flash Cookies' => .7,
    'PDF Bug' => .2,
    'Flash Bug' => .2,
    'Java Bug' => .2,
    'Frequent Pages' => .3,
    'Browsers Finger Print' => .3,
    'Installed Plugins' => .2,
    'URL' => .5,
    'Cached PNG' => .4,
    'System Fonts Detection' => .6,
    'Localstorage' => .8,
    'Geolocation' => .6,
    'AOLTR' => .4,
    'Network Information API' => .3,
    'Battery Status API' => .2
);

// Get RNA Lables
$labels = array();
$n = 1;
foreach ($features as $k => $v) {
    $labels[$k] = "x" . $n;
    $n ++;
}

// Create Users
$users = array();
for($i = 0, $name = "A"; $i < 5; $i ++, $name ++) {
    $users[] = new Profile($name, $features);
}

// Generate Unknown User
$unknown = new Profile("Unknown", $features);

// Generate Unknown RNA
$unknownRNA = array(
    0 => array("o" => 1),
    1 => array("o" => - 1)
);

// Create RNA Values
foreach ($unknown->data as $item => $point) {
    $unknownRNA[0][$labels[$item]] = $point;
    $unknownRNA[1][$labels[$item]] = (- 1 * $point);
}

// Start Perception Class
$perceptron = new Perceptron();

// Train Results
$trainResult = $perceptron->train($unknownRNA, 1, 1);

// Find matches
foreach ($users as $name => &$profile) {
    // Use shorter labels
    $data = array_combine($labels, $profile->data);
    if ($perceptron->testCase($data, $trainResult) == true) {
        $score = $diff = 0;

        // Determing the score and diffrennce
        foreach ($unknown->data as $item => $found) {
            if ($unknown->data[$item] === $profile->data[$item]) {
                if ($profile->data[$item] > 0) {
                    $score += $features[$item];
                } else {
                    $diff += $features[$item];
                }
            }
        }
        // Ser score and diff
        $profile->setScore($score, $diff);
        $matchs[] = $profile;
    }
}

// Sort bases on score and Output
if (count($matchs) > 1) {
    usort($matchs, function ($a, $b) {
        // If score is the same use diffrence
        if ($a->score == $b->score) {
            // Lower the diffrence the better
            return $a->diff == $b->diff ? 0 : ($a->diff > $b->diff ? 1 : - 1);
        }
        // The higher the score the better
        return $a->score > $b->score ? - 1 : 1;
    });

    echo "<br />Possible Match ", implode(",", array_slice(array_map(function ($v) {
        return sprintf(" %s (%0.4f|%0.4f) ", $v->name, $v->score,$v->diff);
    }, $matchs), 0, 2));
} else {
    echo "<br />No match Found ";
}

Keluaran:

Possible Match D (0.7416|0.16853),C (0.5393|0.2809)

Print_r dari "D":

echo "<pre>";
print_r($matchs[0]);


Profile Object(
    [name] => D
    [data] => Array (
        [Real IP address] => -1
        [Used proxy IP address] => -1
        [HTTP Cookies] => 1
        [Session Cookies] => 1
        [3rd Party Cookies] => 1
        [Flash Cookies] => 1
        [PDF Bug] => 1
        [Flash Bug] => 1
        [Java Bug] => -1
        [Frequent Pages] => 1
        [Browsers Finger Print] => -1
        [Installed Plugins] => 1
        [URL] => -1
        [Cached PNG] => 1
        [System Fonts Detection] => 1
        [Localstorage] => -1
        [Geolocation] => -1
        [AOLTR] => 1
        [Network Information API] => -1
        [Battery Status API] => -1
    )
    [score] => 0.74157303370787
    [diff] => 0.1685393258427
    [base] => 8.9
)

Jika Debug = true Anda akan dapat melihat Input (Sensor & Diinginkan), Bobot Awal, Output (Sensor, Jumlah, Jaringan), Kesalahan, Koreksi dan Bobot Akhir .

+----+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+-----+----+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----------+
| o  | x1 | x2 | x3 | x4 | x5 | x6 | x7 | x8 | x9 | x10 | x11 | x12 | x13 | x14 | x15 | x16 | x17 | x18 | x19 | x20 | Bias | Yin | Y  | deltaW1 | deltaW2 | deltaW3 | deltaW4 | deltaW5 | deltaW6 | deltaW7 | deltaW8 | deltaW9 | deltaW10 | deltaW11 | deltaW12 | deltaW13 | deltaW14 | deltaW15 | deltaW16 | deltaW17 | deltaW18 | deltaW19 | deltaW20 | W1 | W2 | W3 | W4 | W5 | W6 | W7 | W8 | W9 | W10 | W11 | W12 | W13 | W14 | W15 | W16 | W17 | W18 | W19 | W20 | deltaBias |
+----+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+-----+----+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----------+
| 1  | 1  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1    | 0   | -1 | 0       | -1      | -1      | -1      | -1      | -1      | -1      | 1       | 1       | 1        | 1        | 1        | 1        | 1        | -1       | -1       | -1       | -1       | 1        | 1        | 0  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1         |
| -1 | -1 | 1  | 1  | 1  | 1  | 1  | 1  | -1 | -1 | -1  | -1  | -1  | -1  | -1  | 1   | 1   | 1   | 1   | -1  | -1  | 1    | -19 | -1 | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1         |
| -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --   | --  | -- | --      | --      | --      | --      | --      | --      | --      | --      | --      | --       | --       | --       | --       | --       | --       | --       | --       | --       | --       | --       | -- | -- | -- | -- | -- | -- | -- | -- | -- | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --        |
| 1  | 1  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1    | 19  | 1  | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1         |
| -1 | -1 | 1  | 1  | 1  | 1  | 1  | 1  | -1 | -1 | -1  | -1  | -1  | -1  | -1  | 1   | 1   | 1   | 1   | -1  | -1  | 1    | -19 | -1 | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1         |
| -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --   | --  | -- | --      | --      | --      | --      | --      | --      | --      | --      | --      | --       | --       | --       | --       | --       | --       | --       | --       | --       | --       | --       | -- | -- | -- | -- | -- | -- | -- | -- | -- | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --        |
+----+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+-----+----+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----------+

x1 hingga x20 mewakili fitur yang dikonversi oleh kode.

// Get RNA Labels
$labels = array();
$n = 1;
foreach ( $features as $k => $v ) {
    $labels[$k] = "x" . $n;
    $n ++;
}

Ini demo online

Kelas yang digunakan:

class Profile {
    public $name, $data = array(), $score, $diff, $base;

    function __construct($name, array $importance) {
        $values = array(-1, 1); // Perception values
        $this->name = $name;
        foreach ($importance as $item => $point) {
            // Generate Random true/false for real Items
            $this->data[$item] = $values[mt_rand(0, 1)];
        }
        $this->base = array_sum($importance);
    }

    public function setScore($score, $diff) {
        $this->score = $score / $this->base;
        $this->diff = $diff / $this->base;
    }
}

Kelas Perceptron yang Dimodifikasi

class Perceptron {
    private $w = array();
    private $dw = array();
    public $debug = false;

    private function initialize($colums) {
        // Initialize perceptron vars
        for($i = 1; $i <= $colums; $i ++) {
            // weighting vars
            $this->w[$i] = 0;
            $this->dw[$i] = 0;
        }
    }

    function train($input, $alpha, $teta) {
        $colums = count($input[0]) - 1;
        $weightCache = array_fill(1, $colums, 0);
        $checkpoints = array();
        $keepTrainning = true;

        // Initialize RNA vars
        $this->initialize(count($input[0]) - 1);
        $just_started = true;
        $totalRun = 0;
        $yin = 0;

        // Trains RNA until it gets stable
        while ($keepTrainning == true) {
            // Sweeps each row of the input subject
            foreach ($input as $row_counter => $row_data) {
                // Finds out the number of columns the input has
                $n_columns = count($row_data) - 1;

                // Calculates Yin
                $yin = 0;
                for($i = 1; $i <= $n_columns; $i ++) {
                    $yin += $row_data["x" . $i] * $weightCache[$i];
                }

                // Calculates Real Output
                $Y = ($yin <= 1) ? - 1 : 1;

                // Sweeps columns ...
                $checkpoints[$row_counter] = 0;
                for($i = 1; $i <= $n_columns; $i ++) {
                    /** DELTAS **/
                    // Is it the first row?
                    if ($just_started == true) {
                        $this->dw[$i] = $weightCache[$i];
                        $just_started = false;
                        // Found desired output?
                    } elseif ($Y == $row_data["o"]) {
                        $this->dw[$i] = 0;
                        // Calculates Delta Ws
                    } else {
                        $this->dw[$i] = $row_data["x" . $i] * $row_data["o"];
                    }

                    /** WEIGHTS **/
                    // Calculate Weights
                    $this->w[$i] = $this->dw[$i] + $weightCache[$i];
                    $weightCache[$i] = $this->w[$i];

                    /** CHECK-POINT **/
                    $checkpoints[$row_counter] += $this->w[$i];
                } // END - for

                foreach ($this->w as $index => $w_item) {
                    $debug_w["W" . $index] = $w_item;
                    $debug_dw["deltaW" . $index] = $this->dw[$index];
                }

                // Special for script debugging
                $debug_vars[] = array_merge($row_data, array(
                    "Bias" => 1,
                    "Yin" => $yin,
                    "Y" => $Y
                ), $debug_dw, $debug_w, array(
                    "deltaBias" => 1
                ));
            } // END - foreach

            // Special for script debugging
             $empty_data_row = array();
            for($i = 1; $i <= $n_columns; $i ++) {
                $empty_data_row["x" . $i] = "--";
                $empty_data_row["W" . $i] = "--";
                $empty_data_row["deltaW" . $i] = "--";
            }
            $debug_vars[] = array_merge($empty_data_row, array(
                "o" => "--",
                "Bias" => "--",
                "Yin" => "--",
                "Y" => "--",
                "deltaBias" => "--"
            ));

            // Counts training times
            $totalRun ++;

            // Now checks if the RNA is stable already
            $referer_value = end($checkpoints);
            // if all rows match the desired output ...
            $sum = array_sum($checkpoints);
            $n_rows = count($checkpoints);
            if ($totalRun > 1 && ($sum / $n_rows) == $referer_value) {
                $keepTrainning = false;
            }
        } // END - while

        // Prepares the final result
        $result = array();
        for($i = 1; $i <= $n_columns; $i ++) {
            $result["w" . $i] = $this->w[$i];
        }

        $this->debug($this->print_html_table($debug_vars));

        return $result;
    } // END - train
    function testCase($input, $results) {
        // Sweeps input columns
        $result = 0;
        $i = 1;
        foreach ($input as $column_value) {
            // Calculates teste Y
            $result += $results["w" . $i] * $column_value;
            $i ++;
        }
        // Checks in each class the test fits
        return ($result > 0) ? true : false;
    } // END - test_class

    // Returns the html code of a html table base on a hash array
    function print_html_table($array) {
        $html = "";
        $inner_html = "";
        $table_header_composed = false;
        $table_header = array();

        // Builds table contents
        foreach ($array as $array_item) {
            $inner_html .= "<tr>\n";
            foreach ( $array_item as $array_col_label => $array_col ) {
                $inner_html .= "<td>\n";
                $inner_html .= $array_col;
                $inner_html .= "</td>\n";

                if ($table_header_composed == false) {
                    $table_header[] = $array_col_label;
                }
            }
            $table_header_composed = true;
            $inner_html .= "</tr>\n";
        }

        // Builds full table
        $html = "<table border=1>\n";
        $html .= "<tr>\n";
        foreach ($table_header as $table_header_item) {
            $html .= "<td>\n";
            $html .= "<b>" . $table_header_item . "</b>";
            $html .= "</td>\n";
        }
        $html .= "</tr>\n";

        $html .= $inner_html . "</table>";

        return $html;
    } // END - print_html_table

    // Debug function
    function debug($message) {
        if ($this->debug == true) {
            echo "<b>DEBUG:</b> $message";
        }
    } // END - debug
} // END - class

Kesimpulan

Mengidentifikasi pengguna tanpa Pengenal Unik bukanlah tugas yang mudah atau sederhana. itu tergantung pada pengumpulan jumlah Data Acak yang cukup yang dapat Anda kumpulkan dari pengguna dengan berbagai metode.

Bahkan jika Anda memilih untuk tidak menggunakan Jaringan Syaraf Tiruan, saya sarankan setidaknya menggunakan Matriks Probabilitas Sederhana dengan prioritas dan kemungkinan - dan saya berharap kode dan contoh yang diberikan di atas memberi Anda cukup untuk melanjutkan.

Baba
sumber
@ Baba Apa yang Anda maksud dengan "Menggunakan Blobs" untuk sidik jari browser?
billmalarky
1
@ Baba Bagaimana orang menggunakannya untuk sidik jari peramban? Cukup periksa apa yang ada di dalamnya pada waktu tertentu?
billmalarky
@Baba kerja hebat, saya selalu mencoba memiliki beberapa strategi multi-level untuk mengidentifikasi pengguna, tetapi seperti yang Anda katakan cache dapat dihapus, IP diubah, pengguna di belakang proxy atau NAT - terutama orang-orang itu -, cookie dihapus, dll. ... tetapi bahkan dengan semua upaya ini adalah probabilitas masalah, juga jika pengguna yang buruk menggunakan browser Tor misalnya, kebanyakan jika tidak semua strategi yang disebutkan tidak akan bekerja. Saya menyukai browserleaks.com tetapi dengan Tor semua kembali tidak terdefinisi atau tidak diketahui
Mi-Creativity
Hanya Catatan yang ditujukan hanya untuk "menghilangkan debu" dari permata publikasi ini: Daftar tautan rusak pada 07.09.17: - Implement Bayesian inference using PHP, semua 3 bagian. - Frequency vs Probability - Joint Probability -Input (Sensor & Desired), Initial Weights, Output (Sensor, Sum, Network), Error, Correction and Final Weights
Ziezi
28

Teknik ini (untuk mendeteksi pengguna yang sama tanpa cookie - atau bahkan tanpa alamat ip) disebut sidik jari peramban . Pada dasarnya Anda merangkak sebagai informasi tentang peramban sebanyak mungkin - hasil yang lebih baik dapat dicapai dengan javascript, flash atau java (mis. Ekstensi yang dipasang, font, dll.). Setelah itu, Anda dapat menyimpan hasil hash, jika mau.

Itu tidak sempurna, tetapi:

83,6% dari browser yang dilihat memiliki sidik jari yang unik; di antara mereka yang mengaktifkan Flash atau Java, 94,2%. Ini tidak termasuk cookie!

Info lebih lanjut:

pozs
sumber
saya pikir, itu masih jawabannya. jika Anda perlu mengidentifikasi perangkat, Anda hanya perlu mendapatkan data tersebut - f.ex. OS, ekstensi umum (dan 'versinya), font yang dipasang, dll ...
pozs
Ini tidak akan bekerja dengan baik. Setiap browser mendukung sesi dan cookie. Gunakan alat yang tepat untuk pekerjaan itu.
Man Vs Code
1
@ slash197 bagaimana dengan cache file? maksud saya menggunakan media flash transparan 1px x 1px bersama dengan file xml memegang id yang dihasilkan di dalam (xml harus dibuat sekali di server sebelum itu diunduh ke pengguna lokal HD) dengan cara ini bahkan jika pengguna menghapus cookie atau logout, Anda masih dapat memiliki jembatan menggunakan metode sendAndLoad skrip tindakan.
Mbarry
Minimum perubahan akan mempengaruhi hasil hash. misalnya versi pemain gelombang kejut. solusi yang mungkin dengan file cache xml yang disimpan secara lokal dengan kunci unik yang dihasilkan + media flash 1px x 1px tersembunyi (skrip tindakan) pada browser, dengan cara ini Anda menyingkirkan cookie, masalah kedaluwarsa sesi jika itu adalah masalah utama. Anda masih dapat memiliki jembatan antara database sql Anda dan kunci pada mesin lokal pengguna.
Mbarry
@ Malry Saya bukan penggemar flash tetapi jika di browser ada pengaya pemblokiran flash seperti saya memiliki media flash 1x1 piksel yang akan dinonaktifkan, apakah saya kehabisan?
slash197
7

Sidik jari yang disebutkan di atas berfungsi, tetapi masih bisa mengalami tabrakan.

Salah satu caranya adalah menambahkan UID ke url setiap interaksi dengan pengguna.

http://someplace.com/12899823/user/profile

Di mana setiap tautan di situs disesuaikan dengan pengubah ini. Ini mirip dengan cara ASP.Net digunakan untuk bekerja menggunakan data FORM antar halaman.

Justin Alexander
sumber
Saya memikirkan hal itu tetapi itu adalah cara termudah bagi pengguna untuk memodifikasinya
slash197
1
bukan dari id adalah hash referensi diri. Membuatnya aman secara kriptografis.
Justin Alexander
Juga, metode ini ok ketika seseorang menjelajahi situs tetapi bagaimana Anda mengusulkan penanganan kasus ketika pengguna kembali kembali setelah seminggu dan cukup ketik alamat situs web, tanpa id?
slash197
@ slash197 dalam hal itu mengapa Anda tidak memberi tahu pengguna untuk login, itulah yang terjadi bahkan ketika pengguna menghapus cookie.
Akash Kava
6

Sudahkah Anda melihat ke Evercookie ? Ini mungkin atau mungkin tidak berfungsi di seluruh browser. Ekstrak dari situs mereka.

"Jika pengguna mendapat cookie di satu browser dan beralih ke browser lain, asalkan mereka masih memiliki cookie Local Shared Object, cookie itu akan mereproduksi di kedua browser."

Alexis Tyler
sumber
Saya ingin tahu apakah itu berfungsi dengan JavaScript dinonaktifkan. Apakah Anda punya pengalaman?
Voitcus
Ini disebut evercookie karena suatu alasan, itu akan berhasil apa pun yang terjadi. Hampir tidak mungkin bagi mereka untuk menghapus cookie.
Alexis Tyler
Tidak akan berhasil apa pun yang terjadi. Dari baris pertama deskripsi: 'evercookie adalah API javascript ...'. Ini tidak akan berfungsi jika javascript dinonaktifkan.
gdw2
Bahkan tidak harus dinonaktifkan. Ghostery dan uBlock tetes evercookie
opengrid
3

Anda dapat melakukan ini dengan png yang di-cache, itu akan menjadi agak tidak dapat diandalkan (browser yang berbeda berperilaku berbeda, dan itu akan gagal jika pengguna membersihkan cache mereka), tetapi itu adalah pilihan.

1: mengatur Database yang menyimpan id pengguna unik sebagai string hex

2: membuat file genUser.php (atau bahasa apa pun) yang menghasilkan id pengguna, menyimpannya dalam DB dan kemudian membuat warna yang sebenarnya .png dari nilai string hex (setiap piksel akan menjadi 4 byte) dan kembali itu ke browser. Pastikan untuk mengatur tipe konten dan header cache.

3: di HTML atau JS buat gambar seperti <img id='user_id' src='genUser.php' />

4: gambar gambar itu ke kanvas ctx.drawImage(document.getElementById('user_id'), 0, 0);

5: baca byte dari gambar itu dengan menggunakan ctx.getImageData, dan konversi bilangan bulat menjadi string hex.

6: Itu adalah id pengguna unik Anda yang sekarang di-cache di komputer pengguna Anda.

hobberwickey
sumber
Dia menginginkan sesuatu yang dapat melacak pengguna "lintas browser" yang tidak akan berfungsi di sini (setiap browser memiliki basis data cache sendiri).
EricLaw
Di mana Anda melihat itu, pertanyaannya hanya meminta "Lupa menyebutkan bahwa itu harus kompatibel dengan browser", yaitu bekerja di browser apa pun.
hobberwickey
Pertanyaannya ditulis dengan buruk. I'm after device recognitionadalah hadiah untuk apa yang dia inginkan, dan dia menguraikan di sini: stackoverflow.com/questions/15966812/…
EricLaw
2

Berdasarkan apa yang Anda katakan:

Pada dasarnya saya setelah pengenalan perangkat tidak benar-benar pengguna

Cara terbaik untuk melakukannya adalah dengan mengirim alamat mac yang merupakan NIC ID.

Anda dapat melihat posting ini: Bagaimana saya bisa mendapatkan MAC dan alamat IP dari klien yang terhubung di PHP?

Mehdi Karamosly
sumber
Maaf, tetapi NIC ID mudah dipalsukan. Ini jelas bukan cara terbaik.
asgs
Sidik jari peramban @asgs mungkin akan lebih baik, atau apa cara terbaik menurut Anda?
Mehdi Karamosly
Tidak ada cara terbaik, itu adalah bagian yang menyedihkan tentang hal itu. Namun, itu dan Browser FingerPrinting dalam kombinasi dengan studi Probabilitas yang disajikan Baba di atas akan menjadi yang terbaik menurut saya.
asgs
1

Anda bisa melakukannya dengan etag. Meskipun saya tidak yakin apakah ini legal sebagai sekelompok tuntutan hukum diajukan.

Jika Anda benar-benar memperingatkan pengguna Anda atau jika Anda memiliki sesuatu seperti situs web intranet mungkin tidak masalah.

Brian McGinity
sumber
Etag tidak kompatibel lintas browser.
slash197
1
Etag adalah bagian dari spesifikasi HTTP / 1.1. Semua browser populer mendukung etag, Anda perlu menulis browser sendiri untuk tidak mendukung header ETag / If-None-Match.
Brian McGinity
Saya tidak mengatakan itu tidak mendukungnya, saya katakan itu tidak kompatibel dengan browser. Jika sebuah tag disimpan di Firefox, itu tidak tersedia di chrome sehingga konten akan diunduh lagi karena tidak ada cache.
slash197
Sekarang saya mengerti apa yang Anda katakan. Kamu benar. Setiap browser memiliki penyimpanan cache sendiri, karenanya etag berbeda.
Brian McGinity
0

Tidak efisien, tetapi mungkin memberi Anda hasil yang diinginkan, akan menjadi polling API di pihak Anda. Memiliki proses latar belakang di sisi klien yang mengirim data pengguna pada suatu interval. Anda akan memerlukan pengenal pengguna untuk mengirim ke API Anda. Setelah Anda memilikinya, Anda dapat mengirim informasi apa pun yang terkait dengan pengenal unik itu.

Ini menghilangkan kebutuhan akan cookie dan penyimpanan lokal.

rexposadas
sumber
0

Saya tidak percaya, http://browserspy.dk masih belum disebutkan di sini! Situs ini menjelaskan banyak fitur (dalam hal pengenalan pola), yang dapat digunakan untuk membangun classifier.

Dan tentu saja, untuk mengevaluasi fitur-fitur yang saya sarankan Support Vector Machines dan libsvm pada khususnya.

Valentin Heinitz
sumber
0

Lacak mereka selama sesi atau sesi?

Jika situs Anda adalah HTTPS Everywhere Anda dapat menggunakan ID Sesi TLS untuk melacak sesi pengguna

Neil McGuigan
sumber
1
pertanyaannya di sini adalah bagaimana?
user455318
-2
  1. buat cross-platform dummy (nsapi) plugin dan hasilkan nama unik untuk nama atau versi plugin ketika pengguna mengunduhnya (mis. setelah login).
  2. menyediakan installer untuk plugin / instal sesuai kebijakan

ini akan mengharuskan pengguna untuk menginstal pengidentifikasi.

setelah plugin diinstal, sidik jari dari browser apa pun (plugin diaktifkan) akan berisi plugin khusus ini. Untuk mengembalikan info ke server, diperlukan algoritme untuk mendeteksi plugin secara efektif di sisi klien, jika tidak, IE dan Firefox> = 28 pengguna akan membutuhkan tabel kemungkinan identifikasi yang valid.

Ini membutuhkan investasi yang relatif tinggi ke dalam teknologi yang kemungkinan akan ditutup oleh vendor browser. Saat Anda dapat meyakinkan pengguna untuk menginstal plugin, mungkin ada opsi seperti menginstal proxy lokal , menggunakan vpn atau menambal driver jaringan.

Pengguna yang tidak ingin diidentifikasi (atau mesin mereka) akan selalu menemukan cara untuk mencegahnya.

aec8adaikaeNg6hey2oof8otai9quo
sumber
Hai, selamat datang untuk menumpuk overflow. Tolong dicatat; this will require the user to willingly install the identifier.mungkin bukan apa yang dimaksud dengan poster asli (OP).
Stefan