How to use vs2008 [VC++9](managed code) static lib in vc++6.0

Question

I have encryption decryption code in C#, VB.net and VC++ (VS 2008) and encrypted file by anyone of this can be decrypted by anyone.

Now the requirement is, I have to use VC++ (VS 2008) static lib file in VC++ 6.0.

OR suggest any other alternative to do this(without dll)

namespace RijndaelEncDec
{

    void Rijndael::LN_EncryptFile(String^ fileSource, String^ fileDestination, String^ password)
    {
        // Declare the streams used
        // to encrypt to an in memory
        // array of bytes.

        CryptoStream^   cryptoStream;

        FileStream^ fsIn;
        FileStream^ fsOut ;

        // Declare the RijndaelManaged object
        // used to encrypt the data.
        RijndaelManaged^ RijndaelCipher;

        try
        {           
            fsIn=gcnew FileStream(fileSource, FileMode::Open, FileAccess::Read);
            fsOut = gcnew FileStream(fileDestination, FileMode::Create, FileAccess::Write);


            array<Byte>^  salt = gcnew array<Byte>(13){ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xF1, 0xF0, 0xEE, 0x21, 0x22, 0x45 };
            Rfc2898DeriveBytes ^secretKey =gcnew Rfc2898DeriveBytes(password,salt);

            RijndaelCipher = gcnew RijndaelManaged();
            RijndaelCipher->Padding = PaddingMode::PKCS7;
            RijndaelCipher->Mode=CipherMode::CBC;
            RijndaelCipher->BlockSize=128;
            RijndaelCipher->Key = secretKey->GetBytes(32);
            RijndaelCipher->IV = secretKey->GetBytes(16);


            ICryptoTransform^ encryptor = RijndaelCipher->CreateEncryptor();
            cryptoStream = gcnew CryptoStream(fsOut, encryptor, CryptoStreamMode::Write);


            int ByteData;
            while ((ByteData=fsIn->ReadByte()) != -1)
            {
              cryptoStream->WriteByte(ByteData);
            }

          cryptoStream->FlushFinalBlock();

        }
         catch (FileNotFoundException^ ex)
            {
                if ((ex->FileName->CompareTo(fileSource) == 0) && (GlobalVariableClass::logPermission == true))
                {
                    StreamWriter^ writer = gcnew StreamWriter(GlobalVariableClass::logFileLocation);
                    writer->WriteLine(ex->Message);
                    writer->Close();
                }
                if ((ex->FileName->CompareTo(fileDestination) == 0) && GlobalVariableClass::logPermission == true)
                {
                    StreamWriter^ writer = gcnew StreamWriter(GlobalVariableClass::logFileLocation);
                    writer->WriteLine(ex->Message + " i.e. Input file for Encryption");
                    writer->Close();
                }

            }
         catch (Exception^ ex)
            {
                if(GlobalVariableClass::logPermission==true)
                {
                    StreamWriter^ writer = gcnew StreamWriter(GlobalVariableClass::logFileLocation);
                    writer->WriteLine(ex->Message + " During Encrypting File");
                    writer->Close();

                }


            }
        finally
        {


            // Close the streams.

            if (cryptoStream)
                cryptoStream->Close();
            if(fsIn)
                fsIn->Close();
            if(fsOut)
                fsOut->Close();
            // Clear the RijndaelManaged object.
            if (RijndaelCipher)
                RijndaelCipher->Clear();
        }

        // Return the encrypted bytes from the memory stream.
        return ;//msEncrypt->ToArray();
    }

