Reconhecimento do usuário sem cookies ou armazenamento local

Estou construindo uma ferramenta analítica e, atualmente, posso obter o endereço IP, o navegador e o sistema operacional do usuário do agente do usuário.

Gostaria de saber se existe a possibilidade de detectar o mesmo usuário sem usar cookies ou armazenamento local? Não estou esperando exemplos de código aqui; apenas uma dica simples de onde procurar mais.

Esqueceu-se de mencionar que precisaria ser compatível com vários navegadores se fosse o mesmo computador / dispositivo. Basicamente, estou atrás do reconhecimento do dispositivo e não do usuário.

Introdução

Se o entendi corretamente, você precisa identificar um usuário para quem não possui um identificador exclusivo, para descobrir quem eles são combinando dados aleatórios. Você não pode armazenar a identidade do usuário de maneira confiável porque:

• Cookies podem ser excluídos
• Endereço IP pode mudar
• O navegador pode mudar
• O cache do navegador pode ser excluído

Um Java Applet ou Com Object seria uma solução fácil usando um hash de informações de hardware, mas hoje em dia as pessoas têm tanta segurança que seria difícil convencer as pessoas a instalar esses tipos de programas em seu sistema. Isso deixa você com o uso de cookies e outras ferramentas semelhantes.

Cookies e outras ferramentas similares

Você pode considerar criar um perfil de dados e usar testes de probabilidade para identificar um usuário provável . Um perfil útil para isso pode ser gerado por alguma combinação do seguinte:

1. Endereço de IP
   • Endereço IP real
   • Endereço IP do proxy (os usuários geralmente usam o mesmo proxy repetidamente)
2. Biscoitos
   • Cookies HTTP
   • Cookies de sessão
   • Cookies de terceiros
   • Cookies em Flash (a maioria das pessoas não sabe como excluí-los )
3. Web Bugs (menos confiável porque os bugs são corrigidos, mas ainda são úteis)
   • Bug em PDF
   • Flash Bug
   • Java Bug
