ਪਾਈਡਰਾਸਨ: ਮੈਂ ਸਲਾਟ ਅਤੇ ਬਲੌਬਸ ਨਾਲ ਇੱਕ ASN.1 ਲਾਇਬ੍ਰੇਰੀ ਕਿਵੇਂ ਲਿਖੀ

ASN.1 ਇਹ ਢਾਂਚਾਗਤ ਜਾਣਕਾਰੀ ਦਾ ਵਰਣਨ ਕਰਨ ਵਾਲੀ ਭਾਸ਼ਾ ਦਾ ਇੱਕ ਮਿਆਰੀ (ISO, ITU-T, GOST) ਹੈ, ਨਾਲ ਹੀ ਇਸ ਜਾਣਕਾਰੀ ਨੂੰ ਏਨਕੋਡ ਕਰਨ ਲਈ ਨਿਯਮ। ਮੇਰੇ ਲਈ, ਇੱਕ ਪ੍ਰੋਗਰਾਮਰ ਦੇ ਰੂਪ ਵਿੱਚ, ਇਹ JSON, XML, XDR ਅਤੇ ਹੋਰਾਂ ਦੇ ਨਾਲ, ਡੇਟਾ ਨੂੰ ਸੀਰੀਅਲਾਈਜ਼ ਕਰਨ ਅਤੇ ਪੇਸ਼ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਫਾਰਮੈਟ ਹੈ। ਇਹ ਸਾਡੇ ਰੋਜ਼ਾਨਾ ਜੀਵਨ ਵਿੱਚ ਬਹੁਤ ਆਮ ਹੈ, ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਲੋਕ ਇਸਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਨ: ਸੈਲੂਲਰ, ਟੈਲੀਫੋਨ, VoIP ਸੰਚਾਰ (UMTS, LTE, WiMAX, SS7, H.323), ਨੈੱਟਵਰਕ ਪ੍ਰੋਟੋਕੋਲ (LDAP, SNMP, Kerberos) ਵਿੱਚ, ਹਰ ਚੀਜ਼ ਵਿੱਚ ਜੋ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ (X.509, CMS, PKCS ਮਾਨਕਾਂ), ਬੈਂਕ ਕਾਰਡਾਂ ਅਤੇ ਬਾਇਓਮੈਟ੍ਰਿਕ ਪਾਸਪੋਰਟਾਂ ਵਿੱਚ, ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਨਾਲ ਸਬੰਧਤ ਹੈ।

ਇਹ ਲੇਖ ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ ਪਾਈਡਰਾਸਨ: ਪਾਈਥਨ ASN.1 ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਨਾਲ ਸਬੰਧਤ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਸਰਗਰਮੀ ਨਾਲ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਐਟਲਸ.

ਆਮ ਤੌਰ 'ਤੇ, ASN.1 ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਕਾਰਜਾਂ ਲਈ ਸਿਫਾਰਸ਼ ਕਰਨ ਯੋਗ ਨਹੀਂ ਹੈ: ASN.1 ਅਤੇ ਇਸਦੇ ਕੋਡੇਕਸ ਗੁੰਝਲਦਾਰ ਹਨ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕੋਡ ਸਧਾਰਨ ਨਹੀਂ ਹੋਵੇਗਾ, ਅਤੇ ਇਹ ਹਮੇਸ਼ਾ ਇੱਕ ਵਾਧੂ ਹਮਲਾ ਵੈਕਟਰ ਹੁੰਦਾ ਹੈ। ਬਸ ਦੇਖੋ ਸੂਚੀ ਨੂੰ ASN.1 ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਿੱਚ ਕਮਜ਼ੋਰੀਆਂ। ਉਸ ਵਿੱਚ ਬਰੂਸ ਸਨੀਅਰ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਇੰਜੀਨੀਅਰਿੰਗ ਇਸ ਦੀ ਗੁੰਝਲਤਾ ਦੇ ਕਾਰਨ ਇਸ ਮਿਆਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਵਿਰੁੱਧ ਵੀ ਸਲਾਹ ਦਿੰਦਾ ਹੈ: "ਸਭ ਤੋਂ ਮਸ਼ਹੂਰ TLV ਏਨਕੋਡਿੰਗ ASN.1 ਹੈ, ਪਰ ਇਹ ਬਹੁਤ ਹੀ ਗੁੰਝਲਦਾਰ ਹੈ ਅਤੇ ਅਸੀਂ ਇਸ ਤੋਂ ਦੂਰ ਰਹਿੰਦੇ ਹਾਂ।" ਪਰ, ਬਦਕਿਸਮਤੀ ਨਾਲ, ਅੱਜ ਸਾਡੇ ਕੋਲ ਹੈ ਜਨਤਕ ਕੁੰਜੀ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਜਿਸ ਵਿੱਚ ਉਹ ਸਰਗਰਮੀ ਨਾਲ ਵਰਤੇ ਜਾਂਦੇ ਹਨ X.509 ਸਰਟੀਫਿਕੇਟ, CRL, OCSP, TSP, CMP ਪ੍ਰੋਟੋਕੋਲ, ਸੀ.ਐਮ.ਸੀ., ਸੁਨੇਹੇ CMS, ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਮਿਆਰ ਪੀ.ਕੇ.ਸੀ.ਐਸ. ਇਸ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਨਾਲ ਸਬੰਧਤ ਕੁਝ ਵੀ ਕਰ ਰਹੇ ਹੋ ਤਾਂ ਤੁਹਾਨੂੰ ASN.1 ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ASN.1 ਨੂੰ ਕਈ ਤਰੀਕਿਆਂ/ਕੋਡੈਕਸ ਵਿੱਚ ਏਨਕੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

• ਬੀ.ਈ.ਆਰ. (ਬੁਨਿਆਦੀ ਏਨਕੋਡਿੰਗ ਨਿਯਮ)
• ਸੀ.ਈ.ਆਰ (ਕੈਨੋਨੀਕਲ ਏਨਕੋਡਿੰਗ ਨਿਯਮ)
• DER (ਵਿਸ਼ੇਸ਼ ਏਨਕੋਡਿੰਗ ਨਿਯਮ)
• ਜੀ.ਐਸ.ਈ.ਆਰ (ਆਮ ਸਤਰ ਇੰਕੋਡਿੰਗ ਨਿਯਮ)
• ਜੇ.ਈ.ਆਰ (JSON ਏਨਕੋਡਿੰਗ ਨਿਯਮ)
• LWER (ਹਲਕੇ ਭਾਰ ਏਨਕੋਡਿੰਗ ਨਿਯਮ)
• OER (ਓਕਟੇਟ ਐਨਕੋਡਿੰਗ ਨਿਯਮ)
• ਪ੍ਰਤੀ (ਪੈਕਡ ਏਨਕੋਡਿੰਗ ਨਿਯਮ)
• SER (ਸਿਗਨਲ ਖਾਸ ਏਨਕੋਡਿੰਗ ਨਿਯਮ)
• ਚੇਲੇ (XML ਏਨਕੋਡਿੰਗ ਨਿਯਮ)

ਅਤੇ ਕਈ ਹੋਰ। ਪਰ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਕੰਮਾਂ ਵਿੱਚ, ਅਭਿਆਸ ਵਿੱਚ, ਦੋ ਵਰਤੇ ਜਾਂਦੇ ਹਨ: BER ਅਤੇ DER. ਹਸਤਾਖਰ ਕੀਤੇ XML ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਵੀ (XMLDSig, XAdES) ਅਜੇ ਵੀ ਬੇਸ64-ਏਨਕੋਡ ਕੀਤੇ ASN.1 DER ਆਬਜੈਕਟ ਹੋਣਗੇ, ਜਿਵੇਂ ਕਿ JSON-ਅਧਾਰਿਤ ਪ੍ਰੋਟੋਕੋਲ ਵਿੱਚ ACME ਆਉ ਇਨਕ੍ਰਿਪਟ ਤੋਂ। ਤੁਸੀਂ ਲੇਖਾਂ ਅਤੇ ਕਿਤਾਬਾਂ ਵਿੱਚ ਇਹਨਾਂ ਸਾਰੇ ਕੋਡੇਕਸ ਅਤੇ BER/CER/DER ਕੋਡਿੰਗ ਸਿਧਾਂਤਾਂ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸਮਝ ਸਕਦੇ ਹੋ: ASN.1 ਸਧਾਰਨ ਸ਼ਬਦਾਂ ਵਿੱਚ, ASN.1 — ਓਲੀਵੀਅਰ ਡੁਬਿਊਸਨ ਦੁਆਰਾ ਵਿਭਿੰਨ ਪ੍ਰਣਾਲੀਆਂ ਵਿਚਕਾਰ ਸੰਚਾਰ, ASN.1 ਪ੍ਰੋ ਜੌਹਨ ਲਾਰਮਾਊਥ ਦੁਆਰਾ ਸੰਪੂਰਨ.

