Nombre descriptivo de Google que usa OpenID?

Question

Cuando juego ping-pong con el proveedor de Google OpenID, no puedo obtener un nombre/apodo/nombre de usuario amistoso (como quiera llamarlo).

me cae algo atroz aspecto como el siguiente:

www.google.com/accounts/o8/id?id=AItOawmtAnQvSXGhRTkAHZWyxi4L4EKa7xoTT1dk 

en lugar de algo agradable como

JohnDoe 

¿Cuál es el protocolo para obtener el nombre del usuario de Google de una manera agradable y simpático, como por ejemplo, ¿myopenid hace?

** Estoy usando DotNetOpenAuth *

Answer 1

No se puede. El identificador que emite el OP depende estrictamente del OP. El RP realmente no tiene voz ni voto. Ahora, algunos OP admiten atributos de oferta con el inicio de sesión, como el apodo, la dirección de correo electrónico, etc. Google tiene un soporte muy limitado para estos, y solo ofrece una dirección de correo electrónico.

Google optó por no emitir identificadores reconocibles por el usuario porque es un riesgo de divulgación de información. Yahoo fue en ambas rutas al ofrecer a los usuarios un identificador amigable para los humanos y no amigable para los humanos que el usuario puede elegir. MyOpenID y otros OP suelen ir con solo un identificador fácil de usar que el usuario selecciona cuando se registra en el PO.

Es posible que desee un caso especial Google en su RP para elegir una cadena más amigable para mostrar al usuario cuando está conectado, o como Google no es el único que hace esto, escriba el código para descubrir cuando el identificador es ilegible y muestra algo más amigable para el usuario para que sepa que está conectado (tal vez su dirección de correo electrónico o un apodo que elige en su sitio).

Precaución: si decide mostrar un identificador más amigable que el que los problemas de Google, todavía debe utilizar el funcionario Reclamado Identificador de Google para el nombre de usuario oficial de que el usuario que se pasa a FormsAuthentication.RedirectFromLogin y el nombre de usuario búsqueda en su base de datos. Cualquier otra cosa que juntas generalmente presenta riesgos de seguridad.

Answer 2

A partir de 2012, parece que el Google OpenID endpoint admite la recuperación de nombre y apellido a través del protocolo de intercambio de atributos. Aquí hay un ejemplo de código Python que utiliza el marco web Pyramid y el paquete python-openid de Janrain.

from openid.consumer import consumer 
from openid.extensions.ax import AttrInfo, FetchRequest, FetchResponse 
from openid.store.filestore import FileOpenIDStore 
from openid.store.sqlstore import PostgreSQLStore, MySQLStore, SQLiteStore 

AX_FIRSTNAME = 'http://axschema.org/namePerson/first' 
AX_LASTNAME = 'http://axschema.org/namePerson/last' 
AX_EMAIL = 'http://axschema.org/contact/email' 

@view_config(route_name='openID_start', permission=NO_PERMISSION_REQUIRED) 
def start(request): 
    'Start openID authentication process' 
    params = request.params 
    openIDURL = params.get('openIDURL') 
    if not openIDURL: 
     return HTTPResponse('Parameter expected: openIDURL') 
    openIDConsumer = get_consumer(request) 
    try: 
     openIDRequest = openIDConsumer.begin(openIDURL) 
    except consumer.DiscoveryFailure, error: 
     return HTTPResponse('Discovery failed: %s' % escape(error)) 
    else: 
     if not openIDRequest: 
      return HTTPResponse('Not an openID provider: %s' % escape(openIDURL)) 

     axRequest = FetchRequest() 
     axRequest.add(AttrInfo(AX_FIRSTNAME, required=True)) 
     axRequest.add(AttrInfo(AX_LASTNAME, required=True)) 
     axRequest.add(AttrInfo(AX_EMAIL, required=True)) 
     openIDRequest.addExtension(axRequest) 

     sourceURL = request.host_url 
     targetURL = request.route_url('openID_finish') 
     if openIDRequest.shouldSendRedirect(): 
      return HTTPFound(location=openIDRequest.redirectURL(sourceURL, targetURL)) 
     return HTTPResponse(openIDRequest.htmlMarkup(sourceURL, targetURL)) 

@view_config(route_name='openID_finish', permission=NO_PERMISSION_REQUIRED) 
def finish(request): 
    'Finish openID authentication process' 
    openIDConsumer = get_consumer(request) 
    targetURL = request.route_url('openID_finish') 
    openIDResponse = openIDConsumer.complete(request.params, targetURL) 
    html = openIDResponse.status + '<br>' 
    for key, value in openIDResponse.__dict__.iteritems(): 
     html += '%s: %s<br>' % (escape(key), escape(value)) 
    html += '<br>' 
    if consumer.SUCCESS == openIDResponse.status: 
     axResponse = FetchResponse.fromSuccessResponse(openIDResponse) 
     html += 'First name: %s<br>' % escape(axResponse.get(AX_FIRSTNAME)) 
     html += 'Last name: %s<br>' % escape(axResponse.get(AX_LASTNAME)) 
     html += 'Email: %s<br>' % escape(axResponse.get(AX_EMAIL)) 
    return HTTPResponse(html) 

def get_consumer(request): 
    try: 
     openIDStore = { 
      'sqlite': SQLiteStore, 
      'postgresql': PostgreSQLStore, 
      'mysql': MySQLStore, 
     }[db.bind.name](db.bind.raw_connection()) 
    except KeyError: 
     openIDStore = FileOpenIDStore('data/openIDs') 
    try: 
     openIDStore.createTables() 
    except: 
     pass 
    return consumer.Consumer(request.session, openIDStore) 

Answer 3

base sobre la respuesta Roy, he tratado de hacer la misma solicitud utilizando DotNetOpenAuth y funcionó bien. la solicitud:

var req = openid.CreateRequest("https://www.google.com/accounts/o8/id"); 
var fetch = new FetchRequest(); 
fetch.Attributes.Add(new AttributeRequest(WellKnownAttributes.Contact.Email,true)); 
fetch.Attributes.Add(new AttributeRequest(WellKnownAttributes.Name.First,true)); 
fetch.Attributes.Add(new AttributeRequest(WellKnownAttributes.Name.Last,true)); 

req.AddExtension(fetch); 

Nota: asegúrese de que el segundo Parm de AttributeRequest constructor se establece en true.

la parte de respuesta es directa.

var openid = new OpenIdRelyingParty(); 
var response = openid.GetResponse(); 
var fetch = response.GetExtension<FetchResponse>(); 
if (fetch != null) { 
IList<string> emailAddresses =fetch.Attributes[WellKnownAttributes.Contact.Email].Values; 
IList<string> firstNames = fetch.Attributes[WellKnownAttributes.Name.First].Values; 
IList<string> lastName = fetch.Attributes[WellKnownAttributes.Name.Last].Values; 
}