RSA encryption using c++ (incorrect result)

Question

I have PHP code, which make RSA encryption. This PHP code give me correct output. I need same result, but using c++. I try make c++ code, but got incorrect RSA encryption result. Not same like if using php code. What i need change in c++ code, for getting same result like on php? Thanks.

PHP code:

<?php
    include('Crypt/RSA.php');

    $publickey_mod = "981b4b1e5d0a4db79229c454d091ec76afb1e0b945ea68ee3402ab82450b7fc0b6030641dc8fb098f864f847cdb0fabf7d2f1514ddea140a4d51195cdbbc0ff05eb5bb3a708aed95c6481a6b120c308a577494eec0135cb3dd478c5b9279b95edf8fcd875dfb309a35d2454ba47ce7032961f41ea51dfc3b2a2ee776d2a60edbe33f02a82a4d40c323f4eca0802321d3e163b20ed7e44714c9f476ce51c0010f410cdfa7bb93524550e9e2390b5e470e8450f11a8840ca6eb0a9d343892fb87ae52c17af1720017e82055c3e1ea7e184923b9efce36e910a72886971db9f19eda6d3533de6e3949d92434730691209fc5e0a8f3ac525c7aca900782e6b2244b7";
    $publickey_exp = "010001";
    $password = "password";
        
    $rsa = new Crypt_RSA();
    $rsa->setEncryptionMode(CRYPT_RSA_ENCRYPTION_PKCS1);
    $rsa->loadKey(array(
        'n' => new Math_BigInteger($publickey_mod, 16),
        'e' => new Math_BigInteger($publickey_exp, 16)
    ));
        
    echo "result=\"" . base64_encode($rsa->encrypt($password)) . "\"";
?>

PHP outputs:

#1
result="N29/RawYj7rbAc4347axmxlD5vAN2kUWDUURX7ADU1pr9+b9SC7i+TzqXyhI0MumVuQOD6uc/t1uwCbuNjz/X6W5scEBapemO4OZzjBJLrEf1gTA9wJKub5VE3dUhbrTWh30NsrL/ZZgVs9vp9kqCFXpJESU8OGfnfiiMBN0WSEZjSfieDe6hkn+00Hwjl1ZmouKMxpgBjmZlXIK7PkmLs6HBsScgnscCPUUX/vfPy/krpBVjaR3xgky0sbKvpZi6pwh0AjfAVbJk8nYS/5SuXEcORpRRm2PBQAk9/4cDiEsEqODBICzIerBln/3FnsI6OTOLHYkhZ5vQLyp6pTjvw=="

#2
result="U1Wy9TQP5K4DznmvuiLl90aPKIfxrzjAkQKGrp740NEh3mgWWtHPICJFa8ORm0LpJ5ZBoZi04CvHaYS+HAC5HTJn+S6xkp+8lX8xiurxDjAKWNQc5d/la9jNinB45DUQZOEiGg5u+Qpzgt48qNH3Y5PrwIMlDSil1u3YpuL+LMHwGCMD5dg5wsRX23HXJucGWOkRepST3+BLQns0Jp6ivoBOKH6wvFS41hYH3zK9d4vmuu7oKUl2c6G5G1A0f7SzFw2PsbQns/814dLr02vi/WAnD/N0sY221NlS5t9IApO2wCf0k/MmL69GixqPY8/bThJ2nmgYQktkAOCXouSQvA=="

#3
result="SF7o6F7/vVikGSzPl06yMwOc/si7EtMhbLm19/RSmuaFP+GcC6DHYGhk/BUOiwKb+ZzzxoMNFjum8J52z/ScvYEiEM7ieTDrqBnk1p/dTzWfGJ+Rs3+FsEYzrQ/l0Rh4s9TPC3s8V0dhO+eoRlT/8vyZMXe7win8XWbwBxQ6tDcemzjLAiT/c44re6qBidzDGd7kP/Vxd/ocy712/1fFP2Rm5O4YHb/5AulG5ISxDvUa98TQuGWBeV1j5cBzwodFi6sWcVR9LJtpOCjf4GH5GpO5rGEBDMB7DHwrwhTHMulKC2JxdAi+7SJtI1nSlN/AHyrIXPPADsgINH+qPFl+eA=="

#4
result="lIduaeOFDnOb1ddXJQ29RD/4j2iQsrcWgZUsLPrz+B51Xw4VSkO4fZJngqUkBw1mxaG9lvCGeID5j1v2Bv9ki9sfmApcGqV7aAPjHkiTBPvDjpWscGJlZXaHJfg1L/oBheF9mJ08uJzI5KAy6+TtByLrMhcLi077tj0rHvM92zqQhHHooGWaqbnWFzBlLT3Ham5ZcpHXbAnSYwWVc7ILno0Y/poCm+TGG8taXZXFZqEzYvKhDgm+LVHqZfpEE8rnQNfwLgJAZLsE/dWQvtFa/rHjcCA+O6qO2mFnVjg8i3iIzy4gHs12wb+BlLglrWvV1cl6XvNc1mGfDy4H324ptA=="