BER ਇੱਕ ਬਾਈਨਰੀ ਬਾਈਟ-ਅਧਾਰਿਤ (ਉਦਾਹਰਨ ਲਈ PER, ਸੈਲੂਲਰ ਸੰਚਾਰ ਵਿੱਚ ਪ੍ਰਸਿੱਧ - ਬਿੱਟ-ਅਧਾਰਿਤ) TLV ਫਾਰਮੈਟ ਹੈ। ਹਰੇਕ ਤੱਤ ਨੂੰ ਇੰਕੋਡ ਕੀਤਾ ਗਿਆ ਹੈ: ਟੈਗ (Tag), ਏਨਕੋਡ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਤੱਤ ਦੀ ਕਿਸਮ ਦੀ ਪਛਾਣ ਕਰਨਾ (ਪੂਰਨ ਅੰਕ, ਸਤਰ, ਮਿਤੀ, ਆਦਿ), ਲੰਬਾਈ (Length) ਸਮੱਗਰੀ ਅਤੇ ਸਮੱਗਰੀ ਆਪਣੇ ਆਪ (Value). BER ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਅਨਿਸ਼ਚਿਤ ਲੰਬਾਈ ਦਾ ਮੁੱਲ ਸੈੱਟ ਕਰਕੇ ਅਤੇ ਐਂਡ-ਆਫ-ਓਕਟੇਟਸ ਸੁਨੇਹੇ ਨੂੰ ਅੰਤ-ਔਫ-ਓਕਟੇਟ ਚਿੰਨ੍ਹ ਦੇ ਨਾਲ ਖਤਮ ਕਰਕੇ ਲੰਬਾਈ ਦਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਨਾ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਲੰਬਾਈ ਏਨਕੋਡਿੰਗ ਤੋਂ ਇਲਾਵਾ, BER ਵਿੱਚ ਡੇਟਾ ਕਿਸਮਾਂ ਨੂੰ ਏਨਕੋਡ ਕਰਨ ਦੇ ਤਰੀਕੇ ਵਿੱਚ ਬਹੁਤ ਪਰਿਵਰਤਨਸ਼ੀਲਤਾ ਹੈ, ਜਿਵੇਂ ਕਿ:

• ਪੂਰਨ ਅੰਕ, ਵਸਤੂ ਪਛਾਣਕਰਤਾ, ਬਿੱਟ ਸਟ੍ਰਿੰਗ ਅਤੇ ਤੱਤ ਦੀ ਲੰਬਾਈ ਆਮ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ (ਘੱਟੋ-ਘੱਟ ਰੂਪ ਵਿੱਚ ਏਨਕੋਡ ਨਹੀਂ ਕੀਤੀ ਗਈ);
• BOOLEAN ਕਿਸੇ ਵੀ ਗੈਰ-ਜ਼ੀਰੋ ਸਮੱਗਰੀ ਲਈ ਸੱਚ ਹੈ;
• BIT STRING ਵਿੱਚ "ਵਾਧੂ" ਜ਼ੀਰੋ ਬਿੱਟ ਹੋ ਸਕਦੇ ਹਨ;
• BIT STRING, OCTET STRING ਅਤੇ ਮਿਤੀ/ਸਮਾਂ ਸਮੇਤ ਉਹਨਾਂ ਦੀਆਂ ਸਾਰੀਆਂ ਪ੍ਰਾਪਤ ਕੀਤੀਆਂ ਸਟ੍ਰਿੰਗ ਕਿਸਮਾਂ ਨੂੰ ਵੇਰੀਏਬਲ-ਲੰਬਾਈ ਦੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸਦੀ ਲੰਬਾਈ (ਡੀ)ਏਨਕੋਡਿੰਗ ਦੇ ਸਮੇਂ ਪਹਿਲਾਂ ਤੋਂ ਨਹੀਂ ਜਾਣੀ ਜਾਂਦੀ ਹੈ;
• UTCTtime/GeneralizedTime ਕੋਲ ਸਮਾਂ ਜ਼ੋਨ ਆਫਸੈੱਟ ਅਤੇ ਸਕਿੰਟਾਂ ਦੇ "ਵਾਧੂ" ਜ਼ੀਰੋ ਫਰੈਕਸ਼ਨਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਦੇ ਵੱਖੋ-ਵੱਖਰੇ ਤਰੀਕੇ ਹੋ ਸਕਦੇ ਹਨ;
• DEFAULT SEQUENCE ਮੁੱਲਾਂ ਨੂੰ ਏਨਕੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ ਨਹੀਂ;
• ਇੱਕ BIT STRING ਵਿੱਚ ਆਖਰੀ ਬਿੱਟਾਂ ਦੇ ਨਾਮਿਤ ਮੁੱਲ ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ ਅਨਕੋਡ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ;
• SEQUENCE (OF)/SET (OF) ਵਿੱਚ ਤੱਤਾਂ ਦਾ ਕੋਈ ਵੀ ਕ੍ਰਮ ਹੋ ਸਕਦਾ ਹੈ।

ਉਪਰੋਕਤ ਸਾਰੇ ਦੇ ਕਾਰਨ, ਡੇਟਾ ਨੂੰ ਏਨਕੋਡਿੰਗ ਕਰਨਾ ਤਾਂ ਜੋ ਇਹ ਅਸਲ ਰੂਪ ਦੇ ਸਮਾਨ ਹੋਵੇ ਹਮੇਸ਼ਾ ਸੰਭਵ ਨਹੀਂ ਹੁੰਦਾ। ਇਸ ਲਈ, ਨਿਯਮਾਂ ਦੇ ਇੱਕ ਸਬਸੈੱਟ ਦੀ ਖੋਜ ਕੀਤੀ ਗਈ ਸੀ: DER - ਸਿਰਫ਼ ਇੱਕ ਵੈਧ ਏਨਕੋਡਿੰਗ ਵਿਧੀ ਨੂੰ ਸਖਤੀ ਨਾਲ ਨਿਯੰਤ੍ਰਿਤ ਕਰਨਾ, ਜੋ ਕਿ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਕਾਰਜਾਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਜਿੱਥੇ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਬਿੱਟ ਬਦਲਣ ਨਾਲ ਦਸਤਖਤ ਜਾਂ ਚੈੱਕਸਮ ਅਵੈਧ ਹੋ ਜਾਵੇਗਾ। DER ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਣ ਨੁਕਸਾਨ ਹੈ: ਸਾਰੇ ਤੱਤਾਂ ਦੀ ਲੰਬਾਈ ਨੂੰ ਏਨਕੋਡਿੰਗ ਸਮੇਂ ਪਹਿਲਾਂ ਤੋਂ ਜਾਣਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਡੇਟਾ ਦੇ ਸਟ੍ਰੀਮ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਦੀ ਆਗਿਆ ਨਹੀਂ ਦਿੰਦਾ ਹੈ। CER ਕੋਡੇਕ ਵਿੱਚ ਇਹ ਕਮੀ ਨਹੀਂ ਹੈ, ਇਸੇ ਤਰ੍ਹਾਂ ਡੇਟਾ ਦੀ ਇੱਕ ਅਸਪਸ਼ਟ ਨੁਮਾਇੰਦਗੀ ਦੀ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ। ਬਦਕਿਸਮਤੀ ਨਾਲ (ਜਾਂ ਇਹ ਖੁਸ਼ਕਿਸਮਤ ਹੈ ਕਿ ਸਾਡੇ ਕੋਲ ਹੋਰ ਵੀ ਗੁੰਝਲਦਾਰ ਡੀਕੋਡਰ ਨਹੀਂ ਹਨ?), ਇਹ ਪ੍ਰਸਿੱਧ ਨਹੀਂ ਹੋਇਆ। ਇਸਲਈ, ਅਭਿਆਸ ਵਿੱਚ ਅਸੀਂ BER ਅਤੇ DER ਏਨਕੋਡਡ ਡੇਟਾ ਦੀ "ਮਿਸ਼ਰਤ" ਵਰਤੋਂ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਾਂ। ਕਿਉਂਕਿ CER ਅਤੇ DER ਦੋਵੇਂ BER ਦੇ ਸਬਸੈੱਟ ਹਨ, ਕੋਈ ਵੀ BER ਡੀਕੋਡਰ ਉਹਨਾਂ ਨੂੰ ਸੰਭਾਲ ਸਕਦਾ ਹੈ।

