def get(self,
request,
name,
url_subdir='',
url_file=None,
format=None,
**kwargs):
name = util.name_url_decode(name)
options_form, values = get_dnssec_options_form_data(request.GET)
rdtypes = set(values['rr'])
denial_of_existence = values['doe']
dnssec_algorithms = set(values['a'])
ds_algorithms = set(values['ds'])
trusted_keys_explicit = values['tk']
trusted_zones = values['ta']
redundant_edges = values['red']
trusted_keys = trusted_keys_explicit + trusted_zones
a = DynamicAnalyst(name)
name_obj = a.analyze()
name_obj.populate_status(trusted_keys,
supported_algs=dnssec_algorithms,
supported_digest_algs=ds_algorithms)
G = self._graph_name(name_obj, trusted_keys, rdtypes,
denial_of_existence)
G.add_trust(trusted_keys, supported_algs=dnssec_algorithms)
G.remove_extra_edges(redundant_edges)
if url_file == 'auth_graph':
return self.dnssec_auth_graph(request, name_obj, G, format)
else:
raise Http404
def get(self, request, name, url_subdir='', **kwargs):
name = util.name_url_decode(name)
options_form, values = get_dnssec_options_form_data(request.GET)
name_obj = _OfflineDomainNameAnalysis(name)
name_obj.analysis_end = datetime.datetime.now(
fmt.utc).replace(microsecond=0)
name_obj.base_url_with_timestamp = '../'
name_obj.previous = OfflineDomainNameAnalysis.objects.latest(name)
template = 'dnssec.html'
analyzed_name_obj = name_obj
date_form = domain_date_search_form(name)(
initial={
'date': fmt.datetime_to_str(name_obj.analysis_end)[:10]
})
return render_to_response(template, {
'name_obj': name_obj,
'analyzed_name_obj': analyzed_name_obj,
'url_subdir': url_subdir,
'title': name_obj,
'options_form': options_form,
'date_form': date_form,
'use_js': True,
'query_string': request.META['QUERY_STRING']
},
context_instance=RequestContext(request))
def get(self, request, name, timestamp=None, url_subdir='', **kwargs):
name = util.name_url_decode(name)
if timestamp is None:
name_obj = OfflineDomainNameAnalysis.objects.latest(name)
else:
date = util.datetime_url_decode(timestamp)
name_obj = OfflineDomainNameAnalysis.objects.get_by_date(
name, date)
if name_obj is None:
raise Http404
return self._get(request, name_obj, timestamp, url_subdir, None,
**kwargs)
def get(self, request, name, group_id, url_subdir='', **kwargs):
if 'reset_query' in request.GET:
return reset_query_string(request)
name = util.name_url_decode(name)
try:
group = OfflineDomainNameAnalysis.objects.get(pk=int(group_id))
except OfflineDomainNameAnalysis.DoesNotExist:
name_obj = None
else:
name_obj = OfflineDomainNameAnalysis.objects.get_by_group(
name, group)
if not url_subdir:
url_subdir = ''
if name_obj is None:
raise Http404
return self._get(request, name_obj, None, url_subdir, None, **kwargs)
def get(self, request, name, timestamp=None, url_subdir='', **kwargs):
if 'reset_query' in request.GET:
return reset_query_string(request)
name = util.name_url_decode(name)
if 'date_search' in request.GET:
date_form = domain_date_search_form(name)(request.GET)
if date_form.is_valid():
return HttpResponseRedirect(
'%s%s' %
(date_form.name_obj.base_url_with_timestamp(), url_subdir))
else:
date_form = None
if timestamp is None:
name_obj = OfflineDomainNameAnalysis.objects.latest(name)
else:
date = util.datetime_url_decode(timestamp)
name_obj = OfflineDomainNameAnalysis.objects.get_by_date(
name, date)
if name_obj is None:
subdir_path_length = len(url_subdir.split('/')) - 1
if timestamp is None:
return HttpResponseRedirect(('../' * subdir_path_length) +
'analyze/')
else:
raise Http404
if date_form is None:
date_form = domain_date_search_form(name)(
initial={
'date': fmt.datetime_to_str(name_obj.analysis_end)[:10]
})
return self._get(request, name_obj, timestamp, url_subdir, date_form,
**kwargs)
def analyze(request, name, url_subdir=None):
name = util.name_url_decode(name)
name_obj = OfflineDomainNameAnalysis.objects.latest(name)
if not url_subdir:
url_subdir = ''
if name_obj is None:
name_obj = OfflineDomainNameAnalysis(name)
else:
name_obj.retrieve_ancestry(name_obj.RDTYPES_DELEGATION)
name_obj.retrieve_related(name_obj.RDTYPES_DELEGATION)
form_class = domain_analysis_form(name_obj.name)
error_msg = None
if request.POST:
request_logger = logging.getLogger('django.request')
analysis_logger = log.IsolatedLogger(logging.DEBUG)
def success_callback(name_obj):
analysis_logger.logger.info('Success!')
if name_obj.group is not None:
next_url = name_obj.base_url_with_timestamp()
else:
next_url = '../'
analysis_logger.handler.queue.put(
'{"type":"next-location","url":"%s"}\r\n' % escape(next_url))
analysis_logger.close()
def exc_callback(exc_info):
analysis_logger.logger.error('Error analyzing %s' % name_obj)
request_logger.error('Error analyzing %s' % name_obj,
exc_info=exc_info)
analysis_logger.handler.queue.put(
'{"type":"next-location","url":"./"}\r\n')
analysis_logger.close()
# instantiate a bound form
analyze_form = form_class(request.POST)
if analyze_form.is_valid():
extra_rdtypes = analyze_form.cleaned_data['extra_types']
if analyze_form.cleaned_data[
'analysis_type'] == ANALYSIS_TYPE_AUTHORITATIVE:
analyst_cls = Analyst
force_ancestor = analyze_form.cleaned_data['force_ancestor']
explicit_delegations = _set_mappings(
force_ancestor,
analyze_form.cleaned_data['explicit_delegation'])
else:
analyst_cls = RecursiveAnalyst
force_ancestor = dns.name.root
explicit_delegations = _set_mappings(
WILDCARD_EXPLICIT_DELEGATION,
analyze_form.cleaned_data['explicit_delegation'])
if analyze_form.cleaned_data['perspective'] == 'client':
sockname = os.path.join(
tempfile.gettempdir(),
hashlib.sha1(
analyze_form.cleaned_data['sockname']).hexdigest())
th_factories = (
transport.DNSQueryTransportHandlerWebSocketFactory(
sockname), )
force_ancestor = dns.name.root
force_group = True
elif analyze_form.cleaned_data['perspective'] == 'other':
th_factories = (transport.DNSQueryTransportHandlerHTTPFactory(
analyze_form.cleaned_data['looking_glass']), )
force_group = False
else:
th_factories = None
force_group = False
opt = analyze_form.cleaned_data['ecs']
if opt is not None:
class Foo(object):
edns_options = [opt]
query_class_mixin = Foo
force_group = True
else:
query_class_mixin = None
edns_diagnostics = analyze_form.cleaned_data['edns_diagnostics']
stop_at_explicit = {force_ancestor: True}
start_time = datetime.datetime.now(fmt.utc).replace(microsecond=0)
# for ajax requests, analyze asynchronously, using a logger with
# callbacks and streaming output to the browser. If there is an
# error with the analysis, it will be handled by the javascript.
if request.is_ajax():
a = analyst_cls(name_obj.name,
logger=analysis_logger.logger,
query_class_mixin=query_class_mixin,
edns_diagnostics=edns_diagnostics,
stop_at_explicit=stop_at_explicit,
explicit_delegations=explicit_delegations,
extra_rdtypes=extra_rdtypes,
th_factories=th_factories,
start_time=start_time,
force_ancestor=force_ancestor,
force_group=force_group)
a.analyze_async(success_callback, exc_callback)
#TODO set alarm here for too long waits
return StreamingHttpResponse(analysis_logger.handler)
# for non-ajax requests analyze synchronously
else:
a = analyst_cls(name_obj.name,
query_class_mixin=query_class_mixin,
edns_diagnostics=edns_diagnostics,
stop_at_explicit=stop_at_explicit,
explicit_delegations=explicit_delegations,
extra_rdtypes=extra_rdtypes,
th_factories=th_factories,
start_time=start_time,
force_ancestor=force_ancestor,
force_group=force_group)
try:
name_obj = a.analyze()
# if there is an error with the analysis, then return the bound form,
# so the errors will be rendered with the form.
except:
request_logger.exception('Error analyzing %s' % name_obj)
error_msg = u'There was an error analyzing %s. We\'ve been notified of the problem and will look into fixing it. Please try again later.' % name_obj
# if there were no errors, then return a redirect
else:
if name_obj.group is not None:
next_url = name_obj.base_url_with_timestamp()
else:
next_url = '../'
return HttpResponseRedirect(next_url)
# if the form contents were invalid in an ajax request, then send a
# critical-level error, which will prompt the browser to re-issue a
# POST, so the errors are seen.
elif request.is_ajax():
analysis_logger.logger.critical('Form error')
analysis_logger.close()
return StreamingHttpResponse(analysis_logger.handler,
content_type='application/json')
# instantiate an unbound form
else:
analyze_form = form_class()
return render_to_response('analyze.html', {
'name_obj': name_obj,
'url_subdir': url_subdir,
'title': name_obj,
'error_msg': error_msg,
'analyze_form': analyze_form
},
context_instance=RequestContext(request))
