Search is not available for this dataset
text
stringlengths 75
104k
|
|---|
def _get_or_create_subscription(self):
"""In a broadcast queue, workers have a unique subscription ensuring
that every worker recieves a copy of every task."""
topic_path = self._get_topic_path()
subscription_name = '{}-{}-{}-worker'.format(
queue.PUBSUB_OBJECT_PREFIX, self.name, uuid4().hex)
subscription_path = self.subscriber_client.subscription_path(
self.project, subscription_name)
try:
self.subscriber_client.get_subscription(subscription_path)
except google.cloud.exceptions.NotFound:
logger.info("Creating worker subscription {}".format(
subscription_name))
self.subscriber_client.create_subscription(
subscription_path, topic_path)
return subscription_path
|
def cleanup(self):
"""Deletes this worker's subscription."""
if self.subscription:
logger.info("Deleting worker subscription...")
self.subscriber_client.delete_subscription(self.subscription)
|
def _get_or_create_subscription(self):
"""Workers all share the same subscription so that tasks are
distributed across all workers."""
topic_path = self._get_topic_path()
subscription_name = '{}-{}-shared'.format(
PUBSUB_OBJECT_PREFIX, self.name)
subscription_path = self.subscriber_client.subscription_path(
self.project, subscription_name)
try:
self.subscriber_client.get_subscription(subscription_path)
except google.cloud.exceptions.NotFound:
logger.info("Creating shared subscription {}".format(
subscription_name))
try:
self.subscriber_client.create_subscription(
subscription_path, topic=topic_path)
except google.cloud.exceptions.Conflict:
# Another worker created the subscription before us, ignore.
pass
return subscription_path
|
def enqueue(self, f, *args, **kwargs):
"""Enqueues a function for the task queue to execute."""
task = Task(uuid4().hex, f, args, kwargs)
self.storage.put_task(task)
return self.enqueue_task(task)
|
def enqueue_task(self, task):
"""Enqueues a task directly. This is used when a task is retried or if
a task was manually created.
Note that this does not store the task.
"""
data = dumps(task)
if self._async:
self.publisher_client.publish(self.topic_path, data=data)
logger.info('Task {} queued.'.format(task.id))
else:
unpickled_task = unpickle(data)
logger.info(
'Executing task {} synchronously.'.format(unpickled_task.id)
)
with measure_time() as summary, self.queue_context():
unpickled_task.execute(queue=self)
summary(unpickled_task.summary())
return TaskResult(task.id, self)
|
def unpickle(pickled_string):
"""Unpickles a string, but raises a unified UnpickleError in case anything
fails.
This is a helper method to not have to deal with the fact that `loads()`
potentially raises many types of exceptions (e.g. AttributeError,
IndexError, TypeError, KeyError, etc.)
"""
try:
obj = loads(pickled_string)
except Exception as e:
raise UnpickleError('Could not unpickle', pickled_string, e)
return obj
|
def main(path, pid, queue):
"""
Standalone PSQ worker.
The queue argument must be the full importable path to a psq.Queue
instance.
Example usage:
psqworker config.q
psqworker --path /opt/app queues.fast
"""
setup_logging()
if pid:
with open(os.path.expanduser(pid), "w") as f:
f.write(str(os.getpid()))
if not path:
path = os.getcwd()
sys.path.insert(0, path)
queue = import_queue(queue)
import psq
worker = psq.Worker(queue=queue)
worker.listen()
|
def result(self, timeout=None):
"""Gets the result of the task.
Arguments:
timeout: Maximum seconds to wait for a result before raising a
TimeoutError. If set to None, this will wait forever. If the
queue doesn't store results and timeout is None, this call will
never return.
"""
start = time.time()
while True:
task = self.get_task()
if not task or task.status not in (FINISHED, FAILED):
if not timeout:
continue
elif time.time() - start < timeout:
continue
else:
raise TimeoutError()
if task.status == FAILED:
raise task.result
return task.result
|
def service_start(service=None, param=None):
"""
Launch a Process, return his pid
"""
if service is not None:
to_run = ["python", service]
if param is not None:
to_run += param
return subprocess.Popen(to_run)
return False
|
def update_running_pids(old_procs):
"""
Update the list of the running process and return the list
"""
new_procs = []
for proc in old_procs:
if proc.poll() is None and check_pid(proc.pid):
publisher.debug(str(proc.pid) + ' is alive')
new_procs.append(proc)
else:
try:
publisher.debug(str(proc.pid) + ' is gone')
os.kill(proc.pid, signal.SIGKILL)
except:
# the process is just already gone
pass
return new_procs
|
def run_splitted_processing(max_simultaneous_processes, process_name,
filenames):
"""
Run processes which push the routing dump of the RIPE in a redis
database.
The dump has been splitted in multiple files and each process run
on one of this files.
"""
pids = []
while len(filenames) > 0:
while len(filenames) > 0 and len(pids) < max_simultaneous_processes:
filename = filenames.pop()
pids.append(service_start(service=process_name,
param=['-f', filename, '-d',
imported_day]))
while len(pids) == max_simultaneous_processes:
time.sleep(sleep_timer)
pids = update_running_pids(pids)
while len(pids) > 0:
# Wait until all the processes are finished
time.sleep(sleep_timer)
pids = update_running_pids(pids)
|
def fsplit(file_to_split):
"""
Split the file and return the list of filenames.
"""
dirname = file_to_split + '_splitted'
if not os.path.exists(dirname):
os.mkdir(dirname)
part_file_size = os.path.getsize(file_to_split) / number_of_files + 1
splitted_files = []
with open(file_to_split, "r") as f:
number = 0
actual = 0
while 1:
prec = actual
# Jump of "size" from the current place in the file
f.seek(part_file_size, os.SEEK_CUR)
# find the next separator or EOF
s = f.readline()
if len(s) == 0:
s = f.readline()
while len(s) != 0 and s != separator:
s = f.readline()
# Get the current place
actual = f.tell()
new_file = os.path.join(dirname, str(number))
# Create the new file
with open(file_to_split, "r") as temp:
temp.seek(prec)
# Get the text we want to put in the new file
copy = temp.read(actual - prec)
# Write the new file
open(new_file, 'w').write(copy)
splitted_files.append(new_file)
number += 1
# End of file
if len(s) == 0:
break
return splitted_files
|
def __entry_point():
"""
Function called when an query is made on /json. Expects a JSON
object with at least a 'method' entry.
"""
ip = request.remote_addr
ua = request.headers.get('User-Agent', 'Empty User-Agent')
method = request.json.get('method')
if method is None:
__query_logging(ip, ua, method, level='warning')
return json.dumps({'error': 'No method provided.'})
if method not in authorized_methods:
# unauthorized query
__query_logging(ip, ua, method, level='warning')
return json.dumps({'error': 'Unauthorized method.'})
fct = globals().get(method)
if fct is None:
# unknown method, the method is authorized, but does not exists...
__query_logging(ip, ua, method, level='warning')
return json.dumps({'error': 'Unknown method.'})
if request.json.get('ip') is None:
__query_logging(ip, ua, method, level='warning')
return json.dumps({'error': 'No IP provided, not going to work.'})
try:
result = fct(request.json)
__query_logging(ip, ua, method, request.json.get('ip'),
request.json.get('announce_date'), request.json.get('days_limit'))
return result
except Exception:
__query_logging(ip, ua, method, request.json.get('ip'), level='error')
return json.dumps({'error': 'Something went wrong.'})
|
def asn(self, ip, announce_date=None):
"""
Give an IP, maybe a date, get the ASN.
This is the fastest command.
:param ip: IP address to search for
:param announce_date: Date of the announcement
:rtype: String, ASN.
"""
assignations, announce_date, _ = self.run(ip, announce_date)
return next((assign for assign in assignations if assign is not None), None), announce_date
|
def date_asn_block(self, ip, announce_date=None):
"""
Get the ASN and the IP Block announcing the IP at a specific date.
:param ip: IP address to search for
:param announce_date: Date of the announcement
:rtype: tuple
.. code-block:: python
(announce_date, asn, block)
.. note::
the returned announce_date might be different of the one
given in parameter because some raw files are missing and we
don't have the information. In this case, the nearest known
date will be chosen,
"""
assignations, announce_date, keys = self.run(ip, announce_date)
pos = next((i for i, j in enumerate(assignations) if j is not None), None)
if pos is not None:
block = keys[pos]
if block != '0.0.0.0/0':
return announce_date, assignations[pos], block
return None
|
def history(self, ip, days_limit=None):
"""
Get the full history of an IP. It takes time.
:param ip: IP address to search for
:param days_limit: Max amount of days to query. (None means no limit)
:rtype: list. For each day in the database: day, asn, block
"""
all_dates = sorted(self.routing_db.smembers('imported_dates'), reverse=True)
if days_limit is not None:
all_dates = all_dates[:days_limit]
return [self.date_asn_block(ip, date) for date in all_dates]
|
def aggregate_history(self, ip, days_limit=None):
"""
Get the full history of an IP, aggregate the result instead of
returning one line per day.
:param ip: IP address to search for
:param days_limit: Max amount of days to query. (None means no limit)
:rtype: list. For each change: FirstDay, LastDay, ASN, Block
"""
first_date = None
last_date = None
prec_asn = None
prec_block = None
for entry in self.history(ip, days_limit):
if entry is None:
continue
date, asn, block = entry
if first_date is None:
last_date = date
first_date = date
prec_asn = asn
prec_block = block
elif prec_asn == asn and prec_block == block:
first_date = date
else:
yield first_date, last_date, prec_asn, prec_block
last_date = date
first_date = date
prec_asn = asn
prec_block = block
if first_date is not None:
yield first_date, last_date, prec_asn, prec_block
|
def downloadURL(url, filename):
"""
Inconditianilly download the URL in a temporary directory.
When finished, the file is moved in the real directory.
Like this an other process will not attempt to extract an inclomplete file.
"""
path_temp_bviewfile = os.path.join(c.raw_data, c.bview_dir, 'tmp', filename)
path_bviewfile = os.path.join(c.raw_data, c.bview_dir, filename)
try:
f = urlopen(url)
except:
return False
if f.getcode() != 200:
publisher.warning('{} unavailable, code: {}'.format(url, f.getcode()))
return False
try:
with open(path_temp_bviewfile, 'w') as outfile:
outfile.write(f.read())
os.rename(path_temp_bviewfile, path_bviewfile)
except:
os.remove(path_temp_bviewfile)
return False
return True
|
def already_downloaded(filename):
"""
Verify that the file has not already been downloaded.
"""
cur_file = os.path.join(c.bview_dir, filename)
old_file = os.path.join(c.bview_dir, 'old', filename)
if not os.path.exists(cur_file) and not os.path.exists(old_file):
return False
return True
|
def to_download():
"""
Build interval of urls to download.
We always get the first file of the next day.
Ex: 2013-01-01 => 2013-01-02.0000
"""
first_day = parse(interval_first)
last_day = parse(interval_last)
format_change = parse('2010-06-14')
one_day = datetime.timedelta(1)
cur_day = first_day
url_list = []
while cur_day < last_day:
fname = filename.format(day=cur_day.strftime("%Y%m%d"))
if cur_day > format_change:
cur_day += one_day
url = base_url.format(year_month=cur_day.strftime("%Y.%m"),
file_day=cur_day.strftime("%Y%m%d"))
else:
url = base_url_old.format(year_month=cur_day.strftime("%Y.%m"),
file_day=cur_day.strftime("%Y%m%d"))
cur_day += one_day
url_list.append((fname, url))
return sorted(url_list, key=lambda tup: tup[0], reverse=True)
|
def strToBool(val):
"""
Helper function to turn a string representation of "true" into
boolean True.
"""
if isinstance(val, str):
val = val.lower()
return val in ['true', 'on', 'yes', True]
|
def get_page_url(page_num, current_app, url_view_name, url_extra_args, url_extra_kwargs, url_param_name, url_get_params, url_anchor):
"""
Helper function to return a valid URL string given the template tag parameters
"""
if url_view_name is not None:
# Add page param to the kwargs list. Overrides any previously set parameter of the same name.
url_extra_kwargs[url_param_name] = page_num
try:
url = reverse(url_view_name, args=url_extra_args, kwargs=url_extra_kwargs, current_app=current_app)
except NoReverseMatch as e: # Attempt to load view from application root, allowing the use of non-namespaced view names if your view is defined in the root application
if settings.SETTINGS_MODULE:
if django.VERSION < (1, 9, 0):
separator = '.'
else:
separator = ':' # Namespace separator changed to colon after 1.8
project_name = settings.SETTINGS_MODULE.split('.')[0]
try:
url = reverse(project_name + separator + url_view_name, args=url_extra_args, kwargs=url_extra_kwargs, current_app=current_app)
except NoReverseMatch:
raise e # Raise the original exception so the error message doesn't confusingly include something the Developer didn't add to the view name themselves
else:
raise e # We can't determine the project name so just re-throw the exception
else:
url = ''
url_get_params = url_get_params or QueryDict(url)
url_get_params = url_get_params.copy()
url_get_params[url_param_name] = str(page_num)
if len(url_get_params) > 0:
if not isinstance(url_get_params, QueryDict):
tmp = QueryDict(mutable=True)
tmp.update(url_get_params)
url_get_params = tmp
url += '?' + url_get_params.urlencode()
if (url_anchor is not None):
url += '#' + url_anchor
return url
|
def bootstrap_paginate(parser, token):
"""
Renders a Page object as a Twitter Bootstrap styled pagination bar.
Compatible with Bootstrap 3.x and 4.x only.
Example::
{% bootstrap_paginate page_obj range=10 %}
Named Parameters::
range - The size of the pagination bar (ie, if set to 10 then, at most,
10 page numbers will display at any given time) Defaults to
None, which shows all pages.
size - Accepts "small", and "large". Defaults to
None which is the standard size.
show_prev_next - Accepts "true" or "false". Determines whether or not
to show the previous and next page links. Defaults to
"true"
show_first_last - Accepts "true" or "false". Determines whether or not
to show the first and last page links. Defaults to
"false"
previous_label - The text to display for the previous page link.
Defaults to "←"
next_label - The text to display for the next page link. Defaults to
"→"
first_label - The text to display for the first page link. Defaults to
"«"
last_label - The text to display for the last page link. Defaults to
"»"
url_view_name - The named URL to use. Defaults to None. If None, then the
default template simply appends the url parameter as a
relative URL link, eg: <a href="?page=1">1</a>
url_param_name - The name of the parameter to use in the URL. If
url_view_name is set to None, this string is used as the
parameter name in the relative URL path. If a URL
name is specified, this string is used as the
parameter name passed into the reverse() method for
the URL.
url_extra_args - This is used only in conjunction with url_view_name.
When referencing a URL, additional arguments may be
passed in as a list.
url_extra_kwargs - This is used only in conjunction with url_view_name.
When referencing a URL, additional named arguments
may be passed in as a dictionary.
url_get_params - The other get parameters to pass, only the page
number will be overwritten. Use this to preserve
filters.
url_anchor - The anchor to use in URLs. Defaults to None.
extra_pagination_classes - A space separated list of CSS class names
that will be added to the top level <ul>
HTML element. In particular, this can be
utilized in Bootstrap 4 installatinos to
add the appropriate alignment classes from
Flexbox utilites, eg: justify-content-center
"""
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError("'%s' takes at least one argument"
" (Page object reference)" % bits[0])
page = parser.compile_filter(bits[1])
kwargs = {}
bits = bits[2:]
kwarg_re = re.compile(r'(\w+)=(.+)')
if len(bits):
for bit in bits:
match = kwarg_re.match(bit)
if not match:
raise TemplateSyntaxError("Malformed arguments to bootstrap_pagination paginate tag")
name, value = match.groups()
kwargs[name] = parser.compile_filter(value)
return BootstrapPaginationNode(page, kwargs)
|
def configure_devel_jobs(
config_url, rosdistro_name, source_build_name, groovy_script=None,
dry_run=False, whitelist_repository_names=None):
"""
Configure all Jenkins devel jobs.
L{configure_release_job} will be invoked for source repository and target
which matches the build file criteria.
"""
config = get_config_index(config_url)
build_files = get_source_build_files(config, rosdistro_name)
build_file = build_files[source_build_name]
index = get_index(config.rosdistro_index_url)
dist_cache = None
if build_file.notify_maintainers:
dist_cache = get_distribution_cache(index, rosdistro_name)
# get targets
targets = []
for os_name in build_file.targets.keys():
for os_code_name in build_file.targets[os_name].keys():
for arch in build_file.targets[os_name][os_code_name]:
targets.append((os_name, os_code_name, arch))
print('The build file contains the following targets:')
for os_name, os_code_name, arch in targets:
print(' -', os_name, os_code_name, arch)
dist_file = get_distribution_file(index, rosdistro_name, build_file)
if not dist_file:
print('No distribution file matches the build file')
return
devel_view_name = get_devel_view_name(
rosdistro_name, source_build_name, pull_request=False)
pull_request_view_name = get_devel_view_name(
rosdistro_name, source_build_name, pull_request=True)
# all further configuration will be handled by either the Jenkins API
# or by a generated groovy script
from ros_buildfarm.jenkins import connect
jenkins = connect(config.jenkins_url) if groovy_script is None else False
view_configs = {}
views = {}
if build_file.test_commits_force is not False:
views[devel_view_name] = configure_devel_view(
jenkins, devel_view_name, dry_run=dry_run)
if build_file.test_pull_requests_force is not False:
views[pull_request_view_name] = configure_devel_view(
jenkins, pull_request_view_name, dry_run=dry_run)
if not jenkins:
view_configs.update(views)
groovy_data = {
'dry_run': dry_run,
'expected_num_views': len(view_configs),
}
repo_names = dist_file.repositories.keys()
filtered_repo_names = build_file.filter_repositories(repo_names)
devel_job_names = []
pull_request_job_names = []
job_configs = OrderedDict()
for repo_name in sorted(repo_names):
if whitelist_repository_names:
if repo_name not in whitelist_repository_names:
print(
"Skipping repository '%s' not in explicitly passed list" %
repo_name, file=sys.stderr)
continue
is_disabled = repo_name not in filtered_repo_names
if is_disabled and build_file.skip_ignored_repositories:
print("Skipping ignored repository '%s'" % repo_name,
file=sys.stderr)
continue
repo = dist_file.repositories[repo_name]
if not repo.source_repository:
print("Skipping repository '%s': no source section" % repo_name)
continue
if not repo.source_repository.version:
print("Skipping repository '%s': no source version" % repo_name)
continue
job_types = []
# check for testing commits
if build_file.test_commits_force is False:
print(("Skipping repository '%s': 'test_commits' is forced to " +
"false in the build file") % repo_name)
elif repo.source_repository.test_commits is False:
print(("Skipping repository '%s': 'test_commits' of the " +
"repository set to false") % repo_name)
elif repo.source_repository.test_commits is None and \
not build_file.test_commits_default:
print(("Skipping repository '%s': 'test_commits' defaults to " +
"false in the build file") % repo_name)
else:
job_types.append('commit')
if not is_disabled:
# check for testing pull requests
if build_file.test_pull_requests_force is False:
# print(("Skipping repository '%s': 'test_pull_requests' " +
# "is forced to false in the build file") % repo_name)
pass
elif repo.source_repository.test_pull_requests is False:
# print(("Skipping repository '%s': 'test_pull_requests' of " +
# "the repository set to false") % repo_name)
pass
elif repo.source_repository.test_pull_requests is None and \
not build_file.test_pull_requests_default:
# print(("Skipping repository '%s': 'test_pull_requests' " +
# "defaults to false in the build file") % repo_name)
pass
else:
print("Pull request job for repository '%s'" % repo_name)
job_types.append('pull_request')
for job_type in job_types:
pull_request = job_type == 'pull_request'
for os_name, os_code_name, arch in targets:
try:
job_name, job_config = configure_devel_job(
config_url, rosdistro_name, source_build_name,
repo_name, os_name, os_code_name, arch, pull_request,
config=config, build_file=build_file,
index=index, dist_file=dist_file,
dist_cache=dist_cache, jenkins=jenkins, views=views,
is_disabled=is_disabled,
groovy_script=groovy_script,
dry_run=dry_run)
if not pull_request:
devel_job_names.append(job_name)
else:
pull_request_job_names.append(job_name)
if groovy_script is not None:
print("Configuration for job '%s'" % job_name)
job_configs[job_name] = job_config
except JobValidationError as e:
print(e.message, file=sys.stderr)
groovy_data['expected_num_jobs'] = len(job_configs)
groovy_data['job_prefixes_and_names'] = {}
devel_job_prefix = '%s__' % devel_view_name
pull_request_job_prefix = '%s__' % pull_request_view_name
if not whitelist_repository_names:
groovy_data['job_prefixes_and_names']['devel'] = \
(devel_job_prefix, devel_job_names)
groovy_data['job_prefixes_and_names']['pull_request'] = \
(pull_request_job_prefix, pull_request_job_names)
if groovy_script is None:
# delete obsolete jobs in these views
from ros_buildfarm.jenkins import remove_jobs
print('Removing obsolete devel jobs')
remove_jobs(
jenkins, devel_job_prefix, devel_job_names, dry_run=dry_run)
print('Removing obsolete pull request jobs')
remove_jobs(
jenkins, pull_request_job_prefix, pull_request_job_names,
dry_run=dry_run)
if groovy_script is not None:
print(
"Writing groovy script '%s' to reconfigure %d views and %d jobs" %
(groovy_script, len(view_configs), len(job_configs)))
content = expand_template(
'snippet/reconfigure_jobs.groovy.em', groovy_data)
write_groovy_script_and_configs(
groovy_script, content, job_configs, view_configs=view_configs)
|
def configure_devel_job(
config_url, rosdistro_name, source_build_name,
repo_name, os_name, os_code_name, arch,
pull_request=False,
config=None, build_file=None,
index=None, dist_file=None, dist_cache=None,
jenkins=None, views=None,
is_disabled=False,
groovy_script=None,
source_repository=None,
build_targets=None,
dry_run=False):
"""
Configure a single Jenkins devel job.
This includes the following steps:
- clone the source repository to use
- clone the ros_buildfarm repository
- write the distribution repository keys into files
- invoke the release/run_devel_job.py script
"""
if config is None:
config = get_config_index(config_url)
if build_file is None:
build_files = get_source_build_files(config, rosdistro_name)
build_file = build_files[source_build_name]
# Overwrite build_file.targets if build_targets is specified
if build_targets is not None:
build_file.targets = build_targets
if index is None:
index = get_index(config.rosdistro_index_url)
if dist_file is None:
dist_file = get_distribution_file(index, rosdistro_name, build_file)
if not dist_file:
raise JobValidationError(
'No distribution file matches the build file')
repo_names = dist_file.repositories.keys()
if repo_name is not None:
if repo_name not in repo_names:
raise JobValidationError(
"Invalid repository name '%s' " % repo_name +
'choose one of the following: %s' %
', '.join(sorted(repo_names)))
repo = dist_file.repositories[repo_name]
if not repo.source_repository:
raise JobValidationError(
"Repository '%s' has no source section" % repo_name)
if not repo.source_repository.version:
raise JobValidationError(
"Repository '%s' has no source version" % repo_name)
source_repository = repo.source_repository
if os_name not in build_file.targets.keys():
raise JobValidationError(
"Invalid OS name '%s' " % os_name +
'choose one of the following: ' +
', '.join(sorted(build_file.targets.keys())))
if os_code_name not in build_file.targets[os_name].keys():
raise JobValidationError(
"Invalid OS code name '%s' " % os_code_name +
'choose one of the following: ' +
', '.join(sorted(build_file.targets[os_name].keys())))
if arch not in build_file.targets[os_name][os_code_name]:
raise JobValidationError(
"Invalid architecture '%s' " % arch +
'choose one of the following: %s' % ', '.join(sorted(
build_file.targets[os_name][os_code_name])))
if dist_cache is None and build_file.notify_maintainers:
dist_cache = get_distribution_cache(index, rosdistro_name)
if jenkins is None:
from ros_buildfarm.jenkins import connect
jenkins = connect(config.jenkins_url)
if views is None:
view_name = get_devel_view_name(
rosdistro_name, source_build_name, pull_request=pull_request)
configure_devel_view(jenkins, view_name, dry_run=dry_run)
job_name = get_devel_job_name(
rosdistro_name, source_build_name,
repo_name, os_name, os_code_name, arch, pull_request)
job_config = _get_devel_job_config(
index, config, rosdistro_name, source_build_name,
build_file, os_name, os_code_name, arch, source_repository,
repo_name, pull_request, job_name, dist_cache=dist_cache,
is_disabled=is_disabled)
# jenkinsapi.jenkins.Jenkins evaluates to false if job count is zero
if isinstance(jenkins, object) and jenkins is not False:
from ros_buildfarm.jenkins import configure_job
configure_job(jenkins, job_name, job_config, dry_run=dry_run)
return job_name, job_config
|
def configure_release_jobs(
config_url, rosdistro_name, release_build_name, groovy_script=None,
dry_run=False, whitelist_package_names=None):
"""
Configure all Jenkins release jobs.
L{configure_release_job} will be invoked for every released package and
target which matches the build file criteria.
Additionally a job to import Debian packages into the Debian repository is
created.
"""
config = get_config_index(config_url)
build_files = get_release_build_files(config, rosdistro_name)
build_file = build_files[release_build_name]
index = get_index(config.rosdistro_index_url)
# get targets
platforms = []
for os_name in build_file.targets.keys():
for os_code_name in build_file.targets[os_name].keys():
platforms.append((os_name, os_code_name))
print('The build file contains the following targets:')
for os_name, os_code_name in platforms:
print(' - %s %s: %s' % (os_name, os_code_name, ', '.join(
build_file.targets[os_name][os_code_name])))
dist_file = get_distribution_file(index, rosdistro_name, build_file)
if not dist_file:
print('No distribution file matches the build file')
return
pkg_names = dist_file.release_packages.keys()
filtered_pkg_names = build_file.filter_packages(pkg_names)
explicitly_ignored_pkg_names = set(pkg_names) - set(filtered_pkg_names)
if explicitly_ignored_pkg_names:
print(('The following packages are being %s because of ' +
'white-/blacklisting:') %
('ignored' if build_file.skip_ignored_packages else 'disabled'))
for pkg_name in sorted(explicitly_ignored_pkg_names):
print(' -', pkg_name)
dist_cache = get_distribution_cache(index, rosdistro_name)
if explicitly_ignored_pkg_names:
# get direct dependencies from distro cache for each package
direct_dependencies = {}
for pkg_name in pkg_names:
direct_dependencies[pkg_name] = _get_direct_dependencies(
pkg_name, dist_cache, pkg_names) or set([])
# find recursive downstream deps for all explicitly ignored packages
ignored_pkg_names = set(explicitly_ignored_pkg_names)
while True:
implicitly_ignored_pkg_names = _get_downstream_package_names(
ignored_pkg_names, direct_dependencies)
if implicitly_ignored_pkg_names - ignored_pkg_names:
ignored_pkg_names |= implicitly_ignored_pkg_names
continue
break
implicitly_ignored_pkg_names = \
ignored_pkg_names - explicitly_ignored_pkg_names
if implicitly_ignored_pkg_names:
print(('The following packages are being %s because their ' +
'dependencies are being ignored:') % ('ignored'
if build_file.skip_ignored_packages else 'disabled'))
for pkg_name in sorted(implicitly_ignored_pkg_names):
print(' -', pkg_name)
filtered_pkg_names = \
set(filtered_pkg_names) - implicitly_ignored_pkg_names
# all further configuration will be handled by either the Jenkins API
# or by a generated groovy script
jenkins = False
if groovy_script is None:
from ros_buildfarm.jenkins import connect
jenkins = connect(config.jenkins_url)
all_view_configs = {}
all_job_configs = OrderedDict()
job_name, job_config = configure_import_package_job(
config_url, rosdistro_name, release_build_name,
config=config, build_file=build_file, jenkins=jenkins, dry_run=dry_run)
if not jenkins:
all_job_configs[job_name] = job_config
job_name, job_config = configure_sync_packages_to_main_job(
config_url, rosdistro_name, release_build_name,
config=config, build_file=build_file, jenkins=jenkins, dry_run=dry_run)
if not jenkins:
all_job_configs[job_name] = job_config
for os_name, os_code_name in platforms:
for arch in sorted(build_file.targets[os_name][os_code_name]):
job_name, job_config = configure_sync_packages_to_testing_job(
config_url, rosdistro_name, release_build_name,
os_code_name, arch,
config=config, build_file=build_file, jenkins=jenkins,
dry_run=dry_run)
if not jenkins:
all_job_configs[job_name] = job_config
targets = []
for os_name, os_code_name in platforms:
targets.append((os_name, os_code_name, 'source'))
for arch in build_file.targets[os_name][os_code_name]:
targets.append((os_name, os_code_name, arch))
views = configure_release_views(
jenkins, rosdistro_name, release_build_name, targets,
dry_run=dry_run)
if not jenkins:
all_view_configs.update(views)
groovy_data = {
'dry_run': dry_run,
'expected_num_views': len(views),
}
# binary jobs must be generated in topological order
from catkin_pkg.package import parse_package_string
from ros_buildfarm.common import topological_order_packages
pkgs = {}
for pkg_name in pkg_names:
if pkg_name not in dist_cache.release_package_xmls:
print("Skipping package '%s': no released package.xml in cache" %
(pkg_name), file=sys.stderr)
continue
pkg_xml = dist_cache.release_package_xmls[pkg_name]
pkg = parse_package_string(pkg_xml)
pkgs[pkg_name] = pkg
ordered_pkg_tuples = topological_order_packages(pkgs)
other_build_files = [v for k, v in build_files.items() if k != release_build_name]
all_source_job_names = []
all_binary_job_names = []
for pkg_name in [p.name for _, p in ordered_pkg_tuples]:
if whitelist_package_names:
if pkg_name not in whitelist_package_names:
print("Skipping package '%s' not in the explicitly passed list" %
pkg_name, file=sys.stderr)
continue
pkg = dist_file.release_packages[pkg_name]
repo_name = pkg.repository_name
repo = dist_file.repositories[repo_name]
is_disabled = pkg_name not in filtered_pkg_names
if is_disabled and build_file.skip_ignored_packages:
print("Skipping ignored package '%s' in repository '%s'" %
(pkg_name, repo_name), file=sys.stderr)
continue
if not repo.release_repository:
print(("Skipping package '%s' in repository '%s': no release " +
"section") % (pkg_name, repo_name), file=sys.stderr)
continue
if not repo.release_repository.version:
print(("Skipping package '%s' in repository '%s': no release " +
"version") % (pkg_name, repo_name), file=sys.stderr)
continue
for os_name, os_code_name in platforms:
other_build_files_same_platform = []
for other_build_file in other_build_files:
if os_name not in other_build_file.targets:
continue
if os_code_name not in other_build_file.targets[os_name]:
continue
other_build_files_same_platform.append(other_build_file)
try:
source_job_names, binary_job_names, job_configs = \
configure_release_job(
config_url, rosdistro_name, release_build_name,
pkg_name, os_name, os_code_name,
config=config, build_file=build_file,
index=index, dist_file=dist_file,
dist_cache=dist_cache,
jenkins=jenkins, views=views,
generate_import_package_job=False,
generate_sync_packages_jobs=False,
is_disabled=is_disabled,
other_build_files_same_platform=other_build_files_same_platform,
groovy_script=groovy_script,
dry_run=dry_run)
all_source_job_names += source_job_names
all_binary_job_names += binary_job_names
if groovy_script is not None:
print('Configuration for jobs: ' +
', '.join(source_job_names + binary_job_names))
for source_job_name in source_job_names:
all_job_configs[source_job_name] = job_configs[source_job_name]
for binary_job_name in binary_job_names:
all_job_configs[binary_job_name] = job_configs[binary_job_name]
except JobValidationError as e:
print(e.message, file=sys.stderr)
groovy_data['expected_num_jobs'] = len(all_job_configs)
groovy_data['job_prefixes_and_names'] = {}
# with an explicit list of packages we don't delete obsolete jobs
if not whitelist_package_names:
# delete obsolete binary jobs
for os_name, os_code_name in platforms:
for arch in build_file.targets[os_name][os_code_name]:
binary_view = get_release_binary_view_name(
rosdistro_name, release_build_name,
os_name, os_code_name, arch)
binary_job_prefix = '%s__' % binary_view
excluded_job_names = set([
j for j in all_binary_job_names
if j.startswith(binary_job_prefix)])
if groovy_script is None:
print("Removing obsolete binary jobs with prefix '%s'" %
binary_job_prefix)
from ros_buildfarm.jenkins import remove_jobs
remove_jobs(
jenkins, binary_job_prefix, excluded_job_names,
dry_run=dry_run)
else:
binary_key = 'binary_%s_%s_%s' % \
(os_name, os_code_name, arch)
groovy_data['job_prefixes_and_names'][binary_key] = \
(binary_job_prefix, excluded_job_names)
# delete obsolete source jobs
# requires knowledge about all other release build files
for os_name, os_code_name in platforms:
other_source_job_names = []
# get source job names for all other release build files
for other_release_build_name in [
k for k in build_files.keys() if k != release_build_name]:
other_build_file = build_files[other_release_build_name]
other_dist_file = get_distribution_file(
index, rosdistro_name, other_build_file)
if not other_dist_file:
continue
if os_name not in other_build_file.targets or \
os_code_name not in other_build_file.targets[os_name]:
continue
if other_build_file.skip_ignored_packages:
filtered_pkg_names = other_build_file.filter_packages(
pkg_names)
else:
filtered_pkg_names = pkg_names
for pkg_name in sorted(filtered_pkg_names):
pkg = other_dist_file.release_packages[pkg_name]
repo_name = pkg.repository_name
repo = other_dist_file.repositories[repo_name]
if not repo.release_repository:
continue
if not repo.release_repository.version:
continue
other_job_name = get_sourcedeb_job_name(
rosdistro_name, other_release_build_name,
pkg_name, os_name, os_code_name)
other_source_job_names.append(other_job_name)
source_view_prefix = get_release_source_view_name(
rosdistro_name, os_name, os_code_name)
source_job_prefix = '%s__' % source_view_prefix
excluded_job_names = set([
j for j in (all_source_job_names + other_source_job_names)
if j.startswith(source_job_prefix)])
if groovy_script is None:
print("Removing obsolete source jobs with prefix '%s'" %
source_job_prefix)
from ros_buildfarm.jenkins import remove_jobs
remove_jobs(
jenkins, source_job_prefix, excluded_job_names,
dry_run=dry_run)
else:
source_key = 'source_%s_%s' % (os_name, os_code_name)
groovy_data['job_prefixes_and_names'][source_key] = (
source_job_prefix, excluded_job_names)
if groovy_script is not None:
print(
"Writing groovy script '%s' to reconfigure %d views and %d jobs" %
(groovy_script, len(all_view_configs), len(all_job_configs)))
content = expand_template(
'snippet/reconfigure_jobs.groovy.em', groovy_data)
write_groovy_script_and_configs(
groovy_script, content, all_job_configs,
view_configs=all_view_configs)
|
def configure_release_job(
config_url, rosdistro_name, release_build_name,
pkg_name, os_name, os_code_name,
config=None, build_file=None,
index=None, dist_file=None, dist_cache=None,
jenkins=None, views=None,
generate_import_package_job=True,
generate_sync_packages_jobs=True,
is_disabled=False, other_build_files_same_platform=None,
groovy_script=None,
filter_arches=None,
dry_run=False):
"""
Configure a Jenkins release job.
The following jobs are created for each package:
- M source jobs, one for each OS node name
- M * N binary jobs, one for each combination of OS code name and arch
"""
if config is None:
config = get_config_index(config_url)
if build_file is None:
build_files = get_release_build_files(config, rosdistro_name)
build_file = build_files[release_build_name]
if index is None:
index = get_index(config.rosdistro_index_url)
if dist_file is None:
dist_file = get_distribution_file(index, rosdistro_name, build_file)
if not dist_file:
raise JobValidationError(
'No distribution file matches the build file')
pkg_names = dist_file.release_packages.keys()
if pkg_name not in pkg_names:
raise JobValidationError(
"Invalid package name '%s' " % pkg_name +
'choose one of the following: ' + ', '.join(sorted(pkg_names)))
pkg = dist_file.release_packages[pkg_name]
repo_name = pkg.repository_name
repo = dist_file.repositories[repo_name]
if not repo.release_repository:
raise JobValidationError(
"Repository '%s' has no release section" % repo_name)
if not repo.release_repository.version:
raise JobValidationError(
"Repository '%s' has no release version" % repo_name)
if os_name not in build_file.targets.keys():
raise JobValidationError(
"Invalid OS name '%s' " % os_name +
'choose one of the following: ' +
', '.join(sorted(build_file.targets.keys())))
if os_code_name not in build_file.targets[os_name].keys():
raise JobValidationError(
"Invalid OS code name '%s' " % os_code_name +
'choose one of the following: ' +
', '.join(sorted(build_file.targets[os_name].keys())))
if dist_cache is None and \
(build_file.notify_maintainers or
build_file.abi_incompatibility_assumed):
dist_cache = get_distribution_cache(index, rosdistro_name)
if jenkins is None:
from ros_buildfarm.jenkins import connect
jenkins = connect(config.jenkins_url)
if views is None:
targets = []
targets.append((os_name, os_code_name, 'source'))
for arch in build_file.targets[os_name][os_code_name]:
targets.append((os_name, os_code_name, arch))
configure_release_views(
jenkins, rosdistro_name, release_build_name, targets,
dry_run=dry_run)
if generate_import_package_job:
configure_import_package_job(
config_url, rosdistro_name, release_build_name,
config=config, build_file=build_file, jenkins=jenkins,
dry_run=dry_run)
if generate_sync_packages_jobs:
configure_sync_packages_to_main_job(
config_url, rosdistro_name, release_build_name,
config=config, build_file=build_file, jenkins=jenkins,
dry_run=dry_run)
for arch in build_file.targets[os_name][os_code_name]:
configure_sync_packages_to_testing_job(
config_url, rosdistro_name, release_build_name,
os_code_name, arch,
config=config, build_file=build_file, jenkins=jenkins,
dry_run=dry_run)
source_job_names = []
binary_job_names = []
job_configs = {}
# sourcedeb job
# since sourcedeb jobs are potentially being shared across multiple build
# files the configuration has to take all of them into account in order to
# generate a job which all build files agree on
source_job_name = get_sourcedeb_job_name(
rosdistro_name, release_build_name,
pkg_name, os_name, os_code_name)
# while the package is disabled in the current build file
# it might be used by sibling build files
is_source_disabled = is_disabled
if is_source_disabled and other_build_files_same_platform:
# check if sourcedeb job is used by any other build file with the same platform
for other_build_file in other_build_files_same_platform:
if other_build_file.filter_packages([pkg_name]):
is_source_disabled = False
break
job_config = _get_sourcedeb_job_config(
config_url, rosdistro_name, release_build_name,
config, build_file, os_name, os_code_name,
pkg_name, repo_name, repo.release_repository, dist_cache=dist_cache,
is_disabled=is_source_disabled,
other_build_files_same_platform=other_build_files_same_platform)
# jenkinsapi.jenkins.Jenkins evaluates to false if job count is zero
if isinstance(jenkins, object) and jenkins is not False:
from ros_buildfarm.jenkins import configure_job
configure_job(jenkins, source_job_name, job_config, dry_run=dry_run)
source_job_names.append(source_job_name)
job_configs[source_job_name] = job_config
dependency_names = []
if build_file.abi_incompatibility_assumed:
dependency_names = _get_direct_dependencies(
pkg_name, dist_cache, pkg_names)
# if dependencies are not yet available in rosdistro cache
# skip binary jobs
if dependency_names is None:
print(("Skipping binary jobs for package '%s' because it is not " +
"yet in the rosdistro cache") % pkg_name, file=sys.stderr)
return source_job_names, binary_job_names, job_configs
# binarydeb jobs
for arch in build_file.targets[os_name][os_code_name]:
if filter_arches and arch not in filter_arches:
continue
job_name = get_binarydeb_job_name(
rosdistro_name, release_build_name,
pkg_name, os_name, os_code_name, arch)
upstream_job_names = [source_job_name] + [
get_binarydeb_job_name(
rosdistro_name, release_build_name,
dependency_name, os_name, os_code_name, arch)
for dependency_name in dependency_names]
job_config = _get_binarydeb_job_config(
config_url, rosdistro_name, release_build_name,
config, build_file, os_name, os_code_name, arch,
pkg_name, repo_name, repo.release_repository,
dist_cache=dist_cache, upstream_job_names=upstream_job_names,
is_disabled=is_disabled)
# jenkinsapi.jenkins.Jenkins evaluates to false if job count is zero
if isinstance(jenkins, object) and jenkins is not False:
configure_job(jenkins, job_name, job_config, dry_run=dry_run)
binary_job_names.append(job_name)
job_configs[job_name] = job_config
return source_job_names, binary_job_names, job_configs
|
def configure_doc_jobs(
config_url, rosdistro_name, doc_build_name, groovy_script=None,
dry_run=False, whitelist_repository_names=None):
"""
Configure all Jenkins doc jobs.
L{configure_doc_job} will be invoked for doc repository and target
which matches the build file criteria.
"""
config = get_config_index(config_url)
build_files = get_doc_build_files(config, rosdistro_name)
build_file = build_files[doc_build_name]
index = get_index(config.rosdistro_index_url)
dist_cache = None
if build_file.notify_maintainers:
dist_cache = get_distribution_cache(index, rosdistro_name)
# get targets
targets = []
for os_name in build_file.targets.keys():
for os_code_name in build_file.targets[os_name].keys():
for arch in build_file.targets[os_name][os_code_name]:
targets.append((os_name, os_code_name, arch))
print('The build file contains the following targets:')
for os_name, os_code_name, arch in targets:
print(' -', os_name, os_code_name, arch)
dist_file = get_distribution_file(index, rosdistro_name, build_file)
if not dist_file:
print('No distribution file matches the build file')
return
doc_view_name = get_doc_view_name(rosdistro_name, doc_build_name)
# all further configuration will be handled by either the Jenkins API
# or by a generated groovy script
from ros_buildfarm.jenkins import connect
jenkins = connect(config.jenkins_url) if groovy_script is None else False
view_configs = {}
views = {}
views[doc_view_name] = configure_doc_view(
jenkins, doc_view_name, dry_run=dry_run)
if not jenkins:
view_configs.update(views)
groovy_data = {
'dry_run': dry_run,
'expected_num_views': len(view_configs),
}
repo_names = dist_file.repositories.keys()
filtered_repo_names = build_file.filter_repositories(repo_names)
job_names = []
job_configs = OrderedDict()
for repo_name in sorted(repo_names):
if whitelist_repository_names:
if repo_name not in whitelist_repository_names:
print(
"Skipping repository '%s' not in explicitly passed list" %
repo_name, file=sys.stderr)
continue
is_disabled = repo_name not in filtered_repo_names
if is_disabled and build_file.skip_ignored_repositories:
print("Skipping ignored repository '%s'" % repo_name,
file=sys.stderr)
continue
repo = dist_file.repositories[repo_name]
if not repo.doc_repository:
print("Skipping repository '%s': no doc section" % repo_name)
continue
if not repo.doc_repository.version:
print("Skipping repository '%s': no doc version" % repo_name)
continue
for os_name, os_code_name, arch in targets:
try:
job_name, job_config = configure_doc_job(
config_url, rosdistro_name, doc_build_name,
repo_name, os_name, os_code_name, arch,
config=config, build_file=build_file,
index=index, dist_file=dist_file,
dist_cache=dist_cache, jenkins=jenkins, views=views,
is_disabled=is_disabled,
groovy_script=groovy_script,
dry_run=dry_run)
job_names.append(job_name)
if groovy_script is not None:
print("Configuration for job '%s'" % job_name)
job_configs[job_name] = job_config
except JobValidationError as e:
print(e.message, file=sys.stderr)
groovy_data['expected_num_jobs'] = len(job_configs)
groovy_data['job_prefixes_and_names'] = {}
job_prefix = '%s__' % doc_view_name
if not whitelist_repository_names:
groovy_data['job_prefixes_and_names']['doc'] = (job_prefix, job_names)
if groovy_script is None:
# delete obsolete jobs in this view
from ros_buildfarm.jenkins import remove_jobs
print('Removing obsolete doc jobs')
remove_jobs(jenkins, job_prefix, job_names, dry_run=dry_run)
if groovy_script is not None:
print(
"Writing groovy script '%s' to reconfigure %d views and %d jobs" %
(groovy_script, len(view_configs), len(job_configs)))
content = expand_template(
'snippet/reconfigure_jobs.groovy.em', groovy_data)
write_groovy_script_and_configs(
groovy_script, content, job_configs, view_configs=view_configs)
|
def configure_doc_job(
config_url, rosdistro_name, doc_build_name,
repo_name, os_name, os_code_name, arch,
config=None, build_file=None,
index=None, dist_file=None, dist_cache=None,
jenkins=None, views=None,
is_disabled=False,
groovy_script=None,
doc_repository=None,
dry_run=False):
"""
Configure a single Jenkins doc job.
This includes the following steps:
- clone the doc repository to use
- clone the ros_buildfarm repository
- write the distribution repository keys into files
- invoke the run_doc_job.py script
"""
if config is None:
config = get_config_index(config_url)
if build_file is None:
build_files = get_doc_build_files(config, rosdistro_name)
build_file = build_files[doc_build_name]
if index is None:
index = get_index(config.rosdistro_index_url)
if dist_file is None:
dist_file = get_distribution_file(index, rosdistro_name, build_file)
if not dist_file:
raise JobValidationError(
'No distribution file matches the build file')
repo_names = dist_file.repositories.keys()
if repo_name is not None:
if repo_name not in repo_names:
raise JobValidationError(
"Invalid repository name '%s' " % repo_name +
'choose one of the following: %s' %
', '.join(sorted(repo_names)))
repo = dist_file.repositories[repo_name]
if not repo.doc_repository:
raise JobValidationError(
"Repository '%s' has no doc section" % repo_name)
if not repo.doc_repository.version:
raise JobValidationError(
"Repository '%s' has no doc version" % repo_name)
doc_repository = repo.doc_repository
if os_name not in build_file.targets.keys():
raise JobValidationError(
"Invalid OS name '%s' " % os_name +
'choose one of the following: ' +
', '.join(sorted(build_file.targets.keys())))
if os_code_name not in build_file.targets[os_name].keys():
raise JobValidationError(
"Invalid OS code name '%s' " % os_code_name +
'choose one of the following: ' +
', '.join(sorted(build_file.targets[os_name].keys())))
if arch not in build_file.targets[os_name][os_code_name]:
raise JobValidationError(
"Invalid architecture '%s' " % arch +
'choose one of the following: %s' % ', '.join(sorted(
build_file.targets[os_name][os_code_name])))
if dist_cache is None and build_file.notify_maintainers:
dist_cache = get_distribution_cache(index, rosdistro_name)
if jenkins is None:
from ros_buildfarm.jenkins import connect
jenkins = connect(config.jenkins_url)
if views is None:
view_name = get_doc_view_name(
rosdistro_name, doc_build_name)
configure_doc_view(jenkins, view_name, dry_run=dry_run)
job_name = get_doc_job_name(
rosdistro_name, doc_build_name,
repo_name, os_name, os_code_name, arch)
job_config = _get_doc_job_config(
config, config_url, rosdistro_name, doc_build_name,
build_file, os_name, os_code_name, arch, doc_repository,
repo_name, dist_cache=dist_cache, is_disabled=is_disabled)
# jenkinsapi.jenkins.Jenkins evaluates to false if job count is zero
if isinstance(jenkins, object) and jenkins is not False:
from ros_buildfarm.jenkins import configure_job
configure_job(jenkins, job_name, job_config, dry_run=dry_run)
return job_name, job_config
|
def get_affected_by_sync(
package_descriptors, targets,
testing_repo_data, main_repo_data):
"""
For each package and target check if it is affected by a sync.
This is the case when the package version in the testing repo is different
from the version in the main repo.
:return: a dict indexed by package names containing
dicts indexed by targets containing a boolean flag
"""
affected_by_sync = {}
for package_descriptor in package_descriptors.values():
pkg_name = package_descriptor.pkg_name
debian_pkg_name = package_descriptor.debian_pkg_name
affected_by_sync[pkg_name] = {}
for target in targets:
testing_version = _strip_version_suffix(
testing_repo_data.get(target, {}).get(debian_pkg_name, None))
main_version = _strip_version_suffix(
main_repo_data.get(target, {}).get(debian_pkg_name, None))
affected_by_sync[pkg_name][target] = \
testing_version != main_version
return affected_by_sync
|
def get_regressions(
package_descriptors, targets,
building_repo_data, testing_repo_data, main_repo_data):
"""
For each package and target check if it is a regression.
This is the case if the main repo contains a package version which is
higher then in any of the other repos or if any of the other repos does not
contain that package at all.
:return: a dict indexed by package names containing
dicts indexed by targets containing a boolean flag
"""
regressions = {}
for package_descriptor in package_descriptors.values():
pkg_name = package_descriptor.pkg_name
debian_pkg_name = package_descriptor.debian_pkg_name
regressions[pkg_name] = {}
for target in targets:
regressions[pkg_name][target] = False
main_version = \
main_repo_data.get(target, {}).get(debian_pkg_name, None)
if main_version is not None:
main_ver_loose = LooseVersion(main_version)
for repo_data in [building_repo_data, testing_repo_data]:
version = \
repo_data.get(target, {}).get(debian_pkg_name, None)
if not version or main_ver_loose > LooseVersion(version):
regressions[pkg_name][target] = True
return regressions
|
def get_version_status(
package_descriptors, targets, repos_data,
strip_version=False, strip_os_code_name=False):
"""
For each package and target check if it is affected by a sync.
This is the case when the package version in the testing repo is different
from the version in the main repo.
:return: a dict indexed by package names containing
dicts indexed by targets containing
a list of status strings (one for each repo)
"""
status = {}
for package_descriptor in package_descriptors.values():
pkg_name = package_descriptor.pkg_name
debian_pkg_name = package_descriptor.debian_pkg_name
ref_version = package_descriptor.version
if strip_version:
ref_version = _strip_version_suffix(ref_version)
status[pkg_name] = {}
for target in targets:
statuses = []
for repo_data in repos_data:
version = repo_data.get(target, {}).get(debian_pkg_name, None)
if strip_version:
version = _strip_version_suffix(version)
if strip_os_code_name:
version = _strip_os_code_name_suffix(
version, target.os_code_name)
if ref_version:
if not version:
statuses.append('missing')
elif version.startswith(ref_version): # including equal
statuses.append('equal')
else:
if _version_is_gt_other(version, ref_version):
statuses.append('higher')
else:
statuses.append('lower')
else:
if not version:
statuses.append('ignore')
else:
statuses.append('obsolete')
status[pkg_name][target] = statuses
return status
|
def _strip_version_suffix(version):
"""
Remove trailing junk from the version number.
>>> strip_version_suffix('')
''
>>> strip_version_suffix('None')
'None'
>>> strip_version_suffix('1.2.3-4trusty-20140131-1359-+0000')
'1.2.3-4'
>>> strip_version_suffix('1.2.3-foo')
'1.2.3'
"""
global version_regex
if not version:
return version
match = version_regex.search(version)
return match.group(0) if match else version
|
def get_homogeneous(package_descriptors, targets, repos_data):
"""
For each package check if the version in one repo is equal for all targets.
The version could be different in different repos though.
:return: a dict indexed by package names containing a boolean flag
"""
homogeneous = {}
for package_descriptor in package_descriptors.values():
pkg_name = package_descriptor.pkg_name
debian_pkg_name = package_descriptor.debian_pkg_name
versions = []
for repo_data in repos_data:
versions.append(set([]))
for target in targets:
version = _strip_version_suffix(
repo_data.get(target, {}).get(debian_pkg_name, None))
versions[-1].add(version)
homogeneous[pkg_name] = max([len(v) for v in versions]) == 1
return homogeneous
|
def get_package_counts(package_descriptors, targets, repos_data):
"""
Get the number of packages per target and repository.
:return: a dict indexed by targets containing
a list of integer values (one for each repo)
"""
counts = {}
for target in targets:
counts[target] = [0] * len(repos_data)
for package_descriptor in package_descriptors.values():
debian_pkg_name = package_descriptor.debian_pkg_name
for target in targets:
for i, repo_data in enumerate(repos_data):
version = repo_data.get(target, {}).get(debian_pkg_name, None)
if version:
counts[target][i] += 1
return counts
|
def get_jenkins_job_urls(
rosdistro_name, jenkins_url, release_build_name, targets):
"""
Get the Jenkins job urls for each target.
The placeholder {pkg} needs to be replaced with the ROS package name.
:return: a dict indexed by targets containing a string
"""
urls = {}
for target in targets:
view_name = get_release_view_name(
rosdistro_name, release_build_name,
target.os_name, target.os_code_name, target.arch)
base_url = jenkins_url + '/view/%s/job/%s__{pkg}__' % \
(view_name, view_name)
if target.arch == 'source':
urls[target] = base_url + '%s_%s__source' % \
(target.os_name, target.os_code_name)
else:
urls[target] = base_url + '%s_%s_%s__binary' % \
(target.os_name, target.os_code_name, target.arch)
return urls
|
def configure_ci_jobs(
config_url, rosdistro_name, ci_build_name,
groovy_script=None, dry_run=False):
"""Configure all Jenkins CI jobs."""
config = get_config_index(config_url)
build_files = get_ci_build_files(config, rosdistro_name)
build_file = build_files[ci_build_name]
index = get_index(config.rosdistro_index_url)
# get targets
targets = []
for os_name in build_file.targets.keys():
for os_code_name in build_file.targets[os_name].keys():
for arch in build_file.targets[os_name][os_code_name]:
targets.append((os_name, os_code_name, arch))
print('The build file contains the following targets:')
for os_name, os_code_name, arch in targets:
print(' -', os_name, os_code_name, arch)
dist_file = get_distribution_file(index, rosdistro_name, build_file)
if not dist_file:
print('No distribution file matches the build file')
return
ci_view_name = get_ci_view_name(rosdistro_name)
# all further configuration will be handled by either the Jenkins API
# or by a generated groovy script
from ros_buildfarm.jenkins import connect
jenkins = connect(config.jenkins_url) if groovy_script is None else False
view_configs = {}
views = {
ci_view_name: configure_ci_view(
jenkins, ci_view_name, dry_run=dry_run)
}
if not jenkins:
view_configs.update(views)
groovy_data = {
'dry_run': dry_run,
'expected_num_views': len(view_configs),
}
ci_job_names = []
job_configs = OrderedDict()
is_disabled = False
for os_name, os_code_name, arch in targets:
try:
job_name, job_config = configure_ci_job(
config_url, rosdistro_name, ci_build_name,
os_name, os_code_name, arch,
config=config, build_file=build_file,
index=index, dist_file=dist_file,
jenkins=jenkins, views=views,
is_disabled=is_disabled,
groovy_script=groovy_script,
dry_run=dry_run,
trigger_timer=build_file.jenkins_job_schedule)
ci_job_names.append(job_name)
if groovy_script is not None:
print("Configuration for job '%s'" % job_name)
job_configs[job_name] = job_config
except JobValidationError as e:
print(e.message, file=sys.stderr)
groovy_data['expected_num_jobs'] = len(job_configs)
groovy_data['job_prefixes_and_names'] = {}
if groovy_script is not None:
print(
"Writing groovy script '%s' to reconfigure %d jobs" %
(groovy_script, len(job_configs)))
content = expand_template(
'snippet/reconfigure_jobs.groovy.em', groovy_data)
write_groovy_script_and_configs(
groovy_script, content, job_configs, view_configs)
|
def configure_ci_job(
config_url, rosdistro_name, ci_build_name,
os_name, os_code_name, arch,
config=None, build_file=None,
index=None, dist_file=None,
jenkins=None, views=None,
is_disabled=False,
groovy_script=None,
build_targets=None,
dry_run=False,
underlay_source_paths=None,
trigger_timer=None):
"""
Configure a single Jenkins CI job.
This includes the following steps:
- clone the ros_buildfarm repository
- write the distribution repository keys into files
- invoke the ci/run_ci_job.py script
"""
if config is None:
config = get_config_index(config_url)
if build_file is None:
build_files = get_ci_build_files(config, rosdistro_name)
build_file = build_files[ci_build_name]
# Overwrite build_file.targets if build_targets is specified
if build_targets is not None:
build_file.targets = build_targets
if index is None:
index = get_index(config.rosdistro_index_url)
if dist_file is None:
dist_file = get_distribution_file(index, rosdistro_name, build_file)
if not dist_file:
raise JobValidationError(
'No distribution file matches the build file')
if os_name not in build_file.targets.keys():
raise JobValidationError(
"Invalid OS name '%s' " % os_name +
'choose one of the following: ' +
', '.join(sorted(build_file.targets.keys())))
if os_code_name not in build_file.targets[os_name].keys():
raise JobValidationError(
"Invalid OS code name '%s' " % os_code_name +
'choose one of the following: ' +
', '.join(sorted(build_file.targets[os_name].keys())))
if arch not in build_file.targets[os_name][os_code_name]:
raise JobValidationError(
"Invalid architecture '%s' " % arch +
'choose one of the following: %s' % ', '.join(sorted(
build_file.targets[os_name][os_code_name])))
if len(build_file.underlay_from_ci_jobs) > 1:
raise JobValidationError(
'Only a single underlay job is currently supported, but the ' +
'build file lists %d.' % len(build_file.underlay_from_ci_jobs))
underlay_source_job = None
if build_file.underlay_from_ci_jobs:
underlay_source_job = get_ci_job_name(
rosdistro_name, os_name, os_code_name, arch,
build_file.underlay_from_ci_jobs[0])
underlay_source_paths = (underlay_source_paths or []) + \
['$UNDERLAY_JOB_SPACE']
if jenkins is None:
from ros_buildfarm.jenkins import connect
jenkins = connect(config.jenkins_url)
if views is None:
view_name = get_ci_view_name(rosdistro_name)
configure_ci_view(jenkins, view_name, dry_run=dry_run)
job_name = get_ci_job_name(
rosdistro_name, os_name, os_code_name, arch, ci_build_name)
job_config = _get_ci_job_config(
index, rosdistro_name, build_file, os_name,
os_code_name, arch,
build_file.repos_files,
underlay_source_job,
underlay_source_paths,
trigger_timer,
is_disabled=is_disabled)
# jenkinsapi.jenkins.Jenkins evaluates to false if job count is zero
if isinstance(jenkins, object) and jenkins is not False:
from ros_buildfarm.jenkins import configure_job
configure_job(jenkins, job_name, job_config, dry_run=dry_run)
return job_name, job_config
|
def write_groovy_script_and_configs(
filename, content, job_configs, view_configs=None):
"""Write out the groovy script and configs to file.
This writes the reconfigure script to the file location
and places the expanded configs in subdirectories 'view_configs' /
'job_configs' that the script can then access when run.
"""
with open(filename, 'w') as h:
h.write(content)
if view_configs:
view_config_dir = os.path.join(os.path.dirname(filename), 'view_configs')
if not os.path.isdir(view_config_dir):
os.makedirs(view_config_dir)
for config_name, config_body in view_configs.items():
config_filename = os.path.join(view_config_dir, config_name)
with open(config_filename, 'w') as config_fh:
config_fh.write(config_body)
job_config_dir = os.path.join(os.path.dirname(filename), 'job_configs')
if not os.path.isdir(job_config_dir):
os.makedirs(job_config_dir)
# prefix each config file with a serial number to maintain order
format_str = '%0' + str(len(str(len(job_configs)))) + 'd'
i = 0
for config_name, config_body in job_configs.items():
i += 1
config_filename = os.path.join(
job_config_dir,
format_str % i + ' ' + config_name)
with open(config_filename, 'w') as config_fh:
config_fh.write(config_body)
|
def topological_order_packages(packages):
"""
Order packages topologically.
First returning packages which have message generators and then
the rest based on all direct depends and indirect recursive run_depends.
:param packages: A dict mapping relative paths to ``Package`` objects ``dict``
:returns: A list of tuples containing the relative path and a ``Package`` object, ``list``
"""
from catkin_pkg.topological_order import _PackageDecorator
from catkin_pkg.topological_order import _sort_decorated_packages
decorators_by_name = {}
for path, package in packages.items():
decorators_by_name[package.name] = _PackageDecorator(package, path)
# calculate transitive dependencies
for decorator in decorators_by_name.values():
decorator.depends_for_topological_order = set([])
all_depends = \
decorator.package.build_depends + decorator.package.buildtool_depends + \
decorator.package.run_depends + decorator.package.test_depends
# skip external dependencies, meaning names that are not known packages
unique_depend_names = set([
d.name for d in all_depends if d.name in decorators_by_name.keys()])
for name in unique_depend_names:
if name in decorator.depends_for_topological_order:
# avoid function call to improve performance
# check within the loop since the set changes every cycle
continue
decorators_by_name[name]._add_recursive_run_depends(
decorators_by_name, decorator.depends_for_topological_order)
ordered_pkg_tuples = _sort_decorated_packages(decorators_by_name)
for pkg_path, pkg in ordered_pkg_tuples:
if pkg_path is None:
raise RuntimeError('Circular dependency in: %s' % pkg)
return ordered_pkg_tuples
|
def parse_public(data):
"""
Loads a public key from a DER or PEM-formatted file. Supports RSA, DSA and
EC public keys. For RSA keys, both the old RSAPublicKey and
SubjectPublicKeyInfo structures are supported. Also allows extracting a
public key from an X.509 certificate.
:param data:
A byte string to load the public key from
:raises:
ValueError - when the data does not appear to contain a public key
:return:
An asn1crypto.keys.PublicKeyInfo object
"""
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
key_type = None
# Appears to be PEM formatted
if data[0:5] == b'-----':
key_type, algo, data = _unarmor_pem(data)
if key_type == 'private key':
raise ValueError(pretty_message(
'''
The data specified does not appear to be a public key or
certificate, but rather a private key
'''
))
# When a public key returning from _unarmor_pem has a known algorithm
# of RSA, that means the DER structure is of the type RSAPublicKey, so
# we need to wrap it in the PublicKeyInfo structure.
if algo == 'rsa':
return keys.PublicKeyInfo.wrap(data, 'rsa')
if key_type is None or key_type == 'public key':
try:
pki = keys.PublicKeyInfo.load(data)
# Call .native to fully parse since asn1crypto is lazy
pki.native
return pki
except (ValueError):
pass # Data was not PublicKeyInfo
try:
rpk = keys.RSAPublicKey.load(data)
# Call .native to fully parse since asn1crypto is lazy
rpk.native
return keys.PublicKeyInfo.wrap(rpk, 'rsa')
except (ValueError):
pass # Data was not an RSAPublicKey
if key_type is None or key_type == 'certificate':
try:
parsed_cert = x509.Certificate.load(data)
key_info = parsed_cert['tbs_certificate']['subject_public_key_info']
return key_info
except (ValueError):
pass # Data was not a cert
raise ValueError('The data specified does not appear to be a known public key or certificate format')
|
def parse_certificate(data):
"""
Loads a certificate from a DER or PEM-formatted file. Supports X.509
certificates only.
:param data:
A byte string to load the certificate from
:raises:
ValueError - when the data does not appear to contain a certificate
:return:
An asn1crypto.x509.Certificate object
"""
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
key_type = None
# Appears to be PEM formatted
if data[0:5] == b'-----':
key_type, _, data = _unarmor_pem(data)
if key_type == 'private key':
raise ValueError(pretty_message(
'''
The data specified does not appear to be a certificate, but
rather a private key
'''
))
if key_type == 'public key':
raise ValueError(pretty_message(
'''
The data specified does not appear to be a certificate, but
rather a public key
'''
))
if key_type is None or key_type == 'certificate':
try:
return x509.Certificate.load(data)
except (ValueError):
pass # Data was not a Certificate
raise ValueError(pretty_message(
'''
The data specified does not appear to be a known certificate format
'''
))
|
def parse_private(data, password=None):
"""
Loads a private key from a DER or PEM-formatted file. Supports RSA, DSA and
EC private keys. Works with the follow formats:
- RSAPrivateKey (PKCS#1)
- ECPrivateKey (SECG SEC1 V2)
- DSAPrivateKey (OpenSSL)
- PrivateKeyInfo (RSA/DSA/EC - PKCS#8)
- EncryptedPrivateKeyInfo (RSA/DSA/EC - PKCS#8)
- Encrypted RSAPrivateKey (PEM only, OpenSSL)
- Encrypted DSAPrivateKey (PEM only, OpenSSL)
- Encrypted ECPrivateKey (PEM only, OpenSSL)
:param data:
A byte string to load the private key from
:param password:
The password to unencrypt the private key
:raises:
ValueError - when the data does not appear to contain a private key, or the password is invalid
:return:
An asn1crypto.keys.PrivateKeyInfo object
"""
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
if password is not None:
if not isinstance(password, byte_cls):
raise TypeError(pretty_message(
'''
password must be a byte string, not %s
''',
type_name(password)
))
else:
password = b''
# Appears to be PEM formatted
if data[0:5] == b'-----':
key_type, _, data = _unarmor_pem(data, password)
if key_type == 'public key':
raise ValueError(pretty_message(
'''
The data specified does not appear to be a private key, but
rather a public key
'''
))
if key_type == 'certificate':
raise ValueError(pretty_message(
'''
The data specified does not appear to be a private key, but
rather a certificate
'''
))
try:
pki = keys.PrivateKeyInfo.load(data)
# Call .native to fully parse since asn1crypto is lazy
pki.native
return pki
except (ValueError):
pass # Data was not PrivateKeyInfo
try:
parsed_wrapper = keys.EncryptedPrivateKeyInfo.load(data)
encryption_algorithm_info = parsed_wrapper['encryption_algorithm']
encrypted_data = parsed_wrapper['encrypted_data'].native
decrypted_data = _decrypt_encrypted_data(encryption_algorithm_info, encrypted_data, password)
pki = keys.PrivateKeyInfo.load(decrypted_data)
# Call .native to fully parse since asn1crypto is lazy
pki.native
return pki
except (ValueError):
pass # Data was not EncryptedPrivateKeyInfo
try:
parsed = keys.RSAPrivateKey.load(data)
# Call .native to fully parse since asn1crypto is lazy
parsed.native
return keys.PrivateKeyInfo.wrap(parsed, 'rsa')
except (ValueError):
pass # Data was not an RSAPrivateKey
try:
parsed = keys.DSAPrivateKey.load(data)
# Call .native to fully parse since asn1crypto is lazy
parsed.native
return keys.PrivateKeyInfo.wrap(parsed, 'dsa')
except (ValueError):
pass # Data was not a DSAPrivateKey
try:
parsed = keys.ECPrivateKey.load(data)
# Call .native to fully parse since asn1crypto is lazy
parsed.native
return keys.PrivateKeyInfo.wrap(parsed, 'ec')
except (ValueError):
pass # Data was not an ECPrivateKey
raise ValueError(pretty_message(
'''
The data specified does not appear to be a known private key format
'''
))
|
def _unarmor_pem(data, password=None):
"""
Removes PEM-encoding from a public key, private key or certificate. If the
private key is encrypted, the password will be used to decrypt it.
:param data:
A byte string of the PEM-encoded data
:param password:
A byte string of the encryption password, or None
:return:
A 3-element tuple in the format: (key_type, algorithm, der_bytes). The
key_type will be a unicode string of "public key", "private key" or
"certificate". The algorithm will be a unicode string of "rsa", "dsa"
or "ec".
"""
object_type, headers, der_bytes = pem.unarmor(data)
type_regex = '^((DSA|EC|RSA) PRIVATE KEY|ENCRYPTED PRIVATE KEY|PRIVATE KEY|PUBLIC KEY|RSA PUBLIC KEY|CERTIFICATE)'
armor_type = re.match(type_regex, object_type)
if not armor_type:
raise ValueError(pretty_message(
'''
data does not seem to contain a PEM-encoded certificate, private
key or public key
'''
))
pem_header = armor_type.group(1)
data = data.strip()
# RSA private keys are encrypted after being DER-encoded, but before base64
# encoding, so they need to be hanlded specially
if pem_header in set(['RSA PRIVATE KEY', 'DSA PRIVATE KEY', 'EC PRIVATE KEY']):
algo = armor_type.group(2).lower()
return ('private key', algo, _unarmor_pem_openssl_private(headers, der_bytes, password))
key_type = pem_header.lower()
algo = None
if key_type == 'encrypted private key':
key_type = 'private key'
elif key_type == 'rsa public key':
key_type = 'public key'
algo = 'rsa'
return (key_type, algo, der_bytes)
|
def _unarmor_pem_openssl_private(headers, data, password):
"""
Parses a PKCS#1 private key, or encrypted private key
:param headers:
A dict of "Name: Value" lines from right after the PEM header
:param data:
A byte string of the DER-encoded PKCS#1 private key
:param password:
A byte string of the password to use if the private key is encrypted
:return:
A byte string of the DER-encoded private key
"""
enc_algo = None
enc_iv_hex = None
enc_iv = None
if 'DEK-Info' in headers:
params = headers['DEK-Info']
if params.find(',') != -1:
enc_algo, enc_iv_hex = params.strip().split(',')
else:
enc_algo = 'RC4'
if not enc_algo:
return data
if enc_iv_hex:
enc_iv = binascii.unhexlify(enc_iv_hex.encode('ascii'))
enc_algo = enc_algo.lower()
enc_key_length = {
'aes-128-cbc': 16,
'aes-128': 16,
'aes-192-cbc': 24,
'aes-192': 24,
'aes-256-cbc': 32,
'aes-256': 32,
'rc4': 16,
'rc4-64': 8,
'rc4-40': 5,
'rc2-64-cbc': 8,
'rc2-40-cbc': 5,
'rc2-cbc': 16,
'rc2': 16,
'des-ede3-cbc': 24,
'des-ede3': 24,
'des3': 24,
'des-ede-cbc': 16,
'des-cbc': 8,
'des': 8,
}[enc_algo]
enc_key = hashlib.md5(password + enc_iv[0:8]).digest()
while enc_key_length > len(enc_key):
enc_key += hashlib.md5(enc_key + password + enc_iv[0:8]).digest()
enc_key = enc_key[0:enc_key_length]
enc_algo_name = {
'aes-128-cbc': 'aes',
'aes-128': 'aes',
'aes-192-cbc': 'aes',
'aes-192': 'aes',
'aes-256-cbc': 'aes',
'aes-256': 'aes',
'rc4': 'rc4',
'rc4-64': 'rc4',
'rc4-40': 'rc4',
'rc2-64-cbc': 'rc2',
'rc2-40-cbc': 'rc2',
'rc2-cbc': 'rc2',
'rc2': 'rc2',
'des-ede3-cbc': 'tripledes',
'des-ede3': 'tripledes',
'des3': 'tripledes',
'des-ede-cbc': 'tripledes',
'des-cbc': 'des',
'des': 'des',
}[enc_algo]
decrypt_func = crypto_funcs[enc_algo_name]
if enc_algo_name == 'rc4':
return decrypt_func(enc_key, data)
return decrypt_func(enc_key, data, enc_iv)
|
def parse_pkcs12(data, password=None):
"""
Parses a PKCS#12 ANS.1 DER-encoded structure and extracts certs and keys
:param data:
A byte string of a DER-encoded PKCS#12 file
:param password:
A byte string of the password to any encrypted data
:raises:
ValueError - when any of the parameters are of the wrong type or value
OSError - when an error is returned by one of the OS decryption functions
:return:
A three-element tuple of:
1. An asn1crypto.keys.PrivateKeyInfo object
2. An asn1crypto.x509.Certificate object
3. A list of zero or more asn1crypto.x509.Certificate objects that are
"extra" certificates, possibly intermediates from the cert chain
"""
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
if password is not None:
if not isinstance(password, byte_cls):
raise TypeError(pretty_message(
'''
password must be a byte string, not %s
''',
type_name(password)
))
else:
password = b''
certs = {}
private_keys = {}
pfx = pkcs12.Pfx.load(data)
auth_safe = pfx['auth_safe']
if auth_safe['content_type'].native != 'data':
raise ValueError(pretty_message(
'''
Only password-protected PKCS12 files are currently supported
'''
))
authenticated_safe = pfx.authenticated_safe
mac_data = pfx['mac_data']
if mac_data:
mac_algo = mac_data['mac']['digest_algorithm']['algorithm'].native
key_length = {
'sha1': 20,
'sha224': 28,
'sha256': 32,
'sha384': 48,
'sha512': 64,
'sha512_224': 28,
'sha512_256': 32,
}[mac_algo]
mac_key = pkcs12_kdf(
mac_algo,
password,
mac_data['mac_salt'].native,
mac_data['iterations'].native,
key_length,
3 # ID 3 is for generating an HMAC key
)
hash_mod = getattr(hashlib, mac_algo)
computed_hmac = hmac.new(mac_key, auth_safe['content'].contents, hash_mod).digest()
stored_hmac = mac_data['mac']['digest'].native
if not constant_compare(computed_hmac, stored_hmac):
raise ValueError('Password provided is invalid')
for content_info in authenticated_safe:
content = content_info['content']
if isinstance(content, core.OctetString):
_parse_safe_contents(content.native, certs, private_keys, password)
elif isinstance(content, cms.EncryptedData):
encrypted_content_info = content['encrypted_content_info']
encryption_algorithm_info = encrypted_content_info['content_encryption_algorithm']
encrypted_content = encrypted_content_info['encrypted_content'].native
decrypted_content = _decrypt_encrypted_data(encryption_algorithm_info, encrypted_content, password)
_parse_safe_contents(decrypted_content, certs, private_keys, password)
else:
raise ValueError(pretty_message(
'''
Public-key-based PKCS12 files are not currently supported
'''
))
key_fingerprints = set(private_keys.keys())
cert_fingerprints = set(certs.keys())
common_fingerprints = sorted(list(key_fingerprints & cert_fingerprints))
key = None
cert = None
other_certs = []
if len(common_fingerprints) >= 1:
fingerprint = common_fingerprints[0]
key = private_keys[fingerprint]
cert = certs[fingerprint]
other_certs = [certs[f] for f in certs if f != fingerprint]
return (key, cert, other_certs)
if len(private_keys) > 0:
first_key = sorted(list(private_keys.keys()))[0]
key = private_keys[first_key]
if len(certs) > 0:
first_key = sorted(list(certs.keys()))[0]
cert = certs[first_key]
del certs[first_key]
if len(certs) > 0:
other_certs = sorted(list(certs.values()))
return (key, cert, other_certs)
|
def _parse_safe_contents(safe_contents, certs, private_keys, password):
"""
Parses a SafeContents PKCS#12 ANS.1 structure and extracts certs and keys
:param safe_contents:
A byte string of ber-encoded SafeContents, or a asn1crypto.pkcs12.SafeContents
parsed object
:param certs:
A dict to store certificates in
:param keys:
A dict to store keys in
:param password:
A byte string of the password to any encrypted data
"""
if isinstance(safe_contents, byte_cls):
safe_contents = pkcs12.SafeContents.load(safe_contents)
for safe_bag in safe_contents:
bag_value = safe_bag['bag_value']
if isinstance(bag_value, pkcs12.CertBag):
if bag_value['cert_id'].native == 'x509':
cert = bag_value['cert_value'].parsed
public_key_info = cert['tbs_certificate']['subject_public_key_info']
certs[public_key_info.fingerprint] = bag_value['cert_value'].parsed
elif isinstance(bag_value, keys.PrivateKeyInfo):
private_keys[bag_value.fingerprint] = bag_value
elif isinstance(bag_value, keys.EncryptedPrivateKeyInfo):
encryption_algorithm_info = bag_value['encryption_algorithm']
encrypted_key_bytes = bag_value['encrypted_data'].native
decrypted_key_bytes = _decrypt_encrypted_data(encryption_algorithm_info, encrypted_key_bytes, password)
private_key = keys.PrivateKeyInfo.load(decrypted_key_bytes)
private_keys[private_key.fingerprint] = private_key
elif isinstance(bag_value, pkcs12.SafeContents):
_parse_safe_contents(bag_value, certs, private_keys, password)
else:
# We don't care about CRL bags or secret bags
pass
|
def _decrypt_encrypted_data(encryption_algorithm_info, encrypted_content, password):
"""
Decrypts encrypted ASN.1 data
:param encryption_algorithm_info:
An instance of asn1crypto.pkcs5.Pkcs5EncryptionAlgorithm
:param encrypted_content:
A byte string of the encrypted content
:param password:
A byte string of the encrypted content's password
:return:
A byte string of the decrypted plaintext
"""
decrypt_func = crypto_funcs[encryption_algorithm_info.encryption_cipher]
# Modern, PKCS#5 PBES2-based encryption
if encryption_algorithm_info.kdf == 'pbkdf2':
if encryption_algorithm_info.encryption_cipher == 'rc5':
raise ValueError(pretty_message(
'''
PBES2 encryption scheme utilizing RC5 encryption is not supported
'''
))
enc_key = pbkdf2(
encryption_algorithm_info.kdf_hmac,
password,
encryption_algorithm_info.kdf_salt,
encryption_algorithm_info.kdf_iterations,
encryption_algorithm_info.key_length
)
enc_iv = encryption_algorithm_info.encryption_iv
plaintext = decrypt_func(enc_key, encrypted_content, enc_iv)
elif encryption_algorithm_info.kdf == 'pbkdf1':
derived_output = pbkdf1(
encryption_algorithm_info.kdf_hmac,
password,
encryption_algorithm_info.kdf_salt,
encryption_algorithm_info.kdf_iterations,
encryption_algorithm_info.key_length + 8
)
enc_key = derived_output[0:8]
enc_iv = derived_output[8:16]
plaintext = decrypt_func(enc_key, encrypted_content, enc_iv)
elif encryption_algorithm_info.kdf == 'pkcs12_kdf':
enc_key = pkcs12_kdf(
encryption_algorithm_info.kdf_hmac,
password,
encryption_algorithm_info.kdf_salt,
encryption_algorithm_info.kdf_iterations,
encryption_algorithm_info.key_length,
1 # ID 1 is for generating a key
)
# Since RC4 is a stream cipher, we don't use an IV
if encryption_algorithm_info.encryption_cipher == 'rc4':
plaintext = decrypt_func(enc_key, encrypted_content)
else:
enc_iv = pkcs12_kdf(
encryption_algorithm_info.kdf_hmac,
password,
encryption_algorithm_info.kdf_salt,
encryption_algorithm_info.kdf_iterations,
encryption_algorithm_info.encryption_block_size,
2 # ID 2 is for generating an IV
)
plaintext = decrypt_func(enc_key, encrypted_content, enc_iv)
return plaintext
|
def aes_cbc_no_padding_decrypt(key, data, iv):
"""
Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key and no
padding.
:param key:
The encryption key - a byte string either 16, 24 or 32 bytes long
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector - a byte string 16-bytes long
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by OpenSSL
:return:
A byte string of the plaintext
"""
cipher = _calculate_aes_cipher(key)
if len(iv) != 16:
raise ValueError(pretty_message(
'''
iv must be 16 bytes long - is %s
''',
len(iv)
))
return _decrypt(cipher, key, data, iv, False)
|
def aes_cbc_pkcs7_encrypt(key, data, iv):
"""
Encrypts plaintext using AES in CBC mode with a 128, 192 or 256 bit key and
PKCS#7 padding.
:param key:
The encryption key - a byte string either 16, 24 or 32 bytes long
:param data:
The plaintext - a byte string
:param iv:
The initialization vector - either a byte string 16-bytes long or None
to generate an IV
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by OpenSSL
:return:
A tuple of two byte strings (iv, ciphertext)
"""
cipher = _calculate_aes_cipher(key)
if not iv:
iv = rand_bytes(16)
elif len(iv) != 16:
raise ValueError(pretty_message(
'''
iv must be 16 bytes long - is %s
''',
len(iv)
))
return (iv, _encrypt(cipher, key, data, iv, True))
|
def aes_cbc_pkcs7_decrypt(key, data, iv):
"""
Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key
:param key:
The encryption key - a byte string either 16, 24 or 32 bytes long
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector - a byte string 16-bytes long
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by OpenSSL
:return:
A byte string of the plaintext
"""
cipher = _calculate_aes_cipher(key)
if len(iv) != 16:
raise ValueError(pretty_message(
'''
iv must be 16 bytes long - is %s
''',
len(iv)
))
return _decrypt(cipher, key, data, iv, True)
|
def _calculate_aes_cipher(key):
"""
Determines if the key is a valid AES 128, 192 or 256 key
:param key:
A byte string of the key to use
:raises:
ValueError - when an invalid key is provided
:return:
A unicode string of the AES variation - "aes128", "aes192" or "aes256"
"""
if len(key) not in [16, 24, 32]:
raise ValueError(pretty_message(
'''
key must be either 16, 24 or 32 bytes (128, 192 or 256 bits)
long - is %s
''',
len(key)
))
if len(key) == 16:
cipher = 'aes128'
elif len(key) == 24:
cipher = 'aes192'
elif len(key) == 32:
cipher = 'aes256'
return cipher
|
def rc4_encrypt(key, data):
"""
Encrypts plaintext using RC4 with a 40-128 bit key
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The plaintext - a byte string
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by OpenSSL
:return:
A byte string of the ciphertext
"""
if len(key) < 5 or len(key) > 16:
raise ValueError(pretty_message(
'''
key must be 5 to 16 bytes (40 to 128 bits) long - is %s
''',
len(key)
))
return _encrypt('rc4', key, data, None, None)
|
def rc4_decrypt(key, data):
"""
Decrypts RC4 ciphertext using a 40-128 bit key
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The ciphertext - a byte string
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by OpenSSL
:return:
A byte string of the plaintext
"""
if len(key) < 5 or len(key) > 16:
raise ValueError(pretty_message(
'''
key must be 5 to 16 bytes (40 to 128 bits) long - is %s
''',
len(key)
))
return _decrypt('rc4', key, data, None, None)
|
def tripledes_cbc_pkcs5_decrypt(key, data, iv):
"""
Decrypts 3DES ciphertext in CBC mode using either the 2 or 3 key variant
(16 or 24 byte long key) and PKCS#5 padding.
:param key:
The encryption key - a byte string 16 or 24 bytes long (2 or 3 key mode)
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector - a byte string 8-bytes long
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by OpenSSL
:return:
A byte string of the plaintext
"""
if len(key) != 16 and len(key) != 24:
raise ValueError(pretty_message(
'''
key must be 16 bytes (2 key) or 24 bytes (3 key) long - is %s
''',
len(key)
))
if len(iv) != 8:
raise ValueError(pretty_message(
'''
iv must be 8 bytes long - is %s
''',
len(iv)
))
cipher = 'tripledes_3key'
# Expand 2-key to actual 24 byte byte string used by cipher
if len(key) == 16:
key = key + key[0:8]
cipher = 'tripledes_2key'
return _decrypt(cipher, key, data, iv, True)
|
def des_cbc_pkcs5_decrypt(key, data, iv):
"""
Decrypts DES ciphertext in CBC mode using a 56 bit key and PKCS#5 padding.
:param key:
The encryption key - a byte string 8 bytes long (includes error correction bits)
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector - a byte string 8-bytes long
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by OpenSSL
:return:
A byte string of the plaintext
"""
if len(key) != 8:
raise ValueError(pretty_message(
'''
key must be 8 bytes (56 bits + 8 parity bits) long - is %s
''',
len(key)
))
if len(iv) != 8:
raise ValueError(pretty_message(
'''
iv must be 8 bytes long - is %s
''',
len(iv)
))
return _decrypt('des', key, data, iv, True)
|
def _encrypt(cipher, key, data, iv, padding):
"""
Encrypts plaintext
:param cipher:
A unicode string of "aes128", "aes192", "aes256", "des",
"tripledes_2key", "tripledes_3key", "rc2", "rc4"
:param key:
The encryption key - a byte string 5-32 bytes long
:param data:
The plaintext - a byte string
:param iv:
The initialization vector - a byte string - unused for RC4
:param padding:
Boolean, if padding should be used - unused for RC4
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by OpenSSL
:return:
A byte string of the ciphertext
"""
if not isinstance(key, byte_cls):
raise TypeError(pretty_message(
'''
key must be a byte string, not %s
''',
type_name(key)
))
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
if cipher != 'rc4' and not isinstance(iv, byte_cls):
raise TypeError(pretty_message(
'''
iv must be a byte string, not %s
''',
type_name(iv)
))
if cipher != 'rc4' and not padding:
raise ValueError('padding must be specified')
evp_cipher_ctx = None
try:
evp_cipher_ctx = libcrypto.EVP_CIPHER_CTX_new()
if is_null(evp_cipher_ctx):
handle_openssl_error(0)
evp_cipher, buffer_size = _setup_evp_encrypt_decrypt(cipher, data)
if iv is None:
iv = null()
if cipher in set(['rc2', 'rc4']):
res = libcrypto.EVP_EncryptInit_ex(evp_cipher_ctx, evp_cipher, null(), null(), null())
handle_openssl_error(res)
res = libcrypto.EVP_CIPHER_CTX_set_key_length(evp_cipher_ctx, len(key))
handle_openssl_error(res)
if cipher == 'rc2':
res = libcrypto.EVP_CIPHER_CTX_ctrl(
evp_cipher_ctx,
LibcryptoConst.EVP_CTRL_SET_RC2_KEY_BITS,
len(key) * 8,
null()
)
handle_openssl_error(res)
evp_cipher = null()
res = libcrypto.EVP_EncryptInit_ex(evp_cipher_ctx, evp_cipher, null(), key, iv)
handle_openssl_error(res)
if padding is not None:
res = libcrypto.EVP_CIPHER_CTX_set_padding(evp_cipher_ctx, int(padding))
handle_openssl_error(res)
buffer = buffer_from_bytes(buffer_size)
output_length = new(libcrypto, 'int *')
res = libcrypto.EVP_EncryptUpdate(evp_cipher_ctx, buffer, output_length, data, len(data))
handle_openssl_error(res)
output = bytes_from_buffer(buffer, deref(output_length))
res = libcrypto.EVP_EncryptFinal_ex(evp_cipher_ctx, buffer, output_length)
handle_openssl_error(res)
output += bytes_from_buffer(buffer, deref(output_length))
return output
finally:
if evp_cipher_ctx:
libcrypto.EVP_CIPHER_CTX_free(evp_cipher_ctx)
|
def _setup_evp_encrypt_decrypt(cipher, data):
"""
Creates an EVP_CIPHER pointer object and determines the buffer size
necessary for the parameter specified.
:param evp_cipher_ctx:
An EVP_CIPHER_CTX pointer
:param cipher:
A unicode string of "aes128", "aes192", "aes256", "des",
"tripledes_2key", "tripledes_3key", "rc2", "rc4"
:param key:
The key byte string
:param data:
The plaintext or ciphertext as a byte string
:param padding:
If padding is to be used
:return:
A 2-element tuple with the first element being an EVP_CIPHER pointer
and the second being an integer that is the required buffer size
"""
evp_cipher = {
'aes128': libcrypto.EVP_aes_128_cbc,
'aes192': libcrypto.EVP_aes_192_cbc,
'aes256': libcrypto.EVP_aes_256_cbc,
'rc2': libcrypto.EVP_rc2_cbc,
'rc4': libcrypto.EVP_rc4,
'des': libcrypto.EVP_des_cbc,
'tripledes_2key': libcrypto.EVP_des_ede_cbc,
'tripledes_3key': libcrypto.EVP_des_ede3_cbc,
}[cipher]()
if cipher == 'rc4':
buffer_size = len(data)
else:
block_size = {
'aes128': 16,
'aes192': 16,
'aes256': 16,
'rc2': 8,
'des': 8,
'tripledes_2key': 8,
'tripledes_3key': 8,
}[cipher]
buffer_size = block_size * int(math.ceil(len(data) / block_size))
return (evp_cipher, buffer_size)
|
def handle_error(result):
"""
Extracts the last Windows error message into a python unicode string
:param result:
A function result, 0 or None indicates failure
:return:
A unicode string error message
"""
if result:
return
_, error_string = get_error()
if not isinstance(error_string, str_cls):
error_string = _try_decode(error_string)
raise OSError(error_string)
|
def handle_error(result, exception_class=None):
"""
Extracts the last Windows error message into a python unicode string
:param result:
A function result, 0 or None indicates failure
:param exception_class:
The exception class to use for the exception if an error occurred
:return:
A unicode string error message
"""
if result == 0:
return
if result == Secur32Const.SEC_E_OUT_OF_SEQUENCE:
raise TLSError('A packet was received out of order')
if result == Secur32Const.SEC_E_MESSAGE_ALTERED:
raise TLSError('A packet was received altered')
if result == Secur32Const.SEC_E_CONTEXT_EXPIRED:
raise TLSError('The TLS session expired')
_, error_string = get_error()
if not isinstance(error_string, str_cls):
error_string = _try_decode(error_string)
if exception_class is None:
exception_class = OSError
raise exception_class(('SECURITY_STATUS error 0x%0.2X: ' % result) + error_string)
|
def generate_pair(algorithm, bit_size=None, curve=None):
"""
Generates a public/private key pair
:param algorithm:
The key algorithm - "rsa", "dsa" or "ec"
:param bit_size:
An integer - used for "rsa" and "dsa". For "rsa" the value maye be 1024,
2048, 3072 or 4096. For "dsa" the value may be 1024, plus 2048 or 3072
if OpenSSL 1.0.0 or newer is available.
:param curve:
A unicode string - used for "ec" keys. Valid values include "secp256r1",
"secp384r1" and "secp521r1".
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A 2-element tuple of (PublicKey, PrivateKey). The contents of each key
may be saved by calling .asn1.dump().
"""
if algorithm not in set(['rsa', 'dsa', 'ec']):
raise ValueError(pretty_message(
'''
algorithm must be one of "rsa", "dsa", "ec", not %s
''',
repr(algorithm)
))
if algorithm == 'rsa':
if bit_size not in set([1024, 2048, 3072, 4096]):
raise ValueError(pretty_message(
'''
bit_size must be one of 1024, 2048, 3072, 4096, not %s
''',
repr(bit_size)
))
elif algorithm == 'dsa':
if libcrypto_version_info < (1,):
if bit_size != 1024:
raise ValueError(pretty_message(
'''
bit_size must be 1024, not %s
''',
repr(bit_size)
))
else:
if bit_size not in set([1024, 2048, 3072]):
raise ValueError(pretty_message(
'''
bit_size must be one of 1024, 2048, 3072, not %s
''',
repr(bit_size)
))
elif algorithm == 'ec':
if curve not in set(['secp256r1', 'secp384r1', 'secp521r1']):
raise ValueError(pretty_message(
'''
curve must be one of "secp256r1", "secp384r1", "secp521r1",
not %s
''',
repr(curve)
))
if algorithm == 'rsa':
rsa = None
exponent = None
try:
rsa = libcrypto.RSA_new()
if is_null(rsa):
handle_openssl_error(0)
exponent_pointer = new(libcrypto, 'BIGNUM **')
result = libcrypto.BN_dec2bn(exponent_pointer, b'65537')
handle_openssl_error(result)
exponent = unwrap(exponent_pointer)
result = libcrypto.RSA_generate_key_ex(rsa, bit_size, exponent, null())
handle_openssl_error(result)
buffer_length = libcrypto.i2d_RSAPublicKey(rsa, null())
if buffer_length < 0:
handle_openssl_error(buffer_length)
buffer = buffer_from_bytes(buffer_length)
result = libcrypto.i2d_RSAPublicKey(rsa, buffer_pointer(buffer))
if result < 0:
handle_openssl_error(result)
public_key_bytes = bytes_from_buffer(buffer, buffer_length)
buffer_length = libcrypto.i2d_RSAPrivateKey(rsa, null())
if buffer_length < 0:
handle_openssl_error(buffer_length)
buffer = buffer_from_bytes(buffer_length)
result = libcrypto.i2d_RSAPrivateKey(rsa, buffer_pointer(buffer))
if result < 0:
handle_openssl_error(result)
private_key_bytes = bytes_from_buffer(buffer, buffer_length)
finally:
if rsa:
libcrypto.RSA_free(rsa)
if exponent:
libcrypto.BN_free(exponent)
elif algorithm == 'dsa':
dsa = None
try:
dsa = libcrypto.DSA_new()
if is_null(dsa):
handle_openssl_error(0)
result = libcrypto.DSA_generate_parameters_ex(dsa, bit_size, null(), 0, null(), null(), null())
handle_openssl_error(result)
result = libcrypto.DSA_generate_key(dsa)
handle_openssl_error(result)
buffer_length = libcrypto.i2d_DSA_PUBKEY(dsa, null())
if buffer_length < 0:
handle_openssl_error(buffer_length)
buffer = buffer_from_bytes(buffer_length)
result = libcrypto.i2d_DSA_PUBKEY(dsa, buffer_pointer(buffer))
if result < 0:
handle_openssl_error(result)
public_key_bytes = bytes_from_buffer(buffer, buffer_length)
buffer_length = libcrypto.i2d_DSAPrivateKey(dsa, null())
if buffer_length < 0:
handle_openssl_error(buffer_length)
buffer = buffer_from_bytes(buffer_length)
result = libcrypto.i2d_DSAPrivateKey(dsa, buffer_pointer(buffer))
if result < 0:
handle_openssl_error(result)
private_key_bytes = bytes_from_buffer(buffer, buffer_length)
finally:
if dsa:
libcrypto.DSA_free(dsa)
elif algorithm == 'ec':
ec_key = None
try:
curve_id = {
'secp256r1': LibcryptoConst.NID_X9_62_prime256v1,
'secp384r1': LibcryptoConst.NID_secp384r1,
'secp521r1': LibcryptoConst.NID_secp521r1,
}[curve]
ec_key = libcrypto.EC_KEY_new_by_curve_name(curve_id)
if is_null(ec_key):
handle_openssl_error(0)
result = libcrypto.EC_KEY_generate_key(ec_key)
handle_openssl_error(result)
libcrypto.EC_KEY_set_asn1_flag(ec_key, LibcryptoConst.OPENSSL_EC_NAMED_CURVE)
buffer_length = libcrypto.i2o_ECPublicKey(ec_key, null())
if buffer_length < 0:
handle_openssl_error(buffer_length)
buffer = buffer_from_bytes(buffer_length)
result = libcrypto.i2o_ECPublicKey(ec_key, buffer_pointer(buffer))
if result < 0:
handle_openssl_error(result)
public_key_point_bytes = bytes_from_buffer(buffer, buffer_length)
# i2o_ECPublicKey only returns the ECPoint bytes, so we have to
# manually wrap it in a PublicKeyInfo structure to get it to parse
public_key = keys.PublicKeyInfo({
'algorithm': keys.PublicKeyAlgorithm({
'algorithm': 'ec',
'parameters': keys.ECDomainParameters(
name='named',
value=curve
)
}),
'public_key': public_key_point_bytes
})
public_key_bytes = public_key.dump()
buffer_length = libcrypto.i2d_ECPrivateKey(ec_key, null())
if buffer_length < 0:
handle_openssl_error(buffer_length)
buffer = buffer_from_bytes(buffer_length)
result = libcrypto.i2d_ECPrivateKey(ec_key, buffer_pointer(buffer))
if result < 0:
handle_openssl_error(result)
private_key_bytes = bytes_from_buffer(buffer, buffer_length)
finally:
if ec_key:
libcrypto.EC_KEY_free(ec_key)
return (load_public_key(public_key_bytes), load_private_key(private_key_bytes))
|
def generate_dh_parameters(bit_size):
"""
Generates DH parameters for use with Diffie-Hellman key exchange. Returns
a structure in the format of DHParameter defined in PKCS#3, which is also
used by the OpenSSL dhparam tool.
THIS CAN BE VERY TIME CONSUMING!
:param bit_size:
The integer bit size of the parameters to generate. Must be between 512
and 4096, and divisible by 64. Recommended secure value as of early 2016
is 2048, with an absolute minimum of 1024.
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
An asn1crypto.algos.DHParameters object. Use
oscrypto.asymmetric.dump_dh_parameters() to save to disk for usage with
web servers.
"""
if not isinstance(bit_size, int_types):
raise TypeError(pretty_message(
'''
bit_size must be an integer, not %s
''',
type_name(bit_size)
))
if bit_size < 512:
raise ValueError('bit_size must be greater than or equal to 512')
if bit_size > 4096:
raise ValueError('bit_size must be less than or equal to 4096')
if bit_size % 64 != 0:
raise ValueError('bit_size must be a multiple of 64')
dh = None
try:
dh = libcrypto.DH_new()
if is_null(dh):
handle_openssl_error(0)
result = libcrypto.DH_generate_parameters_ex(dh, bit_size, LibcryptoConst.DH_GENERATOR_2, null())
handle_openssl_error(result)
buffer_length = libcrypto.i2d_DHparams(dh, null())
if buffer_length < 0:
handle_openssl_error(buffer_length)
buffer = buffer_from_bytes(buffer_length)
result = libcrypto.i2d_DHparams(dh, buffer_pointer(buffer))
if result < 0:
handle_openssl_error(result)
dh_params_bytes = bytes_from_buffer(buffer, buffer_length)
return algos.DHParameters.load(dh_params_bytes)
finally:
if dh:
libcrypto.DH_free(dh)
|
def load_certificate(source):
"""
Loads an x509 certificate into a Certificate object
:param source:
A byte string of file contents, a unicode string filename or an
asn1crypto.x509.Certificate object
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A Certificate object
"""
if isinstance(source, asn1x509.Certificate):
certificate = source
elif isinstance(source, byte_cls):
certificate = parse_certificate(source)
elif isinstance(source, str_cls):
with open(source, 'rb') as f:
certificate = parse_certificate(f.read())
else:
raise TypeError(pretty_message(
'''
source must be a byte string, unicode string or
asn1crypto.x509.Certificate object, not %s
''',
type_name(source)
))
return _load_x509(certificate)
|
def _load_x509(certificate):
"""
Loads an ASN.1 object of an x509 certificate into a Certificate object
:param certificate:
An asn1crypto.x509.Certificate object
:return:
A Certificate object
"""
source = certificate.dump()
buffer = buffer_from_bytes(source)
evp_pkey = libcrypto.d2i_X509(null(), buffer_pointer(buffer), len(source))
if is_null(evp_pkey):
handle_openssl_error(0)
return Certificate(evp_pkey, certificate)
|
def load_private_key(source, password=None):
"""
Loads a private key into a PrivateKey object
:param source:
A byte string of file contents, a unicode string filename or an
asn1crypto.keys.PrivateKeyInfo object
:param password:
A byte or unicode string to decrypt the private key file. Unicode
strings will be encoded using UTF-8. Not used is the source is a
PrivateKeyInfo object.
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
oscrypto.errors.AsymmetricKeyError - when the private key is incompatible with the OS crypto library
OSError - when an error is returned by the OS crypto library
:return:
A PrivateKey object
"""
if isinstance(source, keys.PrivateKeyInfo):
private_object = source
else:
if password is not None:
if isinstance(password, str_cls):
password = password.encode('utf-8')
if not isinstance(password, byte_cls):
raise TypeError(pretty_message(
'''
password must be a byte string, not %s
''',
type_name(password)
))
if isinstance(source, str_cls):
with open(source, 'rb') as f:
source = f.read()
elif not isinstance(source, byte_cls):
raise TypeError(pretty_message(
'''
source must be a byte string, unicode string or
asn1crypto.keys.PrivateKeyInfo object, not %s
''',
type_name(source)
))
private_object = parse_private(source, password)
return _load_key(private_object)
|
def load_public_key(source):
"""
Loads a public key into a PublicKey object
:param source:
A byte string of file contents, a unicode string filename or an
asn1crypto.keys.PublicKeyInfo object
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
oscrypto.errors.AsymmetricKeyError - when the public key is incompatible with the OS crypto library
OSError - when an error is returned by the OS crypto library
:return:
A PublicKey object
"""
if isinstance(source, keys.PublicKeyInfo):
public_key = source
elif isinstance(source, byte_cls):
public_key = parse_public(source)
elif isinstance(source, str_cls):
with open(source, 'rb') as f:
public_key = parse_public(f.read())
else:
raise TypeError(pretty_message(
'''
source must be a byte string, unicode string or
asn1crypto.keys.PublicKeyInfo object, not %s
''',
type_name(public_key)
))
if public_key.algorithm == 'dsa':
if libcrypto_version_info < (1,) and public_key.hash_algo == 'sha2':
raise AsymmetricKeyError(pretty_message(
'''
OpenSSL 0.9.8 only supports DSA keys based on SHA1 (2048 bits or
less) - this key is based on SHA2 and is %s bits
''',
public_key.bit_size
))
elif public_key.hash_algo is None:
raise IncompleteAsymmetricKeyError(pretty_message(
'''
The DSA key does not contain the necessary p, q and g
parameters and can not be used
'''
))
data = public_key.dump()
buffer = buffer_from_bytes(data)
evp_pkey = libcrypto.d2i_PUBKEY(null(), buffer_pointer(buffer), len(data))
if is_null(evp_pkey):
handle_openssl_error(0)
return PublicKey(evp_pkey, public_key)
|
def _load_key(private_object):
"""
Loads a private key into a PrivateKey object
:param private_object:
An asn1crypto.keys.PrivateKeyInfo object
:return:
A PrivateKey object
"""
if libcrypto_version_info < (1,) and private_object.algorithm == 'dsa' and private_object.hash_algo == 'sha2':
raise AsymmetricKeyError(pretty_message(
'''
OpenSSL 0.9.8 only supports DSA keys based on SHA1 (2048 bits or
less) - this key is based on SHA2 and is %s bits
''',
private_object.bit_size
))
source = private_object.unwrap().dump()
buffer = buffer_from_bytes(source)
evp_pkey = libcrypto.d2i_AutoPrivateKey(null(), buffer_pointer(buffer), len(source))
if is_null(evp_pkey):
handle_openssl_error(0)
return PrivateKey(evp_pkey, private_object)
|
def _encrypt(certificate_or_public_key, data, padding):
"""
Encrypts plaintext using an RSA public key or certificate
:param certificate_or_public_key:
A PublicKey, Certificate or PrivateKey object
:param data:
The byte string to encrypt
:param padding:
The padding mode to use
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the encrypted data
"""
if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):
raise TypeError(pretty_message(
'''
certificate_or_public_key must be an instance of the Certificate or
PublicKey class, not %s
''',
type_name(certificate_or_public_key)
))
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
rsa = None
try:
buffer_size = libcrypto.EVP_PKEY_size(certificate_or_public_key.evp_pkey)
buffer = buffer_from_bytes(buffer_size)
rsa = libcrypto.EVP_PKEY_get1_RSA(certificate_or_public_key.evp_pkey)
res = libcrypto.RSA_public_encrypt(len(data), data, buffer, rsa, padding)
handle_openssl_error(res)
return bytes_from_buffer(buffer, res)
finally:
if rsa:
libcrypto.RSA_free(rsa)
|
def _decrypt(private_key, ciphertext, padding):
"""
Decrypts RSA ciphertext using a private key
:param private_key:
A PrivateKey object
:param ciphertext:
The ciphertext - a byte string
:param padding:
The padding mode to use
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the plaintext
"""
if not isinstance(private_key, PrivateKey):
raise TypeError(pretty_message(
'''
private_key must be an instance of the PrivateKey class, not %s
''',
type_name(private_key)
))
if not isinstance(ciphertext, byte_cls):
raise TypeError(pretty_message(
'''
ciphertext must be a byte string, not %s
''',
type_name(ciphertext)
))
rsa = None
try:
buffer_size = libcrypto.EVP_PKEY_size(private_key.evp_pkey)
buffer = buffer_from_bytes(buffer_size)
rsa = libcrypto.EVP_PKEY_get1_RSA(private_key.evp_pkey)
res = libcrypto.RSA_private_decrypt(len(ciphertext), ciphertext, buffer, rsa, padding)
handle_openssl_error(res)
return bytes_from_buffer(buffer, res)
finally:
if rsa:
libcrypto.RSA_free(rsa)
|
def _verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=False):
"""
Verifies an RSA, DSA or ECDSA signature
:param certificate_or_public_key:
A Certificate or PublicKey instance to verify the signature with
:param signature:
A byte string of the signature to verify
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha224", "sha256", "sha384" or "sha512"
:param rsa_pss_padding:
If the certificate_or_public_key is an RSA key, this enables PSS padding
:raises:
oscrypto.errors.SignatureError - when the signature is determined to be invalid
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
"""
if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):
raise TypeError(pretty_message(
'''
certificate_or_public_key must be an instance of the Certificate or
PublicKey class, not %s
''',
type_name(certificate_or_public_key)
))
if not isinstance(signature, byte_cls):
raise TypeError(pretty_message(
'''
signature must be a byte string, not %s
''',
type_name(signature)
))
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
valid_hash_algorithms = set(['md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512'])
if certificate_or_public_key.algorithm == 'rsa' and not rsa_pss_padding:
valid_hash_algorithms |= set(['raw'])
if hash_algorithm not in valid_hash_algorithms:
valid_hash_algorithms_error = '"md5", "sha1", "sha224", "sha256", "sha384", "sha512"'
if certificate_or_public_key.algorithm == 'rsa' and not rsa_pss_padding:
valid_hash_algorithms_error += ', "raw"'
raise ValueError(pretty_message(
'''
hash_algorithm must be one of %s, not %s
''',
valid_hash_algorithms_error,
repr(hash_algorithm)
))
if certificate_or_public_key.algorithm != 'rsa' and rsa_pss_padding:
raise ValueError(pretty_message(
'''
PSS padding can only be used with RSA keys - the key provided is a
%s key
''',
certificate_or_public_key.algorithm.upper()
))
if certificate_or_public_key.algorithm == 'rsa' and hash_algorithm == 'raw':
if len(data) > certificate_or_public_key.byte_size - 11:
raise ValueError(pretty_message(
'''
data must be 11 bytes shorter than the key size when
hash_algorithm is "raw" - key size is %s bytes, but data is
%s bytes long
''',
certificate_or_public_key.byte_size,
len(data)
))
rsa = None
try:
rsa = libcrypto.EVP_PKEY_get1_RSA(certificate_or_public_key.evp_pkey)
if is_null(rsa):
handle_openssl_error(0)
buffer_size = libcrypto.EVP_PKEY_size(certificate_or_public_key.evp_pkey)
decrypted_buffer = buffer_from_bytes(buffer_size)
decrypted_length = libcrypto.RSA_public_decrypt(
len(signature),
signature,
decrypted_buffer,
rsa,
LibcryptoConst.RSA_PKCS1_PADDING
)
handle_openssl_error(decrypted_length)
decrypted_bytes = bytes_from_buffer(decrypted_buffer, decrypted_length)
if not constant_compare(data, decrypted_bytes):
raise SignatureError('Signature is invalid')
return
finally:
if rsa:
libcrypto.RSA_free(rsa)
evp_md_ctx = None
rsa = None
dsa = None
dsa_sig = None
ec_key = None
ecdsa_sig = None
try:
if libcrypto_version_info < (1, 1):
evp_md_ctx = libcrypto.EVP_MD_CTX_create()
else:
evp_md_ctx = libcrypto.EVP_MD_CTX_new()
evp_md = {
'md5': libcrypto.EVP_md5,
'sha1': libcrypto.EVP_sha1,
'sha224': libcrypto.EVP_sha224,
'sha256': libcrypto.EVP_sha256,
'sha384': libcrypto.EVP_sha384,
'sha512': libcrypto.EVP_sha512
}[hash_algorithm]()
if libcrypto_version_info < (1,):
if certificate_or_public_key.algorithm == 'rsa' and rsa_pss_padding:
digest = getattr(hashlib, hash_algorithm)(data).digest()
rsa = libcrypto.EVP_PKEY_get1_RSA(certificate_or_public_key.evp_pkey)
if is_null(rsa):
handle_openssl_error(0)
buffer_size = libcrypto.EVP_PKEY_size(certificate_or_public_key.evp_pkey)
decoded_buffer = buffer_from_bytes(buffer_size)
decoded_length = libcrypto.RSA_public_decrypt(
len(signature),
signature,
decoded_buffer,
rsa,
LibcryptoConst.RSA_NO_PADDING
)
handle_openssl_error(decoded_length)
res = libcrypto.RSA_verify_PKCS1_PSS(
rsa,
digest,
evp_md,
decoded_buffer,
LibcryptoConst.EVP_MD_CTX_FLAG_PSS_MDLEN
)
elif certificate_or_public_key.algorithm == 'rsa':
res = libcrypto.EVP_DigestInit_ex(evp_md_ctx, evp_md, null())
handle_openssl_error(res)
res = libcrypto.EVP_DigestUpdate(evp_md_ctx, data, len(data))
handle_openssl_error(res)
res = libcrypto.EVP_VerifyFinal(
evp_md_ctx,
signature,
len(signature),
certificate_or_public_key.evp_pkey
)
elif certificate_or_public_key.algorithm == 'dsa':
digest = getattr(hashlib, hash_algorithm)(data).digest()
signature_buffer = buffer_from_bytes(signature)
signature_pointer = buffer_pointer(signature_buffer)
dsa_sig = libcrypto.d2i_DSA_SIG(null(), signature_pointer, len(signature))
if is_null(dsa_sig):
raise SignatureError('Signature is invalid')
dsa = libcrypto.EVP_PKEY_get1_DSA(certificate_or_public_key.evp_pkey)
if is_null(dsa):
handle_openssl_error(0)
res = libcrypto.DSA_do_verify(digest, len(digest), dsa_sig, dsa)
elif certificate_or_public_key.algorithm == 'ec':
digest = getattr(hashlib, hash_algorithm)(data).digest()
signature_buffer = buffer_from_bytes(signature)
signature_pointer = buffer_pointer(signature_buffer)
ecdsa_sig = libcrypto.d2i_ECDSA_SIG(null(), signature_pointer, len(signature))
if is_null(ecdsa_sig):
raise SignatureError('Signature is invalid')
ec_key = libcrypto.EVP_PKEY_get1_EC_KEY(certificate_or_public_key.evp_pkey)
if is_null(ec_key):
handle_openssl_error(0)
res = libcrypto.ECDSA_do_verify(digest, len(digest), ecdsa_sig, ec_key)
else:
evp_pkey_ctx_pointer_pointer = new(libcrypto, 'EVP_PKEY_CTX **')
res = libcrypto.EVP_DigestVerifyInit(
evp_md_ctx,
evp_pkey_ctx_pointer_pointer,
evp_md,
null(),
certificate_or_public_key.evp_pkey
)
handle_openssl_error(res)
evp_pkey_ctx_pointer = unwrap(evp_pkey_ctx_pointer_pointer)
if rsa_pss_padding:
# Enable PSS padding
res = libcrypto.EVP_PKEY_CTX_ctrl(
evp_pkey_ctx_pointer,
LibcryptoConst.EVP_PKEY_RSA,
-1, # All operations
LibcryptoConst.EVP_PKEY_CTRL_RSA_PADDING,
LibcryptoConst.RSA_PKCS1_PSS_PADDING,
null()
)
handle_openssl_error(res)
# Use the hash algorithm output length as the salt length
res = libcrypto.EVP_PKEY_CTX_ctrl(
evp_pkey_ctx_pointer,
LibcryptoConst.EVP_PKEY_RSA,
LibcryptoConst.EVP_PKEY_OP_SIGN | LibcryptoConst.EVP_PKEY_OP_VERIFY,
LibcryptoConst.EVP_PKEY_CTRL_RSA_PSS_SALTLEN,
-1,
null()
)
handle_openssl_error(res)
res = libcrypto.EVP_DigestUpdate(evp_md_ctx, data, len(data))
handle_openssl_error(res)
res = libcrypto.EVP_DigestVerifyFinal(evp_md_ctx, signature, len(signature))
if res < 1:
raise SignatureError('Signature is invalid')
handle_openssl_error(res)
finally:
if evp_md_ctx:
if libcrypto_version_info < (1, 1):
libcrypto.EVP_MD_CTX_destroy(evp_md_ctx)
else:
libcrypto.EVP_MD_CTX_free(evp_md_ctx)
if rsa:
libcrypto.RSA_free(rsa)
if dsa:
libcrypto.DSA_free(dsa)
if dsa_sig:
libcrypto.DSA_SIG_free(dsa_sig)
if ec_key:
libcrypto.EC_KEY_free(ec_key)
if ecdsa_sig:
libcrypto.ECDSA_SIG_free(ecdsa_sig)
|
def rsa_pkcs1v15_sign(private_key, data, hash_algorithm):
"""
Generates an RSASSA-PKCS-v1.5 signature.
When the hash_algorithm is "raw", the operation is identical to RSA
private key encryption. That is: the data is not hashed and no ASN.1
structure with an algorithm identifier of the hash algorithm is placed in
the encrypted byte string.
:param private_key:
The PrivateKey to generate the signature with
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha224", "sha256", "sha384",
"sha512" or "raw"
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the signature
"""
if private_key.algorithm != 'rsa':
raise ValueError(pretty_message(
'''
The key specified is not an RSA private key, but %s
''',
private_key.algorithm.upper()
))
return _sign(private_key, data, hash_algorithm)
|
def _sign(private_key, data, hash_algorithm, rsa_pss_padding=False):
"""
Generates an RSA, DSA or ECDSA signature
:param private_key:
The PrivateKey to generate the signature with
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha224", "sha256", "sha384" or "sha512"
:param rsa_pss_padding:
If the private_key is an RSA key, this enables PSS padding
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the signature
"""
if not isinstance(private_key, PrivateKey):
raise TypeError(pretty_message(
'''
private_key must be an instance of PrivateKey, not %s
''',
type_name(private_key)
))
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
valid_hash_algorithms = set(['md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512'])
if private_key.algorithm == 'rsa' and not rsa_pss_padding:
valid_hash_algorithms |= set(['raw'])
if hash_algorithm not in valid_hash_algorithms:
valid_hash_algorithms_error = '"md5", "sha1", "sha224", "sha256", "sha384", "sha512"'
if private_key.algorithm == 'rsa' and not rsa_pss_padding:
valid_hash_algorithms_error += ', "raw"'
raise ValueError(pretty_message(
'''
hash_algorithm must be one of %s, not %s
''',
valid_hash_algorithms_error,
repr(hash_algorithm)
))
if private_key.algorithm != 'rsa' and rsa_pss_padding:
raise ValueError(pretty_message(
'''
PSS padding can only be used with RSA keys - the key provided is a
%s key
''',
private_key.algorithm.upper()
))
if private_key.algorithm == 'rsa' and hash_algorithm == 'raw':
if len(data) > private_key.byte_size - 11:
raise ValueError(pretty_message(
'''
data must be 11 bytes shorter than the key size when
hash_algorithm is "raw" - key size is %s bytes, but data is
%s bytes long
''',
private_key.byte_size,
len(data)
))
rsa = None
try:
rsa = libcrypto.EVP_PKEY_get1_RSA(private_key.evp_pkey)
if is_null(rsa):
handle_openssl_error(0)
buffer_size = libcrypto.EVP_PKEY_size(private_key.evp_pkey)
signature_buffer = buffer_from_bytes(buffer_size)
signature_length = libcrypto.RSA_private_encrypt(
len(data),
data,
signature_buffer,
rsa,
LibcryptoConst.RSA_PKCS1_PADDING
)
handle_openssl_error(signature_length)
return bytes_from_buffer(signature_buffer, signature_length)
finally:
if rsa:
libcrypto.RSA_free(rsa)
evp_md_ctx = None
rsa = None
dsa = None
dsa_sig = None
ec_key = None
ecdsa_sig = None
try:
if libcrypto_version_info < (1, 1):
evp_md_ctx = libcrypto.EVP_MD_CTX_create()
else:
evp_md_ctx = libcrypto.EVP_MD_CTX_new()
evp_md = {
'md5': libcrypto.EVP_md5,
'sha1': libcrypto.EVP_sha1,
'sha224': libcrypto.EVP_sha224,
'sha256': libcrypto.EVP_sha256,
'sha384': libcrypto.EVP_sha384,
'sha512': libcrypto.EVP_sha512
}[hash_algorithm]()
if libcrypto_version_info < (1,):
if private_key.algorithm == 'rsa' and rsa_pss_padding:
digest = getattr(hashlib, hash_algorithm)(data).digest()
rsa = libcrypto.EVP_PKEY_get1_RSA(private_key.evp_pkey)
if is_null(rsa):
handle_openssl_error(0)
buffer_size = libcrypto.EVP_PKEY_size(private_key.evp_pkey)
em_buffer = buffer_from_bytes(buffer_size)
res = libcrypto.RSA_padding_add_PKCS1_PSS(
rsa,
em_buffer,
digest,
evp_md,
LibcryptoConst.EVP_MD_CTX_FLAG_PSS_MDLEN
)
handle_openssl_error(res)
signature_buffer = buffer_from_bytes(buffer_size)
signature_length = libcrypto.RSA_private_encrypt(
buffer_size,
em_buffer,
signature_buffer,
rsa,
LibcryptoConst.RSA_NO_PADDING
)
handle_openssl_error(signature_length)
elif private_key.algorithm == 'rsa':
buffer_size = libcrypto.EVP_PKEY_size(private_key.evp_pkey)
signature_buffer = buffer_from_bytes(buffer_size)
signature_length = new(libcrypto, 'unsigned int *')
res = libcrypto.EVP_DigestInit_ex(evp_md_ctx, evp_md, null())
handle_openssl_error(res)
res = libcrypto.EVP_DigestUpdate(evp_md_ctx, data, len(data))
handle_openssl_error(res)
res = libcrypto.EVP_SignFinal(
evp_md_ctx,
signature_buffer,
signature_length,
private_key.evp_pkey
)
handle_openssl_error(res)
signature_length = deref(signature_length)
elif private_key.algorithm == 'dsa':
digest = getattr(hashlib, hash_algorithm)(data).digest()
dsa = libcrypto.EVP_PKEY_get1_DSA(private_key.evp_pkey)
if is_null(dsa):
handle_openssl_error(0)
dsa_sig = libcrypto.DSA_do_sign(digest, len(digest), dsa)
if is_null(dsa_sig):
handle_openssl_error(0)
buffer_size = libcrypto.i2d_DSA_SIG(dsa_sig, null())
signature_buffer = buffer_from_bytes(buffer_size)
signature_pointer = buffer_pointer(signature_buffer)
signature_length = libcrypto.i2d_DSA_SIG(dsa_sig, signature_pointer)
handle_openssl_error(signature_length)
elif private_key.algorithm == 'ec':
digest = getattr(hashlib, hash_algorithm)(data).digest()
ec_key = libcrypto.EVP_PKEY_get1_EC_KEY(private_key.evp_pkey)
if is_null(ec_key):
handle_openssl_error(0)
ecdsa_sig = libcrypto.ECDSA_do_sign(digest, len(digest), ec_key)
if is_null(ecdsa_sig):
handle_openssl_error(0)
buffer_size = libcrypto.i2d_ECDSA_SIG(ecdsa_sig, null())
signature_buffer = buffer_from_bytes(buffer_size)
signature_pointer = buffer_pointer(signature_buffer)
signature_length = libcrypto.i2d_ECDSA_SIG(ecdsa_sig, signature_pointer)
handle_openssl_error(signature_length)
else:
buffer_size = libcrypto.EVP_PKEY_size(private_key.evp_pkey)
signature_buffer = buffer_from_bytes(buffer_size)
signature_length = new(libcrypto, 'size_t *', buffer_size)
evp_pkey_ctx_pointer_pointer = new(libcrypto, 'EVP_PKEY_CTX **')
res = libcrypto.EVP_DigestSignInit(
evp_md_ctx,
evp_pkey_ctx_pointer_pointer,
evp_md,
null(),
private_key.evp_pkey
)
handle_openssl_error(res)
evp_pkey_ctx_pointer = unwrap(evp_pkey_ctx_pointer_pointer)
if rsa_pss_padding:
# Enable PSS padding
res = libcrypto.EVP_PKEY_CTX_ctrl(
evp_pkey_ctx_pointer,
LibcryptoConst.EVP_PKEY_RSA,
-1, # All operations
LibcryptoConst.EVP_PKEY_CTRL_RSA_PADDING,
LibcryptoConst.RSA_PKCS1_PSS_PADDING,
null()
)
handle_openssl_error(res)
# Use the hash algorithm output length as the salt length
res = libcrypto.EVP_PKEY_CTX_ctrl(
evp_pkey_ctx_pointer,
LibcryptoConst.EVP_PKEY_RSA,
LibcryptoConst.EVP_PKEY_OP_SIGN | LibcryptoConst.EVP_PKEY_OP_VERIFY,
LibcryptoConst.EVP_PKEY_CTRL_RSA_PSS_SALTLEN,
-1,
null()
)
handle_openssl_error(res)
res = libcrypto.EVP_DigestUpdate(evp_md_ctx, data, len(data))
handle_openssl_error(res)
res = libcrypto.EVP_DigestSignFinal(evp_md_ctx, signature_buffer, signature_length)
handle_openssl_error(res)
signature_length = deref(signature_length)
return bytes_from_buffer(signature_buffer, signature_length)
finally:
if evp_md_ctx:
if libcrypto_version_info < (1, 1):
libcrypto.EVP_MD_CTX_destroy(evp_md_ctx)
else:
libcrypto.EVP_MD_CTX_free(evp_md_ctx)
if rsa:
libcrypto.RSA_free(rsa)
if dsa:
libcrypto.DSA_free(dsa)
if dsa_sig:
libcrypto.DSA_SIG_free(dsa_sig)
if ec_key:
libcrypto.EC_KEY_free(ec_key)
if ecdsa_sig:
libcrypto.ECDSA_SIG_free(ecdsa_sig)
|
def public_key(self):
"""
:return:
The PublicKey object for the public key this certificate contains
"""
if not self._public_key and self.x509:
evp_pkey = libcrypto.X509_get_pubkey(self.x509)
self._public_key = PublicKey(evp_pkey, self.asn1['tbs_certificate']['subject_public_key_info'])
return self._public_key
|
def generate_pair(algorithm, bit_size=None, curve=None):
"""
Generates a public/private key pair
:param algorithm:
The key algorithm - "rsa", "dsa" or "ec"
:param bit_size:
An integer - used for "rsa" and "dsa". For "rsa" the value maye be 1024,
2048, 3072 or 4096. For "dsa" the value may be 1024, plus 2048 or 3072
if on Windows 8 or newer.
:param curve:
A unicode string - used for "ec" keys. Valid values include "secp256r1",
"secp384r1" and "secp521r1".
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A 2-element tuple of (PublicKey, PrivateKey). The contents of each key
may be saved by calling .asn1.dump().
"""
if algorithm not in set(['rsa', 'dsa', 'ec']):
raise ValueError(pretty_message(
'''
algorithm must be one of "rsa", "dsa", "ec", not %s
''',
repr(algorithm)
))
if algorithm == 'rsa':
if bit_size not in set([1024, 2048, 3072, 4096]):
raise ValueError(pretty_message(
'''
bit_size must be one of 1024, 2048, 3072, 4096, not %s
''',
repr(bit_size)
))
elif algorithm == 'dsa':
# Windows Vista and 7 only support SHA1-based DSA keys
if _win_version_info < (6, 2) or _backend == 'winlegacy':
if bit_size != 1024:
raise ValueError(pretty_message(
'''
bit_size must be 1024, not %s
''',
repr(bit_size)
))
else:
if bit_size not in set([1024, 2048, 3072]):
raise ValueError(pretty_message(
'''
bit_size must be one of 1024, 2048, 3072, not %s
''',
repr(bit_size)
))
elif algorithm == 'ec':
if curve not in set(['secp256r1', 'secp384r1', 'secp521r1']):
raise ValueError(pretty_message(
'''
curve must be one of "secp256r1", "secp384r1", "secp521r1", not %s
''',
repr(curve)
))
if _backend == 'winlegacy':
if algorithm == 'ec':
pub_info, priv_info = _pure_python_ec_generate_pair(curve)
return (PublicKey(None, pub_info), PrivateKey(None, priv_info))
return _advapi32_generate_pair(algorithm, bit_size)
else:
return _bcrypt_generate_pair(algorithm, bit_size, curve)
|
def _advapi32_generate_pair(algorithm, bit_size=None):
"""
Generates a public/private key pair using CryptoAPI
:param algorithm:
The key algorithm - "rsa" or "dsa"
:param bit_size:
An integer - used for "rsa" and "dsa". For "rsa" the value maye be 1024,
2048, 3072 or 4096. For "dsa" the value may be 1024.
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A 2-element tuple of (PublicKey, PrivateKey). The contents of each key
may be saved by calling .asn1.dump().
"""
if algorithm == 'rsa':
provider = Advapi32Const.MS_ENH_RSA_AES_PROV
algorithm_id = Advapi32Const.CALG_RSA_SIGN
struct_type = 'RSABLOBHEADER'
else:
provider = Advapi32Const.MS_ENH_DSS_DH_PROV
algorithm_id = Advapi32Const.CALG_DSS_SIGN
struct_type = 'DSSBLOBHEADER'
context_handle = None
key_handle = None
try:
context_handle = open_context_handle(provider, verify_only=False)
key_handle_pointer = new(advapi32, 'HCRYPTKEY *')
flags = (bit_size << 16) | Advapi32Const.CRYPT_EXPORTABLE
res = advapi32.CryptGenKey(context_handle, algorithm_id, flags, key_handle_pointer)
handle_error(res)
key_handle = unwrap(key_handle_pointer)
out_len = new(advapi32, 'DWORD *')
res = advapi32.CryptExportKey(
key_handle,
null(),
Advapi32Const.PRIVATEKEYBLOB,
0,
null(),
out_len
)
handle_error(res)
buffer_length = deref(out_len)
buffer_ = buffer_from_bytes(buffer_length)
res = advapi32.CryptExportKey(
key_handle,
null(),
Advapi32Const.PRIVATEKEYBLOB,
0,
buffer_,
out_len
)
handle_error(res)
blob_struct_pointer = struct_from_buffer(advapi32, struct_type, buffer_)
blob_struct = unwrap(blob_struct_pointer)
struct_size = sizeof(advapi32, blob_struct)
private_blob = bytes_from_buffer(buffer_, buffer_length)[struct_size:]
if algorithm == 'rsa':
public_info, private_info = _advapi32_interpret_rsa_key_blob(bit_size, blob_struct, private_blob)
else:
# The public key for a DSA key is not available in from the private
# key blob, so we have to separately export the public key
public_out_len = new(advapi32, 'DWORD *')
res = advapi32.CryptExportKey(
key_handle,
null(),
Advapi32Const.PUBLICKEYBLOB,
0,
null(),
public_out_len
)
handle_error(res)
public_buffer_length = deref(public_out_len)
public_buffer = buffer_from_bytes(public_buffer_length)
res = advapi32.CryptExportKey(
key_handle,
null(),
Advapi32Const.PUBLICKEYBLOB,
0,
public_buffer,
public_out_len
)
handle_error(res)
public_blob = bytes_from_buffer(public_buffer, public_buffer_length)[struct_size:]
public_info, private_info = _advapi32_interpret_dsa_key_blob(bit_size, public_blob, private_blob)
return (load_public_key(public_info), load_private_key(private_info))
finally:
if context_handle:
close_context_handle(context_handle)
if key_handle:
advapi32.CryptDestroyKey(key_handle)
|
def _bcrypt_generate_pair(algorithm, bit_size=None, curve=None):
"""
Generates a public/private key pair using CNG
:param algorithm:
The key algorithm - "rsa", "dsa" or "ec"
:param bit_size:
An integer - used for "rsa" and "dsa". For "rsa" the value maye be 1024,
2048, 3072 or 4096. For "dsa" the value may be 1024, plus 2048 or 3072
if on Windows 8 or newer.
:param curve:
A unicode string - used for "ec" keys. Valid values include "secp256r1",
"secp384r1" and "secp521r1".
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A 2-element tuple of (PublicKey, PrivateKey). The contents of each key
may be saved by calling .asn1.dump().
"""
if algorithm == 'rsa':
alg_constant = BcryptConst.BCRYPT_RSA_ALGORITHM
struct_type = 'BCRYPT_RSAKEY_BLOB'
private_blob_type = BcryptConst.BCRYPT_RSAFULLPRIVATE_BLOB
public_blob_type = BcryptConst.BCRYPT_RSAPUBLIC_BLOB
elif algorithm == 'dsa':
alg_constant = BcryptConst.BCRYPT_DSA_ALGORITHM
if bit_size > 1024:
struct_type = 'BCRYPT_DSA_KEY_BLOB_V2'
else:
struct_type = 'BCRYPT_DSA_KEY_BLOB'
private_blob_type = BcryptConst.BCRYPT_DSA_PRIVATE_BLOB
public_blob_type = BcryptConst.BCRYPT_DSA_PUBLIC_BLOB
else:
alg_constant = {
'secp256r1': BcryptConst.BCRYPT_ECDSA_P256_ALGORITHM,
'secp384r1': BcryptConst.BCRYPT_ECDSA_P384_ALGORITHM,
'secp521r1': BcryptConst.BCRYPT_ECDSA_P521_ALGORITHM,
}[curve]
bit_size = {
'secp256r1': 256,
'secp384r1': 384,
'secp521r1': 521,
}[curve]
struct_type = 'BCRYPT_ECCKEY_BLOB'
private_blob_type = BcryptConst.BCRYPT_ECCPRIVATE_BLOB
public_blob_type = BcryptConst.BCRYPT_ECCPUBLIC_BLOB
alg_handle = open_alg_handle(alg_constant)
key_handle_pointer = new(bcrypt, 'BCRYPT_KEY_HANDLE *')
res = bcrypt.BCryptGenerateKeyPair(alg_handle, key_handle_pointer, bit_size, 0)
handle_error(res)
key_handle = unwrap(key_handle_pointer)
res = bcrypt.BCryptFinalizeKeyPair(key_handle, 0)
handle_error(res)
private_out_len = new(bcrypt, 'ULONG *')
res = bcrypt.BCryptExportKey(key_handle, null(), private_blob_type, null(), 0, private_out_len, 0)
handle_error(res)
private_buffer_length = deref(private_out_len)
private_buffer = buffer_from_bytes(private_buffer_length)
res = bcrypt.BCryptExportKey(
key_handle,
null(),
private_blob_type,
private_buffer,
private_buffer_length,
private_out_len,
0
)
handle_error(res)
private_blob_struct_pointer = struct_from_buffer(bcrypt, struct_type, private_buffer)
private_blob_struct = unwrap(private_blob_struct_pointer)
struct_size = sizeof(bcrypt, private_blob_struct)
private_blob = bytes_from_buffer(private_buffer, private_buffer_length)[struct_size:]
if algorithm == 'rsa':
private_key = _bcrypt_interpret_rsa_key_blob('private', private_blob_struct, private_blob)
elif algorithm == 'dsa':
if bit_size > 1024:
private_key = _bcrypt_interpret_dsa_key_blob('private', 2, private_blob_struct, private_blob)
else:
private_key = _bcrypt_interpret_dsa_key_blob('private', 1, private_blob_struct, private_blob)
else:
private_key = _bcrypt_interpret_ec_key_blob('private', private_blob_struct, private_blob)
public_out_len = new(bcrypt, 'ULONG *')
res = bcrypt.BCryptExportKey(key_handle, null(), public_blob_type, null(), 0, public_out_len, 0)
handle_error(res)
public_buffer_length = deref(public_out_len)
public_buffer = buffer_from_bytes(public_buffer_length)
res = bcrypt.BCryptExportKey(
key_handle,
null(),
public_blob_type,
public_buffer,
public_buffer_length,
public_out_len,
0
)
handle_error(res)
public_blob_struct_pointer = struct_from_buffer(bcrypt, struct_type, public_buffer)
public_blob_struct = unwrap(public_blob_struct_pointer)
struct_size = sizeof(bcrypt, public_blob_struct)
public_blob = bytes_from_buffer(public_buffer, public_buffer_length)[struct_size:]
if algorithm == 'rsa':
public_key = _bcrypt_interpret_rsa_key_blob('public', public_blob_struct, public_blob)
elif algorithm == 'dsa':
if bit_size > 1024:
public_key = _bcrypt_interpret_dsa_key_blob('public', 2, public_blob_struct, public_blob)
else:
public_key = _bcrypt_interpret_dsa_key_blob('public', 1, public_blob_struct, public_blob)
else:
public_key = _bcrypt_interpret_ec_key_blob('public', public_blob_struct, public_blob)
return (load_public_key(public_key), load_private_key(private_key))
|
def generate_dh_parameters(bit_size):
"""
Generates DH parameters for use with Diffie-Hellman key exchange. Returns
a structure in the format of DHParameter defined in PKCS#3, which is also
used by the OpenSSL dhparam tool.
THIS CAN BE VERY TIME CONSUMING!
:param bit_size:
The integer bit size of the parameters to generate. Must be between 512
and 4096, and divisible by 64. Recommended secure value as of early 2016
is 2048, with an absolute minimum of 1024.
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
An asn1crypto.algos.DHParameters object. Use
oscrypto.asymmetric.dump_dh_parameters() to save to disk for usage with
web servers.
"""
if not isinstance(bit_size, int_types):
raise TypeError(pretty_message(
'''
bit_size must be an integer, not %s
''',
type_name(bit_size)
))
if bit_size < 512:
raise ValueError('bit_size must be greater than or equal to 512')
if bit_size > 4096:
raise ValueError('bit_size must be less than or equal to 4096')
if bit_size % 64 != 0:
raise ValueError('bit_size must be a multiple of 64')
alg_handle = None
# The following algorithm has elements taken from OpenSSL. In short, it
# generates random numbers and then ensures that they are valid for the
# hardcoded generator of 2, and then ensures the number is a "safe" prime
# by ensuring p//2 is prime also.
# OpenSSL allows use of generator 2 or 5, but we hardcode 2 since it is
# the default, and what is used by Security.framework on OS X also.
g = 2
try:
byte_size = bit_size // 8
if _backend == 'win':
alg_handle = open_alg_handle(BcryptConst.BCRYPT_RNG_ALGORITHM)
buffer = buffer_from_bytes(byte_size)
while True:
if _backend == 'winlegacy':
rb = os.urandom(byte_size)
else:
res = bcrypt.BCryptGenRandom(alg_handle, buffer, byte_size, 0)
handle_error(res)
rb = bytes_from_buffer(buffer)
p = int_from_bytes(rb)
# If a number is even, it can't be prime
if p % 2 == 0:
continue
# Perform the generator checks outlined in OpenSSL's
# dh_builtin_genparams() located in dh_gen.c
if g == 2:
if p % 24 != 11:
continue
elif g == 5:
rem = p % 10
if rem != 3 and rem != 7:
continue
divisible = False
for prime in _SMALL_PRIMES:
if p % prime == 0:
divisible = True
break
# If the number is not divisible by any of the small primes, then
# move on to the full Miller-Rabin test.
if not divisible and _is_prime(bit_size, p):
q = p // 2
if _is_prime(bit_size, q):
return algos.DHParameters({'p': p, 'g': g})
finally:
if alg_handle:
close_alg_handle(alg_handle)
|
def _is_prime(bit_size, n):
"""
An implementation of Miller–Rabin for checking if a number is prime.
:param bit_size:
An integer of the number of bits in the prime number
:param n:
An integer, the prime number
:return:
A boolean
"""
r = 0
s = n - 1
while s % 2 == 0:
r += 1
s //= 2
if bit_size >= 1300:
k = 2
elif bit_size >= 850:
k = 3
elif bit_size >= 650:
k = 4
elif bit_size >= 550:
k = 5
elif bit_size >= 450:
k = 6
for _ in range(k):
a = random.randrange(2, n - 1)
x = pow(a, s, n)
if x == 1 or x == n - 1:
continue
for _ in range(r - 1):
x = pow(x, 2, n)
if x == n - 1:
break
else:
return False
return True
|
def _advapi32_interpret_rsa_key_blob(bit_size, blob_struct, blob):
"""
Takes a CryptoAPI RSA private key blob and converts it into the ASN.1
structures for the public and private keys
:param bit_size:
The integer bit size of the key
:param blob_struct:
An instance of the advapi32.RSAPUBKEY struct
:param blob:
A byte string of the binary data after the header
:return:
A 2-element tuple of (asn1crypto.keys.PublicKeyInfo,
asn1crypto.keys.PrivateKeyInfo)
"""
len1 = bit_size // 8
len2 = bit_size // 16
prime1_offset = len1
prime2_offset = prime1_offset + len2
exponent1_offset = prime2_offset + len2
exponent2_offset = exponent1_offset + len2
coefficient_offset = exponent2_offset + len2
private_exponent_offset = coefficient_offset + len2
public_exponent = blob_struct.rsapubkey.pubexp
modulus = int_from_bytes(blob[0:prime1_offset][::-1])
prime1 = int_from_bytes(blob[prime1_offset:prime2_offset][::-1])
prime2 = int_from_bytes(blob[prime2_offset:exponent1_offset][::-1])
exponent1 = int_from_bytes(blob[exponent1_offset:exponent2_offset][::-1])
exponent2 = int_from_bytes(blob[exponent2_offset:coefficient_offset][::-1])
coefficient = int_from_bytes(blob[coefficient_offset:private_exponent_offset][::-1])
private_exponent = int_from_bytes(blob[private_exponent_offset:private_exponent_offset + len1][::-1])
public_key_info = keys.PublicKeyInfo({
'algorithm': keys.PublicKeyAlgorithm({
'algorithm': 'rsa',
}),
'public_key': keys.RSAPublicKey({
'modulus': modulus,
'public_exponent': public_exponent,
}),
})
rsa_private_key = keys.RSAPrivateKey({
'version': 'two-prime',
'modulus': modulus,
'public_exponent': public_exponent,
'private_exponent': private_exponent,
'prime1': prime1,
'prime2': prime2,
'exponent1': exponent1,
'exponent2': exponent2,
'coefficient': coefficient,
})
private_key_info = keys.PrivateKeyInfo({
'version': 0,
'private_key_algorithm': keys.PrivateKeyAlgorithm({
'algorithm': 'rsa',
}),
'private_key': rsa_private_key,
})
return (public_key_info, private_key_info)
|
def _advapi32_interpret_dsa_key_blob(bit_size, public_blob, private_blob):
"""
Takes a CryptoAPI DSS private key blob and converts it into the ASN.1
structures for the public and private keys
:param bit_size:
The integer bit size of the key
:param public_blob:
A byte string of the binary data after the public key header
:param private_blob:
A byte string of the binary data after the private key header
:return:
A 2-element tuple of (asn1crypto.keys.PublicKeyInfo,
asn1crypto.keys.PrivateKeyInfo)
"""
len1 = 20
len2 = bit_size // 8
q_offset = len2
g_offset = q_offset + len1
x_offset = g_offset + len2
y_offset = x_offset
p = int_from_bytes(private_blob[0:q_offset][::-1])
q = int_from_bytes(private_blob[q_offset:g_offset][::-1])
g = int_from_bytes(private_blob[g_offset:x_offset][::-1])
x = int_from_bytes(private_blob[x_offset:x_offset + len1][::-1])
y = int_from_bytes(public_blob[y_offset:y_offset + len2][::-1])
public_key_info = keys.PublicKeyInfo({
'algorithm': keys.PublicKeyAlgorithm({
'algorithm': 'dsa',
'parameters': keys.DSAParams({
'p': p,
'q': q,
'g': g,
})
}),
'public_key': core.Integer(y),
})
private_key_info = keys.PrivateKeyInfo({
'version': 0,
'private_key_algorithm': keys.PrivateKeyAlgorithm({
'algorithm': 'dsa',
'parameters': keys.DSAParams({
'p': p,
'q': q,
'g': g,
})
}),
'private_key': core.Integer(x),
})
return (public_key_info, private_key_info)
|
def _bcrypt_interpret_rsa_key_blob(key_type, blob_struct, blob):
"""
Take a CNG BCRYPT_RSAFULLPRIVATE_BLOB and converts it into an ASN.1
structure
:param key_type:
A unicode string of "private" or "public"
:param blob_struct:
An instance of BCRYPT_RSAKEY_BLOB
:param blob:
A byte string of the binary data contained after the struct
:return:
An asn1crypto.keys.PrivateKeyInfo or asn1crypto.keys.PublicKeyInfo
object, based on the key_type param
"""
public_exponent_byte_length = native(int, blob_struct.cbPublicExp)
modulus_byte_length = native(int, blob_struct.cbModulus)
modulus_offset = public_exponent_byte_length
public_exponent = int_from_bytes(blob[0:modulus_offset])
modulus = int_from_bytes(blob[modulus_offset:modulus_offset + modulus_byte_length])
if key_type == 'public':
return keys.PublicKeyInfo({
'algorithm': keys.PublicKeyAlgorithm({
'algorithm': 'rsa',
}),
'public_key': keys.RSAPublicKey({
'modulus': modulus,
'public_exponent': public_exponent,
}),
})
elif key_type == 'private':
prime1_byte_length = native(int, blob_struct.cbPrime1)
prime2_byte_length = native(int, blob_struct.cbPrime2)
prime1_offset = modulus_offset + modulus_byte_length
prime2_offset = prime1_offset + prime1_byte_length
exponent1_offset = prime2_offset + prime2_byte_length
exponent2_offset = exponent1_offset + prime2_byte_length
coefficient_offset = exponent2_offset + prime2_byte_length
private_exponent_offset = coefficient_offset + prime1_byte_length
prime1 = int_from_bytes(blob[prime1_offset:prime2_offset])
prime2 = int_from_bytes(blob[prime2_offset:exponent1_offset])
exponent1 = int_from_bytes(blob[exponent1_offset:exponent2_offset])
exponent2 = int_from_bytes(blob[exponent2_offset:coefficient_offset])
coefficient = int_from_bytes(blob[coefficient_offset:private_exponent_offset])
private_exponent = int_from_bytes(blob[private_exponent_offset:private_exponent_offset + modulus_byte_length])
rsa_private_key = keys.RSAPrivateKey({
'version': 'two-prime',
'modulus': modulus,
'public_exponent': public_exponent,
'private_exponent': private_exponent,
'prime1': prime1,
'prime2': prime2,
'exponent1': exponent1,
'exponent2': exponent2,
'coefficient': coefficient,
})
return keys.PrivateKeyInfo({
'version': 0,
'private_key_algorithm': keys.PrivateKeyAlgorithm({
'algorithm': 'rsa',
}),
'private_key': rsa_private_key,
})
else:
raise ValueError(pretty_message(
'''
key_type must be one of "public", "private", not %s
''',
repr(key_type)
))
|
def _bcrypt_interpret_dsa_key_blob(key_type, version, blob_struct, blob):
"""
Take a CNG BCRYPT_DSA_KEY_BLOB or BCRYPT_DSA_KEY_BLOB_V2 and converts it
into an ASN.1 structure
:param key_type:
A unicode string of "private" or "public"
:param version:
An integer - 1 or 2, indicating the blob is BCRYPT_DSA_KEY_BLOB or
BCRYPT_DSA_KEY_BLOB_V2
:param blob_struct:
An instance of BCRYPT_DSA_KEY_BLOB or BCRYPT_DSA_KEY_BLOB_V2
:param blob:
A byte string of the binary data contained after the struct
:return:
An asn1crypto.keys.PrivateKeyInfo or asn1crypto.keys.PublicKeyInfo
object, based on the key_type param
"""
key_byte_length = native(int, blob_struct.cbKey)
if version == 1:
q = int_from_bytes(native(byte_cls, blob_struct.q))
g_offset = key_byte_length
public_offset = g_offset + key_byte_length
private_offset = public_offset + key_byte_length
p = int_from_bytes(blob[0:g_offset])
g = int_from_bytes(blob[g_offset:public_offset])
elif version == 2:
seed_byte_length = native(int, blob_struct.cbSeedLength)
group_byte_length = native(int, blob_struct.cbGroupSize)
q_offset = seed_byte_length
p_offset = q_offset + group_byte_length
g_offset = p_offset + key_byte_length
public_offset = g_offset + key_byte_length
private_offset = public_offset + key_byte_length
# The seed is skipped since it is not part of the ASN.1 structure
q = int_from_bytes(blob[q_offset:p_offset])
p = int_from_bytes(blob[p_offset:g_offset])
g = int_from_bytes(blob[g_offset:public_offset])
else:
raise ValueError('version must be 1 or 2, not %s' % repr(version))
if key_type == 'public':
public = int_from_bytes(blob[public_offset:private_offset])
return keys.PublicKeyInfo({
'algorithm': keys.PublicKeyAlgorithm({
'algorithm': 'dsa',
'parameters': keys.DSAParams({
'p': p,
'q': q,
'g': g,
})
}),
'public_key': core.Integer(public),
})
elif key_type == 'private':
private = int_from_bytes(blob[private_offset:private_offset + key_byte_length])
return keys.PrivateKeyInfo({
'version': 0,
'private_key_algorithm': keys.PrivateKeyAlgorithm({
'algorithm': 'dsa',
'parameters': keys.DSAParams({
'p': p,
'q': q,
'g': g,
})
}),
'private_key': core.Integer(private),
})
else:
raise ValueError(pretty_message(
'''
key_type must be one of "public", "private", not %s
''',
repr(key_type)
))
|
def _bcrypt_interpret_ec_key_blob(key_type, blob_struct, blob):
"""
Take a CNG BCRYPT_ECCKEY_BLOB and converts it into an ASN.1 structure
:param key_type:
A unicode string of "private" or "public"
:param blob_struct:
An instance of BCRYPT_ECCKEY_BLOB
:param blob:
A byte string of the binary data contained after the struct
:return:
An asn1crypto.keys.PrivateKeyInfo or asn1crypto.keys.PublicKeyInfo
object, based on the key_type param
"""
magic = native(int, blob_struct.dwMagic)
key_byte_length = native(int, blob_struct.cbKey)
curve = {
BcryptConst.BCRYPT_ECDSA_PRIVATE_P256_MAGIC: 'secp256r1',
BcryptConst.BCRYPT_ECDSA_PRIVATE_P384_MAGIC: 'secp384r1',
BcryptConst.BCRYPT_ECDSA_PRIVATE_P521_MAGIC: 'secp521r1',
BcryptConst.BCRYPT_ECDSA_PUBLIC_P256_MAGIC: 'secp256r1',
BcryptConst.BCRYPT_ECDSA_PUBLIC_P384_MAGIC: 'secp384r1',
BcryptConst.BCRYPT_ECDSA_PUBLIC_P521_MAGIC: 'secp521r1',
}[magic]
public = b'\x04' + blob[0:key_byte_length * 2]
if key_type == 'public':
return keys.PublicKeyInfo({
'algorithm': keys.PublicKeyAlgorithm({
'algorithm': 'ec',
'parameters': keys.ECDomainParameters(
name='named',
value=curve
)
}),
'public_key': public,
})
elif key_type == 'private':
private = int_from_bytes(blob[key_byte_length * 2:key_byte_length * 3])
return keys.PrivateKeyInfo({
'version': 0,
'private_key_algorithm': keys.PrivateKeyAlgorithm({
'algorithm': 'ec',
'parameters': keys.ECDomainParameters(
name='named',
value=curve
)
}),
'private_key': keys.ECPrivateKey({
'version': 'ecPrivkeyVer1',
'private_key': private,
'public_key': public,
}),
})
else:
raise ValueError(pretty_message(
'''
key_type must be one of "public", "private", not %s
''',
repr(key_type)
))
|
def _load_key(key_object, container):
"""
Loads a certificate, public key or private key into a Certificate,
PublicKey or PrivateKey object
:param key_object:
An asn1crypto.x509.Certificate, asn1crypto.keys.PublicKeyInfo or
asn1crypto.keys.PrivateKeyInfo object
:param container:
The class of the object to hold the key_handle
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
oscrypto.errors.AsymmetricKeyError - when the key is incompatible with the OS crypto library
OSError - when an error is returned by the OS crypto library
:return:
A PrivateKey, PublicKey or Certificate object, based on container
"""
key_info = key_object
if isinstance(key_object, x509.Certificate):
key_info = key_object['tbs_certificate']['subject_public_key_info']
algo = key_info.algorithm
curve_name = None
if algo == 'ec':
curve_type, curve_name = key_info.curve
if curve_type != 'named':
raise AsymmetricKeyError(pretty_message(
'''
Windows only supports EC keys using named curves
'''
))
if curve_name not in set(['secp256r1', 'secp384r1', 'secp521r1']):
raise AsymmetricKeyError(pretty_message(
'''
Windows only supports EC keys using the named curves
secp256r1, secp384r1 and secp521r1
'''
))
elif algo == 'dsa':
if key_info.hash_algo is None:
raise IncompleteAsymmetricKeyError(pretty_message(
'''
The DSA key does not contain the necessary p, q and g
parameters and can not be used
'''
))
elif key_info.bit_size > 1024 and (_win_version_info < (6, 2) or _backend == 'winlegacy'):
raise AsymmetricKeyError(pretty_message(
'''
Windows XP, 2003, Vista, 7 and Server 2008 only support DSA
keys based on SHA1 (1024 bits or less) - this key is based
on %s and is %s bits
''',
key_info.hash_algo.upper(),
key_info.bit_size
))
elif key_info.bit_size == 2048 and key_info.hash_algo == 'sha1':
raise AsymmetricKeyError(pretty_message(
'''
Windows only supports 2048 bit DSA keys based on SHA2 - this
key is 2048 bits and based on SHA1, a non-standard
combination that is usually generated by old versions
of OpenSSL
'''
))
if _backend == 'winlegacy':
if algo == 'ec':
return container(None, key_object)
return _advapi32_load_key(key_object, key_info, container)
return _bcrypt_load_key(key_object, key_info, container, curve_name)
|
def _advapi32_load_key(key_object, key_info, container):
"""
Loads a certificate, public key or private key into a Certificate,
PublicKey or PrivateKey object via CryptoAPI
:param key_object:
An asn1crypto.x509.Certificate, asn1crypto.keys.PublicKeyInfo or
asn1crypto.keys.PrivateKeyInfo object
:param key_info:
An asn1crypto.keys.PublicKeyInfo or asn1crypto.keys.PrivateKeyInfo
object
:param container:
The class of the object to hold the key_handle
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
oscrypto.errors.AsymmetricKeyError - when the key is incompatible with the OS crypto library
OSError - when an error is returned by the OS crypto library
:return:
A PrivateKey, PublicKey or Certificate object, based on container
"""
key_type = 'public' if isinstance(key_info, keys.PublicKeyInfo) else 'private'
algo = key_info.algorithm
if algo == 'rsa':
provider = Advapi32Const.MS_ENH_RSA_AES_PROV
else:
provider = Advapi32Const.MS_ENH_DSS_DH_PROV
context_handle = None
key_handle = None
try:
context_handle = open_context_handle(provider, verify_only=key_type == 'public')
blob = _advapi32_create_blob(key_info, key_type, algo)
buffer_ = buffer_from_bytes(blob)
key_handle_pointer = new(advapi32, 'HCRYPTKEY *')
res = advapi32.CryptImportKey(
context_handle,
buffer_,
len(blob),
null(),
0,
key_handle_pointer
)
handle_error(res)
key_handle = unwrap(key_handle_pointer)
output = container(key_handle, key_object)
output.context_handle = context_handle
if algo == 'rsa':
ex_blob = _advapi32_create_blob(key_info, key_type, algo, signing=False)
ex_buffer = buffer_from_bytes(ex_blob)
ex_key_handle_pointer = new(advapi32, 'HCRYPTKEY *')
res = advapi32.CryptImportKey(
context_handle,
ex_buffer,
len(ex_blob),
null(),
0,
ex_key_handle_pointer
)
handle_error(res)
output.ex_key_handle = unwrap(ex_key_handle_pointer)
return output
except (Exception):
if key_handle:
advapi32.CryptDestroyKey(key_handle)
if context_handle:
close_context_handle(context_handle)
raise
|
def _advapi32_create_blob(key_info, key_type, algo, signing=True):
"""
Generates a blob for importing a key to CryptoAPI
:param key_info:
An asn1crypto.keys.PublicKeyInfo or asn1crypto.keys.PrivateKeyInfo
object
:param key_type:
A unicode string of "public" or "private"
:param algo:
A unicode string of "rsa" or "dsa"
:param signing:
If the key handle is for signing - may only be False for rsa keys
:return:
A byte string of a blob to pass to advapi32.CryptImportKey()
"""
if key_type == 'public':
blob_type = Advapi32Const.PUBLICKEYBLOB
else:
blob_type = Advapi32Const.PRIVATEKEYBLOB
if algo == 'rsa':
struct_type = 'RSABLOBHEADER'
if signing:
algorithm_id = Advapi32Const.CALG_RSA_SIGN
else:
algorithm_id = Advapi32Const.CALG_RSA_KEYX
else:
struct_type = 'DSSBLOBHEADER'
algorithm_id = Advapi32Const.CALG_DSS_SIGN
blob_header_pointer = struct(advapi32, 'BLOBHEADER')
blob_header = unwrap(blob_header_pointer)
blob_header.bType = blob_type
blob_header.bVersion = Advapi32Const.CUR_BLOB_VERSION
blob_header.reserved = 0
blob_header.aiKeyAlg = algorithm_id
blob_struct_pointer = struct(advapi32, struct_type)
blob_struct = unwrap(blob_struct_pointer)
blob_struct.publickeystruc = blob_header
bit_size = key_info.bit_size
len1 = bit_size // 8
len2 = bit_size // 16
if algo == 'rsa':
pubkey_pointer = struct(advapi32, 'RSAPUBKEY')
pubkey = unwrap(pubkey_pointer)
pubkey.bitlen = bit_size
if key_type == 'public':
parsed_key_info = key_info['public_key'].parsed
pubkey.magic = Advapi32Const.RSA1
pubkey.pubexp = parsed_key_info['public_exponent'].native
blob_data = int_to_bytes(parsed_key_info['modulus'].native, signed=False, width=len1)[::-1]
else:
parsed_key_info = key_info['private_key'].parsed
pubkey.magic = Advapi32Const.RSA2
pubkey.pubexp = parsed_key_info['public_exponent'].native
blob_data = int_to_bytes(parsed_key_info['modulus'].native, signed=False, width=len1)[::-1]
blob_data += int_to_bytes(parsed_key_info['prime1'].native, signed=False, width=len2)[::-1]
blob_data += int_to_bytes(parsed_key_info['prime2'].native, signed=False, width=len2)[::-1]
blob_data += int_to_bytes(parsed_key_info['exponent1'].native, signed=False, width=len2)[::-1]
blob_data += int_to_bytes(parsed_key_info['exponent2'].native, signed=False, width=len2)[::-1]
blob_data += int_to_bytes(parsed_key_info['coefficient'].native, signed=False, width=len2)[::-1]
blob_data += int_to_bytes(parsed_key_info['private_exponent'].native, signed=False, width=len1)[::-1]
blob_struct.rsapubkey = pubkey
else:
pubkey_pointer = struct(advapi32, 'DSSPUBKEY')
pubkey = unwrap(pubkey_pointer)
pubkey.bitlen = bit_size
if key_type == 'public':
pubkey.magic = Advapi32Const.DSS1
params = key_info['algorithm']['parameters'].native
key_data = int_to_bytes(key_info['public_key'].parsed.native, signed=False, width=len1)[::-1]
else:
pubkey.magic = Advapi32Const.DSS2
params = key_info['private_key_algorithm']['parameters'].native
key_data = int_to_bytes(key_info['private_key'].parsed.native, signed=False, width=20)[::-1]
blob_struct.dsspubkey = pubkey
blob_data = int_to_bytes(params['p'], signed=False, width=len1)[::-1]
blob_data += int_to_bytes(params['q'], signed=False, width=20)[::-1]
blob_data += int_to_bytes(params['g'], signed=False, width=len1)[::-1]
blob_data += key_data
dssseed_pointer = struct(advapi32, 'DSSSEED')
dssseed = unwrap(dssseed_pointer)
# This indicates no counter or seed info is available
dssseed.counter = 0xffffffff
blob_data += struct_bytes(dssseed_pointer)
return struct_bytes(blob_struct_pointer) + blob_data
|
def _bcrypt_load_key(key_object, key_info, container, curve_name):
"""
Loads a certificate, public key or private key into a Certificate,
PublicKey or PrivateKey object via CNG
:param key_object:
An asn1crypto.x509.Certificate, asn1crypto.keys.PublicKeyInfo or
asn1crypto.keys.PrivateKeyInfo object
:param key_info:
An asn1crypto.keys.PublicKeyInfo or asn1crypto.keys.PrivateKeyInfo
object
:param container:
The class of the object to hold the key_handle
:param curve_name:
None or a unicode string of the curve name for an EC key
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
oscrypto.errors.AsymmetricKeyError - when the key is incompatible with the OS crypto library
OSError - when an error is returned by the OS crypto library
:return:
A PrivateKey, PublicKey or Certificate object, based on container
"""
alg_handle = None
key_handle = None
key_type = 'public' if isinstance(key_info, keys.PublicKeyInfo) else 'private'
algo = key_info.algorithm
try:
alg_selector = key_info.curve[1] if algo == 'ec' else algo
alg_constant = {
'rsa': BcryptConst.BCRYPT_RSA_ALGORITHM,
'dsa': BcryptConst.BCRYPT_DSA_ALGORITHM,
'secp256r1': BcryptConst.BCRYPT_ECDSA_P256_ALGORITHM,
'secp384r1': BcryptConst.BCRYPT_ECDSA_P384_ALGORITHM,
'secp521r1': BcryptConst.BCRYPT_ECDSA_P521_ALGORITHM,
}[alg_selector]
alg_handle = open_alg_handle(alg_constant)
if algo == 'rsa':
if key_type == 'public':
blob_type = BcryptConst.BCRYPT_RSAPUBLIC_BLOB
magic = BcryptConst.BCRYPT_RSAPUBLIC_MAGIC
parsed_key = key_info['public_key'].parsed
prime1_size = 0
prime2_size = 0
else:
blob_type = BcryptConst.BCRYPT_RSAFULLPRIVATE_BLOB
magic = BcryptConst.BCRYPT_RSAFULLPRIVATE_MAGIC
parsed_key = key_info['private_key'].parsed
prime1 = int_to_bytes(parsed_key['prime1'].native)
prime2 = int_to_bytes(parsed_key['prime2'].native)
exponent1 = int_to_bytes(parsed_key['exponent1'].native)
exponent2 = int_to_bytes(parsed_key['exponent2'].native)
coefficient = int_to_bytes(parsed_key['coefficient'].native)
private_exponent = int_to_bytes(parsed_key['private_exponent'].native)
prime1_size = len(prime1)
prime2_size = len(prime2)
public_exponent = int_to_bytes(parsed_key['public_exponent'].native)
modulus = int_to_bytes(parsed_key['modulus'].native)
blob_struct_pointer = struct(bcrypt, 'BCRYPT_RSAKEY_BLOB')
blob_struct = unwrap(blob_struct_pointer)
blob_struct.Magic = magic
blob_struct.BitLength = key_info.bit_size
blob_struct.cbPublicExp = len(public_exponent)
blob_struct.cbModulus = len(modulus)
blob_struct.cbPrime1 = prime1_size
blob_struct.cbPrime2 = prime2_size
blob = struct_bytes(blob_struct_pointer) + public_exponent + modulus
if key_type == 'private':
blob += prime1 + prime2
blob += fill_width(exponent1, prime1_size)
blob += fill_width(exponent2, prime2_size)
blob += fill_width(coefficient, prime1_size)
blob += fill_width(private_exponent, len(modulus))
elif algo == 'dsa':
if key_type == 'public':
blob_type = BcryptConst.BCRYPT_DSA_PUBLIC_BLOB
public_key = key_info['public_key'].parsed.native
params = key_info['algorithm']['parameters']
else:
blob_type = BcryptConst.BCRYPT_DSA_PRIVATE_BLOB
public_key = key_info.public_key.native
private_bytes = int_to_bytes(key_info['private_key'].parsed.native)
params = key_info['private_key_algorithm']['parameters']
public_bytes = int_to_bytes(public_key)
p = int_to_bytes(params['p'].native)
g = int_to_bytes(params['g'].native)
q = int_to_bytes(params['q'].native)
if key_info.bit_size > 1024:
q_len = len(q)
else:
q_len = 20
key_width = max(len(public_bytes), len(g), len(p))
public_bytes = fill_width(public_bytes, key_width)
p = fill_width(p, key_width)
g = fill_width(g, key_width)
q = fill_width(q, q_len)
# We don't know the count or seed, so we set them to the max value
# since setting them to 0 results in a parameter error
count = b'\xff' * 4
seed = b'\xff' * q_len
if key_info.bit_size > 1024:
if key_type == 'public':
magic = BcryptConst.BCRYPT_DSA_PUBLIC_MAGIC_V2
else:
magic = BcryptConst.BCRYPT_DSA_PRIVATE_MAGIC_V2
blob_struct_pointer = struct(bcrypt, 'BCRYPT_DSA_KEY_BLOB_V2')
blob_struct = unwrap(blob_struct_pointer)
blob_struct.dwMagic = magic
blob_struct.cbKey = key_width
# We don't know if SHA256 was used here, but the output is long
# enough for the generation of q for the supported 2048/224,
# 2048/256 and 3072/256 FIPS approved pairs
blob_struct.hashAlgorithm = BcryptConst.DSA_HASH_ALGORITHM_SHA256
blob_struct.standardVersion = BcryptConst.DSA_FIPS186_3
blob_struct.cbSeedLength = q_len
blob_struct.cbGroupSize = q_len
blob_struct.Count = byte_array(count)
blob = struct_bytes(blob_struct_pointer)
blob += seed + q + p + g + public_bytes
if key_type == 'private':
blob += fill_width(private_bytes, q_len)
else:
if key_type == 'public':
magic = BcryptConst.BCRYPT_DSA_PUBLIC_MAGIC
else:
magic = BcryptConst.BCRYPT_DSA_PRIVATE_MAGIC
blob_struct_pointer = struct(bcrypt, 'BCRYPT_DSA_KEY_BLOB')
blob_struct = unwrap(blob_struct_pointer)
blob_struct.dwMagic = magic
blob_struct.cbKey = key_width
blob_struct.Count = byte_array(count)
blob_struct.Seed = byte_array(seed)
blob_struct.q = byte_array(q)
blob = struct_bytes(blob_struct_pointer) + p + g + public_bytes
if key_type == 'private':
blob += fill_width(private_bytes, q_len)
elif algo == 'ec':
if key_type == 'public':
blob_type = BcryptConst.BCRYPT_ECCPUBLIC_BLOB
public_key = key_info['public_key']
else:
blob_type = BcryptConst.BCRYPT_ECCPRIVATE_BLOB
public_key = key_info.public_key
private_bytes = int_to_bytes(key_info['private_key'].parsed['private_key'].native)
blob_struct_pointer = struct(bcrypt, 'BCRYPT_ECCKEY_BLOB')
blob_struct = unwrap(blob_struct_pointer)
magic = {
('public', 'secp256r1'): BcryptConst.BCRYPT_ECDSA_PUBLIC_P256_MAGIC,
('public', 'secp384r1'): BcryptConst.BCRYPT_ECDSA_PUBLIC_P384_MAGIC,
('public', 'secp521r1'): BcryptConst.BCRYPT_ECDSA_PUBLIC_P521_MAGIC,
('private', 'secp256r1'): BcryptConst.BCRYPT_ECDSA_PRIVATE_P256_MAGIC,
('private', 'secp384r1'): BcryptConst.BCRYPT_ECDSA_PRIVATE_P384_MAGIC,
('private', 'secp521r1'): BcryptConst.BCRYPT_ECDSA_PRIVATE_P521_MAGIC,
}[(key_type, curve_name)]
key_width = {
'secp256r1': 32,
'secp384r1': 48,
'secp521r1': 66
}[curve_name]
x, y = public_key.to_coords()
x_bytes = int_to_bytes(x)
y_bytes = int_to_bytes(y)
x_bytes = fill_width(x_bytes, key_width)
y_bytes = fill_width(y_bytes, key_width)
blob_struct.dwMagic = magic
blob_struct.cbKey = key_width
blob = struct_bytes(blob_struct_pointer) + x_bytes + y_bytes
if key_type == 'private':
blob += fill_width(private_bytes, key_width)
key_handle_pointer = new(bcrypt, 'BCRYPT_KEY_HANDLE *')
res = bcrypt.BCryptImportKeyPair(
alg_handle,
null(),
blob_type,
key_handle_pointer,
blob,
len(blob),
BcryptConst.BCRYPT_NO_KEY_VALIDATION
)
handle_error(res)
key_handle = unwrap(key_handle_pointer)
return container(key_handle, key_object)
finally:
if alg_handle:
close_alg_handle(alg_handle)
|
def load_public_key(source):
"""
Loads a public key into a PublicKey object
:param source:
A byte string of file contents, a unicode string filename or an
asn1crypto.keys.PublicKeyInfo object
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
oscrypto.errors.AsymmetricKeyError - when the public key is incompatible with the OS crypto library
OSError - when an error is returned by the OS crypto library
:return:
A PublicKey object
"""
if isinstance(source, keys.PublicKeyInfo):
public_key = source
elif isinstance(source, byte_cls):
public_key = parse_public(source)
elif isinstance(source, str_cls):
with open(source, 'rb') as f:
public_key = parse_public(f.read())
else:
raise TypeError(pretty_message(
'''
source must be a byte string, unicode string or
asn1crypto.keys.PublicKeyInfo object, not %s
''',
type_name(public_key)
))
return _load_key(public_key, PublicKey)
|
def load_pkcs12(source, password=None):
"""
Loads a .p12 or .pfx file into a PrivateKey object and one or more
Certificates objects
:param source:
A byte string of file contents or a unicode string filename
:param password:
A byte or unicode string to decrypt the PKCS12 file. Unicode strings
will be encoded using UTF-8.
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
oscrypto.errors.AsymmetricKeyError - when a contained key is incompatible with the OS crypto library
OSError - when an error is returned by the OS crypto library
:return:
A three-element tuple containing (PrivateKey, Certificate, [Certificate, ...])
"""
if password is not None:
if isinstance(password, str_cls):
password = password.encode('utf-8')
if not isinstance(password, byte_cls):
raise TypeError(pretty_message(
'''
password must be a byte string, not %s
''',
type_name(password)
))
if isinstance(source, str_cls):
with open(source, 'rb') as f:
source = f.read()
elif not isinstance(source, byte_cls):
raise TypeError(pretty_message(
'''
source must be a byte string or a unicode string, not %s
''',
type_name(source)
))
key_info, cert_info, extra_certs_info = parse_pkcs12(source, password)
key = None
cert = None
if key_info:
key = _load_key(key_info, PrivateKey)
if cert_info:
cert = _load_key(cert_info.public_key, Certificate)
extra_certs = [_load_key(info.public_key, Certificate) for info in extra_certs_info]
return (key, cert, extra_certs)
|
def rsa_pkcs1v15_verify(certificate_or_public_key, signature, data, hash_algorithm):
"""
Verifies an RSASSA-PKCS-v1.5 signature.
When the hash_algorithm is "raw", the operation is identical to RSA
public key decryption. That is: the data is not hashed and no ASN.1
structure with an algorithm identifier of the hash algorithm is placed in
the encrypted byte string.
:param certificate_or_public_key:
A Certificate or PublicKey instance to verify the signature with
:param signature:
A byte string of the signature to verify
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384", "sha512" or "raw"
:raises:
oscrypto.errors.SignatureError - when the signature is determined to be invalid
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
"""
if certificate_or_public_key.algorithm != 'rsa':
raise ValueError('The key specified is not an RSA public key')
return _verify(certificate_or_public_key, signature, data, hash_algorithm)
|
def rsa_pss_verify(certificate_or_public_key, signature, data, hash_algorithm):
"""
Verifies an RSASSA-PSS signature. For the PSS padding the mask gen algorithm
will be mgf1 using the same hash algorithm as the signature. The salt length
with be the length of the hash algorithm, and the trailer field with be the
standard 0xBC byte.
:param certificate_or_public_key:
A Certificate or PublicKey instance to verify the signature with
:param signature:
A byte string of the signature to verify
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384" or "sha512"
:raises:
oscrypto.errors.SignatureError - when the signature is determined to be invalid
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
"""
if certificate_or_public_key.algorithm != 'rsa':
raise ValueError('The key specified is not an RSA public key')
return _verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=True)
|
def _verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=False):
"""
Verifies an RSA, DSA or ECDSA signature
:param certificate_or_public_key:
A Certificate or PublicKey instance to verify the signature with
:param signature:
A byte string of the signature to verify
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384", "sha512" or "raw"
:param rsa_pss_padding:
If PSS padding should be used for RSA keys
:raises:
oscrypto.errors.SignatureError - when the signature is determined to be invalid
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
"""
if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):
raise TypeError(pretty_message(
'''
certificate_or_public_key must be an instance of the Certificate or
PublicKey class, not %s
''',
type_name(certificate_or_public_key)
))
if not isinstance(signature, byte_cls):
raise TypeError(pretty_message(
'''
signature must be a byte string, not %s
''',
type_name(signature)
))
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
valid_hash_algorithms = set(['md5', 'sha1', 'sha256', 'sha384', 'sha512'])
if certificate_or_public_key.algorithm == 'rsa' and not rsa_pss_padding:
valid_hash_algorithms |= set(['raw'])
if hash_algorithm not in valid_hash_algorithms:
valid_hash_algorithms_error = '"md5", "sha1", "sha256", "sha384", "sha512"'
if certificate_or_public_key.algorithm == 'rsa' and not rsa_pss_padding:
valid_hash_algorithms_error += ', "raw"'
raise ValueError(pretty_message(
'''
hash_algorithm must be one of %s, not %s
''',
valid_hash_algorithms_error,
repr(hash_algorithm)
))
if certificate_or_public_key.algorithm != 'rsa' and rsa_pss_padding is not False:
raise ValueError(pretty_message(
'''
PSS padding may only be used with RSA keys - signing via a %s key
was requested
''',
certificate_or_public_key.algorithm.upper()
))
if hash_algorithm == 'raw':
if len(data) > certificate_or_public_key.byte_size - 11:
raise ValueError(pretty_message(
'''
data must be 11 bytes shorter than the key size when
hash_algorithm is "raw" - key size is %s bytes, but
data is %s bytes long
''',
certificate_or_public_key.byte_size,
len(data)
))
if _backend == 'winlegacy':
if certificate_or_public_key.algorithm == 'ec':
return _pure_python_ecdsa_verify(certificate_or_public_key, signature, data, hash_algorithm)
return _advapi32_verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding)
return _bcrypt_verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding)
|
def _advapi32_verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=False):
"""
Verifies an RSA, DSA or ECDSA signature via CryptoAPI
:param certificate_or_public_key:
A Certificate or PublicKey instance to verify the signature with
:param signature:
A byte string of the signature to verify
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384", "sha512" or "raw"
:param rsa_pss_padding:
If PSS padding should be used for RSA keys
:raises:
oscrypto.errors.SignatureError - when the signature is determined to be invalid
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
"""
algo = certificate_or_public_key.algorithm
if algo == 'rsa' and rsa_pss_padding:
hash_length = {
'sha1': 20,
'sha224': 28,
'sha256': 32,
'sha384': 48,
'sha512': 64
}.get(hash_algorithm, 0)
decrypted_signature = raw_rsa_public_crypt(certificate_or_public_key, signature)
key_size = certificate_or_public_key.bit_size
if not verify_pss_padding(hash_algorithm, hash_length, key_size, data, decrypted_signature):
raise SignatureError('Signature is invalid')
return
if algo == 'rsa' and hash_algorithm == 'raw':
padded_plaintext = raw_rsa_public_crypt(certificate_or_public_key, signature)
try:
plaintext = remove_pkcs1v15_signature_padding(certificate_or_public_key.byte_size, padded_plaintext)
if not constant_compare(plaintext, data):
raise ValueError()
except (ValueError):
raise SignatureError('Signature is invalid')
return
hash_handle = None
try:
alg_id = {
'md5': Advapi32Const.CALG_MD5,
'sha1': Advapi32Const.CALG_SHA1,
'sha256': Advapi32Const.CALG_SHA_256,
'sha384': Advapi32Const.CALG_SHA_384,
'sha512': Advapi32Const.CALG_SHA_512,
}[hash_algorithm]
hash_handle_pointer = new(advapi32, 'HCRYPTHASH *')
res = advapi32.CryptCreateHash(
certificate_or_public_key.context_handle,
alg_id,
null(),
0,
hash_handle_pointer
)
handle_error(res)
hash_handle = unwrap(hash_handle_pointer)
res = advapi32.CryptHashData(hash_handle, data, len(data), 0)
handle_error(res)
if algo == 'dsa':
# Windows doesn't use the ASN.1 Sequence for DSA signatures,
# so we have to convert it here for the verification to work
try:
signature = algos.DSASignature.load(signature).to_p1363()
# Switch the two integers so that the reversal later will
# result in the correct order
half_len = len(signature) // 2
signature = signature[half_len:] + signature[:half_len]
except (ValueError, OverflowError, TypeError):
raise SignatureError('Signature is invalid')
# The CryptoAPI expects signatures to be in little endian byte order,
# which is the opposite of other systems, so we must reverse it
reversed_signature = signature[::-1]
res = advapi32.CryptVerifySignatureW(
hash_handle,
reversed_signature,
len(signature),
certificate_or_public_key.key_handle,
null(),
0
)
handle_error(res)
finally:
if hash_handle:
advapi32.CryptDestroyHash(hash_handle)
|
def _bcrypt_verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=False):
"""
Verifies an RSA, DSA or ECDSA signature via CNG
:param certificate_or_public_key:
A Certificate or PublicKey instance to verify the signature with
:param signature:
A byte string of the signature to verify
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384", "sha512" or "raw"
:param rsa_pss_padding:
If PSS padding should be used for RSA keys
:raises:
oscrypto.errors.SignatureError - when the signature is determined to be invalid
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
"""
if hash_algorithm == 'raw':
digest = data
else:
hash_constant = {
'md5': BcryptConst.BCRYPT_MD5_ALGORITHM,
'sha1': BcryptConst.BCRYPT_SHA1_ALGORITHM,
'sha256': BcryptConst.BCRYPT_SHA256_ALGORITHM,
'sha384': BcryptConst.BCRYPT_SHA384_ALGORITHM,
'sha512': BcryptConst.BCRYPT_SHA512_ALGORITHM
}[hash_algorithm]
digest = getattr(hashlib, hash_algorithm)(data).digest()
padding_info = null()
flags = 0
if certificate_or_public_key.algorithm == 'rsa':
if rsa_pss_padding:
flags = BcryptConst.BCRYPT_PAD_PSS
padding_info_struct_pointer = struct(bcrypt, 'BCRYPT_PSS_PADDING_INFO')
padding_info_struct = unwrap(padding_info_struct_pointer)
# This has to be assigned to a variable to prevent cffi from gc'ing it
hash_buffer = buffer_from_unicode(hash_constant)
padding_info_struct.pszAlgId = cast(bcrypt, 'wchar_t *', hash_buffer)
padding_info_struct.cbSalt = len(digest)
else:
flags = BcryptConst.BCRYPT_PAD_PKCS1
padding_info_struct_pointer = struct(bcrypt, 'BCRYPT_PKCS1_PADDING_INFO')
padding_info_struct = unwrap(padding_info_struct_pointer)
# This has to be assigned to a variable to prevent cffi from gc'ing it
if hash_algorithm == 'raw':
padding_info_struct.pszAlgId = null()
else:
hash_buffer = buffer_from_unicode(hash_constant)
padding_info_struct.pszAlgId = cast(bcrypt, 'wchar_t *', hash_buffer)
padding_info = cast(bcrypt, 'void *', padding_info_struct_pointer)
else:
# Windows doesn't use the ASN.1 Sequence for DSA/ECDSA signatures,
# so we have to convert it here for the verification to work
try:
signature = algos.DSASignature.load(signature).to_p1363()
except (ValueError, OverflowError, TypeError):
raise SignatureError('Signature is invalid')
res = bcrypt.BCryptVerifySignature(
certificate_or_public_key.key_handle,
padding_info,
digest,
len(digest),
signature,
len(signature),
flags
)
failure = res == BcryptConst.STATUS_INVALID_SIGNATURE
failure = failure or res == BcryptConst.STATUS_INVALID_PARAMETER
if failure:
raise SignatureError('Signature is invalid')
handle_error(res)
|
def rsa_pkcs1v15_sign(private_key, data, hash_algorithm):
"""
Generates an RSASSA-PKCS-v1.5 signature.
When the hash_algorithm is "raw", the operation is identical to RSA
private key encryption. That is: the data is not hashed and no ASN.1
structure with an algorithm identifier of the hash algorithm is placed in
the encrypted byte string.
:param private_key:
The PrivateKey to generate the signature with
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384", "sha512" or "raw"
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the signature
"""
if private_key.algorithm != 'rsa':
raise ValueError('The key specified is not an RSA private key')
return _sign(private_key, data, hash_algorithm)
|
def rsa_pss_sign(private_key, data, hash_algorithm):
"""
Generates an RSASSA-PSS signature. For the PSS padding the mask gen
algorithm will be mgf1 using the same hash algorithm as the signature. The
salt length with be the length of the hash algorithm, and the trailer field
with be the standard 0xBC byte.
:param private_key:
The PrivateKey to generate the signature with
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384" or "sha512"
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the signature
"""
if private_key.algorithm != 'rsa':
raise ValueError('The key specified is not an RSA private key')
return _sign(private_key, data, hash_algorithm, rsa_pss_padding=True)
|
def dsa_sign(private_key, data, hash_algorithm):
"""
Generates a DSA signature
:param private_key:
The PrivateKey to generate the signature with
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384" or "sha512"
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the signature
"""
if private_key.algorithm != 'dsa':
raise ValueError('The key specified is not a DSA private key')
return _sign(private_key, data, hash_algorithm)
|
def ecdsa_sign(private_key, data, hash_algorithm):
"""
Generates an ECDSA signature
:param private_key:
The PrivateKey to generate the signature with
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384" or "sha512"
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the signature
"""
if private_key.algorithm != 'ec':
raise ValueError('The key specified is not an EC private key')
return _sign(private_key, data, hash_algorithm)
|
def _sign(private_key, data, hash_algorithm, rsa_pss_padding=False):
"""
Generates an RSA, DSA or ECDSA signature
:param private_key:
The PrivateKey to generate the signature with
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384", "sha512" or "raw"
:param rsa_pss_padding:
If PSS padding should be used for RSA keys
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the signature
"""
if not isinstance(private_key, PrivateKey):
raise TypeError(pretty_message(
'''
private_key must be an instance of PrivateKey, not %s
''',
type_name(private_key)
))
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
valid_hash_algorithms = set(['md5', 'sha1', 'sha256', 'sha384', 'sha512'])
if private_key.algorithm == 'rsa' and not rsa_pss_padding:
valid_hash_algorithms |= set(['raw'])
if hash_algorithm not in valid_hash_algorithms:
valid_hash_algorithms_error = '"md5", "sha1", "sha256", "sha384", "sha512"'
if private_key.algorithm == 'rsa' and not rsa_pss_padding:
valid_hash_algorithms_error += ', "raw"'
raise ValueError(pretty_message(
'''
hash_algorithm must be one of %s, not %s
''',
valid_hash_algorithms_error,
repr(hash_algorithm)
))
if private_key.algorithm != 'rsa' and rsa_pss_padding is not False:
raise ValueError(pretty_message(
'''
PSS padding may only be used with RSA keys - signing via a %s key
was requested
''',
private_key.algorithm.upper()
))
if hash_algorithm == 'raw':
if len(data) > private_key.byte_size - 11:
raise ValueError(pretty_message(
'''
data must be 11 bytes shorter than the key size when
hash_algorithm is "raw" - key size is %s bytes, but data
is %s bytes long
''',
private_key.byte_size,
len(data)
))
if _backend == 'winlegacy':
if private_key.algorithm == 'ec':
return _pure_python_ecdsa_sign(private_key, data, hash_algorithm)
return _advapi32_sign(private_key, data, hash_algorithm, rsa_pss_padding)
return _bcrypt_sign(private_key, data, hash_algorithm, rsa_pss_padding)
|
def _advapi32_sign(private_key, data, hash_algorithm, rsa_pss_padding=False):
"""
Generates an RSA, DSA or ECDSA signature via CryptoAPI
:param private_key:
The PrivateKey to generate the signature with
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode string of "md5", "sha1", "sha256", "sha384", "sha512" or "raw"
:param rsa_pss_padding:
If PSS padding should be used for RSA keys
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the signature
"""
algo = private_key.algorithm
if algo == 'rsa' and hash_algorithm == 'raw':
padded_data = add_pkcs1v15_signature_padding(private_key.byte_size, data)
return raw_rsa_private_crypt(private_key, padded_data)
if algo == 'rsa' and rsa_pss_padding:
hash_length = {
'sha1': 20,
'sha224': 28,
'sha256': 32,
'sha384': 48,
'sha512': 64
}.get(hash_algorithm, 0)
padded_data = add_pss_padding(hash_algorithm, hash_length, private_key.bit_size, data)
return raw_rsa_private_crypt(private_key, padded_data)
if private_key.algorithm == 'dsa' and hash_algorithm == 'md5':
raise ValueError(pretty_message(
'''
Windows does not support md5 signatures with DSA keys
'''
))
hash_handle = None
try:
alg_id = {
'md5': Advapi32Const.CALG_MD5,
'sha1': Advapi32Const.CALG_SHA1,
'sha256': Advapi32Const.CALG_SHA_256,
'sha384': Advapi32Const.CALG_SHA_384,
'sha512': Advapi32Const.CALG_SHA_512,
}[hash_algorithm]
hash_handle_pointer = new(advapi32, 'HCRYPTHASH *')
res = advapi32.CryptCreateHash(
private_key.context_handle,
alg_id,
null(),
0,
hash_handle_pointer
)
handle_error(res)
hash_handle = unwrap(hash_handle_pointer)
res = advapi32.CryptHashData(hash_handle, data, len(data), 0)
handle_error(res)
out_len = new(advapi32, 'DWORD *')
res = advapi32.CryptSignHashW(
hash_handle,
Advapi32Const.AT_SIGNATURE,
null(),
0,
null(),
out_len
)
handle_error(res)
buffer_length = deref(out_len)
buffer_ = buffer_from_bytes(buffer_length)
res = advapi32.CryptSignHashW(
hash_handle,
Advapi32Const.AT_SIGNATURE,
null(),
0,
buffer_,
out_len
)
handle_error(res)
output = bytes_from_buffer(buffer_, deref(out_len))
# CryptoAPI outputs the signature in little endian byte order, so we
# must swap it for compatibility with other systems
output = output[::-1]
if algo == 'dsa':
# Switch the two integers because the reversal just before switched
# then
half_len = len(output) // 2
output = output[half_len:] + output[:half_len]
# Windows doesn't use the ASN.1 Sequence for DSA signatures,
# so we have to convert it here for the verification to work
output = algos.DSASignature.from_p1363(output).dump()
return output
finally:
if hash_handle:
advapi32.CryptDestroyHash(hash_handle)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.