pyasn1 ਨਾਲ ਸਮੱਸਿਆਵਾਂ

ਕੰਮ 'ਤੇ ਅਸੀਂ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਨਾਲ ਸਬੰਧਤ ਬਹੁਤ ਸਾਰੇ ਪਾਈਥਨ ਪ੍ਰੋਗਰਾਮ ਲਿਖਦੇ ਹਾਂ। ਅਤੇ ਕੁਝ ਸਾਲ ਪਹਿਲਾਂ ਮੁਫਤ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦਾ ਕੋਈ ਵਿਕਲਪ ਨਹੀਂ ਸੀ: ਜਾਂ ਤਾਂ ਇਹ ਬਹੁਤ ਘੱਟ-ਪੱਧਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਇੰਕੋਡ/ਡੀਕੋਡ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀਆਂ ਹਨ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਪੂਰਨ ਅੰਕ ਅਤੇ ਇੱਕ ਢਾਂਚਾ ਸਿਰਲੇਖ, ਜਾਂ ਇਹ ਲਾਇਬ੍ਰੇਰੀ pyasn1. ਅਸੀਂ ਇਸ 'ਤੇ ਕਈ ਸਾਲਾਂ ਤੱਕ ਰਹੇ ਅਤੇ ਪਹਿਲਾਂ ਅਸੀਂ ਬਹੁਤ ਖੁਸ਼ ਹੋਏ, ਕਿਉਂਕਿ ਇਹ ਤੁਹਾਨੂੰ ਉੱਚ-ਪੱਧਰੀ ਵਸਤੂਆਂ ਦੇ ਨਾਲ ASN.1 ਢਾਂਚੇ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ: ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਡੀਕੋਡ ਕੀਤਾ X.509 ਸਰਟੀਫਿਕੇਟ ਆਬਜੈਕਟ ਤੁਹਾਨੂੰ ਇਸਦੇ ਖੇਤਰਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਇੰਟਰਫੇਸ: cert[“tbsCertificate”] ["serialNumber"] ਸਾਨੂੰ ਇਸ ਸਰਟੀਫਿਕੇਟ ਦਾ ਸੀਰੀਅਲ ਨੰਬਰ ਦਿਖਾਏਗਾ। ਇਸੇ ਤਰ੍ਹਾਂ, ਤੁਸੀਂ ਗੁੰਝਲਦਾਰ ਵਸਤੂਆਂ ਨੂੰ ਸੂਚੀਆਂ, ਸ਼ਬਦਕੋਸ਼ਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਕੰਮ ਕਰਕੇ "ਇਕੱਠਾ" ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਫਿਰ ਸਿਰਫ਼ pyasn1.codec.der.encoder.encode ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ ਅਤੇ ਦਸਤਾਵੇਜ਼ ਦੀ ਲੜੀਬੱਧ ਪ੍ਰਤੀਨਿਧਤਾ ਪ੍ਰਾਪਤ ਕਰੋ।

ਹਾਲਾਂਕਿ, ਕਮੀਆਂ, ਸਮੱਸਿਆਵਾਂ ਅਤੇ ਸੀਮਾਵਾਂ ਪ੍ਰਗਟ ਕੀਤੀਆਂ ਗਈਆਂ ਸਨ. ਉੱਥੇ ਸਨ ਅਤੇ, ਬਦਕਿਸਮਤੀ ਨਾਲ, ਅਜੇ ਵੀ pyasn1 ਵਿੱਚ ਤਰੁੱਟੀਆਂ ਹਨ: ਲਿਖਣ ਦੇ ਸਮੇਂ, pyasn1 ਵਿੱਚ ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ GeneralizedTime, ਗਲਤ ਡੀਕੋਡ ਅਤੇ ਏਨਕੋਡ ਕੀਤਾ.

ਸਾਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ, ਸਪੇਸ ਬਚਾਉਣ ਲਈ, ਅਸੀਂ ਅਕਸਰ ਸਿਰਫ਼ ਫਾਈਲ ਪਾਥ, ਔਫਸੈੱਟ ਅਤੇ ਲੰਬਾਈ ਨੂੰ ਉਸ ਵਸਤੂ ਦੇ ਬਾਈਟਾਂ ਵਿੱਚ ਸਟੋਰ ਕਰਦੇ ਹਾਂ ਜਿਸਦਾ ਅਸੀਂ ਹਵਾਲਾ ਦੇਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਆਰਬਿਟਰਰੀ ਹਸਤਾਖਰਿਤ ਫਾਈਲ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ CMS SignedData ASN.1 ਢਾਂਚੇ ਵਿੱਚ ਸਥਿਤ ਹੋਵੇਗੀ:

  0     [1,3,1018]  ContentInfo SEQUENCE
  4     [1,1,   9]   . contentType: ContentType OBJECT IDENTIFIER 1.2.840.113549.1.7.2 (id_signedData)
 19-4   [0,0,1003]   . content: [0] EXPLICIT [UNIV 16] ANY
 19     [1,3, 999]   . . DEFINED BY id_signedData: SignedData SEQUENCE
 23     [1,1,   1]   . . . version: CMSVersion INTEGER v3 (03)
 26     [1,1,  19]   . . . digestAlgorithms: DigestAlgorithmIdentifiers SET OF
                           [...]
 47     [1,3, 769]   . . . encapContentInfo: EncapsulatedContentInfo SEQUENCE
 51     [1,1,   8]   . . . . eContentType: ContentType OBJECT IDENTIFIER 1.3.6.1.5.5.7.12.2 (id_cct_PKIData)
 65-4   [1,3, 751]   . . . . eContent: [0] EXPLICIT OCTET STRING 751 bytes OPTIONAL

                 ТУТ СОДЕРЖИМОЕ ПОДПИСЫВАЕМОГО ФАЙЛА РАЗМЕРОМ 751 байт

820     [1,2, 199]   . . . signerInfos: SignerInfos SET OF
823     [1,2, 196]   . . . . 0: SignerInfo SEQUENCE
826     [1,1,   1]   . . . . . version: CMSVersion INTEGER v3 (03)
829     [0,0,  22]   . . . . . sid: SignerIdentifier CHOICE subjectKeyIdentifier
                               [...]
956     [1,1,  64]   . . . . . signature: SignatureValue OCTET STRING 64 bytes
                     . . . . . . C1:B3:88:BA:F8:92:1C:E6:3E:41:9B:E0:D3:E9:AF:D8
                     . . . . . . 47:4A:8A:9D:94:5D:56:6B:F0:C1:20:38:D2:72:22:12
                     . . . . . . 9F:76:46:F6:51:5F:9A:8D:BF:D7:A6:9B:FD:C5:DA:D2
                     . . . . . . F3:6B:00:14:A4:9D:D7:B5:E1:A6:86:44:86:A7:E8:C9

