Esempio n. 1
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.signed_message_pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))

        self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])

        sd, rest = der_decoder(asn1Object['content'],
                               asn1Spec=rfc5652.SignedData())
        self.assertFalse(rest)
        self.assertTrue(sd.prettyPrint())
        self.assertEqual(asn1Object['content'], der_encoder(sd))

        for sa in sd['signerInfos'][0]['signedAttrs']:
            sat = sa['attrType']
            sav0 = sa['attrValues'][0]

            if sat in rfc6211.id_aa_cmsAlgorithmProtect:
                sav, rest = der_decoder(
                    sav0, asn1Spec=rfc6211.CMSAlgorithmProtection())
                self.assertFalse(rest)
                self.assertTrue(sav.prettyPrint())
                self.assertEqual(sav0, der_encoder(sav))
Esempio n. 2
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))

        assert asn1Object['contentType'] == rfc5652.id_signedData
        sd, rest = der_decoder(asn1Object['content'],
                               asn1Spec=rfc5652.SignedData())
        self.assertFalse(rest)
        self.assertTrue(sd.prettyPrint())
        self.assertEqual(asn1Object['content'], der_encoder(sd))

        found = False
        for sa in sd['signerInfos'][0]['signedAttrs']:
            if sa['attrType'] == rfc5652.id_contentType:
                ct, rest = der_decoder(sa['attrValues'][0],
                                       asn1Spec=rfc5652.ContentType())
                self.assertFalse(rest)
                self.assertTrue(ct.prettyPrint())
                self.assertEqual(sa['attrValues'][0], der_encoder(ct))
                self.assertEqual(rfc9092.id_ct_geofeedCSVwithCRLF, ct)
                found = True

        assert found
Esempio n. 3
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.signed_message_pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)

        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))
        self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])

        sd, rest = der_decoder(asn1Object['content'],
                               asn1Spec=rfc5652.SignedData())
        self.assertFalse(rest)
        self.assertTrue(sd.prettyPrint())
        self.assertEqual(asn1Object['content'], der_encoder(sd))

        cmsAttributesMap = opentypemap.get('cmsAttributesMap')
        for sa in sd['signerInfos'][0]['signedAttrs']:
            sat = sa['attrType']
            sav0 = sa['attrValues'][0]

            if sat in cmsAttributesMap:
                sav, rest = der_decoder(sav0, asn1Spec=cmsAttributesMap[sat])
                self.assertFalse(rest)
                self.assertTrue(sav.prettyPrint())
                self.assertEqual(sav0, der_encoder(sav))
Esempio n. 4
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.tau_pem_text)

        layers = {
            rfc5652.id_ct_contentInfo: rfc5652.ContentInfo(),
            rfc5652.id_signedData: rfc5652.SignedData(),
            rfc5934.id_ct_TAMP_update: rfc5934.TAMPUpdate()
        }

        getNextLayer = {
            rfc5652.id_ct_contentInfo: lambda x: x['contentType'],
            rfc5652.id_signedData:
            lambda x: x['encapContentInfo']['eContentType'],
            rfc5934.id_ct_TAMP_update: lambda x: None
        }

        getNextSubstrate = {
            rfc5652.id_ct_contentInfo: lambda x: x['content'],
            rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContent'],
            rfc5934.id_ct_TAMP_update: lambda x: None
        }

        next_layer = rfc5652.id_ct_contentInfo

        while next_layer:
            asn1Object, rest = der_decoder(substrate,
                                           asn1Spec=layers[next_layer])

            self.assertFalse(rest)
            self.assertTrue(asn1Object.prettyPrint())
            self.assertEqual(substrate, der_encoder(asn1Object))

            substrate = getNextSubstrate[next_layer](asn1Object)
            next_layer = getNextLayer[next_layer](asn1Object)