#5
result="KEgbzIA91SUS7c6sI3Zt4fx4LAcBZs6vth8iYqkZWPMjY+irb5oN4EihbZeR+9DbzTH4RidQBIj8Woj8cqo5tGSka29Bg+eBjIRjQozMlclEiCPg5YG1im5ozCOsTG/rHJr4IZZq1O2Qkh+uV4wvtJaym3H977qgfeHhwhSYbsQeqeyHZy5ieiVKdqAF1WvgHuBfEu6u2eXRoJt6JhmZA+4lZ5zGj6+Efj8njW+4cP+FBArdKZbkj+9UUMtiauYzX3nmVKAiMaVIkQidI+lTeaqOZzANGuqp9Ex8sYkeGLcpDELvC6wdBRaWr+dX9cuEtgeBIT24MkFGmiyc6CmLOA=="

c++ (openssl) code:

#include <string.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <openssl/rsa.h>
#include <openssl/aes.h>
#include <openssl/opensslconf.h>
#include <openssl/engine.h>
#include <openssl/pem.h>
#include <openssl/rc4.h>
#include <openssl/bio.h>
#include <openssl/evp.h>

std::string base64_encode(const std::string& input)
{
    const auto base64_memory = BIO_new(BIO_s_mem());
    auto base64 = BIO_new(BIO_f_base64());
    base64 = BIO_push(base64, base64_memory);
    BIO_write(base64, input.c_str(), static_cast<int>(input.length()));
    BIO_flush(base64);
    BUF_MEM* buffer_memory{};
    BIO_get_mem_ptr(base64, &buffer_memory);
    auto base64_encoded = std::string(buffer_memory->data, buffer_memory->length - 1);
    BIO_free_all(base64);
    return base64_encoded;
}

int main()
{
    char key[] = "981b4b1e5d0a4db79229c454d091ec76afb1e0b945ea68ee3402ab82450b7fc0b6030641dc8fb098f864f847cdb0fabf7d2f1514ddea140a4d51195cdbbc0ff05eb5bb3a708aed95c6481a6b120c308a577494eec0135cb3dd478c5b9279b95edf8fcd875dfb309a35d2454ba47ce7032961f41ea51dfc3b2a2ee776d2a60edbe33f02a82a4d40c323f4eca0802321d3e163b20ed7e44714c9f476ce51c0010f410cdfa7bb93524550e9e2390b5e470e8450f11a8840ca6eb0a9d343892fb87ae52c17af1720017e82055c3e1ea7e184923b9efce36e910a72886971db9f19eda6d3533de6e3949d92434730691209fc5e0a8f3ac525c7aca900782e6b2244b7";

    char palavra[] = "password";
    char crip[512];
    RSA* pubkey = RSA_new();
    BIGNUM* modul = BN_new();
    BIGNUM* expon = BN_new();

    BN_hex2bn(&modul, (const char*)key);
    BN_hex2bn(&expon, "010001");

    RSA_set0_key(pubkey, modul, expon, NULL);

    RSA_public_encrypt(strlen((const char*)palavra), (const unsigned char*)palavra, (unsigned char*)crip, pubkey, RSA_PKCS1_PADDING);

    //std::cout << "result: " +  base64_encode(crip) << std::endl;
    std::cout << "result: " << crip << std::endl;

    return 0;
}

C++ outputs:

#1
result: SNpRW2q1crBPVLPYJ3ZmRm+OaVJkXeHYhQgHZ3Oo+eKe/A==

#2
result: OO7UtCuhjtuh1CkiJyw//5iyKrCMjvHSQOfD3XM3IPIRxFwRfYm1vUoOQZdiJcNs6zdSkcBaHrvnQ/+vwtSmqKkv35NOacoK7cXNpG/i+L+zqYtFRc4/ryPHE5gLo25tHO5g+xHnls5yZc+AD0+IKJ1NJYL20Z5RzXUNYVOEG2zkUa8=

#3
result: IaHXTdFcrWF6eWA2fKsRf/7wEf87Rn0n9zld4jzCySX2msvE9MFPwaaD3eqlfpR3x8wcVyKBVhxaqSDPacBMqpCQOTJI5z9k78E8dkdUtbysfM/jdqVNv+ClSAFAN9R2mtKLaHCPBuYQzvHomwuhxagHLULOGfqKGVSM+hRmL+MK8Eux4xcUvTrarY4YGUbBiJk21m6aYELfpxls/yT1pxI1U3j3odIM4F/RkO3iJ03kVMFSItc3k81E9iZPPC1DowpaD81iZrMCmQbh9PH3U8zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzHBhc3N3b3Jk