ਅਤੇ ਅਸੀਂ ਔਫਸੈੱਟ 65 ਬਾਈਟਸ, 751 ਬਾਈਟ ਲੰਬੇ 'ਤੇ ਅਸਲ ਹਸਤਾਖਰਿਤ ਫਾਈਲ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ। pyasn1 ਇਸ ਜਾਣਕਾਰੀ ਨੂੰ ਆਪਣੇ ਡੀਕੋਡ ਕੀਤੇ ਆਬਜੈਕਟ ਵਿੱਚ ਸਟੋਰ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਅਖੌਤੀ TLVSeeker ਲਿਖਿਆ ਗਿਆ ਸੀ - ਇੱਕ ਛੋਟੀ ਲਾਇਬ੍ਰੇਰੀ ਜੋ ਤੁਹਾਨੂੰ ਟੈਗਸ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਲੰਬਾਈ ਨੂੰ ਡੀਕੋਡ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ, ਜਿਸ ਦੇ ਇੰਟਰਫੇਸ ਵਿੱਚ ਅਸੀਂ "ਅਗਲੇ ਟੈਗ 'ਤੇ ਜਾਓ", "ਟੈਗ ਦੇ ਅੰਦਰ ਜਾਓ" (SEQUENCE ਵਸਤੂ ਦੇ ਅੰਦਰ ਜਾਓ), "ਅਗਲੇ ਟੈਗ 'ਤੇ ਜਾਓ", "ਆਪਣੇ ਆਫਸੈੱਟ ਅਤੇ ਵਸਤੂ ਦੀ ਲੰਬਾਈ ਦੱਸੋ ਜਿੱਥੇ ਅਸੀਂ ਹਾਂ।" ਇਹ ASN.1 DER-ਸੀਰੀਅਲਾਈਜ਼ਡ ਡੇਟਾ ਦੁਆਰਾ "ਮੈਨੁਅਲ" ਵਾਕ ਸੀ। ਪਰ ਇਸ ਤਰੀਕੇ ਨਾਲ BER-ਸੀਰੀਅਲਾਈਜ਼ਡ ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਨਾ ਅਸੰਭਵ ਸੀ, ਕਿਉਂਕਿ, ਉਦਾਹਰਨ ਲਈ, OCTET STRING ਬਾਈਟ ਸਤਰ ਨੂੰ ਕਈ ਹਿੱਸਿਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਏਨਕੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਸਾਡੇ pyasn1 ਕਾਰਜਾਂ ਲਈ ਇੱਕ ਹੋਰ ਕਮਜ਼ੋਰੀ ਡੀਕੋਡ ਕੀਤੀਆਂ ਵਸਤੂਆਂ ਤੋਂ ਇਹ ਸਮਝਣ ਵਿੱਚ ਅਸਮਰੱਥਾ ਹੈ ਕਿ ਕੀ ਇੱਕ ਦਿੱਤਾ ਖੇਤਰ SEQUENCE ਵਿੱਚ ਮੌਜੂਦ ਸੀ ਜਾਂ ਨਹੀਂ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਢਾਂਚੇ ਵਿੱਚ Smth OPTIONAL ਫੀਲਡ ਦਾ ਇੱਕ ਫੀਲਡ ਕ੍ਰਮ ਹੈ, ਤਾਂ ਇਹ ਆਉਣ ਵਾਲੇ ਡੇਟਾ (ਵਿਕਲਪਿਕ) ਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਗੈਰਹਾਜ਼ਰ ਹੋ ਸਕਦਾ ਹੈ, ਜਾਂ ਇਹ ਮੌਜੂਦ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਜ਼ੀਰੋ ਲੰਬਾਈ (ਖਾਲੀ ਸੂਚੀ) ਦਾ ਹੋ ਸਕਦਾ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ, ਇਹ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਅਤੇ ਇਹ ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾ ਦੀ ਵੈਧਤਾ ਦੀ ਸਖਤ ਤਸਦੀਕ ਲਈ ਜ਼ਰੂਰੀ ਹੈ. ਕਲਪਨਾ ਕਰੋ ਕਿ ਕੁਝ ਪ੍ਰਮਾਣੀਕਰਣ ਅਥਾਰਟੀ ਡੇਟਾ ਦੇ ਨਾਲ ਇੱਕ ਸਰਟੀਫਿਕੇਟ ਜਾਰੀ ਕਰੇਗੀ ਜੋ ASN.1 ਸਕੀਮਾਂ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ "ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਹੀਂ" ਵੈਧ ਹੈ! ਉਦਾਹਰਨ ਲਈ, ਪ੍ਰਮਾਣੀਕਰਣ ਅਥਾਰਟੀ “TÜRKTRUST Elektronik Sertifika Hizmet Sağlayıcısı” ਨੇ ਆਪਣੇ ਰੂਟ ਸਰਟੀਫਿਕੇਟ ਵਿੱਚ ਮਨਜ਼ੂਰਸ਼ੁਦਾ ਸੀਮਾਵਾਂ ਨੂੰ ਪਾਰ ਕਰ ਲਿਆ ਹੈ RFC 5280 ਵਿਸ਼ੇ ਦੇ ਹਿੱਸੇ ਦੀ ਲੰਬਾਈ 'ਤੇ ਸੀਮਾਵਾਂ - ਇਸ ਨੂੰ ਸਕੀਮ ਦੇ ਅਨੁਸਾਰ ਇਮਾਨਦਾਰੀ ਨਾਲ ਡੀਕੋਡ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। DER ਕੋਡੇਕ ਦੀ ਲੋੜ ਹੈ ਕਿ ਇੱਕ ਖੇਤਰ ਜਿਸਦਾ ਮੁੱਲ DEFAULT ਦੇ ਬਰਾਬਰ ਹੈ, ਨੂੰ ਪ੍ਰਸਾਰਣ ਦੇ ਦੌਰਾਨ ਏਨਕੋਡ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ - ਅਜਿਹੇ ਦਸਤਾਵੇਜ਼ ਜੀਵਨ ਵਿੱਚ ਵਾਪਰਦੇ ਹਨ, ਅਤੇ PyDERASN ਦੇ ਪਹਿਲੇ ਸੰਸਕਰਣ ਨੇ ਵੀ ਜਾਣਬੁੱਝ ਕੇ ਅਜਿਹੇ ਅਵੈਧ (DER ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ) ਵਿਵਹਾਰ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਹੈ। ਪਿੱਛੇ ਅਨੁਕੂਲਤਾ.

ਇਕ ਹੋਰ ਸੀਮਾ ਇਹ ਆਸਾਨੀ ਨਾਲ ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਅਯੋਗਤਾ ਹੈ ਕਿ ਢਾਂਚੇ ਵਿਚ ਕਿਸੇ ਖਾਸ ਵਸਤੂ ਨੂੰ ਕਿਸ ਰੂਪ (BER/DER) ਵਿਚ ਏਨਕੋਡ ਕੀਤਾ ਗਿਆ ਸੀ। ਉਦਾਹਰਨ ਲਈ, CMS ਸਟੈਂਡਰਡ ਕਹਿੰਦਾ ਹੈ ਕਿ ਸੁਨੇਹਾ BER-ਏਨਕੋਡ ਕੀਤਾ ਗਿਆ ਹੈ, ਪਰ signedAttrs ਖੇਤਰ, ਜਿਸ ਉੱਤੇ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਦਸਤਖਤ ਤਿਆਰ ਕੀਤੇ ਗਏ ਹਨ, DER ਵਿੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇਕਰ ਅਸੀਂ DER ਨਾਲ ਡੀਕੋਡ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਖੁਦ CMS ਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਵਿੱਚ ਅਸਫਲ ਹੋ ਜਾਵਾਂਗੇ; ਜੇਕਰ ਅਸੀਂ BER ਨਾਲ ਡੀਕੋਡ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਇਹ ਨਹੀਂ ਪਤਾ ਹੋਵੇਗਾ ਕਿ ਸਾਈਨ ਕੀਤੇ ਐਟ੍ਰਸ ਕਿਸ ਰੂਪ ਵਿੱਚ ਸੀ। ਨਤੀਜੇ ਵਜੋਂ, TLVSeeker (ਜਿਸਦਾ pyasn1 ਵਿੱਚ ਕੋਈ ਐਨਾਲਾਗ ਨਹੀਂ ਹੈ) ਨੂੰ ਹਰੇਕ ਸਾਈਨ ਕੀਤੇ ਐਟ੍ਰਸ ਫੀਲਡ ਦੀ ਸਥਿਤੀ ਦੀ ਖੋਜ ਕਰਨੀ ਪਵੇਗੀ, ਅਤੇ ਵੱਖਰੇ ਤੌਰ 'ਤੇ, ਇਸ ਨੂੰ ਲੜੀਬੱਧ ਪ੍ਰਤੀਨਿਧਤਾ ਤੋਂ ਬਾਹਰ ਲੈ ਕੇ, ਇਸਨੂੰ DER ਨਾਲ ਡੀਕੋਡ ਕਰਨਾ ਹੋਵੇਗਾ।

