def test_validate_document(url=LISTEN_URL):
data = {
'institution': INSTITUTION,
'notification_url': url,
'document': CERTIFICATE_FILE,
'request_datetime': timezone.now().strftime("%Y-%m-%d %H:%M:%S"),
}
algorithm = ALGORITHM
str_data = json.dumps(data)
# print(str_data)
edata = encrypt(SERVER_PUBLIC_KEY, str_data)
hashsum = get_hash_sum(edata, ALGORITHM)
edata = edata.decode()
params = {
"data_hash": hashsum,
"algorithm": algorithm,
"public_certificate": PUBLIC_CERTIFICATE,
'institution': INSTITUTION,
"data": edata,
}
result = requests.post(SERVER_URL + '/validate/institution_document/',
json=params)
# print(params)
data = result.json()
print(data)
def validate_digest(self):
hashsum = get_hash_sum(self.data['data'], self.data['algorithm'])
if hashsum != self.data['data_hash']:
self._errors['data_hash'] = [
_('Hash sums are not equal %s != %s') %
(hashsum, self.data['data_hash'])
]
def get_request_params(self, data, **kwargs):
algorithm = kwargs.get('algorithm', self.ALGORITHM)
str_data = json.dumps(data)
use = kwargs.get('use', 'sign')
edata_fun = kwargs.get('edata', None)
if edata_fun:
edata = edata_fun(str_data, etype=use)
else:
edata = self.client._encrypt(str_data, etype=use)
hashsum = kwargs.get('hashsum', get_hash_sum(edata, algorithm))
edata = edata.decode()
if use == 'sign':
tmpcert = self.client._get_public_sign_certificate()
else:
tmpcert = self.client._get_public_auth_certificate()
certificate = kwargs.get('public_certificate', tmpcert)
person = kwargs.get('person', self.person)
params = {
"data_hash": hashsum,
"algorithm": algorithm,
"public_certificate": certificate,
'person': person,
"data": edata,
}
return params
def test_authentication_detail(identificacion, url=LISTEN_URL):
authdata = test_authentication(identificacion, url=LISTEN_URL)
data = {
'institution': INSTITUTION,
'notification_url': url,
'identification': identificacion,
'request_datetime': timezone.now().isoformat(),
}
algorithm = ALGORITHM
str_data = json.dumps(data)
# print(str_data)
edata = encrypt(SERVER_PUBLIC_KEY, str_data)
hashsum = get_hash_sum(edata, ALGORITHM)
edata = edata.decode()
params = {
"data_hash": hashsum,
"algorithm": algorithm,
"public_certificate": PUBLIC_CERTIFICATE,
'institution': INSTITUTION,
"data": edata,
}
result = requests.post(
SERVER_URL + "/authenticate/%s/institution_show/" % (authdata['code']), json=params)
# print(params)
data = result.json()
return data
def test_msoffice_signer(identificacion, url=LISTEN_URL):
data = {
'institution': INSTITUTION,
'notification_url': url,
'document': DOCXFILE,
'format': 'msoffice',
'algorithm_hash': 'sha512',
'document_hash': HASHDOCX,
'identification': identificacion,
'resumen': 'Documento de prueba odf',
'request_datetime': timezone.now().strftime("%Y-%m-%d %H:%M:%S"),
}
algorithm = ALGORITHM
str_data = json.dumps(data)
# print(str_data)
edata = encrypt(SERVER_PUBLIC_KEY, str_data)
hashsum = get_hash_sum(edata, ALGORITHM)
edata = edata.decode()
params = {
"data_hash": hashsum,
"algorithm": algorithm,
"public_certificate": PUBLIC_CERTIFICATE,
'institution': INSTITUTION,
"data": edata,
}
result = requests.post(SERVER_URL + '/sign/institution/', json=params)
data = result.json()
print(data)
return data
def test_signer_show(identificacion, url=LISTEN_URL):
signdata = test_xml_signer(identificacion, url=LISTEN_URL)
print(signdata)
data = {
'institution': INSTITUTION,
'notification_url': url,
'identification': identificacion,
'request_datetime': timezone.now().strftime("%Y-%m-%d %H:%M:%S"),
}
algorithm = ALGORITHM
str_data = json.dumps(data)
# print(str_data)
edata = encrypt(SERVER_PUBLIC_KEY, str_data)
hashsum = get_hash_sum(edata, ALGORITHM)
edata = edata.decode()
params = {
"data_hash": hashsum,
"algorithm": algorithm,
"public_certificate": PUBLIC_CERTIFICATE,
'institution': INSTITUTION,
"data": edata,
}
result = requests.post(SERVER_URL + '/sign/%s/institution_show/' %
(signdata['code'], ),
json=params)
data = result.json()
return data
def send_notification(data,
serializer=None,
request=None,
encrypt_method='aes_eax'):
"""
Envia notificación a la institución, cuando se recibe una respuesta por parte del BCCR, este método
reenvía la respuesta a la URL especificada en la petición.
La estructura de envío es:
:params id_transaction: Id de transacción del BCCR
:params data: Es un diccionario con los siguientes atributos
* **code:** Código de identificación de la transacción (no es el mismo que el que se muestra en al usuario en firma)
* **identification:** Identificador del suscriptor
* **id_transaction:** Id de trasnacción en el FVA del BCCR
* **request_datetime:** Hora de recepción de la solicitud
* **sign_document:** Almacena el documento, pero no se garantiza que venga el documento firmado, puede ser None
* **expiration_datetime:** Hora de recepción de la solicitud
* **received_notification:** True si la autenticación ha sido procesada, False si está esperando al usuario
* **duration:** tiempo que duró entre que fue enviada y fue recibida
* **status:** Código de error de la transacción
* **status_text:** Descripción en texto del estado
:params hashsum: Suma hash realizada a data
:params algorithm: Algoritmo con el que se realizó la suma hash
Por defecto se utiliza el método de encripción seleccionado al realizar la petición por parte de la institución, pero en caso de no lograrse
identificar el método se utiliza por defecto 'aes_eax'
"""
if data.notification_url == 'N/D':
return
if serializer is None:
serializer, req = get_datarequest_serializer(data)
ars = serializer(data)
datajson = JSONRenderer().render(ars.data)
edata = encrypt(data.institution.public_key,
datajson,
method=encrypt_method)
hashsum = get_hash_sum(edata, req.algorithm)
error = None
try:
response = requests.post(data.notification_url,
data={
'id_transaction': data.id_transaction,
'data': edata.decode(),
'hashsum': hashsum,
'algorithm': req.algorithm
})
response.raise_for_status()
except Exception as e:
error = e
logger.error('Receptor: notificando a %s lanza %s' %
(data.notification_url, e))
return error
def sign_document_terms(request, pk):
obj = get_object_or_404(UserConditionsAndTerms, pk=pk)
signclient = ClienteFirmador(
settings.DEFAULT_BUSSINESS,
settings.DEFAULT_ENTITY)
if signclient.validar_servicio():
document_resume = "Acepta términos para el uso responsable de la aplicación"
document = b64encode(obj.document_signed.encode())
hash_sum = get_hash_sum(document, 'sha512')
data = signclient.firme(
request.user.username,
document.decode(),
'xml_cofirma',
algoritmo_hash='Sha512',
hash_doc=hash_sum,
resumen=document_resume)
signed_doc = SignDataRequest.objects.create(
institution=Institution.objects.filter(
administrative_institution=True).first(),
notification_url='n/d',
identification=request.user.username,
request_datetime=timezone.now(),
code=data['codigo_verificacion'],
status=data['codigo_error'],
status_text=data['texto_codigo_error'],
expiration_datetime=timezone.now(
) - timezone.timedelta(int(data['tiempo_maximo'])),
id_transaction=int(data['id_solicitud']),
duration=data['tiempo_maximo'],
document_format='xml'
)
request.session['signed_doc'] = signed_doc.pk
else:
logger.warning("Sign BCCR not available")
data = signclient.DEFAULT_ERROR
success = data['codigo_error'] == settings.DEFAULT_SUCCESS_BCCR
return JsonResponse({
'FueExitosaLaSolicitud': success,
'TiempoMaximoDeFirmaEnSegundos': 240,
'TiempoDeEsperaParaConsultarLaFirmaEnSegundos': 2,
'CodigoDeVerificacion': data['codigo_verificacion'],
'IdDeLaSolicitud': data['id_solicitud'],
'DebeMostrarElError': not success,
'DescripcionDelError': data['texto_codigo_error'],
'ResumenDelDocumento': document_resume
})
def get_request_params(self, data, **kwargs):
algorithm = kwargs.get('algorithm', self.ALGORITHM)
server_public_key = kwargs.get('server_public_key',
self.institution.server_public_key)
str_data = json.dumps(data)
edata = encrypt(server_public_key, str_data)
hashsum = kwargs.get('hashsum', get_hash_sum(edata, algorithm))
institution = kwargs.get('institution', str(self.institution.code))
edata = edata.decode()
certificate = kwargs.get('public_certificate',
self.institution.public_certificate)
params = {
"data_hash": hashsum,
"algorithm": algorithm,
"public_certificate": certificate,
'institution': institution,
"data": edata,
}
return params
def own_sign(self, **kwargs):
identification = kwargs.get('identification', self.person)
person = kwargs.get('person', self.person)
document = kwargs.get('document', None)
algorithm = kwargs.get('algorithm', 'sha512')
is_base64 = kwargs.get('is_base64', False)
_format = kwargs.get('_format', 'xml_cofirma')
resume = kwargs.get('resume', 'resumen magnifico')
request_datetime = kwargs.get(
'request_datetime', timezone.now().isoformat())
if not is_base64:
document = b64encode(document).decode()
data = {
'person': person,
'document': document,
'format': _format,
'algorithm_hash': algorithm,
'document_hash': get_hash_sum(document, algorithm),
'identification': identification,
'resumen': resume,
'request_datetime': request_datetime,
}
params = self.get_request_params(data, **kwargs)
headers = {'Accept': 'application/json',
'Content-Type': 'application/json'}
result = self.request_client.post(
self.settings.fva_server_url + self.settings.sign_person,
json=params, headers=headers)
data = result.json()
try:
data = self._decrypt(data['data'])
except:
pass
return data