    void Rijndael::DecryptFile(String^ fileSource, String^ fileDestination, String^ password)
    {



        array<Byte>^  salt = gcnew array<Byte>(13) { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xF1, 0xF0, 0xEE, 0x21, 0x22, 0x45 };
        Rfc2898DeriveBytes ^secretKey =gcnew Rfc2898DeriveBytes(password,salt);       

        CryptoStream^ csDecrypt;
        StreamReader^ srDecrypt;
        FileStream^ fsIn;
        FileStream^ fsOut;

        // Declare the RijndaelManaged object
        // used to decrypt the data.
        RijndaelManaged^ RijndaelCipher;



        try
        {

            fsIn  = gcnew FileStream(fileSource, FileMode::Open, FileAccess::Read);
            fsOut = gcnew FileStream(fileDestination, FileMode::Create, FileAccess::Write);   

            RijndaelCipher = gcnew RijndaelManaged();
            RijndaelCipher->Padding = PaddingMode::PKCS7;
            RijndaelCipher->Key = secretKey->GetBytes(32);
            RijndaelCipher->IV = secretKey->GetBytes(16);

            // Create a decrytor to perform the stream transform.
            ICryptoTransform^ decryptor = RijndaelCipher->CreateDecryptor();

            // Create the streams used for decryption.

            csDecrypt = gcnew CryptoStream(fsOut, decryptor, CryptoStreamMode::Write);

            int ByteData;
            while ((ByteData=fsIn->ReadByte()) != -1)

            {

              csDecrypt->WriteByte(ByteData);

            }





        }
         catch (FileNotFoundException^ ex)
                {
                    if ((ex->FileName->CompareTo(fileSource) == 0) && (GlobalVariableClass::logPermission == true))
                    {

                        StreamWriter^ writer = gcnew StreamWriter(GlobalVariableClass::logFileLocation);
                        writer->WriteLine(ex->Message + " i.e. Input file for decryption");
                        writer->Close();
                    }
                    if ((ex->FileName->CompareTo(fileDestination) == 0) && GlobalVariableClass::logPermission == true)
                    {
                        StreamWriter^ writer = gcnew StreamWriter(GlobalVariableClass::logFileLocation);
                        writer->WriteLine(ex->Message + " i.e. Output file while decryption");
                        writer->Close();
                    }

                }
                catch (Exception^ ex)
                {
                    if (GlobalVariableClass::logPermission == true)
                    {
                        StreamWriter^ writer = gcnew StreamWriter(GlobalVariableClass::logFileLocation);
                        writer->WriteLine(ex->Message + " During Decrypting File");
                        writer->Close();
                    }

                }
        finally
        {
            // Clean things up.

            // Close the streams.
            if (srDecrypt)
                srDecrypt->Close();
            if (csDecrypt)
                csDecrypt->Close();

               fsIn->Close();
               fsOut->Close();


            // Clear the RijndaelManaged object.
            if (RijndaelCipher)
                RijndaelCipher->Clear();
        }

        return ;
    }

    String^ Rijndael:: ReadEncryptFileToBuffer(String^ fileSource,[System::Runtime::InteropServices::OutAttribute]  String ^% buffer,String^ password)
    {
        FileStream^ fsIn; 
        MemoryStream^ memoryStream;
        CryptoStream^ cryptoStream;
        StreamReader^ fileReader,^streamReader;
        RijndaelManaged^ RijndaelCipher;
        String^ decryptText;

         // First we are going to open the file streams
        try
        {
          RijndaelCipher = gcnew RijndaelManaged();
          RijndaelCipher->Mode = CipherMode::CBC;
          RijndaelCipher->KeySize = 256;
          RijndaelCipher->BlockSize = 128;
          RijndaelCipher->Padding = PaddingMode::PKCS7;

          fsIn = gcnew FileStream(fileSource, FileMode::Open, FileAccess::Read);
          fileReader = gcnew StreamReader(fsIn,System::Text::Encoding::Default);
          String^ cipherText = fileReader->ReadToEnd();
          array<Byte>^ cipherByte = System::Text::Encoding::Default->GetBytes(cipherText);



          array<Byte>^  salt = gcnew array<Byte>(13) { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xF1, 0xF0, 0xEE, 0x21, 0x22, 0x45 };  
          Rfc2898DeriveBytes^ secretKey = gcnew Rfc2898DeriveBytes(password, salt);
          ICryptoTransform^ Decryptor = RijndaelCipher->CreateDecryptor(secretKey->GetBytes(32), secretKey->GetBytes(16));





          memoryStream = gcnew MemoryStream(cipherByte);
          cryptoStream = gcnew CryptoStream(memoryStream, Decryptor, CryptoStreamMode::Read);
          streamReader = gcnew StreamReader(cryptoStream);
          decryptText = streamReader->ReadToEnd();
          buffer = decryptText;
          Console::WriteLine(decryptText);



        }
         catch (FileNotFoundException^ ex)
        {
            if (ex->FileName->CompareTo(fileSource) == 0 && GlobalVariableClass::logPermission == true)
            {

                StreamWriter^ writer = gcnew StreamWriter(GlobalVariableClass::logFileLocation);
                writer->WriteLine(ex->Message + " i.e. Input file for decryption Buffer");
                writer->Close();

            }


        }
        catch (Exception^ ex)
        {
            if (GlobalVariableClass::logPermission == true)
            {
                StreamWriter^ writer = gcnew StreamWriter(GlobalVariableClass::logFileLocation);
                writer->WriteLine(ex->Message + "i.e. During Reading Encrypting File to Decrypted Buffer");
                writer->Close();
            }

        }
        finally
        {
          if(fsIn)
          fsIn->Close();
          if(memoryStream)
          memoryStream->Close();
          if(cryptoStream)
          cryptoStream->Close();
          if(streamReader)
          streamReader->Close();

        }
        return decryptText;
    }