ਫੀਲਡ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਆਪਣੇ ਆਪ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਯੋਗਤਾ, ਜੋ ਅਕਸਰ ਵਾਪਰਦੀ ਹੈ, ਸਾਡੇ ਲਈ ਬਹੁਤ ਫਾਇਦੇਮੰਦ ਸੀ। ASN.1 ਢਾਂਚੇ ਨੂੰ ਡੀਕੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਸਾਡੇ ਕੋਲ ਬਹੁਤ ਸਾਰੇ ਖੇਤਰ ਰਹਿ ਸਕਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਢਾਂਚੇ ਦੇ ਖੇਤਰ ਵਿੱਚ ਨਿਰਦਿਸ਼ਟ OBJECT IDENTIFIER ਦੇ ਅਧਾਰ ਤੇ ਚੁਣੀ ਗਈ ਸਕੀਮ ਦੇ ਅਨੁਸਾਰ ਅੱਗੇ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ। ਪਾਈਥਨ ਕੋਡ ਵਿੱਚ, ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿਸੇ ਵੀ ਖੇਤਰ ਲਈ ਡੀਕੋਡਰ ਨੂੰ if ਅਤੇ ਫਿਰ ਕਾਲ ਕਰਨਾ।

ਪਾਈਡਰਾਸਨ ਦਾ ਉਭਾਰ

ਐਟਲਸ 'ਤੇ, ਅਸੀਂ ਨਿਯਮਿਤ ਤੌਰ 'ਤੇ ਸਿਖਰ 'ਤੇ ਪੈਚ ਭੇਜਦੇ ਹਾਂ ਜਦੋਂ ਸਾਨੂੰ ਕੁਝ ਸਮੱਸਿਆਵਾਂ ਮਿਲਦੀਆਂ ਹਨ ਜਾਂ ਸਾਡੇ ਦੁਆਰਾ ਵਰਤੇ ਜਾਂਦੇ ਮੁਫਤ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਸੁਧਾਰ ਹੁੰਦਾ ਹੈ। ਅਸੀਂ pyasn1 ਵਿੱਚ ਕਈ ਵਾਰ ਸੁਧਾਰ ਪੇਸ਼ ਕੀਤੇ, ਪਰ pyasn1 ਦੇ ਕੋਡ ਨੂੰ ਸਮਝਣਾ ਸਭ ਤੋਂ ਆਸਾਨ ਨਹੀਂ ਹੈ ਅਤੇ ਕਈ ਵਾਰ ਅਸੰਗਤ API ਬਦਲਾਅ ਹੁੰਦੇ ਹਨ ਜੋ ਸਾਨੂੰ ਮਾਤ ਦਿੰਦੇ ਹਨ। ਨਾਲ ਹੀ, ਅਸੀਂ ਜਨਰੇਟਿਵ ਟੈਸਟਿੰਗ ਨਾਲ ਟੈਸਟ ਲਿਖਣ ਦੇ ਆਦੀ ਹਾਂ, ਜੋ ਕਿ pyasn1 ਵਿੱਚ ਨਹੀਂ ਸੀ।

ਇੱਕ ਵਧੀਆ ਦਿਨ ਮੈਂ ਫੈਸਲਾ ਕੀਤਾ ਕਿ ਮੇਰੇ ਕੋਲ ਇਹ ਕਾਫ਼ੀ ਹੈ ਅਤੇ ਇਹ ਸਮਾਂ ਆ ਗਿਆ ਸੀ ਕਿ ਮੈਂ ਆਪਣੀ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ __ਸਲਾਟ__ਸ, ਆਫਸੈਟਾਂ ਅਤੇ ਸੁੰਦਰਤਾ ਨਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਬਲੌਬਸ ਨਾਲ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂ! ਸਿਰਫ਼ ਇੱਕ ASN.1 ਕੋਡੇਕ ਬਣਾਉਣਾ ਕਾਫ਼ੀ ਨਹੀਂ ਹੋਵੇਗਾ - ਸਾਨੂੰ ਆਪਣੇ ਸਾਰੇ ਨਿਰਭਰ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਇਸ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਅਤੇ ਇਹ ਕੋਡ ਦੀਆਂ ਲੱਖਾਂ ਲਾਈਨਾਂ ਹਨ ਜੋ ASN.1 ਢਾਂਚੇ ਦੇ ਨਾਲ ਕੰਮ ਨਾਲ ਭਰਪੂਰ ਹਨ। ਅਰਥਾਤ, ਇਸਦੇ ਲਈ ਲੋੜਾਂ ਵਿੱਚੋਂ ਇੱਕ: ਮੌਜੂਦਾ pyasn1 ਕੋਡ ਦੇ ਅਨੁਵਾਦ ਦੀ ਸੌਖ। ਆਪਣੀਆਂ ਸਾਰੀਆਂ ਛੁੱਟੀਆਂ ਬਿਤਾਉਣ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਇਸ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਲਿਖਿਆ ਅਤੇ ਸਾਰੇ ਪ੍ਰੋਜੈਕਟ ਇਸ ਵਿੱਚ ਤਬਦੀਲ ਕਰ ਦਿੱਤੇ। ਕਿਉਂਕਿ ਉਹਨਾਂ ਕੋਲ ਟੈਸਟਾਂ ਦੇ ਨਾਲ ਲਗਭਗ 100% ਕਵਰੇਜ ਹੈ, ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਲਾਇਬ੍ਰੇਰੀ ਪੂਰੀ ਤਰ੍ਹਾਂ ਚਾਲੂ ਸੀ।

PyDERASN, ਇਸੇ ਤਰ੍ਹਾਂ, ਲਗਭਗ 100% ਟੈਸਟ ਕਵਰੇਜ ਹੈ। ਇੱਕ ਮਹਾਨ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਨਾਲ ਜਨਰੇਟਿਵ ਟੈਸਟਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਧਾਰਨਾ. ਇਹ ਵੀ ਕਰਵਾਇਆ ਗਿਆ ਧੁੰਦਲਾ py-afl- ਮੈਂ 32 ਪ੍ਰਮਾਣੂ ਮਸ਼ੀਨਾਂ 'ਤੇ ਖਾਂਦਾ ਹਾਂ. ਇਸ ਤੱਥ ਦੇ ਬਾਵਜੂਦ ਕਿ ਸਾਡੇ ਕੋਲ ਅਮਲੀ ਤੌਰ 'ਤੇ ਕੋਈ Python2 ਕੋਡ ਨਹੀਂ ਬਚਿਆ ਹੈ, PyDERASN ਅਜੇ ਵੀ ਇਸਦੇ ਨਾਲ ਅਨੁਕੂਲਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦਾ ਹੈ ਅਤੇ ਇਸਦੇ ਕਾਰਨ ਸਿਰਫ ਛੇ ਨਸ਼ਾ ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਸਦੇ ਵਿਰੁੱਧ ਟੈਸਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ASN.1:2008 ਪਾਲਣਾ ਟੈਸਟ ਸੂਟ.

ਇਸਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਸਿਧਾਂਤ pyasn1 ਦੇ ਸਮਾਨ ਹੈ - ਉੱਚ-ਪੱਧਰੀ ਪਾਈਥਨ ਵਸਤੂਆਂ ਨਾਲ ਕੰਮ ਕਰਨਾ। ASN.1 ਸਕੀਮਾਂ ਦਾ ਵਰਣਨ ਸਮਾਨ ਹੈ।

class TBSCertificate(Sequence):
    schema = (
        ("version", Version(expl=tag_ctxc(0), default="v1")),
        ("serialNumber", CertificateSerialNumber()),
        ("signature", AlgorithmIdentifier()),
        ("issuer", Name()),
        ("validity", Validity()),
        ("subject", Name()),
        ("subjectPublicKeyInfo", SubjectPublicKeyInfo()),
        ("issuerUniqueID", UniqueIdentifier(impl=tag_ctxp(1), optional=True)),
        ("subjectUniqueID", UniqueIdentifier(impl=tag_ctxp(2), optional=True)),
        ("extensions", Extensions(expl=tag_ctxc(3), optional=True)),
    )

