def _verify_signed_message(self, content_type):
if content_type != 'multipart/signed':
raise AS2MdnException('content-type invalid when signed required')
mdn_signature_thumbprint = self.context.agreement.outbound_agreement.message_encryption_certificate.thumbprint
mdn_signature_cert_path = self.context.agreement.outbound_agreement.message_encryption_certificate.local_file_path
mdn_signature_cert_ca_path = self.context.agreement.outbound_agreement.message_encryption_certificate.local_ca_file_path
mdn_signature_cert_verify = self.context.agreement.outbound_agreement.message_encryption_certificate.is_need_verify
try:
if is_none_or_whitespace(mdn_signature_cert_ca_path):
mdn_signature_cert_ca_path = mdn_signature_cert_path
f_mime_string = SMIMEHelper.format_with_cr_lf(
SMIMEHelper.mime_to_string(self.mime_message))
SMIMEHelper.verify_signed_text(f_mime_string,
mdn_signature_cert_path,
mdn_signature_cert_ca_path,
mdn_signature_cert_verify)
self.context.trace(
"mdn signature verify finished; thumbprint: {thumbprint}, verify certificate: {verify}",
thumbprint=mdn_signature_thumbprint,
verify=mdn_signature_cert_verify)
except:
logger.exception(
"mdn signature verify failed; mdn-message-id: {id}".format(
id=self.mdn_message_id))
raise AS2MdnException(
"mdn signature verify failed; thumbprint: {thumbprint}, verify certificate: {verify}, due to: {message}",
thumbprint=mdn_signature_thumbprint,
verify=mdn_signature_cert_verify,
message=sys.exc_info()[1])
def _verify_signature(self):
if not self.is_signed:
self.context.trace("verify signature ignored")
return
content_type = self.mime_message.get_content_type().lower()
if content_type != 'multipart/signed':
raise AS2VerifySignatureException('verify signature failed; content-type:{type} invalid',
type=content_type)
cert_thumbprint = self.context.agreement.inbound_agreement.message_verify_certificate.thumbprint
cert_local_file_path = self.context.agreement.inbound_agreement.message_verify_certificate.local_file_path
cert_ca_local_file_path = self.context.agreement.inbound_agreement.message_verify_certificate.local_ca_file_path
cert_verify = self.context.agreement.inbound_agreement.message_verify_certificate.is_need_verify
try:
if is_none_or_whitespace(cert_ca_local_file_path):
cert_ca_local_file_path = cert_local_file_path
for part in self.mime_message.get_payload():
if not isinstance(part, email.message.Message):
continue
part_type = part.get_content_type().lower()
part_encoding = part.get('Content-Transfer-Encoding', '').lower()
if 'application/pkcs7-signature' == part_type and 'base64' != part_encoding:
del part['Content-Transfer-Encoding']
email.encoders.encode_base64(part)
self.context.trace('signature content transfer encoding to base64')
f_mime_string = SMIMEHelper.format_with_cr_lf(
SMIMEHelper.mime_to_string(self.mime_message))
SMIMEHelper.verify_signed_text(
f_mime_string,
cert_local_file_path,
cert_ca_local_file_path,
cert_verify)
self.mic_algorithm = self.mime_message.get_param('micalg').lower()
parts = [part for part in self.mime_message.walk() if
part.get_content_type() not in ['multipart/signed', 'application/pkcs7-signature']]
if len(parts) != 1:
raise AS2VerifySignatureException(
"verify signature failed; due to multiple part content in mime message")
self.mime_message = parts[0]
self.context.trace("verify signature finished; thumbprint: {thumbprint}, verify certificate: {verify}",
thumbprint=cert_thumbprint,
verify=cert_verify)
except:
logger.exception("verify signature failed; message-id: {id}".format(id=self.message_id))
raise AS2VerifySignatureException(
"verify signature failed; thumbprint: {thumbprint}, verify certificate: {verify}, due to: {message}",
thumbprint=cert_thumbprint,
verify=cert_verify,
message=sys.exc_info()[1])
def test_mime_to_string_public_cert_without_ca_des_ede3_cbc(self):
crt_path = self.__get_cert_path('P1_public.cer')
alg = "des_ede3_cbc"
rst = SMIMEHelper.encrypt_to_mime(self.clearText, crt_path, alg)
msg = SMIMEHelper.mime_to_string(rst, 0)
assert_not_equal(None, msg)
assert_equal(True, "MIME-Version" in msg)
def test_format_with_cr_lf_public_cert_without_ca_des_ede3_cbc(self):
crt_path = self.__get_cert_path('P1_public.cer')
alg = "des_ede3_cbc"
rst = SMIMEHelper.encrypt_to_mime(self.clearText, crt_path, alg)
msg = SMIMEHelper.mime_to_string(rst)
f_msg = SMIMEHelper.format_with_cr_lf(msg)
assert_not_equal(msg, f_msg)
assert_equal(True, "\r\n" in f_msg)
def test_get_signature_from_mime_without_Override(self):
crt_path = self.__get_cert_path('edi04_with_ca.pem')
pass_phrase = "newegg@123"
rst = SMIMEHelper.sign_to_mime_detached(self.clearText, crt_path, pass_phrase)
signature = SMIMEHelper.get_signature_from_mime(rst, False, 'application/pkcs7-signature')
assert_not_equal(None, signature)
assert_equal(True, "Content-Disposition" in signature)
assert_equal(True, "Content-Type" in signature)
def test_compress_to_mime(self):
mime = SMIMEHelper.compress_to_mime(self.clearText)
assert_not_equal(None, mime)
assert_equal(mime['Content-Transfer-Encoding'], 'base64')
assert_equal(mime['Content-Disposition'], 'attachment; filename="smime.p7z"')
assert_equal(True, 'smime-type="compressed-data"' in mime['Content-Type'])
def _decompress(self):
if not self.is_compressed:
self.context.trace("decompress ignored")
return
content_type = self.mime_message.get_content_type().lower()
s_mime_type = self.mime_message.get_param('smime-type')
if content_type != 'application/pkcs7-mime':
raise AS2DeCompressException('decompress failed; content-type:{type} invalid',
type=content_type)
if s_mime_type != 'compressed-data':
raise AS2DecryptException('decompress failed; s/mime-type:{type} invalid', type=s_mime_type)
try:
decompress_content = self.mime_message.get_payload(decode=True)
content = SMIMEHelper.decompress_text(decompress_content)
self.mime_message = email.message_from_string(content)
self.context.trace("decompress finished")
except:
logger.exception("decompress failed; message-id: {id}".format(id=self.message_id))
raise AS2DeCompressException(
"decompress failed; due to: {message}", message=sys.exc_info()[1])
def test_decrypt_private_key_without_ca_des_ede3_cbc(self):
encrypted_text = '''MIME-Version: 1.0
Content-Disposition: attachment; filename="smime.p7m"
Content-Type: application/x-pkcs7-mime; smime-type=enveloped-data;
name="smime.p7m"
Content-Transfer-Encoding: base64
MIICAgYJKoZIhvcNAQcDoIIB8zCCAe8CAQAxggGrMIIBpwIBADCBjjCBgDELMAkG
A1UEBhMCQ04xCzAJBgNVBAgMAlNDMQswCQYDVQQHDAJDRDEPMA0GA1UECgwGTmV3
ZWdnMQwwCgYDVQQLDANFREkxGDAWBgNVBAMMD0FTMiBDZXJ0aWZpY2F0ZTEeMBwG
CSqGSIb3DQEJARYPdHIyOUBuZXdlZ2cuY29tAgkAtl4VWyGqGb4wDQYJKoZIhvcN
AQEBBQAEggEAzzzLpEFOzQDULtCBBcoDLobNGXSPUfSI45uatdlnqrwh8EsG2qan
Wbti6jMRIm6jvVX7u/lrI/gNK/zpWiMvg3VIgCN1vgPRE808Tx//EPXbyFH+ODGT
n/n77he+krbKY7kFwv86udat2OjzMaGjeQpQ2ILW3YYsf+Ce0zCa/AA0IYQeiZVN
G1ksb3kLstdYsU7hOi6OhgZlAYPZSe3zwnEjqe/uToOl8XedEkvmQvNbNbwEzJhB
44h9O7WTABD8DBHydgPahrOWqmcAOdPRjHHyRSnsss9HY9dCFjLHjiWexSszYLAr
5FgGcwITA+YSAMM3fujgFhJFAp1Z/xtQuDA7BgkqhkiG9w0BBwEwFAYIKoZIhvcN
AwcECIa9BZlgtfVYgBh82ue/PhnoQ6/wrwekWNPOkVJN8kX2xPw=
'''
key_file_path = u'' + self.__get_cert_path('P1_private.pem')
pass_phrase = u"123456"
rst = SMIMEHelper.decrypt_from_text(encrypted_text, key_file_path, pass_phrase)
assert_equal(self.clearText, rst)
def test_decrypt_private_key_with_ca_aes_128_cbc(self):
encrypted_text = '''MIME-Version: 1.0
Content-Disposition: attachment; filename="smime.p7m"
Content-Type: application/x-pkcs7-mime; smime-type=enveloped-data;
name="smime.p7m"
Content-Transfer-Encoding: base64
MIICQgYJKoZIhvcNAQcDoIICMzCCAi8CAQAxggHsMIIB6AIBADCBzzCBujELMAkG
A1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3
d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDEyIEVu
dHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEuMCwGA1UEAxMl
RW50cnVzdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEwxSwIQHnF4IP05B10A
AAAAUNw1czANBgkqhkiG9w0BAQEFAASCAQCeEwTDvzE8KQgO+Pt/vcGfj/ZMKu20
dJz6AufIIBvHmWIQFGAL/PQ3Fk/Awxcyvz9/LvOXvNEAHnxifRXb2LqnoW+Uxoys
gY7eccsx/cQleZ+/GIeY3INPF74BX7ywzhxjy018wvfY8PkuCtWSe8vYKZTmksY4
qdrFxaWIhLHHZDNbRaZ/vrk/BpxZvm5BQdd1B1+g6E8+PVNX8Z/lJXcHmpkdKmEe
WZZtqYUQoZpp70eMPMifl0Beyp2bgP6DwGvPmk2Wv7pNE1+wu3K7C5XoAQ6NfeZp
bhu51OP2Rb28NFwFqSt984vbThCzaRDZyL4eLi5oUtw5H8L7IUQuh3Z2MDoGCSqG
SIb3DQEHATALBglghkgBZQMEAQGAIIIt/NjfM683MbhOQTMf3JuRgSYHx+je3OjP
GnNVcfZP
'''
key_file_path = self.__get_cert_path('edi04_with_ca.pem')
pass_phrase = "newegg@123"
rst = SMIMEHelper.decrypt_from_text(encrypted_text, key_file_path, pass_phrase)
assert_equal(self.clearText, rst)
def test_sign_private_cert_with_ca_sha_1(self):
crt_path = self.__get_cert_path('edi04_with_ca.pem')
pass_phrase = "newegg@123"
rst = SMIMEHelper.sign_to_mime_detached(self.clearText, crt_path, pass_phrase)
assert_not_equal(None, rst)
assert_equal('sha1', rst.get_param('micalg'))
def test_encrypt_public_cert_without_ca_aes_128_cbc(self):
crt_path = self.__get_cert_path('P1_public.cer')
alg = "aes_128_cbc"
rst = SMIMEHelper.encrypt_to_mime(self.clearText, crt_path, alg)
assert_not_equal(None, rst._headers)
assert_equal(('MIME-Version', '1.0'), rst._headers[0])
def test_encrypt_public_cert_with_ca_des_ede3_cbc(self):
crt_path = self.__get_cert_path('mercury_ingrammicro_com.sha256.cer')
alg = "des_ede3_cbc"
rst = SMIMEHelper.encrypt_to_mime(self.clearText, crt_path, alg)
assert_not_equal(None, rst._headers)
assert_equal(('MIME-Version', '1.0'), rst._headers[0])
def test_encrypt_public_cert_with_ca_des_ede3_cbc(self):
crt_path = self.__get_cert_path('edi04_with_ca.crt')
alg = "des_ede3_cbc"
rst = SMIMEHelper.encrypt_to_mime(self.clearText, crt_path, alg)
assert_not_equal(None, rst._headers)
assert_equal(('MIME-Version', '1.0'), rst._headers[0])
def test_extract_payload_with_multipart(self):
signed_mime_message = MIMEMultipart('signed', protocol="application/pkcs7-signature")
payload = SMIMEHelper.extract_payload(signed_mime_message)
assert_not_equal(None, payload)
assert_not_equal("", payload)
assert_equal(True, payload.startswith("--"))
def test_sign_private_cert_with_china_without_ca_sha_1(self):
clearText = '测试文件'
crt_path = self.__get_cert_path('P1_private.pem')
pass_phrase = "123456"
rst = SMIMEHelper.sign_to_mime_detached(clearText, crt_path, pass_phrase)
assert_not_equal(None, rst)
assert_equal('sha1', rst.get_param('micalg'))
def test_decompress_text(self):
b64_decompress_content = '''ME8GCyqGSIb3DQEJEAEJoEAwPgIBADANBgsqhkiG9w0BCRADCDAqBgkqhkiG9w0BBwGgHQQbeJwL
ycgsVgCiktTiEoXc1OLixPRUPQBULQeo
'''
decompress_content = base64.decodestring(b64_decompress_content)
content = SMIMEHelper.decompress_text(decompress_content)
assert_equal(content, self.clearText)
def test_sign_private_cert_with_iso_8859_01_without_ca_sha_1(self):
clearText = 'ISA¦00¦ ¦00¦ ¦16¦081940553PA10 ¦ZZ¦5626958823BVF ¦170522¦1940¦U¦00401¦001038283¦0¦P¦`~'
crt_path = self.__get_cert_path('P1_private.pem')
pass_phrase = "123456"
rst = SMIMEHelper.sign_to_mime_detached(clearText, crt_path, pass_phrase)
assert_not_equal(None, rst)
assert_equal('sha1', rst.get_param('micalg'))
def test_sign_private_cert_without_ca_md5(self):
crt_path = self.__get_cert_path('P1_private.pem')
pass_phrase = "123456"
alg = 'md5'
rst = SMIMEHelper.sign_to_mime_detached(self.clearText, crt_path, pass_phrase, alg)
assert_not_equal(None, rst)
assert_equal('md5', rst.get_param('micalg'))
def _decrypt(self):
if not self.is_encrypted:
self.context.trace("decrypt ignored")
return
content_type = self.mime_message.get_content_type().lower()
s_mime_type = self.mime_message.get_param('smime-type')
if content_type != 'application/pkcs7-mime':
raise AS2DecryptException('decrypt failed; content-type:{type} invalid', type=content_type)
if s_mime_type != 'enveloped-data':
raise AS2DecryptException('decrypt failed; s/mime-type:{type} invalid', type=s_mime_type)
cert_thumbprint = self.context.agreement.inbound_agreement.message_decrypt_certificate.thumbprint
cert_local_file_path = self.context.agreement.inbound_agreement.message_decrypt_certificate.local_file_path
cert_pass_phrase = self.context.agreement.inbound_agreement.message_decrypt_certificate.pass_phrase
try:
content_transfer_encoding = self.mime_message.get('Content-Transfer-Encoding', '').lower()
if 'base64' != content_transfer_encoding:
del self.mime_message['Content-Transfer-Encoding']
email.encoders.encode_base64(self.mime_message)
self.context.trace('content transfer encoding to base64')
f_mime_string = SMIMEHelper.format_with_cr_lf(
SMIMEHelper.mime_to_string(self.mime_message, 78)
)
decrypted_content = SMIMEHelper.decrypt_from_text(
f_mime_string,
cert_local_file_path,
cert_pass_phrase
)
self.mime_message = email.message_from_string(decrypted_content)
self.context.trace("decrypt finished; thumbprint: {thumbprint}",
thumbprint=cert_thumbprint)
except:
logger.exception("decrypt failed; message-id: {id}".format(id=self.message_id))
raise AS2DecryptException("decrypt failed; thumbprint: {thumbprint}, due to: {message}",
thumbprint=cert_thumbprint,
message=sys.exc_info()[1])
def test_extract_payload(self):
text_plain = "test message"
mime_message = email.Message.Message()
mime_message.set_payload(text_plain)
payload = SMIMEHelper.extract_payload(mime_message)
assert_not_equal(None, payload)
assert_not_equal("", payload)
assert_equal(text_plain, payload)
def _compress(self):
if not self.is_compressed:
self.context.trace("compress ignored")
return
try:
f_mime_string = SMIMEHelper.format_with_cr_lf(
SMIMEHelper.mime_to_string(self.mime_message))
self.mic_content = f_mime_string
self.mime_message = SMIMEHelper.compress_to_mime(f_mime_string)
del self.mime_message['MIME-Version']
self.body = self.mime_message.get_payload()
self.context.trace("compress finished")
except:
logger.exception("compress failed; message-id: {id}".format(id=self.message_id))
raise AS2CompressException("compress failed; due to: {message}", message=sys.exc_info()[1])
def encode(self):
try:
self._init_mode(self.context.message.message_mdn.mdn_mode)
self._init_message_id(self.context.message.message_mdn)
self._init_disposition(self.context.message.message_mdn)
self._init_mic(self.context.message.message_is_mic,
self.context.message.message_mdn)
mdn_report = MIMEMultipart(
'report',
boundary=SMIMEHelper.get_random_boundary(),
report_type="disposition-notification")
mdn_confirmation_text = self._build_confirmation_mime()
mdn_feedback_content = self._build_feedback_content_mime()
mdn_report.attach(mdn_confirmation_text)
mdn_report.attach(mdn_feedback_content)
del mdn_report['MIME-Version']
if self.context.agreement.inbound_agreement.is_mdn_signed:
mdn_message = self._signature_mdn_mime(mdn_report)
else:
mdn_message = mdn_report
self.context.trace("mdn signature ignore")
mdn_headers = self._build_mdn_headers(mdn_message)
mdn_body = SMIMEHelper.format_with_cr_lf(
SMIMEHelper.extract_payload(mdn_message))
return mdn_headers, mdn_body
except AS2MdnException as ex:
self.context.trace_error(ex.msg)
raise
except:
self.context.trace_error(sys.exc_info()[1])
raise
def _signature_mdn_mime(self, mdn_report):
signed_mdn_report = MIMEMultipart(
'signed',
boundary=SMIMEHelper.get_random_boundary(),
protocol="application/pkcs7-signature")
signed_mdn_report.attach(mdn_report)
cert_thumbprint = self.context.agreement.outbound_agreement.message_signature_certificate.thumbprint
cert_local_file_path = self.context.agreement.outbound_agreement.message_signature_certificate.local_file_path
cert_pass_phrase = self.context.agreement.outbound_agreement.message_signature_certificate.pass_phrase
cert_signature_algorithm = self.context.agreement.inbound_agreement.mdn_signature_algorithm
try:
mime_message = SMIMEHelper.sign_to_mime_detached(
SMIMEHelper.format_with_cr_lf(
SMIMEHelper.mime_to_string(mdn_report)),
cert_local_file_path, cert_pass_phrase,
cert_signature_algorithm)
signature = SMIMEHelper.get_signature_from_mime(mime_message)
del signature['MIME-Version']
signed_mdn_report.set_param('micalg', cert_signature_algorithm)
signed_mdn_report.attach(signature)
self.context.trace(
"mdn signature finished; thumbprint: {thumbprint}, algorithm: {algorithm}",
thumbprint=cert_thumbprint,
algorithm=cert_signature_algorithm)
except:
logger.exception('sign mdn failed')
raise AS2MdnException(
"mdn signature failed; thumbprint: {thumbprint}, algorithm: {algorithm}, due to: {message}",
thumbprint=cert_thumbprint,
algorithm=cert_signature_algorithm,
message=sys.exc_info()[1])
return signed_mdn_report
def _encryption(self):
if not self.is_encrypted:
self.context.trace("encryption ignored")
return
cert_thumbprint = self.context.agreement.outbound_agreement.message_encryption_certificate.thumbprint
cert_local_file_path = self.context.agreement.outbound_agreement.message_encryption_certificate.local_file_path
cert_encrypt_algorithm = self.context.agreement.outbound_agreement.message_encryption_algorithm
try:
f_mime_string = SMIMEHelper.format_with_cr_lf(
SMIMEHelper.mime_to_string(self.mime_message))
# encrypt without sign and compress
if not self.is_signed and not self.is_compressed:
self.mic_content = f_mime_string
encrypted_mime_message = SMIMEHelper.encrypt_to_mime(
f_mime_string,
cert_local_file_path,
cert_encrypt_algorithm)
encrypted_mime_message.set_type('application/pkcs7-mime')
self.body = encrypted_mime_message.get_payload()
self.mime_message = encrypted_mime_message
self.context.trace("encryption finished; thumbprint: {thumbprint}, algorithm: {algorithm}",
thumbprint=cert_thumbprint,
algorithm=cert_encrypt_algorithm)
except:
logger.exception("encryption failed; message-id: {id}".format(id=self.message_id))
raise AS2EncryptException(
"encryption failed; thumbprint: {thumbprint}, algorithm: {algorithm}, due to: {message}",
thumbprint=cert_thumbprint,
algorithm=cert_encrypt_algorithm,
message=sys.exc_info()[1])
def _signature(self):
if not self.is_signed:
self.context.trace("signature ignored")
return
cert_thumbprint = self.context.agreement.outbound_agreement.message_signature_certificate.thumbprint
cert_local_file_path = self.context.agreement.outbound_agreement.message_signature_certificate.local_file_path
cert_pass_phrase = self.context.agreement.outbound_agreement.message_signature_certificate.pass_phrase
cert_signature_algorithm = self.context.agreement.outbound_agreement.message_signature_algorithm
try:
f_mime_string = SMIMEHelper.format_with_cr_lf(
SMIMEHelper.mime_to_string(self.mime_message))
self.mic_content = f_mime_string
self.mic_algorithm = self.context.agreement.outbound_agreement.message_signature_algorithm
detached_signed_message = SMIMEHelper.sign_to_mime_detached(
f_mime_string,
cert_local_file_path,
cert_pass_phrase,
cert_signature_algorithm)
signature = SMIMEHelper.get_signature_from_mime(detached_signed_message)
if signature is None:
raise Exception("signature is none from detached signed mime message")
signed_mime_message = MIMEMultipart('signed', boundary=SMIMEHelper.get_random_boundary(),
protocol="application/pkcs7-signature")
del signed_mime_message['MIME-Version']
signed_mime_message.set_param('micalg', self.mic_algorithm)
signed_mime_message.attach(self.mime_message)
signed_mime_message.attach(signature)
self.body = SMIMEHelper.format_with_cr_lf(SMIMEHelper.extract_payload(signed_mime_message))
self.mime_message = signed_mime_message
self.context.trace("signature finished; thumbprint: {thumbprint}, algorithm: {algorithm}",
thumbprint=cert_thumbprint,
algorithm=cert_signature_algorithm)
except:
logger.exception("signature failed; message-id: {id}".format(id=self.message_id))
raise AS2SignatureException(
"signature failed; thumbprint: {thumbprint}, algorithm: {algorithm}, due to: {message}",
thumbprint=cert_thumbprint,
algorithm=cert_signature_algorithm,
message=sys.exc_info()[1])
def _build_certificate(self, cert_id):
if cert_id is None:
return None
try:
certificate = CloudStoreHelper().get_document(cert_id, Certificate)
if certificate is None:
raise Exception("as2 certificate is null")
if certificate.type == CertificateType.public:
certificate.local_file_path = os.path.join(
self.conf['app_root_dir'], "cert", "public",
certificate.thumbprint + ".pem")
else:
certificate.local_file_path = os.path.join(
self.conf['app_root_dir'], "cert", "private",
certificate.thumbprint + ".pem")
if not is_none_or_whitespace(certificate.pass_phrase):
certificate.pass_phrase = SMIMEHelper.aes_decrypt(
certificate.pass_phrase, self.conf['app_secure_key'])
if os.path.exists(certificate.local_file_path):
return certificate
local_path = os.path.dirname(certificate.local_file_path)
if not os.path.exists(local_path):
os.makedirs(local_path)
if not DFSHelper.download2file(certificate.dfs_file_path,
certificate.local_file_path):
raise Exception("download certificate file from dfs failed")
return certificate
except:
raise Exception(
"get as2 certificate failed; certificate-id: {id}, due to {msg}"
.format(id=cert_id, msg=sys.exc_info()[1]))
def test_verify_multipart_signed_text_without_ca(self):
signed_msg = '''MIME-Version: 1.0
Content-Type: multipart/signed; protocol="application/x-pkcs7-signature";
micalg="sha1"; boundary="----E67033C32AF07C4C5BE242D36DB48F2F"
This is an S/MIME signed message
------E67033C32AF07C4C5BE242D36DB48F2F
This is test message.
------E67033C32AF07C4C5BE242D36DB48F2F
Content-Type: application/x-pkcs7-signature; name="smime.p7s"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="smime.p7s"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------E67033C32AF07C4C5BE242D36DB48F2F--
'''
f_signed_msg = SMIMEHelper.format_with_cr_lf(signed_msg)
crt_path = self.__get_cert_path('P1_public.cer')
ca_crt_path = self.__get_cert_path('P1_public.cer')
is_verify_cert = True
rst = SMIMEHelper.verify_signed_text(f_signed_msg, crt_path, ca_crt_path, is_verify_cert)
assert_equal(self.clearText, rst.strip())
def test_verify_multipart_signed_text_with_ca(self):
signed_msg = '''MIME-Version: 1.0
Content-Type: multipart/signed; protocol="application/x-pkcs7-signature";
micalg="sha1"; boundary="----61FD602D4D31C5FCAE3D9C6C0E9789D2"
This is an S/MIME signed message
------61FD602D4D31C5FCAE3D9C6C0E9789D2
This is test message.
------61FD602D4D31C5FCAE3D9C6C0E9789D2
Content-Type: application/x-pkcs7-signature; name="smime.p7s"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="smime.p7s"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------61FD602D4D31C5FCAE3D9C6C0E9789D2--
'''
f_signed_msg = SMIMEHelper.format_with_cr_lf(signed_msg)
crt_path = self.__get_cert_path('edi04_with_ca.crt')
ca_crt_path = self.__get_cert_path('edi04_ca_cert_chain.crt')
is_verify_cert = False
rst = SMIMEHelper.verify_signed_text(f_signed_msg, crt_path, ca_crt_path, is_verify_cert)
assert_equal(self.clearText, rst.strip())
def test_verify_signed_data_without_ca(self):
signed_msg = '''MIME-Version: 1.0
Content-Disposition: attachment; filename="smime.p7m"
Content-Type: application/x-pkcs7-mime; smime-type=signed-data; name="smime.p7m"
Content-Transfer-Encoding: base64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=
'''
f_signed_msg = SMIMEHelper.format_with_cr_lf(signed_msg)
crt_path = self.__get_cert_path('P1_public.cer')
ca_crt_path = self.__get_cert_path('P1_public.cer')
is_verify_cert = True
rst = SMIMEHelper.verify_signed_text(f_signed_msg, crt_path, ca_crt_path, is_verify_cert)
assert_equal(self.clearText, rst.strip())
def test_verify_signed_data_no_verify_cert_without_ca(self):
signed_msg = '''MIME-Version: 1.0
Content-Disposition: attachment; filename="smime.p7m"
Content-Type: application/x-pkcs7-mime; smime-type=signed-data; name="smime.p7m"
Content-Transfer-Encoding: base64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'''
f_signed_msg = SMIMEHelper.format_with_cr_lf(signed_msg)
crt_path = self.__get_cert_path('P1_public.cer')
ca_crt_path = self.__get_cert_path('P1_public.cer')
is_verify_cert = False
rst = SMIMEHelper.verify_signed_text(f_signed_msg, crt_path, ca_crt_path, is_verify_cert)
assert_equal(self.clearText, rst.strip())