Produits Entr'ouvert » Larpe

#  SetOutputFilter proxy-html

#  Options +FollowSymlinks

  RewriteEngine on

#  RewriteRule		/dot/ecrire/index.php	/liberty/dot/logout

#  <Location /eo/>

#    ProxyPass		http://www.entrouvert.com/

#    ProxyPassReverse	http://www.entrouvert.com/

#    ProxyHTMLURLMap	/	/eo/

#  </Location>

    Redirect permanent	/dot/ecrire/auth.php	http://test.org/liberty/dot/login

    RewriteEngine on

    RewriteRule		/ecrire/index.php	/liberty/dot/logout

#    Redirect permanent	/dot/ecrire/index.php?logout=1	http://test.org/liberty/dot/liberty/logout

    ProxyPassReverse	http://localhost/~heretik/dotclear/

- Compléter la conf pour que ce soit vraiment générique (+ multi-sites)

- Récupére la css de la page d'authentification

- Texte explicatif + traductions

- Création de nouveaux comptes + jetons

- Faire les paquets Debian

- Tests

  - Linuxfr

    - Remplacer le code html du formulaire par un bouton "connexion" qui fait un SSO

  - Spip

- Configuration des hôtes virtuels d'Apache 2

  - RP par vhost (appli1.example.com, rp de appli1.interne)

  - RP par repertoire (www.example.com/appli1, rp de appl1.interne)

- Début de filtre Python branché sur Apache à la suite du filtre de réécriture html (proxy_html)