Esempio n. 5
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.message1_pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)

        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))
        self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])

        sd, rest = der_decoder(
            asn1Object['content'], asn1Spec=rfc5652.SignedData())

        for sa in sd['signerInfos'][0]['signedAttrs']:
            sat = sa['attrType']
            sav0 = sa['attrValues'][0]

            if sat == rfc7191.id_aa_KP_keyPkgIdAndReceiptReq:
                sav, rest = der_decoder(
                    sav0, asn1Spec=rfc7191.KeyPkgIdentifierAndReceiptReq())

                self.assertFalse(rest)
                self.assertTrue(sav.prettyPrint())
                self.assertEqual(sav0, der_encoder(sav))

                package_id_pem_text = "J7icVjsWIlGdF4cceb+siG3f+D0="
                package_id = pem.readBase64fromText(package_id_pem_text)

                self.assertEqual(package_id, sav['pkgID'])
Esempio n. 6
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.message3_pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))

        self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])

        sd, rest = der_decoder(asn1Object['content'],
            asn1Spec=rfc5652.SignedData())
        self.assertFalse(rest)
        self.assertTrue(sd.prettyPrint())
        self.assertEqual(asn1Object['content'], der_encoder(sd))

        oid = sd['encapContentInfo']['eContentType']

        self.assertEqual(rfc7191.id_ct_KP_keyPackageError, oid)

        kpe, rest = der_decoder(sd['encapContentInfo']['eContent'],
            asn1Spec=rfc7191.KeyPackageError())
        self.assertFalse(rest)
        self.assertTrue(kpe.prettyPrint())
        self.assertEqual(sd['encapContentInfo']['eContent'], der_encoder(kpe))

        package_id_pem_text = "J7icVjsWIlGdF4cceb+siG3f+D0="
        package_id = pem.readBase64fromText(package_id_pem_text)

        self.assertEqual(package_id, kpe['errorOf']['pkgID'])
        self.assertEqual(
            rfc7191.EnumeratedErrorCode(value=10), kpe['errorCode'])
Esempio n. 7
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.signed_pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))
        self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])

        sd, rest = der_decoder(asn1Object['content'],
                               asn1Spec=rfc5652.SignedData())
        self.assertFalse(rest)
        self.assertTrue(sd.prettyPrint())
        self.assertEqual(asn1Object['content'], der_encoder(sd))

        encoded_null = der_encoder(univ.Null(""))

        si = sd['signerInfos'][0]
        self.assertEqual(rfc4357.id_GostR3411_94,
                         si['digestAlgorithm']['algorithm'])
        self.assertEqual(encoded_null, si['digestAlgorithm']['parameters'])

        self.assertEqual(rfc4357.id_GostR3410_2001,
                         si['signatureAlgorithm']['algorithm'])
        self.assertEqual(encoded_null, si['signatureAlgorithm']['parameters'])

        sig = rfc4490.GostR3410_2001_Signature()
        sig = si['signature']
        self.assertEqual(64, len(sig))
Esempio n. 8
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.signed_data_pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))

        self.assertEqual(asn1Object['contentType'], rfc5652.id_signedData)
        sd, rest = der_decoder(asn1Object['content'],
                               asn1Spec=rfc5652.SignedData())

        oid = sd['signerInfos'][0]['signatureAlgorithm']['algorithm']
        self.assertEqual(rfc8708.id_alg_hss_lms_hashsig, oid)
Esempio n. 9
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))

        self.assertEqual(1, asn1Object['version'])
        ts = asn1Object['archiveTimeStampSequence'][0][0]['timeStamp']
        self.assertEqual(rfc5652.id_signedData, ts['contentType'])

        sd, rest = der_decoder(ts['content'], asn1Spec=rfc5652.SignedData())
        self.assertFalse(rest)
        self.assertTrue(sd.prettyPrint())
        self.assertEqual(ts['content'], der_encoder(sd))

        self.assertEqual(3, sd['version'])
        ect = sd['encapContentInfo']['eContentType']
        self.assertEqual(rfc3161.id_ct_TSTInfo, ect)
