web-dev-qa-db-fra.com

Obtenir un identifiant client unique à partir de chrome extension?

Je développe l'extension chrome. J'ai besoin de pouvoir identifier chaque client comme un client unique.

Je ne peux pas stocker guid dans un cookie car le cookie peut être supprimé. J'ai besoin que quelque chose soit lu dans le système lui-même, ce qui est unique.

Maintenant - je sais que JS n'a pas accès aux ressources client (ressources locales) mais - et voici ma question:

Question

Est-ce que chrome Js fournissent une API pour obtenir des informations client uniques (peu m'importe quelles données - tant qu'elles sont uniques).

Éditer :

Juste pour clarifier :

L'utilisateur recevra une clé unique (qui est une donnée de hachage de son ordinateur). ce code me sera envoyé, et je fournirai le résultat correspondant que l'utilisateur sera envoyé (par e-mail) et seulement alors - il pourra utiliser l'extension.

(non, tous les pays ne prennent pas en charge le paiement d'extension via le portefeuille, je suis dans l'un de ces pays)

javascriptgoogle-chromegoogle-chrome-extension
30
Royi Namir

Pour identifier un utilisateur de manière unique, je suggère de générer un jeton aléatoire et de le stocker dans le stockage de votre extension (chrome.storage). L'ID utilisateur doit être généré une seule fois, lorsque le jeton n'existe pas dans le stockage.

Par exemple:

function getRandomToken() {
    // E.g. 8 * 32 = 256 bits token
    var randomPool = new Uint8Array(32);
    crypto.getRandomValues(randomPool);
    var hex = '';
    for (var i = 0; i < randomPool.length; ++i) {
        hex += randomPool[i].toString(16);
    }
    // E.g. db18458e2782b2b77e36769c569e263a53885a9944dd0a861e5064eac16f1a
    return hex;
}

chrome.storage.sync.get('userid', function(items) {
    var userid = items.userid;
    if (userid) {
        useToken(userid);
    } else {
        userid = getRandomToken();
        chrome.storage.sync.set({userid: userid}, function() {
            useToken(userid);
        });
    }
    function useToken(userid) {
        // TODO: Use user id for authentication or whatever you want.
    }
});

Ce mécanisme repose sur chrome.storage.sync , ce qui est assez fiable. Cet ID stocké ne sera perdu que dans les scénarios suivants:

  • L'utilisateur réinstalle l'extension. Le stockage local sera effacé lors de la désinstallation de l'extension.
  • L'un des quotas de stockage a été dépassé (lire la documentation ).
    Cela ne se produira pas car la seule opération d'écriture se produit lors de la première exécution de votre extension.
  • Le stockage de Chrome est corrompu et ne parvient pas à enregistrer les données.
    Même si l'utilisateur n'a pas Chrome Sync activé, les données seront toujours enregistrées localement. Il y a eu des bogues avec les internes de Chrome qui ont entraîné une perte de données, mais ce sont des incidents.
  • L'utilisateur a ouvert les outils de développement pour votre page d'extension et a exécuté chrome.storage.sync.clear() ou quelque chose de similaire.
    Vous ne pouvez pas vous protéger contre les utilisateurs qui possèdent les connaissances nécessaires pour jouer avec les composants internes des extensions Chrome.

La méthode précédente est suffisante si vous souhaitez identifier de manière unique un utilisateur. Si vous voulez vraiment obtenir un ID matériel, utilisez chrome.storage.cpu et chrome.storage.memory également. Je ne vois cependant aucun avantage à utiliser ces sources supplémentaires, car elles peuvent changer si l'utilisateur remplace le matériel, et elles ne sont pas uniques non plus (deux ordinateurs portables identiques rapporteraient les mêmes valeurs, par exemple).

56
Rob W

Comme l'a suggéré Xan, l'API chrome.identity est probablement votre meilleur choix. Vous pouvez obtenir l'adresse e-mail des utilisateurs et l'utiliser comme une graine aléatoire pour générer un code de votre choix. Les informations utilisateur incluent également un champ "id" qui, je pense, est unique, mais je n'ai jamais vu de documentation à l'appui. Vous pouvez ensuite utiliser l'API chrome.storage.sync pour stocker la clé générée dans le stockage de données en ligne des utilisateurs de votre application. De cette façon, l'utilisateur pourra accéder à sa clé privée à tout moment et où qu'il se connecte sur n'importe quel appareil.

Veuillez noter que vous devrez activer les API oAuth2 dans la console des développeurs pour votre application et inclure la clé d'application et les étendues appropriées dans le manifeste de votre application.

Voici un exemple grossier:

function getUserInfo (interactive, callback )
{
    var xmlhttp = new XMLHttpRequest();
    var retry = true;
    var access_token;

    getToken();

    /**
     * Request the Auth Token
     */
    function getToken()
    {       
        chrome.identity.getAuthToken( { 'interactive': interactive }, function (token) {
            if ( chrome.runtime.lastError )
            {
                console.log( "ERROR! " + chrome.runtime.lastError.message );
                return;
            }
            if ( typeof token != 'undefined ')
            {
                access_token = token;
                sendRequest( );
            }
            else
                callback( );
        });

    }

    function sendRequest()
    {       
        xmlhttp.open('GET', 'https://www.googleapis.com/userinfo/v2/me' );
        xmlhttp.setRequestHeader('Authorization','Bearer ' + access_token );
        xmlhttp.onload = requestComplete;
        xmlhttp.send();
    }

    function requestComplete()
    {
        if ( this.status == 401 && retry )
        {
            retry = false; // only retry once
            console.log( "Request failed, retrying... " + this.response );
        }
        else
        {
            console.log( "Request completed. User Info: " + this.response );
            callback(null, this.status, this.response );
            var userInfo = JSON.parse( this.response );
            storeUniqueKey( userInfo );

        }
    }
}

function storeUniqueKey( info )
{
    var key;
    // TODO: Generate some key using the user info: info.loginName
    // user info here contains several fields you might find useful.
    // There is a user "id" field here which is numeric and I believe that
    // is a unique identifier that could come in handy rather than generating your 
    // own key.

    ...

    chrome.storage.sync.set ( { user_key: key } );
}
5
Zoccadoum

Pour ajouter à Rob W's réponse . Dans sa méthode, la chaîne enregistrée se propagerait à chaque Chrome connectée avec le même compte utilisateur Google - avec beaucoup de petits et grands si.

Si vous devez identifier de manière unique un profil utilisateur local et non tous les profils Chrome avec le même utilisateur Google, vous devez utiliser chrome.storage.local de la même manière. Ce ne sera PAS un identifiant d'installation unique Chrome Chrome - uniquement un profil dans cette installation.

Ce qui doit également être noté, c'est que toutes ces données ne sont en aucune façon ou sous une forme liée à quoi que ce soit - elles ont juste une bonne probabilité d'être uniques. Mais absolument rien n'empêche l'utilisateur de lire et de cloner ces données comme bon lui semble. Dans ce scénario, vous ne pouvez pas sécuriser le côté client.

Je pense qu'un moyen plus sûr serait d'utiliser chrome.identity API pour demander et maintenir un jeton hors ligne (donc non expirant) comme preuve de licence. L'utilisateur ne peut pas facilement cloner ce stockage de jetons.

Je ne connais pas encore OAuth pour l'instant, donc si quelqu'un peut signaler ce qui ne va pas avec cette idée - ils sont les bienvenus.

3
Xan