- Ajouter les fonctionnalités liberty

  - SSO (depuis le sp et depuis l'idp)

  - Fédération

  - SLO (depuis le sp et depuis l'idp)

  - Défédération (depuis l'idp)

- Gestion des cookies et des sessions

- Tests

  - Dotclear

import os

app_dir = '/var/lib/larpe'

    # Only filter html code

    if filter.req.content_type is not None:

        is_html = re.search('text/html', filter.req.content_type)

    if filter.req.content_type is not None and not is_html:

        filter.pass_on()

    else:

        if not hasattr(filter.req, 'temp_doc'): # the start

            filter.req.temp_doc = [] # create new attribute to hold document

            # If content-length ended up wrong, Gecko browsers truncated data, so

            if 'Content-Length' in filter.req.headers_out:

                del filter.req.headers_out['Content-Length']

#        filter.write(filter.req.headers_in['Cookie'])

#        delete_cookies(filter)

        #filter.req.headers_out['Set-Cookie'] = 'dc_admin="deleted"; max-age=0; expires=Thu, 01-Jan-1970 00:00:00 GMT; path=/'

        temp_doc = filter.req.temp_doc

        s = filter.read()

        while s: # could get '' at any point, but only get None at end

            temp_doc.append(s)

            s = filter.read()

        if s is None: # the end

            temp_doc = ''.join(temp_doc)

            #filter.req.set_content_length(len(temp_doc)) # this didn't seem to work

            filter.write(temp_doc)

            #filter.write(filter.req.uri)

            filter.close()

def get_abs_path(s):

    if not s:

        return s

    if s[0] == '/':

        return s

    return os.path.join(app_dir, s)

def get_proxied_site_path(filter):

    proxy_domain_name = filter.req.hostname

    proxied_site_dir = get_proxied_site_name(filter)

    return get_abs_path(os.path.join('sp', proxy_domain_name, proxied_site_dir))

def get_proxied_site_name(filter):

    uri_tokens = filter.req.uri.split('/')

    if uri_tokens[1] != 'liberty':

        return uri_tokens[1]

    return uri_tokens[2]

def delete_cookies(filter):

    success = False

    cookies_file_name = get_abs_path(os.path.join(get_proxied_site_path(filter), 'cookies_to_delete'))

    cookies_file = open(cookies_file_name, 'r')

    for cookie in cookies_file.read().split():

        if filter.req.headers_in.has_key('Cookie'):

            cookies_header = filter.req.headers_in['Cookie']

#            filter.req.temp_doc.append(filter.req.headers_in['Cookie'])

            #filter.req.temp_doc.append(cookie[len(cookie) -1:])

            cookies_match =  re.findall(cookie[:len(cookie) -1], cookies_header)

            if len(cookies_match) > 0:

                filter.req.temp_doc.append('User-Agent')

#                filter.req.temp_doc.append('%s="deleted"; max-age=0; expires=Thu, 01-Jan-1970 00:00:00 GMT; path=/' % cookie.split('=')[0])

                filter.req.headers_out['Set-Cookie'] = '%s="deleted"; max-age=0; expires=Thu, 01-Jan-1970 00:00:00 GMT; path=/' % cookie.split('=')[0]

#                cookies_file.close()

#                cookies_file = open(cookies_file_name, 'w')

                break

#            else:

#                filter.req.temp_doc.append('dommage')

    cookies_file.close()

#    if success:

#        cookies_file = open(cookies_file_name, 'w')

#        cookies_file.close()

            'local_auth', 'local_auth_check', 'local_logout']

        #misc.get_html_page('http://localhost/~heretik/dotclear/ecrire/index.php?logout=1')

#        host = 'localhost'

#        query = '/~heretik/dotclear/ecrire/index.php?logout=1'

#        conn = httplib.HTTPConnection(host)

#        conn.request('GET', query, headers = { 'Cookie': 'dc_xd=cbec5e7951856e94d3878c68df6e575a; dc_admin=a%3A3%3A%7Bs%3A7%3A%22user_id%22%3Bs%3A7%3A%22heretik%22%3Bs%3A8%3A%22user_pwd%22%3Bs%3A32%3A%#22cc414bfc9c00475b59c87595299ff31d%22%3Bs%3A8%3A%22remember%22%3Bb%3A0%3B%7D', 'Referer': 'http://localhost/~heretik/dotclear/ecrire/',  })

#        response = conn.getresponse()

#        conn.close()

        #user = get_request().user

        user = get_session().get_user()

        self.local_defederate(session)

    def local_defederate(self, session):

        user = session.get_user()

        self.local_logout()

        if user is not None:

            user_dir = misc.get_abs_path(os.path.join(misc.get_proxied_site_path(), 'users'))

            federation_file_name = os.path.join(user_dir, user.name_identifiers[0])

            if os.path.isfile(federation_file_name):

                os.remove(federation_file_name)

#        if hasattr(session, 'auth_cookie'):

#            cookies_file_name = misc.get_abs_path(os.path.join(misc.get_proxied_site_path(), 'cookies_to_delete'))

#            cookies_file = open(cookies_file_name, 'a')

#            cookies_file.write(session.auth_cookie + '\n')

#            cookies_file.close()

        self.local_defederate(session)

        #user = get_request().user

        user = get_session().get_user()

            return self.local_auth()

        conn.close()

        cookies_match =  re.findall('dc_admin=([^;]+)', cookies)

        if len(cookies_match) > 0:

            set_cookie = 'dc_admin=%s; path=/' % cookies_match[0]

            get_response().set_header('Set-Cookie', set_cookie)

#            get_session().auth_cookie = set_cookie

        #proxied_site_dir = get_request().get_path().split('/')[2]

    _q_exports = ["", "login", "logout", "liberty"]

#        if len(idps) == 0:

        return template.error_page(_('SSO support is not yet configured'))

    def _q_traverse(self, path):

        session = get_session()

        if session:

            get_request().user = session.get_user()

        else:

            get_request().user = None

        response = get_response()

        response.filter = {}

        if not hasattr(response, 'breadcrumb'):

            response.breadcrumb = [ ('', _('Home')) ]

        try:

            return Directory._q_traverse(self, path)

        except errors.TraversalError:

            pass

        return forms.root.RootDirectory()._q_traverse(path)

Variante :

- Interception de l'url d'authentification du site

- Redirection vers l'url /login sur le relais inverse

- Sur l'url /login

  - Si deja authentifié (on a un cookie de session) : c'est bon, on redirige vers l'accueil du site (ou autre)

  - Sinon : faire un SSO

    - Rediriger vers l'idp

    - L'utilisateur s'authentifie

    - L'idp redirige vers le relais inverse

      - Si comptes non fédérés :

        - On affiche une page de d'auth locale

        - On authentifie l'utilisateur sur le relais inverse

        - On envoie la demande d'authentification au site

        - On recoit un cookie de session

        - On redirige vers l'accueil du site (ou autre)

Gestion des cookies

-------------------

- On associe à un name_identifier les cookies courants

- Lors de la défédération, on lie les cookies de l'utilisateur défédéré, et on crée ajoute dans le fichier "cookies_to_delete" une ligne :

  cookie=valeur

- Dans le filtre python d'apache, on lit ce fichier et pour chaque ligne, on recherche cette chaine dans l'entete "Cookie"

- Si on la trouve, on ajoute aux entetes en sortie " Set-Cookie: cookie="deleted" " et on supprime cette ligne du fichier