c++ - .Net के साथ ओपनएसएसएल आरएसए कुंजी का उपयोग करें



openssl rsa (1)

मैं खुलने का समय 0.9.6g का उपयोग कर रहा हूं और मैंने RSA_generate_key () का उपयोग करके सार्वजनिक / निजी कीपर बनाया है। जब मैं PEM_write_bio_RSAPublicKey साथ कुंजी PEM_write_bio_RSAPublicKey , तो यह मुझे कुंजी देता है:

-----BEGIN RSA PUBLIC KEY-----
...
-----END RSA PUBLIC KEY-----

मेरे पास .NET में एक और मॉड्यूल है जो इस प्रारूप में इसके प्रारूप के कारण पास होने पर एक अपवाद फेंकता है। यह प्रारूप की तरह लेता है:

-----BEGIN PUBLIC KEY-----
...
-----END PUBLIC KEY-----

मेरी कुंजियों को इस प्रारूप में कैसे बदलें। मैं C ++ का उपयोग कर रहा हूं।

.NET में, मैं Opensl.net का उपयोग कर रहा हूं, कोड इस प्रकार है:

string publicKey = @"-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAKGtqUVBBqcGCRYa7Sb6JVQirOX3hggWP2k7CzEtbF/soOONK510Kefm
omXBrGn2t79ES+hAcCvGSiiVZGuEb3UPiznzbiY150SME5nRC+zU0vvdX64ni0Mu
DeUlGcxM1eWSpozO71at6mxLloEMUg0oSWHfAlS5a4LVaURrJqXfAgMBAAE=
-----END RSA PUBLIC KEY-----";

Encoding enc = Encoding.ASCII;
string text = "hello world";
byte[] msg = enc.GetBytes(text);
CryptoKey key = CryptoKey.FromPublicKey(publicKey, "");
RSA rsa = key.GetRSA();
byte[] res = rsa.PublicEncrypt(msg, RSA.Padding.PKCS1);

अपवाद पंक्ति में आता है:

CryptoKey key = CryptoKey.FromPublicKey(publicKey, "");

यदि मैं कुंजी का उपयोग करता हूं:

-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCbhcU+fhYmYLESZQAj1hKBXsNY
si0kYHNkxpP7ftxZiTFowWUVXHzQgkcYiCNnp3pt1eG6Vt0WDzyFYXqUUqugvX41
gkaIrKQw/sRiWEx49krcz7Vxr3dufL6Mg3eK7NyWDGsqwFrx/qVNqdhsHg12PGNx
IMY4UBtxin2A8pd4OwIDAQAB
-----END PUBLIC KEY-----

यह बढ़िया काम करता है।

मैं इस मुद्दे के लिए चारों ओर देख रहा था। मुझे लगता है कि मैं जो ढूंढ रहा हूं वह है "rsa public key को pkcs # 1 से x509 फॉर्मेट में कैसे कन्वर्ट करें।


मैं खुलने का समय 0.9.6g का उपयोग कर रहा हूं और मैंने RSA_generate_key () का उपयोग करके सार्वजनिक / निजी कीपर बनाया है। यह मुझे कुंजी देता है जैसे:

-----BEGIN RSA PUBLIC KEY-----
...
-----END RSA PUBLIC KEY-----

मुझे लगता है कि मैं जो ढूंढ रहा हूं वह है "rsa public key को pkcs # 1 से x509 फॉर्मेट में कैसे कन्वर्ट करें।

हाँ, .Net कुछ ASN.1 / DER एन्कोडेड कुंजियों और कुछ PEM एन्कोडेड कुंजियों का उपभोग कर सकते हैं। अंतर PKCS एन्कोडिंग बनाम पारंपरिक एन्कोडिंग है (ओपनएसएसएल इसे "पारंपरिक" कहता है)। पारंपरिक एन्कोडिंग SubjectPublicKeyInfo है और इसमें OID और सार्वजनिक कुंजी शामिल है।

तो आप या तो ASN.1 / DER एन्कोडिंग या PEM एन्कोडिंग की तलाश कर रहे हैं जो SubjectPublicKeyInfo लिखता है, न कि केवल सार्वजनिक कुंजी।

मेरे पास .NET में एक और मॉड्यूल है जो इस प्रारूप में इसके प्रारूप के कारण पास होने पर एक अपवाद फेंकता है। यह प्रारूप की तरह लेता है:

-----BEGIN PUBLIC KEY-----
...
-----END PUBLIC KEY-----

इस स्थिति में, PEM_write_bio_PUBKEY उपयोग PEM_write_bio_PUBKEY बजाय करें।

PEM_write_bio_PUBKEY लिखता है; जबकि PEM_write_bio_RSAPublicKey केवल सार्वजनिक कुंजी लिखता है।