#4
result: BjuGPZe7QHOBMKKXMh8pDlddIbT9NOynRYOi9lGTDVb9YTZ8/X+YIHJKSGWdQ1/OCYgW

#5
result: B4wPPRrrAe5zplMoCcxtf3tzP3y7eC/fkE4cBHRL26clYjzEVyjMzPst/f1zWH++NQcEu8w8m3Fb1OSKdhGkn8gebFxPPZpautAquGDImfl0ftWYtnj2FrNDER4=

What do you mean with "different results" ? As a security feature a lot of algorithms/encryption schemes add a random element so the output = ciphertext looks different each time you run the encryption. The important case is the decryption - does your c++ code decrypt the data from PHP ? So please show us the output of your PHP and c++ functions as asked by @Sammitch. — Michael Fehr, Jun 04 '22 at 06:43
RSA PKCS#1 padding is randomized, it contains at least 64 bytes of random data in the range [1, 256). So trying to create the same ciphertext is a act of futility - even if you use the same runtime. The only proof is showing that it **can be decrypted**. I'll not go into "deterministic encryption" as that doesn't seem on topic for this use case. — Maarten Bodewes, Jun 04 '22 at 17:41
Oh, yeah, that automatic conversion to std::string probably acts on the first NUL character in the string. You'll need to explicitly include the string size when converting. — Maarten Bodewes, Jun 04 '22 at 17:49
if you about the base64 function, i tried without base64 encrypt. result same. bugged output. i added screenshot with output, it contain garbage in the end sometimes. or output is very short... — Makimah, Jun 04 '22 at 20:36
steamcommunity.com dosent accept rsa c++ output, but php rsa output accept. — Makimah, Jun 04 '22 at 20:51
something wrong with this c++ code i cant understand what..... i just need result like on php, for sign in to steam account — Makimah, Jun 04 '22 at 20:55

Topaco · Accepted Answer · 2022-06-05T08:25:46.193

The behavior is actually caused by two counteracting bugs. The first bug always occurs, results in a constant lengthening of the output, and is the cause of the garbage at the end.
The second bug does not always occur, results in a varying shortening of the output and, when it occurs, conceals the first bug.

Bug 1: The modulus 98...b7 consists of 512 hex digits and thus has a size of 256 bytes (2048 bits). Since for RSA the size of the ciphertext is equal to the size of the modulus, crisp must be only 256 bytes and not 512 bytes as in the current code.
This oversized crisp is the cause of the lengthened ciphertext. With the reduction to 256 bytes RSA_public_encrypt() performs a correct RSA encryption with PKCS#1 v1.5 padding and creates ciphertexts with correct length, i.e. 256 bytes.

Bug 2: The string constructor implicitly used when passing the ciphertext to the base64_encode() function is only suitable for 0x00 terminated strings, not for binary data like ciphertexts which may contain 0x00 values. As already suspected in the comment, if the ciphertext contains 0x00 values, only the first null-terminated string is passed and the rest is lost.
So that the full size of the data is taken into account, the size of the ciphertext must be specified explicitly. For this, the appropriate string constructor must be used (see here, (5) from buffer, and here). With this change, the Base64 encoded ciphertexts have the same size, analogous to the PHP code.

The complete changes are:

#define SIZE 256
..
char crip[SIZE]; // fixes bug 1
...
std::cout << "result:\n" + base64_encode(std::string(crip, SIZE)) << std::endl; // fixes bug 2

Example for an output:

result:
LqUnij6tVy+Qprw9nyUeyYgZYwmz/GZ3/A/EVbaDA27ORHzc8tkHWTCVk7DssBSf
LyPRmrBhyUGZMFBjpLH5Iz1VKBacR36UeNif+GzoYdrtmOaSzDs+B74isAToJngJ
0X7hXIOFpMfQylrSFRFoajaBld+edBH9bOQ/U7ogQkoMDHKkTgT07MXj+p7s6dIe
K8E39QIZj5lF85i14MJwEvUBpDKyx3lWjq32d+VJOFHX65g2SQuTugQeAs6+eG7s
e7KDmExvvS+oGA6rInT+icfRN6CKskp4TCto1NgfwtVMVzEfbsHU2aZjcA3EAKSR
Pq3EHfcW3Z2wSy2EjzIbcw==

RSA encryption using c++ (incorrect result)

1 Answers1