Esempio n. 10
0
    def testDerCodec(self):
        cmsAttributesMap = opentypemap.get('cmsAttributesMap')

        substrate = pem.readBase64fromText(self.signed_message_pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))

        secure_header_field_attr_found = False

        self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])

        sd, rest = der_decoder(asn1Object['content'],
                               asn1Spec=rfc5652.SignedData())
        self.assertFalse(rest)
        self.assertTrue(sd.prettyPrint())
        self.assertEqual(asn1Object['content'], der_encoder(sd))

        for sa in sd['signerInfos'][0]['signedAttrs']:
            sat = sa['attrType']
            sav0 = sa['attrValues'][0]

            if sat == rfc7508.id_aa_secureHeaderFieldsIdentifier:
                self.assertIn(sat, cmsAttributesMap)
                sav, rest = der_decoder(sav0, asn1Spec=cmsAttributesMap[sat])
                self.assertFalse(rest)
                self.assertTrue(sav.prettyPrint())
                self.assertEqual(sav0, der_encoder(sav))

                from_field = rfc7508.HeaderFieldName('From')
                alice_email = rfc7508.HeaderFieldValue('*****@*****.**')
                for shf in sav['secHeaderFields']:
                    if shf['field-Name'] == from_field:
                        self.assertEqual(alice_email, shf['field-Value'])
                        secure_header_field_attr_found = True

        self.assertTrue(secure_header_field_attr_found)
Esempio n. 11
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))

        self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])

        inner, rest = der_decoder(asn1Object['content'],
                                  asn1Spec=rfc5652.SignedData())
        self.assertFalse(rest)
        self.assertTrue(inner.prettyPrint())
        self.assertEqual(asn1Object['content'], der_encoder(inner))

        self.assertEqual(rfc4108.id_ct_firmwarePackage,
                         inner['encapContentInfo']['eContentType'])
        self.assertTrue(inner['encapContentInfo']['eContent'])

        attribute_list = []
        for attr in inner['signerInfos'][0]['signedAttrs']:
            attribute_list.append(attr['attrType'])
            if attr['attrType'] == rfc4108.id_aa_targetHardwareIDs:
                av, rest = der_decoder(
                    attr['attrValues'][0],
                    asn1Spec=rfc4108.TargetHardwareIdentifiers())
                self.assertFalse(rest)
                self.assertTrue(av.prettyPrint())
                self.assertEqual(attr['attrValues'][0], der_encoder(av))
                self.assertEqual(2, len(av))

                for oid in av:
                    self.assertIn('1.3.6.1.4.1.221121.1.1.', oid.prettyPrint())

        self.assertIn(rfc5652.id_contentType, attribute_list)
        self.assertIn(rfc5652.id_messageDigest, attribute_list)
        self.assertIn(rfc4108.id_aa_targetHardwareIDs, attribute_list)
        self.assertIn(rfc4108.id_aa_fwPkgMessageDigest, attribute_list)
Esempio n. 12
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.signed_receipt_pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)

        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))
        self.assertEqual(asn1Object['contentType'], rfc5652.id_signedData)

        sd, rest = der_decoder(asn1Object['content'],
                               asn1Spec=rfc5652.SignedData())
        self.assertFalse(rest)
        self.assertTrue(sd.prettyPrint())
        self.assertEqual(asn1Object['content'], der_encoder(sd))
        self.assertEqual(sd['encapContentInfo']['eContentType'],
                         rfc2634.id_ct_receipt)

        receipt, rest = der_decoder(sd['encapContentInfo']['eContent'],
                                    asn1Spec=rfc2634.Receipt())
        self.assertFalse(rest)
        self.assertTrue(receipt.prettyPrint())
        self.assertEqual(sd['encapContentInfo']['eContent'],
                         der_encoder(receipt))
        self.assertEqual(receipt['version'],
                         rfc2634.ESSVersion().subtype(value='v1'))

        for sa in sd['signerInfos'][0]['signedAttrs']:
            sat = sa['attrType']
            sav0 = sa['attrValues'][0]

            cmsAttributesMap = opentypemap.get('cmsAttributesMap')

            if sat in cmsAttributesMap.keys():
                sav, rest = der_decoder(sav0, asn1Spec=cmsAttributesMap[sat])

                self.assertFalse(rest)
                self.assertTrue(sav.prettyPrint())
                self.assertEqual(sav0, der_encoder(sav))