आपको EVP_PKEY की आवश्यकता होगी, इसलिए इसे परिवर्तित करने के लिए EVP_PKEY_set1_RSA का उपयोग करें।

यह OpenSSL में PKCS कुंजी है। इसकी सिर्फ सार्वजनिक कुंजी है। इसे लिखने के लिए आप PEM_write_RSAPublicKey का उपयोग करेंगे:

-----BEGIN RSA PUBLIC KEY-----

और यह OpenSSL में एक पारंपरिक कुंजी है। इसका SubjectPublicKeyInfo है , और इसमें एल्गोरिथ्म ( rsaEncryption ) और सार्वजनिक कुंजी के लिए एक OID शामिल है। इसे लिखने के लिए आप PEM_write_bio_PUBKEY का उपयोग करेंगे:

-----BEGIN PUBLIC KEY-----

PEM_write_RSAPublicKey साथ कुंजी को सहेजने के बजाय, आपको AS2.1 में SubjectPublicKeyInfo संरचना लिखना चाहिए / i2d_RSA_PUBKEY_bio साथ DER प्रारूप; या इसे PEM_write_bio_PUBKEY साथ PEM प्रारूप में PEM_write_bio_PUBKEY

नीचे दिया गया प्रोग्राम RSA कुंजी युग्म बनाता है, और फिर सभी स्वरूपों में सार्वजनिक कुंजी लिखता है। निजी कुंजी को भी सहेजना सुनिश्चित करें।

(और मुझे खुशी है कि आपके पास C ++ टैग है। unique_ptr इस अभ्यास को इतना आसान बनाता है)।

#include <memory>
using std::unique_ptr;

#include <openssl/bn.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/bio.h>
#include <openssl/x509.h>

#include <cassert>
#define ASSERT assert

using BN_ptr = std::unique_ptr<BIGNUM, decltype(&::BN_free)>;
using RSA_ptr = std::unique_ptr<RSA, decltype(&::RSA_free)>;
using EVP_KEY_ptr = std::unique_ptr<EVP_PKEY, decltype(&::EVP_PKEY_free)>;
using BIO_FILE_ptr = std::unique_ptr<BIO, decltype(&::BIO_free)>;

int main(int argc, char* argv[])
{
    int rc;

    RSA_ptr rsa(RSA_new(), ::RSA_free);
    BN_ptr bn(BN_new(), ::BN_free);

    BIO_FILE_ptr pem1(BIO_new_file("rsa-public-1.pem", "w"), ::BIO_free);
    BIO_FILE_ptr pem2(BIO_new_file("rsa-public-2.pem", "w"), ::BIO_free);
    BIO_FILE_ptr der1(BIO_new_file("rsa-public-1.der", "w"), ::BIO_free);
    BIO_FILE_ptr der2(BIO_new_file("rsa-public-2.der", "w"), ::BIO_free);

    rc = BN_set_word(bn.get(), RSA_F4);
    ASSERT(rc == 1);

    // Generate key
    rc = RSA_generate_key_ex(rsa.get(), 2048, bn.get(), NULL);
    ASSERT(rc == 1);

    // Convert RSA key to PKEY
    EVP_KEY_ptr pkey(EVP_PKEY_new(), ::EVP_PKEY_free);
    rc = EVP_PKEY_set1_RSA(pkey.get(), rsa.get());
    ASSERT(rc == 1);

    //////////

    // Write just the public key in ASN.1/DER
    // Load with d2i_RSAPublicKey_bio
    rc = i2d_RSAPublicKey_bio(der1.get(), rsa.get());
    ASSERT(rc == 1);

    // Write just the public key in PEM
    // Load with PEM_read_bio_RSAPublicKey
    rc = PEM_write_bio_RSAPublicKey(pem1.get(), rsa.get());
    ASSERT(rc == 1);

    // Write SubjectPublicKeyInfo with OID and public key in ASN.1/DER
    // Load with d2i_RSA_PUBKEY_bio
    rc = i2d_RSA_PUBKEY_bio(der2.get(), rsa.get());
    ASSERT(rc == 1);

    // Write SubjectPublicKeyInfo with OID and public key in PEM
    // Load with PEM_read_bio_PUBKEY
    rc = PEM_write_bio_PUBKEY(pem2.get(), pkey.get());
    ASSERT(rc == 1);

    return 0;
}

EVP_PKEY_set1_RSA में EVP_PKEY_set1_RSA 1 संदर्भ गणना को EVP_PKEY_set1_RSA देता है, इसलिए आपको डबल फ्री पर EVP_PKEY_set1_RSA नहीं मिलता है।

कार्यक्रम को निष्पादित करने के बाद, आपको अपेक्षित पीईएम और एएसएन .1 / डीईआर:

$ cat rsa-public-1.pem 
-----BEGIN RSA PUBLIC KEY-----
MIIBCgKCAQEA0cgFv6wEcqoOhPtHdVmX4YFlCwodnSqooeCxFF1XadTS4sZkVJTC
kszHmRqXiXL2NmqnuDQsq6nLd+sNoU5yJJ+W1hwo7UToCyJ/81tS4n6mXvF8oilP
8YudD5QnBdW9LhqttBIN4Gk+Cxun+HG1rSJLGP9yiPPFd7DPiFz0Gd+juyWznWnP
gapDIWEKqANKma3j6b9eopBDWB0XAgU0HQ71MSNbcsPvDd23Ftx0re/7jG53V7Bn
eBy7fQsPmxcn4c74Lz4CvhOr7VdQpeBzNeG2CtkefKWyTk7Vu4FZnAgNd/202XAr
c6GmEQqD2M2zXH/nVZg5oLznECDVQ1x/pwIDAQAB
-----END RSA PUBLIC KEY-----

$ cat rsa-public-2.pem 
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0cgFv6wEcqoOhPtHdVmX
4YFlCwodnSqooeCxFF1XadTS4sZkVJTCkszHmRqXiXL2NmqnuDQsq6nLd+sNoU5y
JJ+W1hwo7UToCyJ/81tS4n6mXvF8oilP8YudD5QnBdW9LhqttBIN4Gk+Cxun+HG1
rSJLGP9yiPPFd7DPiFz0Gd+juyWznWnPgapDIWEKqANKma3j6b9eopBDWB0XAgU0
HQ71MSNbcsPvDd23Ftx0re/7jG53V7BneBy7fQsPmxcn4c74Lz4CvhOr7VdQpeBz
NeG2CtkefKWyTk7Vu4FZnAgNd/202XArc6GmEQqD2M2zXH/nVZg5oLznECDVQ1x/
pwIDAQAB
-----END PUBLIC KEY-----

$ dumpasn1 rsa-public-1.der 
  0 266: SEQUENCE {
  4 257:   INTEGER
       :     00 D1 C8 05 BF AC 04 72 AA 0E 84 FB 47 75 59 97
       :     E1 81 65 0B 0A 1D 9D 2A A8 A1 E0 B1 14 5D 57 69
       :     D4 D2 E2 C6 64 54 94 C2 92 CC C7 99 1A 97 89 72
       :     F6 36 6A A7 B8 34 2C AB A9 CB 77 EB 0D A1 4E 72
       :     24 9F 96 D6 1C 28 ED 44 E8 0B 22 7F F3 5B 52 E2
       :     7E A6 5E F1 7C A2 29 4F F1 8B 9D 0F 94 27 05 D5
       :     BD 2E 1A AD B4 12 0D E0 69 3E 0B 1B A7 F8 71 B5
       :     AD 22 4B 18 FF 72 88 F3 C5 77 B0 CF 88 5C F4 19
       :             [ Another 129 bytes skipped ]
265   3:   INTEGER 65537
       :   }

0 warnings, 0 errors.

$ dumpasn1 rsa-public-2.der 
  0 290: SEQUENCE {
  4  13:   SEQUENCE {
  6   9:     OBJECT IDENTIFIER rsaEncryption (1 2 840 113549 1 1 1)
 17   0:     NULL
       :     }
 19 271:   BIT STRING, encapsulates {
 24 266:     SEQUENCE {
 28 257:       INTEGER
       :         00 D1 C8 05 BF AC 04 72 AA 0E 84 FB 47 75 59 97
       :         E1 81 65 0B 0A 1D 9D 2A A8 A1 E0 B1 14 5D 57 69
       :         D4 D2 E2 C6 64 54 94 C2 92 CC C7 99 1A 97 89 72
       :         F6 36 6A A7 B8 34 2C AB A9 CB 77 EB 0D A1 4E 72
       :         24 9F 96 D6 1C 28 ED 44 E8 0B 22 7F F3 5B 52 E2
       :         7E A6 5E F1 7C A2 29 4F F1 8B 9D 0F 94 27 05 D5
       :         BD 2E 1A AD B4 12 0D E0 69 3E 0B 1B A7 F8 71 B5
       :         AD 22 4B 18 FF 72 88 F3 C5 77 B0 CF 88 5C F4 19
       :                 [ Another 129 bytes skipped ]
289   3:       INTEGER 65537
       :       }
       :     }
       :   }

0 warnings, 0 errors.

संबंधित, देखें कि ओपनएसएल का उपयोग करके आरएसए निजी कुंजी कैसे उत्पन्न करें? । यह आपको दिखाता है कि कई स्वरूपों में RSA सार्वजनिक और निजी कुंजी कैसे लिखी जाती है।





rsa