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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
"""
"""
# Created on 2013.07.24
#
# Author: Giovanni Cannata
#
# Copyright 2015 Giovanni Cannata
#
# This file is part of ldap3.
#
# ldap3 is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# ldap3 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with ldap3 in the COPYING and COPYING.LESSER files.
# If not, see <http://www.gnu.org/licenses/>.
from .. import SEQUENCE_TYPES
from ..core.exceptions import LDAPControlsError, LDAPAttributeError, LDAPObjectClassError
from ..protocol.rfc4511 import Controls, Control
def attribute_to_dict(attribute):
return {'type': str(attribute['type']), 'values': [str(val) for val in attribute['vals']]}
def attributes_to_dict(attributes):
attributes_dict = dict()
for attribute in attributes:
attribute_dict = attribute_to_dict(attribute)
attributes_dict[attribute_dict['type']] = attribute_dict['values']
return attributes_dict
def referrals_to_list(referrals):
return [str(referral) for referral in referrals if referral] if referrals else None
def search_refs_to_list(search_refs):
return [str(search_ref) for search_ref in search_refs if search_ref] if search_refs else None
def sasl_to_dict(sasl):
return {'mechanism': str(sasl['mechanism']), 'credentials': str(sasl['credentials'])}
def authentication_choice_to_dict(authentication_choice):
return {'simple': str(authentication_choice['simple']) if authentication_choice.getName() == 'simple' else None, 'sasl': sasl_to_dict(authentication_choice['sasl']) if authentication_choice.getName() == 'sasl' else None}
def decode_referrals(referrals):
return [str(referral) for referral in referrals if referral] if referrals else None
def partial_attribute_to_dict(modification):
return {'type': str(modification['type']), 'value': [str(value) for value in modification['vals']]}
def change_to_dict(change):
return {'operation': int(change['operation']), 'attribute': partial_attribute_to_dict(change['modification'])}
def changes_to_list(changes):
return [change_to_dict(change) for change in changes]
def attributes_to_list(attributes):
return [str(attribute) for attribute in attributes]
def ava_to_dict(ava):
return {'attribute': str(ava['attributeDesc']), 'value': str(ava['assertionValue'])}
def substring_to_dict(substring):
return {'initial': substring['initial'] if substring['initial'] else '', 'any': [middle for middle in substring['any']] if substring['any'] else '', 'final': substring['final'] if substring['final'] else ''}
def prepare_changes_for_request(changes):
prepared = dict()
for change in changes:
prepared[change['attribute']['type']] = (change['operation'], change['attribute']['value'])
return prepared
def build_controls_list(controls):
"""
controls is a list of Control() or tuples
each tuple must have 3 elements: the control OID, the criticality, the value
criticality must be a boolean
"""
if not controls:
return None
if not isinstance(controls, SEQUENCE_TYPES):
raise LDAPControlsError('controls must be a sequence')
built_controls = Controls()
for idx, control in enumerate(controls):
if isinstance(control, Control):
built_controls.setComponentByPosition(idx, control)
elif len(control) == 3 and isinstance(control[1], bool):
built_control = Control()
built_control['controlType'] = control[0]
built_control['criticality'] = control[1]
if control[2] is not None:
built_control['controlValue'] = control[2]
built_controls.setComponentByPosition(idx, built_control)
else:
raise LDAPControlsError('control must be a tuple of 3 elements: controlType, criticality (boolean) and controlValue (None if not provided)')
return built_controls
def validate_assertion_value(schema, name, value):
if schema and schema.attribute_types is not None:
if name not in schema.attribute_types:
raise LDAPAttributeError('invalid attribute type in assertion: ' + name)
if '\\' not in value:
return value.encode('utf-8')
validated_value = bytearray()
pos = 0
while pos < len(value):
if value[pos] == '\\':
byte = value[pos + 1: pos + 3]
if len(byte) == 2:
try:
validated_value.append(int(value[pos + 1: pos + 3], 16))
pos += 3
continue
except ValueError:
pass
validated_value += value[pos].encode('utf-8')
pos += 1
return bytes(validated_value)
def validate_attribute_value(schema, name, value):
if schema:
if schema.attribute_types is not None and name not in schema.attribute_types:
raise LDAPAttributeError('invalid attribute type in attribute')
if schema.object_classes is not None and name == 'objectClass':
if value not in schema.object_classes:
raise LDAPObjectClassError('invalid class in ObjectClass attribute: ' + value)
return value
|
