S'authentifier avec un jeton de AccoutManager

**fakeclk** · 27/07/2012, 23h20

Bonsoir, j'essaye de changer l'authentification de mon application en utilisant oauth qui vient avec l'AccountManager de android pour ne pas avoir à gérer l'authentification de mes utilisateurs. Arriver à lister les comptes et en choisir un n'est pas un problème mais je dois ensuite obtenir un jeton "auth token" et je ne sais pas ce que je suis censé faire avec? Je dois surement l'envpoyer quelque part et le stocké dans l'app pour que les utilisateurs n'aient pas à se logger à chaque fois mais je ne trouve pas le fonctionnement de ce systeme après avoir consulter de nombreux tutoriels...

Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
package test.auth.activity;
 
 
public class TestAuthActivity extends Activity {
 
	String AUTH_TOKEN_TYPE = "Manage your tasks";//"oauth2:https://www.googleapis.com/auth/tasks"; / "oauth2:https://spreadsheets.google.com/feeds/";
	Account account;
	static final int DIALOG_ACCOUNTS = 0;
    AccountManager accountManager;
    Account[] accounts;
    //String token;
 
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);
 
		Bundle options = new Bundle();
		accountManager = AccountManager.get(this);
		accounts = accountManager.getAccountsByType("com.google");
 
	       setContentView(R.layout.main);			// j'affiche le XML de la page
 
	       if(accounts.length > 1){
	    	   showDialog(DIALOG_ACCOUNTS);	
 
	       }else{
	    	   account = accounts[0];
	    	   System.out.println(account.name);
	       }
 
	       accountManager.getAuthToken(account, AUTH_TOKEN_TYPE, options, this, new OnTokenAcquired(), null);
	}
 
	@Override
	protected Dialog onCreateDialog(int id) {
 
		switch (id) {
	    case DIALOG_ACCOUNTS:
 
		AlertDialog.Builder builder = new AlertDialog.Builder(this);
	      builder.setTitle("Select a Google account");
	      final int size = accounts.length;
	      String[] names = new String[size];
	      for (int i = 0; i < size; i++) {
	        names[i] = accounts[i].name; // ID of the account
	      }
	      builder.setItems(names, new DialogInterface.OnClickListener() {
	        public void onClick(DialogInterface dialog, int which) {
 
	        	account = accounts[which];
		    	   System.out.println(account.name);
	        }
	      });
	      return builder.create();
 
		}
 
		return null;
	}
 
	private class OnTokenAcquired implements AccountManagerCallback<Bundle> {
	    @Override
	    public void run(AccountManagerFuture<Bundle> result) {
	        // Get the result of the operation from the AccountManagerFuture.
	        Bundle bundle;
			try {
				bundle = result.getResult();
 
		        // The token is a named value in the bundle. The name of the value
		        // is stored in the constant AccountManager.KEY_AUTHTOKEN.
		        String token = bundle.getString(AccountManager.KEY_AUTHTOKEN);
 
		        Intent launch = (Intent) bundle.get(AccountManager.KEY_INTENT);
		        if (launch != null) {
		            startActivityForResult(launch, 0);
		            return;
		        }
 
			} catch (OperationCanceledException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (AuthenticatorException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
 
 
	    }
	}
 
}

**nicroman** · 28/07/2012, 00h06

http://developer.android.com/trainin...henticate.html

Il y a un exemple ici:
https://developers.google.com/google...sks-on-android

c'est tout ce que j'ai trouvé

**fakeclk** · 28/07/2012, 00h50

Envoyé par nicroman

http://developer.android.com/trainin...henticate.html

Il y a un exemple ici:
https://developers.google.com/google...sks-on-android

c'est tout ce que j'ai trouvé

Merci de ta réponse !

Le truc que je ne comprends pas trop c'est qu'il faut faire des requetes http pour vérifier si le jeton est bon sur le serveur de google mais ca signifie donc que je mon internet doit etre actif à chaque authentification sur l'application ?

**nicroman** · 28/07/2012, 01h18

Ben le jeton te permet de t'authentifier aupres des web-services de google (google apis) donc oui il faut l'internet actif, sinon cela n'a pas trop d'interêt....

Que cherches tu à faire exactement ?

**fakeclk** · 28/07/2012, 01h44

Je cherche juste à authentifier l'utilisateur, rien d'autre :S

**nicroman** · 28/07/2012, 16h50

Mais l'authentifier où ?

Sur le téléphone ? => pas besoin
Sur un web-service google ? => c'est le système de tokens expliqué dans les exemples.
Sur un web-service à toi ? => Tu peux faire du SSO de OAuth2... Mais que faire si l'utilisateur n'a pas de compte google ?

**fakeclk** · 28/07/2012, 17h54

En fait mon application a une base de données interne sqlite et une externe sur un serveur mysql. Ce que j'aimerais c'est que le systeme d'authentification de mon app soit géré par oauth comme ca l'utilisateur n'a pas besoin de se créer un compte dédié à l'application mais un déjà existant (le compte google étant donné que tout android a au moins un compte google) et en plus de ne pas devoir gérer l'authentification du user on ne doit pas gérer les mots de passes dans la base de données mysql et sqlite

**nicroman** · 28/07/2012, 18h59

Envoyé par fakeclk

Ce que j'aimerais c'est que le systeme d'authentification de mon app soit géré par oauth comme ca l'utilisateur n'a pas besoin de se créer un compte dédié à l'application mais un déjà existant

Ok, donc il y a deux choses:
L'application du téléphone (qui utilise la base locale SQLite sans authentification puisque pas besoin de toute manière, et éventuellement une identification qui vient d'un compte google).
L'application web-service qui va gérer la base MySQL (ou autre peu importe, ce qu'on voit c'est le web-service). Elle a besoin elle, d'avoir une méthode d'authentification forte (pour éviter que quelqu'un se fasse passer pour autrui).

