How to Reproduce C# BinaryWriter Serialization for RSA Encryption in Python?

Below is an explanation and sample code that shows why the Python result may be rejected and how to correct it.

What’s Likely Happening

The C# snippet does more than just concatenate two strings. It uses a BinaryWriter to write the strings, which means that each string is preceded by a length prefix (encoded as a 7‐bit integer) before its UTF‑8 bytes are written. When you simply do

PYTHONCopied
data = (string1 + string2).encode()

in Python, the resulting byte sequence does not include those length prefixes. In other words, although the RSA encryption with PKCS#1 v1.5 is standard between .NET and Python libraries, the encrypted plaintext isn’t the same because you are not reproducing the BinaryWriter serialization performed by the C# code.

How to Reproduce .NET’s BinaryWriter Behavior in Python

You need to “serialize” the data in the same way as BinaryWriter.Write(String) does in C#. That means writing a length prefix (in the 7‑bit encoded format) followed by the UTF‑8 encoded string. You would do that for both strings before concatenating and encrypting them. For example, here’s a helper function that mimics the BinaryWriter behavior:

PYTHONCopied
import io

def write_7bit_encoded_int(value, stream):
    # Writes an integer in 7-bit encoding.
    while value >= 0x80:
        stream.write(bytes([(value & 0x7F) | 0x80]))
        value >>= 7
    stream.write(bytes([value]))

def binary_writer_write_string(s, stream):
    encoded = s.encode('utf-8')
    write_7bit_encoded_int(len(encoded), stream)
    stream.write(encoded)

# Example usage:
stream = io.BytesIO()
binary_writer_write_string(string1, stream)
binary_writer_write_string(string2, stream)
plaintext = stream.getvalue()

Now, plaintext should match what the C# BinaryWriter would produce.

Putting It All Together with RSA Encryption

Using the PyCryptodome library, here is a complete sample that converts the key and encrypts the “serialized” message using PKCS#1 v1.5:

PYTHONCopied
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
import io

def write_7bit_encoded_int(value, stream):
    # Writes an integer in 7-bit encoding.
    while value >= 0x80:
        stream.write(bytes([(value & 0x7F) | 0x80]))
        value >>= 7
    stream.write(bytes([value]))

def binary_writer_write_string(s, stream):
    encoded = s.encode('utf-8')
    write_7bit_encoded_int(len(encoded), stream)
    stream.write(encoded)

# Assume modulus and exponent are received as byte arrays from the server:
# modulus = b'...256 bytes...'
# exponent = b'...3 bytes...'
n = int.from_bytes(modulus, 'big')
e = int.from_bytes(exponent, 'big')

# Create the RSA public key:
pubkey = RSA.construct((n, e))

# Prepare data matching BinaryWriter semantics:
stream = io.BytesIO()
binary_writer_write_string(string1, stream)
binary_writer_write_string(string2, stream)
plaintext = stream.getvalue()

# Encrypt with PKCS1 v1.5:
cipher = PKCS1_v1_5.new(pubkey)
encrypted_data = cipher.encrypt(plaintext)

# Now send encrypted_data to the server.

Summary

There is no “special” Python RSA implementation—you’re using standard PKCS#1 v1.5 encryption. The likely issue is that the C# code’s use of BinaryWriter introduces a length–prefix encoding before each string. To interoperate correctly, you need to mimic that same serialization in your Python code before encrypting the data.