'Try to authenticate using an already existing token.
:param request: A request object.
:param auth: Dictionary representing the authentication request.
:returns: A tuple containing the user reference, project identifier,
token expiration, bind information, and original audit
information.'

def authenticate(self, request, auth):

    if ('token' not in auth):
        raise exception.ValidationError(attribute='token', target='auth')
    if ('id' not in auth['token']):
        raise exception.ValidationError(attribute='id', target='token')
    old_token = auth['token']['id']
    if (len(old_token) > CONF.max_token_size):
        raise exception.ValidationSizeError(attribute='token', size=CONF.max_token_size)
    try:
        v3_token_data = self.token_provider_api.validate_token(old_token)
        v2_helper = V2TokenDataHelper()
        v2_helper.v3_to_v2_token(v3_token_data, old_token)
        token_model_ref = token_model.KeystoneToken(token_id=old_token, token_data=v3_token_data)
    except exception.NotFound as e:
        raise exception.Unauthorized(e)
    wsgi.validate_token_bind(request.context_dict, token_model_ref)
    self._restrict_scope(token_model_ref)
    user_id = token_model_ref.user_id
    project_id = self._get_project_id_from_auth(auth)
    if ((not CONF.trust.enabled) and ('trust_id' in auth)):
        raise exception.Forbidden('Trusts    are    disabled.')
    elif (CONF.trust.enabled and ('trust_id' in auth)):
        try:
            trust_ref = self.trust_api.get_trust(auth['trust_id'])
        except exception.TrustNotFound:
            raise exception.Forbidden()
        if (trust_ref['project_id'] and (project_id != trust_ref['project_id'])):
            raise exception.Forbidden()
    expiry = token_model_ref.expires
    user_ref = self.identity_api.get_user(user_id)
    bind = token_model_ref.bind
    original_audit_id = token_model_ref.audit_chain_id
    return (user_ref, project_id, expiry, bind, original_audit_id)