ਹਾਲਾਂਕਿ, PyDERASN ਵਿੱਚ ਮਜ਼ਬੂਤ ​​ਟਾਈਪਿੰਗ ਦੀ ਕੁਝ ਝਲਕ ਹੈ। pyasn1 ਵਿੱਚ, ਜੇਕਰ ਇੱਕ ਫੀਲਡ CMSVersion(INTEGER) ਕਿਸਮ ਦਾ ਸੀ, ਤਾਂ ਇਸਨੂੰ int ਜਾਂ INTEGER ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ। PyDERASN ਨੂੰ ਸਖਤੀ ਨਾਲ ਇਹ ਲੋੜ ਹੁੰਦੀ ਹੈ ਕਿ ਨਿਰਧਾਰਤ ਆਬਜੈਕਟ ਬਿਲਕੁਲ CMSVersion ਹੋਵੇ। Python3 ਕੋਡ ਲਿਖਣ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਵੀ ਵਰਤਦੇ ਹਾਂ ਟਾਈਪਿੰਗ ਐਨੋਟੇਸ਼ਨ, ਇਸ ਲਈ ਸਾਡੇ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਅਸਪਸ਼ਟ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਹੋਣਗੇ ਜਿਵੇਂ ਕਿ def func(ਸੀਰੀਅਲ, ਸਮੱਗਰੀ), ਪਰ def func(ਸੀਰੀਅਲ: CertificateSerialNumber, ਸਮੱਗਰੀ: EncapsulatedContentInfo), ਅਤੇ PyDERASN ਅਜਿਹੇ ਕੋਡ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

ਇਸ ਦੇ ਨਾਲ ਹੀ, PyDERASN ਕੋਲ ਇਸ ਟਾਈਪਿੰਗ ਲਈ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਰਿਆਇਤਾਂ ਹਨ। pyasn1 ਨੇ SubjectKeyIdentifier().subtype(implicitTag=Tag(...)) ਫੀਲਡ ਨੂੰ SubjectKeyIdentifier() (ਲੋੜੀਂਦੇ IMPLICIT TAG ਤੋਂ ਬਿਨਾਂ) ਨੂੰ ਇੱਕ ਵਸਤੂ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦਿੱਤੀ ਅਤੇ ਇਸ ਲਈ ਅਕਸਰ ਆਬਜੈਕਟ ਨੂੰ ਕਾਪੀ ਅਤੇ ਮੁੜ ਬਣਾਉਣਾ ਜ਼ਰੂਰੀ ਸੀ ਬਦਲੇ ਗਏ IMPLICIT/EXPLICIT ਟੈਗਸ। PyDERASN ਸਖਤੀ ਨਾਲ ਸਿਰਫ ਅਧਾਰ ਕਿਸਮ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ - ਇਹ ਆਪਣੇ ਆਪ ਹੀ ਢਾਂਚੇ ਦੀ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ASN.1 ਸਕੀਮਾ ਤੋਂ ਟੈਗਸ ਨੂੰ ਬਦਲ ਦੇਵੇਗਾ। ਇਹ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਨੂੰ ਬਹੁਤ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ।