Cette authentification peut passer par du SSO ("Single Sign-On"), utilisation d'OpenID.... Pour l'instant il n'est pas question de OAuth encore... Il faut juste vérifier qu'un auth-token est correct, et savoir le décoder grace aux services de google.
Cela peut passer par la création d'un couple id/secret pour l'application j'en sais pas plus.

Là où OAuth entre en jeu c'est si l'application web-service va devoir se connecter (en arrière plan) a d'autres services comme google mail, google tasks, etc... Même chose vis à vis de Facebook....

Et non, on n'est pas obligé d'avoir un compte google sur un Android.

**fakeclk** · 29/07/2012, 15h49

Mais si l'auth-token est correct l'authentification est ok et je n'ai qu'a vérifier ca la premiere fois que l'utilisateur s'inscris puis considérer qu'il ne doit plus jms s'authentifier ou quelque chose comme ca ?

**nicroman** · 29/07/2012, 18h33

Non mais je crois qu'on ne se comprend pas bien....

Il y a 3 éléments complètement indépendants:

A. Ton webservice
B. Le service d'auth. Google.
C. Ton appli (qui est, entre autre, cliente du webservice, et connais google-auth).

Là ou l'authentification est nécessaire c'est (A)... oublie donc le reste, et imagine que quelqu'un veuille se connecter à (A)... Comment est-il authentifié ?
Comment (A) peut s'assurer que c'est bien lui qui revient 1 semaine plus tard (quand tous les jetons ont expiré), et non quelqu'un qui se fait passer pour lui (une adresse e-mail n'est pas suffisante donc) ?

Si on rajoute (B)... il est facile, pour (A) de vérifier qu'un jeton est valide sur (B), de récupérer l'identifiant utilisateur correspondant => authentification ok.
Pour éviter par contre de le faire à chaque appel à (A), il faudra authentifier une sorte de session... Que ce soit une véritable session HTTP (par Cookie) ou simplement un jeton de session (faible durée de vie).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Client ==== googe_auth_token ====> (A) 
                                   (A) == google_auth_token ==> (B)
                                   (A) <== user_id =========== (B)
Client <= sesison_id (+user_id) == (A)
Client == requete + session_id ==> (A)
Client <= resultat pour user_id == (A)

**fakeclk** · 30/07/2012, 17h36