    void Rijndael::WriteEncFileFromDecBuffer(String^ buffer, String^ fileDestination, String^ password)
    {
        FileStream^ fsOut; 
        CryptoStream^ cryptoStream;
        StreamReader^ streamReader;

        try
        {
            RijndaelManaged^ RijndaelCipher = gcnew RijndaelManaged();
            RijndaelCipher->Mode = CipherMode::CBC;
            RijndaelCipher->KeySize = 256;
            RijndaelCipher->BlockSize = 128;
            RijndaelCipher->Padding = PaddingMode::PKCS7;

            FileStream^ fsOut = gcnew FileStream(fileDestination, FileMode::Create, FileAccess::Write);

            array<Byte>^  salt = gcnew array<Byte>(13) { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xF1, 0xF0, 0xEE, 0x21, 0x22, 0x45 };
            array<Byte>^ plainText = System::Text::Encoding::Default->GetBytes(buffer);
            Rfc2898DeriveBytes^ secretKey = gcnew Rfc2898DeriveBytes(password, salt);
            ICryptoTransform^ Encryptor = RijndaelCipher->CreateEncryptor(secretKey->GetBytes(32), secretKey->GetBytes(16));

            cryptoStream = gcnew CryptoStream(fsOut, Encryptor, CryptoStreamMode::Write);

            cryptoStream->Write(plainText, 0, plainText->Length);

            cryptoStream->FlushFinalBlock();
            cryptoStream->Close();
            fsOut->Close();
        }

        catch(FileNotFoundException^ ex)
        {
            if ( GlobalVariableClass::logPermission == true)
            {

                StreamWriter^ writer = gcnew StreamWriter(GlobalVariableClass::logFileLocation);
                writer->WriteLine(ex->Message + " i.e. Output file from Dencrypted Buffer");
                writer->Close();
            }

        }
        catch(Exception^ ex)
        {
            if (GlobalVariableClass::logPermission == true)
            {
                StreamWriter^ writer = gcnew StreamWriter(GlobalVariableClass::logFileLocation);
                writer->WriteLine(ex->Message + " During Writing Encrypting File from Decrypted Buffer");
                writer->Close();

            }
        }
        finally
        {
          fsOut->Close();
          cryptoStream->Close();
          streamReader->Close();

        } 
    }
}

Answer 1

Rather I will suggest you to upgrade your VC++ 6.0 code to VC++ 9.0(or any version that include .NetFramework Support), that version can compile your Application code in managed environment too. So now you can use your managed static library or can just embed your library managed code as it is there to use all it functionality as per your requirement.

Your Requirement seems to be relevant in terms of using Static library rather using DLL for encrytion/Decryption code, because DLL can be reversed engineered @ client side.

And yes One more thing your code is written in C++/CLI(manged C++), so make sure to swithed on "CLR support" (by going through Common properties) before Compilation in VC++ 9.0. Go Ahead.

Answer 2

You cannot do this. VS6 was before .NET even existed, and thus you need to provide an interface to the managed component that is accessible from technologies VS6 is aware of. The two simplest options:

1. Create a COM interface for the managed library and use that from C++
2. Create a C-style interface and use that from C++. Not a C++ interface because of issues crossing DLL boundaries with C++ objects and features.

I don't understand the requirement of needing a .lib file though; neither of the obvious solutions would employ this. You should be clearer why you "need" a .lib if you want a better answer. The problem is you have an impossible set of requirements:

1. You cannot use a DLL (limiting yourself to only one PE module)
2. Managed and unmanaged cannot co-exist in the same PE.
3. VS6 cannot write managed code.

These 3 restrictions prove it's impossible as you want; you will need to compromise somewhere.

Answer 3

I guess your best bet is to write a C wrapper for the functions in one of your implementations and make a DLL out of that.