Esempio n. 13
0
    def testDerCodec(self):
        oids = []
        for pem_text in self.pem_text_list:
            substrate = pem.readBase64fromText(pem_text)
            asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)

            self.assertFalse(rest)
            self.assertTrue(asn1Object.prettyPrint())
            self.assertEqual(substrate, der_encoder(asn1Object))
            self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])

            sd, rest = der_decoder(asn1Object['content'],
                                   asn1Spec=rfc5652.SignedData())

            self.assertFalse(rest)
            self.assertTrue(sd.prettyPrint())
            self.assertEqual(asn1Object['content'], der_encoder(sd))

            oids.append(sd['encapContentInfo']['eContentType'])

        self.assertIn(rfc8358.id_ct_asciiTextWithCRLF, oids)
        self.assertIn(rfc8358.id_ct_pdf, oids)
        self.assertIn(rfc8358.id_ct_xml, oids)
Esempio n. 14
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.signed_receipt_pem_text)
        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)

        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))

        self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])

        sd, rest = der_decoder(asn1Object['content'],
                               asn1Spec=rfc5652.SignedData())

        self.assertFalse(rest)
        self.assertTrue(sd.prettyPrint())
        self.assertEqual(asn1Object['content'], der_encoder(sd))
        self.assertEqual(rfc5035.id_ct_receipt,
                         sd['encapContentInfo']['eContentType'])

        receipt, rest = der_decoder(sd['encapContentInfo']['eContent'],
                                    asn1Spec=rfc5035.Receipt())

        self.assertFalse(rest)
        self.assertTrue(receipt.prettyPrint())
        self.assertEqual(sd['encapContentInfo']['eContent'],
                         der_encoder(receipt))

        for sa in sd['signerInfos'][0]['signedAttrs']:
            sat = sa['attrType']
            sav0 = sa['attrValues'][0]

            if sat in rfc5652.cmsAttributesMap.keys():
                sav, rest = der_decoder(sav0,
                                        asn1Spec=rfc5652.cmsAttributesMap[sat])
                self.assertFalse(rest)
                self.assertTrue(sav.prettyPrint())
                self.assertEqual(sav0, der_encoder(sav))
Esempio n. 15
0
    def testDerCodec(self):
        substrate = pem.readBase64fromText(self.pem_text)

        asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)

        self.assertFalse(rest)
        self.assertTrue(asn1Object.prettyPrint())
        self.assertEqual(substrate, der_encoder(asn1Object))
        self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])

        sd, rest = der_decoder(asn1Object['content'],
                               asn1Spec=rfc5652.SignedData())

        self.assertTrue(sd.prettyPrint())

        self.assertEqual(rfc5652.id_data,
                         sd['encapContentInfo']['eContentType'])
        self.assertTrue(sd['encapContentInfo']['eContent'])

        v2 = rfc5280.Version(value='v2')

        self.assertEqual(v2, sd['crls'][0]['crl']['tbsCertList']['version'])

        ocspr_oid = rfc5940.id_ri_ocsp_response

        self.assertEqual(ocspr_oid,
                         sd['crls'][1]['other']['otherRevInfoFormat'])

        ocspr, rest = der_decoder(sd['crls'][1]['other']['otherRevInfo'],
                                  asn1Spec=rfc5940.OCSPResponse())

        self.assertTrue(ocspr.prettyPrint())

        success = rfc2560.OCSPResponseStatus(value='successful')

        self.assertEqual(success, ocspr['responseStatus'])