Donc si je comprends bien tu me dis que le service d'auth. Google n'est pas = Oauth ??

Mon webservice ne représente que des scripts php qui accède à la base de données mysql, donc imaginons que je soit dans mon app et que je veuille accéder à mes données de la base mysql, est ce que dans ce cas avant de lancer la fonction accédant à mysql je vérifie que l'utilisateur est bien loggé par exemple via une variable boolean qui ne dure que le temps que l'app est ouverte et qui est static/accessible depuis toute les classe, si la variable boolean renvoit FAUX alors dans ce cas là je vérifie que mon jeton est valide sur le service d'auth. Google et une fois que Google me certifie qu'il est valide je change cette variable de session à VRAI et je ne dois plus faire cette vérification le temps que mon app est ouverte

**nicroman** · 30/07/2012, 18h05

Oublie l'application cliente totalement... Ce n'est pas l'application qui a besoin d'une authentification... c'est le web-service (les scripts php).

Disons que ton script php soit du style:
"http://monapp.mondomaine.net/dosomething.php?user=nicroman"
Ton script ne peux pas certifier que je sois bien "nicroman" ! Sinon, n'importe qui pourra aller taper ton script et se faire passer pour moi.
C'est le script donc qui doit recevoir un token, et à partir de ce token décider ou non si je suis authentifié correctement....

L'authentification à partir du token peut se faire de plein de manières, dont une SSO avec Google (basée sur OAuth2)...
Si le token est du genre "google

xxxxxx" alors le script saura que xxxxxxxx est un jeton google... Il va donc appeler google/auth et obtenir des informations (tels que le User-ID google)... Pour obtenir ces informations il faut que l'utilisateur en ai donné le droit !
On parle aussi de OpenID pour ce genre d'opérations.

Ensuite, coté client/application, là pour le coup, en général on maintien le token d'authentification qui indique si on est authentifié ou non... Si on l'a pas on passe par la phase d'authenfication...
Attention, le client n'est pas sur, et par conséquence aucune clé d'encryption n'est incluse dedans (ca permet aussi de changer de clé/methode d'authentication sans recompiler les applications).

**fakeclk** · 30/07/2012, 23h25

Ok alors déso d'insister sur ce sujet mais c'est assez important pour mon travail de fin d'études :p En gros j'ai une petit idée de comment implémenter ca et j'espere que je ne suis pas à coté de la plaque :

comme tu l'avais dis, j'ai :

A. Mon webservice
B. Le service d'auth. Google.
C. Mon appli (qui est, entre autre, cliente du webservice, et connais google-auth).

Lorsque l'utilisateur veut utiliser mon app pour le premiere fois je vais lui demander de choisir un compte google qui est présent dans AccountManager (s'il n'en a pas je l invite à en créer un ou en ajouter un dans son account manager :p). une fois qu'il a choisit je demande un access token à google avec le compte qu'il a choisit et j'obtiens entre autre l'ID google de cet utilisateur, j'inscri dans ma base de données sqlite l'ID et le nom du compte ainsi que dans ma BDD Mysql.

Maintenant que je suis inscri j'aimerais accéder à des données via les scripts php, j'envois à mon script l'ID_google ainsi que l'access token, à partir de mon script je recupère l'access token, l'envoi à google qui me répond en m'envoyant l'ID_google correspondant à ca token, je vérifie que cet ID correspond bien à celui que j'avais envoyé à mon script et si la vérification est bonne (le user est authentifié) je continue dans mon script (exécute le reste du code du script)

Donc en reprenant ton schéma ==>

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 
Client ==== googe_auth_token & googleID_1 ====> (A) 
                                   (A) == google_auth_token ==> (B)
                                   (A) <== googleID_2 =========== (B)
                                   (A) (if googleID_1 = googleID_2) => exécute le code  
Client <= renvois les données ou le refus d'accès == (A)

Voila :p j'espere ne pas être à coté de la plaque et encore merci pour ton aide !!

**kracels** · 31/07/2012, 18h09

Ca me parait déjà plus réaliste que ton systeme d'identification sans internet !

