Produits Entr'ouvert » Authentic 2

#!/usr/bin/python

import sys

import os

import xml.etree.ElementTree as ET

	    xmlfiles.append (fullname)

	if not xmlfiles:

		sys.exit (1)

else:

#  Corey Goldberg, Dec 2012

#

import os

import sys

import xml.etree.ElementTree as ET

def usage():

    this_file = os.path.basename(__file__)

if __name__ == '__main__':

try:

    import lasso

except:

apache_configuration= os.path.dirname(__file__)

project = os.path.dirname(apache_configuration)

    import authentic2.settings

    os.environ['DJANGO_SETTINGS_MODULE'] = 'authentic2.settings'

except:

import django.core.handlers.wsgi

application = django.core.handlers.wsgi.WSGIHandler()

import getpass

            raise CommandError("user '%s' does not exist" % username)

        except MultipleObjectsReturned:

            while True:

                for i, user in enumerate(qs):

                try:

                    j = input()

                except SyntaxError:

                    continue

                if not isinstance(uid, int):

                    continue

                try:

                    u = qs[j-1]

                    break

                except IndexError:

                    continue

        self.stdout.write("Changing password for user '%s'\n" % u)

import logging

import datetime

    for line in table:

        line = u"| " + u" | ".join(u"{0:>{1}}".format(x, col_width[i])

                                for i, x in enumerate(line)) + u" |"

class Command(BaseCommand):

    help = '''Clean unused accounts'''

import logging

import sys

from StringIO import StringIO

            if attrs['filter'] != '(objectClass=*)':

                m = re.match(r'\((\w*)=(.*)\)', attrs['filter'])

                if not m:

                    return

                for user_attribute, ldap_attribute in MAPPING.iteritems():

                    if ldap_attribute == m.group(1):

                        break

                else:

                    return

                value = m.group(2)

                if value.endswith('*') and value.startswith('*'):

                dn = 'uid=%s,%s' % (escape_dn_chars(o['uid'][0]), attrs['suffix'])

                self.logger.debug(u'sending entry %s %s', dn, o)

                ldif_writer.unparse(dn, o)

            out.close()

    def handle(self, *args, **options):

        self.logger = logging.getLogger(__name__)

import sys

import xml.etree.ElementTree as etree

import os

                attribute, created = SAMLAttribute.objects.get_or_create(

                    defaults=defaults, **kwargs)

                if created and verbosity > 1:

                pks.append(attribute.pk)

            except SAMLAttribute.MultipleObjectsReturned:

                pks.extend(SAMLAttribute.objects.filter(**kwargs).values_list('pk', flat=True))

    sp = check_support_saml2(tree.find(SP_SSO_DESCRIPTOR_TN))

    if options.get('delete'):

        LibertyProvider.objects.filter(entity_id=entity_id).delete()

        return

    if sp:

        # build an unique slug

                what = 'Creating'

            else:

                what = 'Updating'

        provider.name = name[:128]

        provider.metadata = etree.tostring(tree, encoding='utf-8').decode('utf-8').strip()

        provider.protocol_conformance = 3

                    kwargs, defaults = build_saml_attribute_kwargs(provider, name)

                    if not kwargs:

                        if verbosity > 1:

                        continue

                    # create object with default attribute mapping to the same name

                    # as the attribute if no SAMLAttribute model already exists,

                        attribute, created = SAMLAttribute.objects.get_or_create(

                            defaults=defaults, **kwargs)

                        if created and verbosity > 1:

                                   % {'name': name, 'provider': provider})

                        pks.append(attribute.pk)

                    except SAMLAttribute.MultipleObjectsReturned:

                try:

                    sp_policy = SPOptionsIdPPolicy.objects.get(name=sp_policy_name)

                    if verbosity > 1:

                except:

                    if verbosity > 0:

                        raise CommandError()

            else:

                if verbosity > 1:

            loaded = []

            if doc.getroot().tag == ENTITY_DESCRIPTOR_TN:

                entity_descriptors = [doc.getroot()]

                    if not options['ignore-errors']:

                        raise

                    if verbosity > 0:

                    raise CommandError()

            if options['source']:

                if options['delete']:

                    LibertyProvider.objects.filter(federation_source=source).delete()

                else:

                    to_delete = []

                            to_delete.append(provider)

                    for provider in to_delete:

                        if verbosity > 1:

                        provider.delete()

        else:

            raise CommandError('%s is not a SAMLv2 metadata file' % metadata_file)

        if not options.get('delete'):

            if verbosity > 1:

import xml.etree.ElementTree as etree

from authentic2.compat_lasso import lasso

from authentic2.saml import x509utils

            'SingleSignOn': (('sso',), sso_protocol_profiles),

        }, options)

    root = meta.root_element()

import xml.etree.ElementTree as etree

import collections

from authentic2.compat_lasso import lasso

            [ lasso.SAML2_METADATA_BINDING_POST ], 'acs'),),

        options)

    root = meta.root_element()

import xml.etree.ElementTree as ET

from utils import FancyTreeBuilder

    import sys

    for key, values in parse_attribute_filters_file(sys.argv[1]).iteritems():

        for value in values:

import json

import pprint

            OIDCClaimMapping.objects.filter(provider=provider, claim__in=delete_claims)

        if options.get('show'):

            for field in OIDCProvider._meta.fields:

                value = getattr(provider, field.name)

                if isinstance(value, dict):

                    print

                    pprint.pprint(value)

                elif hasattr(provider, str('get_' + field.attname + '_display')):

                else:

            for claim_mapping in provider.claim_mappings.all():

try:

    import ldap

    from ldap.dn import str2dn, dn2str

                    if not fake:

                        conn.modify(dn, modlist)

                    if verbosity > 1:

                else:

                    if not fake:

                        conn.add(dn, ldap.modlist.addModlist(ldap_attributes))

                    if verbosity > 1:

            # wait for results

            if not fake:

                for x in ldap_users:

                    todelete.add(dn)

        if delete:

            if verbosity > 1:

            if not fake:

                for dn in todelete:

                    conn.delete(dn)

from django.core.management.base import BaseCommand

        Permission = get_permission_model()

        count = Permission.objects.cleanup()

        if count:

        Role = get_role_model()

        count = 0

        count = Role.objects.cleanup()

        if count:

# -*- coding: utf-8 -*-

import json

import pytest

    assert len(mailoutbox) == 1

    mail = mailoutbox[0]

    assert mail.to[0] == new_email

    assert 'http://testserver/accounts/change-email/verify/' in mail.body

import random

import uuid

import time

            crypted2 = crypto.aes_base64url_deterministic_encrypt(key, raw, salt,

                                                                  hash_name=hash_name, count=count)

            assert crypted1 == crypted2

            t = time.time()

            for i in range(100):

                crypted1 = crypto.aes_base64url_deterministic_encrypt(key, raw, salt,

                                                                      hash_name=hash_name,

                                                                      count=count)

            t = time.time()

            for i in range(1000):

                assert crypto.aes_base64url_deterministic_decrypt(key, crypted1, salt,

                                                                  max_count=count) == raw