ਜੇਕਰ ਡੀਕੋਡਿੰਗ ਦੌਰਾਨ ਕੋਈ ਗਲਤੀ ਆਉਂਦੀ ਹੈ, ਤਾਂ pyasn1 ਵਿੱਚ ਇਹ ਸਮਝਣਾ ਆਸਾਨ ਨਹੀਂ ਹੈ ਕਿ ਇਹ ਕਿੱਥੇ ਆਈ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਉੱਪਰ ਦੱਸੇ ਗਏ ਤੁਰਕੀ ਪ੍ਰਮਾਣ-ਪੱਤਰ ਵਿੱਚ, ਸਾਨੂੰ ਹੇਠ ਲਿਖੀ ਗਲਤੀ ਮਿਲੇਗੀ: UTF8String (tbsCertificate:issuer:rdnSequence:3:0:value:DEFINED BY 2.5.4.10:utf8String) (138 'ਤੇ) ਅਸੰਤੁਸ਼ਟ ਸੀਮਾ: 1 ⇐ 77 ⇐ 64 ASN .1 ਢਾਂਚਾ ਲਿਖਣ ਵੇਲੇ ਲੋਕ ਗਲਤੀਆਂ ਕਰ ਸਕਦੇ ਹਨ, ਅਤੇ ਇਸ ਨਾਲ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ ਜਾਂ ਦੂਜੀ ਧਿਰ ਦੇ ਕੋਡ ਕੀਤੇ ਦਸਤਾਵੇਜ਼ਾਂ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ।

PyDERASN ਦਾ ਪਹਿਲਾ ਸੰਸਕਰਣ BER ਏਨਕੋਡਿੰਗ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਸੀ। ਇਹ ਬਹੁਤ ਬਾਅਦ ਵਿੱਚ ਪ੍ਰਗਟ ਹੋਇਆ ਹੈ ਅਤੇ ਅਜੇ ਵੀ ਸਮਾਂ ਖੇਤਰਾਂ ਦੇ ਨਾਲ UTCTtime/GeneralizedTime ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਇਹ ਭਵਿੱਖ ਵਿੱਚ ਆਵੇਗਾ, ਕਿਉਂਕਿ ਪ੍ਰੋਜੈਕਟ ਮੁੱਖ ਤੌਰ 'ਤੇ ਮੇਰੇ ਖਾਲੀ ਸਮੇਂ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ.

ਨਾਲ ਹੀ, ਪਹਿਲੇ ਸੰਸਕਰਣ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਖੇਤਰਾਂ ਨਾਲ ਕੋਈ ਕੰਮ ਨਹੀਂ ਸੀ। ਇਸ ਤੋਂ ਕੁਝ ਮਹੀਨਿਆਂ ਬਾਅਦ ਮੌਕਾ ਪੈਦਾ ਹੋਇਆ ਅਤੇ ਸਰਗਰਮੀ ਨਾਲ ਵਰਤੇ ਜਾਣੇ ਸ਼ੁਰੂ ਹੋ ਗਏ, ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਨੂੰ ਮਹੱਤਵਪੂਰਣ ਰੂਪ ਵਿੱਚ ਘਟਾਉਂਦੇ ਹੋਏ - ਇੱਕ ਡੀਕੋਡਿੰਗ ਓਪਰੇਸ਼ਨ ਵਿੱਚ ਬਹੁਤ ਡੂੰਘਾਈ ਤੱਕ ਪੂਰੀ ਬਣਤਰ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸੰਭਵ ਸੀ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਕੀਮਾ ਦੱਸਦੀ ਹੈ ਕਿ ਕਿਹੜੇ ਖੇਤਰ ਕੀ "ਪਰਿਭਾਸ਼ਿਤ" ਕਰਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, CMS ਸਕੀਮ ਦਾ ਵੇਰਵਾ:

class ContentInfo(Sequence):
    schema = (
        ("contentType", ContentType(defines=((("content",), {
            id_authenticatedData: AuthenticatedData(),
            id_digestedData: DigestedData(),
            id_encryptedData: EncryptedData(),
            id_envelopedData: EnvelopedData(),
            id_signedData: SignedData(),
        }),))),
        ("content", Any(expl=tag_ctxc(0))),
    )

ਕਹਿੰਦਾ ਹੈ ਕਿ ਜੇਕਰ contentType ਵਿੱਚ ਮੁੱਲ id_signedData ਨਾਲ ਇੱਕ OID ਹੈ, ਤਾਂ ਸਮੱਗਰੀ ਖੇਤਰ (ਉਸੇ SEQUENCE ਵਿੱਚ ਸਥਿਤ) ਨੂੰ SignedData ਸਕੀਮ ਦੇ ਅਨੁਸਾਰ ਡੀਕੋਡ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇੰਨੇ ਸਾਰੇ ਬਰੈਕਟ ਕਿਉਂ ਹਨ? ਇੱਕ ਖੇਤਰ ਇੱਕੋ ਸਮੇਂ ਕਈ ਖੇਤਰਾਂ ਨੂੰ "ਪਰਿਭਾਸ਼ਿਤ" ਕਰ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ EnvelopedData ਢਾਂਚੇ ਵਿੱਚ ਹੁੰਦਾ ਹੈ। ਪਰਿਭਾਸ਼ਿਤ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਅਖੌਤੀ ਡੀਕੋਡ ਮਾਰਗ ਦੁਆਰਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ - ਇਹ ਸਾਰੀਆਂ ਬਣਤਰਾਂ ਵਿੱਚ ਕਿਸੇ ਵੀ ਤੱਤ ਦੀ ਸਹੀ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।

ਤੁਸੀਂ ਹਮੇਸ਼ਾ ਇਹਨਾਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨੂੰ ਡਾਇਗ੍ਰਾਮ ਵਿੱਚ ਤੁਰੰਤ ਸ਼ਾਮਲ ਕਰਨ ਦਾ ਮੌਕਾ ਨਹੀਂ ਚਾਹੁੰਦੇ ਹੋ ਜਾਂ ਨਹੀਂ ਚਾਹੁੰਦੇ ਹੋ। ਐਪਲੀਕੇਸ਼ਨ-ਵਿਸ਼ੇਸ਼ ਕੇਸ ਹੋ ਸਕਦੇ ਹਨ ਜਦੋਂ OIDs ਅਤੇ ਬਣਤਰ ਸਿਰਫ਼ ਇੱਕ ਤੀਜੀ-ਧਿਰ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਜਾਣੇ ਜਾਂਦੇ ਹਨ। PyDERASN ਢਾਂਚੇ ਨੂੰ ਡੀਕੋਡ ਕਰਨ ਦੇ ਸਮੇਂ ਇਹਨਾਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਸੈੱਟ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ:

ContentInfo().decode(data, ctx={"defines_by_path": ((
    (
        "content", DecodePathDefBy(id_signedData),
        "certificates", any, "certificate", "tbsCertificate",
        "extensions", any, "extnID",
    ),
    ((("extnValue",), {
        id_ce_authorityKeyIdentifier: AuthorityKeyIdentifier(),
        id_ce_basicConstraints: BasicConstraints(),
        [...]
        id_ru_subjectSignTool: SubjectSignTool(),
    }),),
),)})

ਇੱਥੇ ਅਸੀਂ ਕਹਿੰਦੇ ਹਾਂ ਕਿ ਸਾਰੇ ਨੱਥੀ ਕੀਤੇ ਸਰਟੀਫਿਕੇਟਾਂ ਲਈ CMS SignedData ਵਿੱਚ, ਉਹਨਾਂ ਦੇ ਸਾਰੇ ਐਕਸਟੈਂਸ਼ਨਾਂ (AuthorityKeyIdentifier, Basic Constraints, SubjectSignTool, ਆਦਿ) ਨੂੰ ਡੀਕੋਡ ਕਰੋ। ਅਸੀਂ ਡੀਕੋਡ ਮਾਰਗ ਰਾਹੀਂ ਦਰਸਾਉਂਦੇ ਹਾਂ ਕਿ ਕਿਸ ਤੱਤ ਨੂੰ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨਾਲ "ਬਦਲਿਆ" ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਇਹ ਸਕੀਮਾ ਵਿੱਚ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਸੀ।

ਅੰਤ ਵਿੱਚ, PyDERASN ਕੋਲ ਚਲਾਉਣ ਦੀ ਸਮਰੱਥਾ ਹੈ ਕਮਾਂਡ ਲਾਈਨ ASN.1 ਫਾਈਲਾਂ ਨੂੰ ਡੀਕੋਡਿੰਗ ਕਰਨ ਲਈ ਅਤੇ ਅਮੀਰ ਹੈ ਸੁੰਦਰ ਛਪਾਈ. ਤੁਸੀਂ ਇੱਕ ਆਰਬਿਟਰੇਰੀ ASN.1 ਨੂੰ ਡੀਕੋਡ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਤੁਸੀਂ ਇੱਕ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਸਕੀਮ ਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਕੁਝ ਦੇਖ ਸਕਦੇ ਹੋ:

ਪ੍ਰਦਰਸ਼ਿਤ ਜਾਣਕਾਰੀ: ਆਬਜੈਕਟ ਆਫਸੈੱਟ, ਟੈਗ ਦੀ ਲੰਬਾਈ, ਲੰਬਾਈ ਦੀ ਲੰਬਾਈ, ਸਮਗਰੀ ਦੀ ਲੰਬਾਈ, EOC ਦੀ ਮੌਜੂਦਗੀ (ਐਂਡ-ਆਫ-ਓਕਟੈਟ), BER ਏਨਕੋਡਿੰਗ ਵਿਸ਼ੇਸ਼ਤਾ, ਅਨਿਸ਼ਚਿਤ-ਲੰਬਾਈ ਏਨਕੋਡਿੰਗ ਵਿਸ਼ੇਸ਼ਤਾ, EXPLICIT ਟੈਗ ਦੀ ਲੰਬਾਈ ਅਤੇ ਆਫਸੈੱਟ (ਜੇ ਕੋਈ ਹੈ), ਦੀ ਨੇਸਟਿੰਗ ਡੂੰਘਾਈ ਸੰਰਚਨਾਵਾਂ ਵਿੱਚ ਵਸਤੂ, IMPLICIT/EXPLICIT ਟੈਗ ਮੁੱਲ, ਸਕੀਮ ਦੇ ਅਨੁਸਾਰ ਵਸਤੂ ਦਾ ਨਾਮ, ਇਸਦਾ ਅਧਾਰ ASN.1 ਕਿਸਮ, SEQUENCE/SET OF ਦੇ ਅੰਦਰ ਕ੍ਰਮ ਸੰਖਿਆ, ਚੋਣ ਮੁੱਲ (ਜੇ ਕੋਈ ਹੈ), ਮਨੁੱਖੀ-ਪੜ੍ਹਨਯੋਗ ਨਾਮ ਪੂਰਨ/ਅੰਕਿਤ/ਬਿੱਟ ਸਟ੍ਰਿੰਗ ਸਕੀਮ ਦੇ ਅਨੁਸਾਰ, ਕਿਸੇ ਵੀ ਅਧਾਰ ਕਿਸਮ ਦਾ ਮੁੱਲ, ਸਕੀਮ ਤੋਂ ਡਿਫਾਲਟ/ਵਿਕਲਪਿਕ ਫਲੈਗ, ਇਸ ਗੱਲ ਦਾ ਸੰਕੇਤ ਹੈ ਕਿ ਆਬਜੈਕਟ ਨੂੰ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਦੁਆਰਾ ਡੀਕੋਡ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਜਿਸ OID ਕਾਰਨ ਅਜਿਹਾ ਹੋਇਆ, ਮਨੁੱਖੀ-ਪੜ੍ਹਨਯੋਗ OID।

ਸੁੰਦਰ ਪ੍ਰਿੰਟਿੰਗ ਸਿਸਟਮ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਤਾਂ ਜੋ ਇਹ PP ਵਸਤੂਆਂ ਦਾ ਇੱਕ ਕ੍ਰਮ ਤਿਆਰ ਕਰੇ ਜੋ ਵੱਖਰੇ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਿਜ਼ੂਅਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਸਕ੍ਰੀਨਸ਼ਾਟ ਰੈਂਡਰਰ ਨੂੰ ਸਧਾਰਨ ਰੰਗਦਾਰ ਟੈਕਸਟ ਵਿੱਚ ਦਿਖਾਉਂਦਾ ਹੈ। JSON/HTML ਫਾਰਮੈਟ ਵਿੱਚ ਰੈਂਡਰਰ ਵੀ ਹਨ, ਤਾਂ ਜੋ ਇਸਨੂੰ ASN.1 ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਹਾਈਲਾਈਟ ਕਰਨ ਦੇ ਨਾਲ ਦੇਖਿਆ ਜਾ ਸਕੇ, ਜਿਵੇਂ ਕਿ ਵਿੱਚ asn1js ਪ੍ਰੋਜੈਕਟ.

ਹੋਰ ਲਾਇਬ੍ਰੇਰੀਆਂ

ਇਹ ਟੀਚਾ ਨਹੀਂ ਸੀ, ਪਰ PyDERASN ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਨਿਕਲਿਆ ਹੋਰ ਤੇਜ਼ pyasn1 ਨਾਲੋਂ। ਉਦਾਹਰਨ ਲਈ, ਮੈਗਾਬਾਈਟ ਆਕਾਰ ਦੀਆਂ CRL ਫਾਈਲਾਂ ਨੂੰ ਡੀਕੋਡ ਕਰਨ ਵਿੱਚ ਇੰਨਾ ਸਮਾਂ ਲੱਗ ਸਕਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਵਿਚਕਾਰਲੇ ਡੇਟਾ ਸਟੋਰੇਜ ਫਾਰਮੈਟਾਂ (ਤੇਜ਼) ਬਾਰੇ ਸੋਚਣਾ ਪਵੇਗਾ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਬਦਲਣਾ ਪਵੇਗਾ। pyasn1 CRL ਨੂੰ ਡੀਕੋਡ ਕਰਦਾ ਹੈ CACert.org ਮੇਰੇ ਲੈਪਟਾਪ 'ਤੇ 20 ਮਿੰਟ ਲੱਗਦੇ ਹਨ, ਜਦੋਂ ਕਿ PyDERASN ਸਿਰਫ 28 ਸਕਿੰਟ ਲੈਂਦਾ ਹੈ! ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਹੈ asn1crypto, ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਢਾਂਚੇ ਦੇ ਨਾਲ ਤੇਜ਼ੀ ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਉਦੇਸ਼: ਇਹ 29 ਸਕਿੰਟਾਂ ਵਿੱਚ ਉਸੇ CRL ਨੂੰ ਡੀਕੋਡ (ਪੂਰੀ ਤਰ੍ਹਾਂ, ਆਲਸ ਨਾਲ ਨਹੀਂ) ਕਰਦਾ ਹੈ, ਪਰ Python3 (983 MiB ਬਨਾਮ 498) ਦੇ ਅਧੀਨ ਚੱਲਦੇ ਸਮੇਂ ਲਗਭਗ ਦੁੱਗਣੀ ਰੈਮ ਦੀ ਖਪਤ ਕਰਦਾ ਹੈ, ਅਤੇ Python3.5 (2) ਦੇ ਅਧੀਨ 1677 ਗੁਣਾ ਵਿੱਚ। ਬਨਾਮ 488), ਜਦੋਂ ਕਿ pyasn1 4.3 ਗੁਣਾ ਜ਼ਿਆਦਾ ਖਪਤ ਕਰਦਾ ਹੈ (2093 ਬਨਾਮ 488)।

ਅਸੀਂ asn1crypto 'ਤੇ ਵਿਚਾਰ ਨਹੀਂ ਕੀਤਾ, ਜਿਸਦਾ ਮੈਂ ਜ਼ਿਕਰ ਕੀਤਾ ਹੈ, ਕਿਉਂਕਿ ਪ੍ਰੋਜੈਕਟ ਅਜੇ ਵੀ ਆਪਣੀ ਸ਼ੁਰੂਆਤੀ ਅਵਸਥਾ ਵਿੱਚ ਸੀ ਅਤੇ ਅਸੀਂ ਇਸ ਬਾਰੇ ਨਹੀਂ ਸੁਣਿਆ ਸੀ। ਹੁਣ ਅਸੀਂ ਉਸਦੀ ਦਿਸ਼ਾ ਵੱਲ ਵੀ ਨਹੀਂ ਦੇਖਾਂਗੇ, ਕਿਉਂਕਿ ਮੈਂ ਤੁਰੰਤ ਖੋਜ ਕੀਤੀ ਕਿ ਉਹੀ ਜਨਰਲਾਈਜ਼ਡ ਟਾਈਮ ਇੱਕ ਮਨਮਾਨੀ ਰੂਪ ਨਹੀਂ ਲੈਂਦਾ, ਅਤੇ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਦੌਰਾਨ ਇਹ ਚੁੱਪਚਾਪ ਇੱਕ ਸਕਿੰਟ ਦੇ ਇੱਕ ਹਿੱਸੇ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ। ਇਹ X.509 ਸਰਟੀਫਿਕੇਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਸਵੀਕਾਰਯੋਗ ਹੈ, ਪਰ ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ।

ਇਸ ਸਮੇਂ, PyDERASN ਸਭ ਤੋਂ ਸਖਤ ਮੁਫਤ Python/Go DER ਡੀਕੋਡਰ ਹੈ ਜਿਸ ਬਾਰੇ ਮੈਂ ਜਾਣਦਾ ਹਾਂ। ਮੇਰੇ ਪਿਆਰੇ ਗੋ ਦੀ ਏਨਕੋਡਿੰਗ/asn1 ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਸਖਤ ਜਾਂਚ ਨਹੀਂ ਵਸਤੂ ਪਛਾਣਕਰਤਾ ਅਤੇ UTCTtime/GeneralizedTime ਸਤਰ। ਕਈ ਵਾਰ ਸਖ਼ਤੀ ਰਾਹ ਵਿੱਚ ਆ ਸਕਦੀ ਹੈ (ਮੁੱਖ ਤੌਰ 'ਤੇ ਪੁਰਾਣੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਨਾਲ ਪਿਛੜੇ ਅਨੁਕੂਲਤਾ ਦੇ ਕਾਰਨ ਜਿਸ ਨੂੰ ਕੋਈ ਵੀ ਠੀਕ ਨਹੀਂ ਕਰੇਗਾ), ਇਸਲਈ PyDERASN ਪਾਸ ਹੋ ਸਕਦਾ ਹੈ ਵੱਖ-ਵੱਖ ਸੈਟਿੰਗ ਕਮਜ਼ੋਰ ਜਾਂਚ

ਪ੍ਰੋਜੈਕਟ ਕੋਡ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਸਧਾਰਨ ਹੋਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ। ਸਾਰੀ ਲਾਇਬ੍ਰੇਰੀ ਇੱਕ ਫਾਈਲ ਹੈ। ਕੋਡ ਬੇਲੋੜੀ ਕਾਰਗੁਜ਼ਾਰੀ ਅਨੁਕੂਲਨ ਅਤੇ DRY ਕੋਡ ਦੇ ਬਿਨਾਂ, ਸਮਝਣ ਦੀ ਸੌਖ 'ਤੇ ਜ਼ੋਰ ਦੇ ਨਾਲ ਲਿਖਿਆ ਗਿਆ ਹੈ। ਇਹ, ਜਿਵੇਂ ਕਿ ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਕਿਹਾ ਹੈ, UTCTime/GeneralizedTime ਸਟ੍ਰਿੰਗਜ਼ ਦੇ ਨਾਲ-ਨਾਲ REAL, RELATIVE OID, EXTERNAL, INSTANCE OF, EMBEDD PDV, CHARACTER STRING ਡਾਟਾ ਕਿਸਮਾਂ ਦੀ ਪੂਰੀ BER ਡੀਕੋਡਿੰਗ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਹੋਰ ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਮੈਂ ਨਿੱਜੀ ਤੌਰ 'ਤੇ ਪਾਈਥਨ ਵਿੱਚ ਹੋਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਬਿੰਦੂ ਨਹੀਂ ਦੇਖਦਾ.

ਮੇਰੇ ਸਾਰੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਾਂਗ, ਜਿਵੇਂ ਪਾਈਗੋਸਟ, GoGOST, ਐਨ.ਐਨ.ਸੀ.ਪੀ., GoVPN, PyDERASN ਪੂਰੀ ਤਰ੍ਹਾਂ ਹੈ ਮੁਫ਼ਤ ਸਾਫਟਵੇਅਰ, ਸ਼ਰਤਾਂ ਅਧੀਨ ਵੰਡਿਆ ਗਿਆ LGPLv3+, ਅਤੇ ਮੁਫ਼ਤ ਡਾਊਨਲੋਡ ਲਈ ਉਪਲਬਧ ਹੈ। ਵਰਤੋਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਹਨ ਇੱਥੇ ਅਤੇ ਅੰਦਰ PyGOST ਟੈਸਟ.

ਸਰਗੇਈ ਮਾਤਵੀਵ, cypherpunk, ਮੈਂਬਰ SPO ਫਾਊਂਡੇਸ਼ਨ, ਪਾਈਥਨ/ਗੋ ਡਿਵੈਲਪਰ, ਮੁੱਖ ਮਾਹਰ FSUE "STC "ਐਟਲਸ".

ਸਰੋਤ: www.habr.com