4. Navegadores
   • Acompanhamento de cliques (muitos usuários visitam a mesma série de páginas em cada visita)
   • Impressão digital de navegadores - Plugins instalados (as pessoas geralmente têm conjuntos variados e únicos de plugins)
   • Imagens em cache (às vezes as pessoas excluem seus cookies, mas deixam imagens em cache)
   • Usando Blobs
   • URL (s) (o histórico do navegador ou os cookies podem conter IDs de usuário únicos nos URLs, como https://stackoverflow.com/users/1226894 ou http://www.facebook.com/barackobama?fref=ts )
   • Detecção de fontes do sistema (esta é uma assinatura de chave pouco conhecida, mas geralmente única)
5. HTML5 e Javascript
   • LocalStorage HTML5
   • API de localização geográfica em HTML5 e geocodificação reversa
   • Arquitetura, idioma do sistema operacional, hora do sistema, resolução de tela etc.
   • API de informações de rede
   • API de status da bateria

Os itens que listei são, obviamente, apenas algumas maneiras possíveis de identificar um usuário de forma exclusiva. Há muito mais.

Com esse conjunto de elementos de dados aleatórios dos quais construir um perfil de dados, o que vem a seguir?

O próximo passo é desenvolver algum Fuzzy Logic , ou, ainda melhor, uma Rede Neural Artificial (que usa a lógica fuzzy). Em qualquer um dos casos, a idéia é treinar seu sistema e, em seguida, combinar seu treinamento com a Inferência Bayesiana para aumentar a precisão de seus resultados.

A biblioteca NeuralMesh para PHP permite gerar redes neurais artificiais. Para implementar a inferência bayesiana, confira os seguintes links:

• Implementar inferência bayesiana usando PHP, Parte 1
• Implementar inferência bayesiana usando PHP, parte 2
• Implementar inferência bayesiana usando PHP, parte 3

Neste ponto, você pode estar pensando:

Por que tanta matemática e lógica para uma tarefa aparentemente simples?

Basicamente, porque não é uma tarefa simples . O que você está tentando alcançar é, de fato, Probabilidade pura . Por exemplo, considerando os seguintes usuários conhecidos:

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

Quando você recebe os seguintes dados:

B + C + E + G + F + K

A pergunta que você está fazendo essencialmente é:

Qual é a probabilidade de os dados recebidos (B + C + E + G + F + K) serem realmente Usuário1 ou Usuário2? E qual dessas duas partidas é mais provável?

Para responder efetivamente a essa pergunta, é necessário entender o formato de frequência versus probabilidade e por que a probabilidade conjunta pode ser uma abordagem melhor. Os detalhes são muitos para entrar aqui (e é por isso que eu estou fornecendo links), mas um bom exemplo seria um Aplicativo para Assistente de Diagnóstico Médico , que usa uma combinação de sintomas para identificar possíveis doenças.

Pense por um momento na série de pontos de dados que compõem seu Perfil de Dados (B + C + E + G + F + K no exemplo acima) como Sintomas e Usuários Desconhecidos como Doenças . Ao identificar a doença, você pode identificar ainda um tratamento apropriado (tratar esse usuário como Usuário1).

Obviamente, é mais fácil identificar uma doença para a qual identificamos mais de 1 sintoma . De fato, quanto mais sintomas pudermos identificar, mais fácil e preciso será nosso diagnóstico.

Há alguma outra alternativa?

Claro. Como medida alternativa, você pode criar seu próprio algoritmo de pontuação simples e basear-se em correspondências exatas. Isso não é tão eficiente quanto a probabilidade, mas pode ser mais simples de implementar.

Como exemplo, considere este gráfico de pontuação simples:

+ ------------------------- + -------- + ------------ +
| Propriedade Peso Importância
+ ------------------------- + -------- + ------------ +
| Endereço IP real | 60 5
| Endereço IP do proxy usado | 40 4
| Cookies HTTP | 80 8
| Cookies de sessão | 80 6
| Cookies de terceiros | 60 4
| Cookies em Flash | 90 7
| Bug em PDF | 20 1 |
| Bug em Flash | 20 1 |
| Bug do Java | 20 1 |
| Páginas Frequentes | 40 1 |
| Impressão digital de navegadores | 35 2
| Plugins instalados | 25 1 |
| Imagens em cache | 40 3
| URL 60 4
| Detecção de fontes do sistema | 70 4
| Armazenamento local | 90 8
| Geolocalização | 70 6
| AOLTR 70 4
| API de informações de rede | 40 3
| API de status da bateria | 20 1 |
+ ------------------------- + -------- + ------------ +

Para cada informação que você pode reunir em uma determinada solicitação, conceda a pontuação associada e use a Importância para resolver conflitos quando as pontuações forem iguais.

Prova de conceito

Para uma simples prova de conceito, dê uma olhada no Perceptron . O Perceptron é um modelo de RNA geralmente usado em aplicações de reconhecimento de padrões. Existe até uma classe PHP antiga que a implementa perfeitamente, mas você provavelmente precisaria modificá-la para seus propósitos.

Apesar de ser uma ótima ferramenta, o Perceptron ainda pode retornar vários resultados (possíveis correspondências); portanto, o uso de uma comparação de Pontuação e Diferença ainda é útil para identificar a melhor dessas correspondências.

Premissas

• Armazene todas as informações possíveis sobre cada usuário (IP, cookies etc.)
• Onde o resultado é uma correspondência exata, aumente a pontuação em 1
• Onde o resultado não for uma correspondência exata, diminua a pontuação em 1

Expectativa

1. Gere marcadores de RNA
2. Gere usuários aleatórios emulando um banco de dados
3. Gere um único usuário desconhecido
4. Gerar RNA e valores de usuário desconhecido
5. O sistema mesclará informações de RNA e ensinará o Perceptron
6. Após treinar o Perceptron, o sistema terá um conjunto de pesos
7. Agora você pode testar o padrão do usuário desconhecido e o Perceptron produzirá um conjunto de resultados.
8. Armazenar todos os resultados positivos
9. Classifique as partidas primeiro por Pontuação e depois por Diferença (conforme descrito acima)
10. Gera as duas correspondências mais próximas ou, se nenhuma correspondência for encontrada, gera resultados vazios

Código de Prova de Conceito

$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 ";
}

Resultado:

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

Print_r de "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
)

Se Debug = true, você poderá ver Entrada (Sensor e Desejado), Pesos Iniciais, Saída (Sensor, Soma, Rede), Erro, Correção e Pesos Finais .

+----+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+-----+----+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----------+
| 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 a x20 representam os recursos convertidos pelo código.

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

Aqui está uma demonstração online

Classe usada:

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;
    }
}

Classe Perceptron modificada

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

Conclusão

Identificar um usuário sem um Identificador Único não é uma tarefa direta ou simples. depende da coleta de uma quantidade suficiente de dados aleatórios, que você pode coletar do usuário por vários métodos.

Mesmo se você optar por não usar uma rede neural artificial, sugiro pelo menos usar uma matriz de probabilidade simples com prioridades e probabilidades - e espero que o código e os exemplos fornecidos acima lhe dêem o suficiente para continuar.

Essa técnica (para detectar os mesmos usuários sem cookies - ou mesmo sem o endereço IP) é chamada de impressão digital do navegador . Basicamente, você rastreia o máximo possível de informações sobre o navegador - melhores resultados podem ser alcançados com javascript, flash ou java (por exemplo, extensões instaladas, fontes, etc.). Depois disso, você pode armazenar os resultados com hash, se desejar.