**fakeclk** · 03/08/2012, 04h55

Petit probleme au niveau du schéma :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Client ==== googe_auth_token ====> (A) 
                                   (A) == google_auth_token ==> (B)
                                   (A) <== user_id =========== (B)
Client <= sesison_id (+user_id) == (A)
Client == requete + session_id ==> (A)
Client <= resultat pour user_id == (A)

Lorsqu'il faut récupérer le user_id chez google :

(A) == google_auth_token ==> (B)
(A) <== user_id =========== (B)

cette requete http ne marche pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
<?php
 
if( isset($_POST['authToken'])){		
 
	//pour que la réponse s'affiche comme du texte brut
	header('Content-Type: text/plain');
 
	/*partie à modifier*/
	$name = 'www.googleapis.com';//nom du site
 
	//pour ne pas devoir calculer à la main la longueur du corps, on le stocke dans une variable et la fonction strlen() nous la donne.
	$data = "access_token='".$_POST['authToken']."' ";
 
	//la requête
	$envoi  = "POST /oauth2/v1/tokeninfo HTTP/1.1\r\n";
	$envoi .= "Host: ".$name."\r\n";
	$envoi .= "Connection: Close\r\n";
	$envoi .= "Content-type: application/x-www-form-urlencoded\r\n";
	$envoi .= "Content-Length: ".strlen($data)."\r\n\r\n";
	$envoi .= $data."\r\n";
	/*/partie à modifier*/
 
	/*ouverture socket*/
	$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
	if($socket < 0){
			die('FATAL ERROR: socket_create() : " '.socket_strerror($socket).' "');
	}
 
	if (socket_connect($socket,gethostbyname($name),80) < 0){
			die('FATAL ERROR: socket_connect()');
	}
	/*/ouverture socket*/
 
	/*envoi demande*/
	if(($int = socket_write($socket, $envoi, strlen($envoi))) === false){
			die('FATAL ERROR: socket_write() failed, '.$int.' characters written');
	}
	/*/envoi demande*/
 
	/*lecture réponse*/
	$reception = '';
	while($buff = socket_read($socket, 2000)){
	   $reception.=$buff;
	}
//	echo $reception;
 
	echo(json_encode($reception));
	/*/lecture réponse*/
 
	socket_close($socket);	
}
?>

error_description":"SSL is required to perform this operation."} of type java.lang.String cannot be converted to JSONObject

du coup je ne vois pas comment je peux récupérer les données à partir du script php :S ...

**Karly** · 03/08/2012, 16h22

Je ne sais pas si c'est la bonne méthode mais en tout cas tu peux utiliser cURL (à activer dans ton php.ini) ==> http://unitstep.net/blog/2009/05/05/...otected-sites/

**fakeclk** · 03/08/2012, 17h59

Envoyé par Karly

Je ne sais pas si c'est la bonne méthode mais en tout cas tu peux utiliser cURL (à activer dans ton php.ini) ==> http://unitstep.net/blog/2009/05/05/...otected-sites/

Je pense que ca marche mais j'obtiens comme erreur dans le logcat :

["{\n \"error\": \"invalid_token\",\n \"error_description\": \"Bad Request\"\n}\n"

je ne sais pas si c'est parce que j'envois le jeton d'une mauvais service (quoi que j'imagine que l'on peut envoyer n'importe quel jeton sur " www.googleapis.com/oauth2/v1/tokeninfo?access_token='".$_POST['authToken']."' " OU alors peut etre que mes jetons ne valent rien ?? j'ai vu qu'on pouvait envoyer un clientID et client_secret lorsque l'on demande un jeton :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

accountManagerFuture = am.getAuthToken(accounts[accountref], SCOPE, null, TestAuthActivity.this, null, null);

Moi quand j'ai vu qu'en passant null je recevais quand meme un jeton ben je me suis pas foulé surtout que pour avoir un clientID et clientSecret il faut le créer avec son compte google et a un moment donné on me demande une clé SHA1 ==> aucune idée de comment retrouver cette clé :S ???

S'authentifier avec un jeton de AccoutManager

Android

Discussions similaires

Partager

Partager