Não é infalível, mas:

83,6% dos navegadores vistos tinham uma impressão digital única; entre aqueles com Flash ou Java ativado, 94,2%. Isso não inclui cookies!

Mais informações:

• https://panopticlick.eff.org/
• https://wiki.mozilla.org/Fingerprinting
• https://www.browserleaks.com/

A impressão digital acima mencionada funciona, mas ainda pode sofrer colisões.

Uma maneira é adicionar o UID ao URL de cada interação com o usuário.

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

Onde todos os links no site são adaptados com este modificador. É semelhante à maneira como o ASP.Net costumava trabalhar usando dados FORM entre páginas.

Você já olhou para Evercookie ? Pode ou não funcionar nos navegadores. Um extrato do site deles.

"Se um usuário for cozinhado em um navegador e alternar para outro, contanto que ainda possua o cookie Local Shared Object, o cookie será reproduzido nos dois navegadores."

Você pode fazer isso com um png em cache, seria um pouco confiável (navegadores diferentes se comportam de maneira diferente e falhará se o usuário limpar o cache), mas é uma opção.

1: configure um banco de dados que armazene um ID de usuário exclusivo como uma sequência hexadecimal

2: crie um arquivo genUser.php (ou qualquer outro idioma) que gere um ID de usuário, armazene-o no banco de dados e, em seguida, crie um .png de cor verdadeira a partir dos valores dessa sequência hexadecimal (cada pixel terá 4 bytes) e retornará isso para o navegador. Certifique-se de definir o tipo de conteúdo e os cabeçalhos de cache.

3: no HTML ou JS, crie uma imagem como <img id='user_id' src='genUser.php' />

4: desenhe essa imagem em uma tela ctx.drawImage(document.getElementById('user_id'), 0, 0);

5: leia os bytes dessa imagem usando ctx.getImageData e converta os números inteiros em uma sequência hexadecimal.

6: esse é o seu ID de usuário exclusivo, agora armazenado em cache no computador dos usuários.

Com base no que você disse:

Basicamente, estou atrás do reconhecimento do dispositivo e não do usuário

A melhor maneira de fazer isso é enviar o endereço mac, que é o ID da NIC.

Você pode dar uma olhada neste post: Como posso obter o MAC e o endereço IP de um cliente conectado em PHP?

Você pode fazer isso com etags. Embora eu não tenha certeza se esse processo legal como um monte de ações foram ajuizadas.

Se você avisar corretamente seus usuários ou se você tiver algo como um site de intranet, pode estar tudo bem.

Você pode criar um blob para armazenar um identificador de dispositivo ...

A desvantagem é que o usuário precisa fazer o download do blob ( você pode forçar o download ), pois o navegador não pode acessar o sistema de arquivos para salvar diretamente o arquivo.

referência:

https://www.inkling.com/read/javascript-definitive-guide-david-flanagan-6th/chapter-22/blobs

Ineficiente, mas pode fornecer os resultados desejados, seria pesquisar uma API do seu lado. Tenha um processo em segundo plano no lado do cliente que envie os dados do usuário em um intervalo. Você precisará de um identificador de usuário para enviar para sua API. Depois que você tiver, poderá enviar as informações associadas a esse identificador exclusivo.

Isso elimina a necessidade de cookies e armazenamento local.

Não acredito, http://browserspy.dk ainda não foi mencionado aqui! O site descreve muitos recursos (em termos de reconhecimento de padrões), que podem ser usados ​​para criar um classificador.

E de causa, para avaliar os recursos, sugiro Support Vector Machines e libsvm em particular.

Rastreá-los durante uma sessão ou entre sessões?

Se o seu site for HTTPS Everywhere, você poderá usar o ID da sessão TLS para rastrear a sessão do usuário

1. crie um plug-in fictício de plataforma cruzada (nsapi) e gere um nome exclusivo para o nome ou versão do plug-in quando o usuário fizer o download (por exemplo, após o login).
2. forneça um instalador para o plug-in / instale-o por política

isso exigirá que o usuário instale voluntariamente o identificador.

Depois que o plug-in é instalado, a impressão digital de qualquer navegador (ativado por plug-in) conterá esse plug-in específico. Para retornar as informações para um servidor, é necessário um algoritmo para detectar efetivamente o plug-in no lado do cliente; caso contrário, os usuários do IE e Firefox> = 28 precisarão de uma tabela de possíveis identificações válidas.

Isso requer um investimento relativamente alto em uma tecnologia que provavelmente será desativada pelos fornecedores de navegadores. Quando você consegue convencer seus usuários a instalar um plug-in, também pode haver opções como instalar um proxy local , usar vpn ou corrigir os drivers de rede.

Os usuários que não desejam ser identificados (ou suas máquinas) sempre encontrarão uma maneira de evitá-lo.