IT Note

클래스 구조의 C++ DLL 사용하기

이번에는 클래스 구조의 C++ DLL 사용하는 방법을 알아보곘습니다.

DLL 파일 준비하기

https://rurustory.com/12

저는 지난번 포스팅에서 만든 DLL를 사용하여 만들겠습니다.

DLL 구조

#include "ctest.h"
#define DLL __declspec(dllexport)

extern "C" {
	DLL TestClass* CreateTestClass();

	DLL void SetString(TestClass* obj, string data);
	DLL void SetBool(TestClass* obj, bool data);
	DLL void SetInt(TestClass* obj, int data);

	DLL string GetString(TestClass* obj);
	DLL bool GetBool(TestClass* obj);
	DLL int GetInt(TestClass* obj);

	DLL void DeleteTestClass(TestClass* obj);
}

DLL 호출하기

C#에서는 C++과 다르게 헤더파일(.h)이 필요가 없습니다.

DllImport 라는 함수를 사용하여 DLL의 함수를 가져올수 있습니다.

[DllImport("DLL 경로와 파일명")]
사용할 함수();

DLL 함수 클래스로 감싸기

사실 클래스로 감싸지않고 바로 사용을 할 수도 있지만 나중에 좀 더 사용하기 편하게 DLL를 C# 클래스 형태로 만들어보겠습니다.

코드

using System;
using System.Runtime.InteropServices;

namespace DLLTest
{
    class TestClass
    {
        [DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
        static private extern IntPtr CreateTestClass();

        [DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
        static private extern void SetBool(IntPtr obj, bool data);

        [DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
        static private extern void SetInt(IntPtr obj, int data);

        [DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
        static private extern bool GetBool(IntPtr obj);

        [DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
        static private extern int GetInt(IntPtr obj);

        [DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
        static private extern void DeleteTestClass(IntPtr obj);

        private IntPtr obj;

        public TestClass()
        {
            obj = CreateTestClass();
        }

        ~TestClass()
        {
            DeleteTestClass(obj);
        }

        public void SetBool(bool data) { SetBool(obj, data); }
        public void SetInt(int data) { SetInt(obj, data); }

        public bool GetBool() { return GetBool(obj); }
        public int GetInt() { return GetInt(obj); }

    }
}

코드 설명

[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
static private extern IntPtr CreateTestClass();

[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
static private extern void SetBool(IntPtr obj, bool data);

[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
static private extern void SetInt(IntPtr obj, int data);

[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
static private extern bool GetBool(IntPtr obj);

[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
static private extern int GetInt(IntPtr obj);

[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
static private extern void DeleteTestClass(IntPtr obj);

먼저 DllImport 를 이용하여 DLL의 함수들을 가져옵니다.

C#에서는 IntPtr 를이용하여 C++의 오브젝트 주소를 가져올 수 있습니다.

private IntPtr obj;

public TestClass()
{
    obj = CreateTestClass();
}

~TestClass()
{
    DeleteTestClass(obj);
}

IntPtr 형태의 obj를 생성하고 생성자에서 C++에서 만들어 놓은 CreateTestClass()를 이용하여 obj에 객체를 생성해줍니다.

그리고 소멸자에 꼭 C++에서 만든 DeleteTestClass()를 이용하여 동적할당을 해제해줍니다.

public void SetBool(bool data) { SetBool(obj, data); }
public void SetInt(int data) { SetInt(obj, data); }

public bool GetBool() { return GetBool(obj); }
public int GetInt() { return GetInt(obj); }

TestClass의 함수들을 만들어주고 return으로 C++ 의 함수들을 다시 재호출하여 TestClass 함수만 사용해도 C++ 함수들을 사용할 수 있도록 만들어줍니다.

클래스 테스트

전체 코드

using System;
using System.Runtime.InteropServices;

namespace DLLTest
{
	class TestClass
	{
		[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
		static private extern IntPtr CreateTestClass();

		[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
		static private extern void SetBool(IntPtr obj, bool data);

		[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
		static private extern void SetInt(IntPtr obj, int data);

		[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
		static private extern bool GetBool(IntPtr obj);

		[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
		static private extern int GetInt(IntPtr obj);

		[DllImport("D:\\C_Project\\ctest\\x64\\Release\\ctest.dll", CallingConvention = CallingConvention.Cdecl)]
		static private extern void DeleteTestClass(IntPtr obj);

		private IntPtr obj;

		public TestClass()
		{
			obj = CreateTestClass();
		}

		~TestClass()
		{
			DeleteTestClass(obj);
		}

		public void SetBool(bool data) { SetBool(obj, data); }
		public void SetInt(int data) { SetInt(obj, data); }

		public bool GetBool() { return GetBool(obj); }
		public int GetInt() { return GetInt(obj); }

	}

	class test
	{
		static void Main(string[] args)
		{
			TestClass lib = new TestClass();

			lib.SetBool(true);
			lib.SetInt(200);

			Console.WriteLine("[GetBool] " + lib.GetBool());
			Console.WriteLine("[GetInt] " + lib.GetInt());
		}
	}
}

이제 우리가 아는 클래스 형태로 C++의 DLL를 사용할 수 있습니다.

실행 결과

마무리

추가로 C++ 문자열을 C#에서 쓰는게 조금 복잡해서 따로 포스팅을 하였습니다.

궁금하신 분들은 아래 링크에서 확인 할 수 있습니다!

https://rurustory.com/1

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

클래스를 DLL로 만들고 사용하기

클래스를 DLL로 만들고 사용하는 방법을 알아보겠습니다.

클래스 구조 코드 준비하기

헤더파일(.h파일)

#include <iostream>
using std::cout;
using std::endl;

#include <string>
using std::string;

class TestClass 
{
private:
	string stringTest;
	bool boolTest;
	int intTest;

public:
	TestClass();
	~TestClass();

	void SetString(string data);
	void SetBool(bool data);
	void SetInt(int data);

	string GetString();
	bool GetBool();
	int GetInt();
};

cpp파일

#include "ctest.h"

TestClass::TestClass() { cout << "Init TestClass!!" << endl; }
TestClass::~TestClass() { cout << "End TestClass!!" << endl; }

void TestClass::SetString(string data) { stringTest = data; }
void TestClass::SetBool(bool data) { boolTest = data; }
void TestClass::SetInt(int data) { intTest = data; }

string TestClass::GetString() {	return stringTest; }
bool TestClass::GetBool() { return boolTest; }
int TestClass::GetInt() { return intTest; }

위와 같이 DLL로 만들 클래스 구조의 코드를 준비합니다.

DLL Wrapper(래퍼) 선언부 만들기

헤더파일(.h파일)

#include "ctest.h"
#define DLL __declspec(dllexport)

extern "C" {
	DLL TestClass* CreateTestClass();

	DLL void SetString(TestClass* obj, string data);
	DLL void SetBool(TestClass* obj, bool data);
	DLL void SetInt(TestClass* obj, int data);

	DLL string GetString(TestClass* obj);
	DLL bool GetBool(TestClass* obj);
	DLL int GetInt(TestClass* obj);

	DLL void DeleteTestClass(TestClass* obj);
}

코드 설명

일반적인 DLL 만드는 방법과 동일하게 __declspec(dllexport) 명령어를 이용하여 DLL 라이브러리에서 호출가능한 함수로 만들어줍니다.

그리고 DLL에서 네임 맹글링된 함수를 가져오기 어렵기 때문에 extern "C" 명령어를 이용하여 네임 맹글링을 제거합니다.

이제부터 네임 맹글링을 하지않기 때문에 클래스를 사용하려면 클래스를 동적 할당하여 각 함수마다 동적 할당된 클래스의 주소를 알려주어야 합니다.

마지막으로 동적 할당하여 객체를 생성하였기 때문에 꼭 동적 할당 해제하는 함수도 만들어줘야 합니다.

DLL Wrapper(래퍼) 구현부 만들기

cpp파일

#include "ctestDLL.h"

TestClass* CreateTestClass() { return new TestClass(); }

void SetString(TestClass* obj, string data) { obj->SetString(data); }
void SetBool(TestClass* obj, bool data){ obj->SetBool(data); }
void SetInt(TestClass* obj, int data){ obj->SetInt(data); }

string GetString(TestClass* obj) { return obj->GetString(); }
bool GetBool(TestClass* obj){ return obj->GetBool(); }
int GetInt(TestClass* obj){ return obj->GetInt(); }

void DeleteTestClass(TestClass* obj) 
{
	if (obj) {
		delete obj;
		obj = nullptr;
	}
}

코드 설명

new를 이용하여 클래스를 동적할당하는 함수를 구현합니다.

각 함수에서는 동적할당한 클래스의 주소를 받고 동적할당한 클래스에서 함수를 다시 실행시켜야 합니다.

delete를 이용하여 꼭 동적할당해제를 해줘야합니다.

DLL 파일로 만들기

빌드 설정

빌드하기전에 [프로젝트 속성 > 구성 속성 > 일반] 에서 구성 형식을 동적 라이브러리(.dll)인지 꼭 확인해야합니다.

빌드 결과

빌드가 완료 되면 위와같이 dll파일과 lib파일이 생깁니다.

여기서 dll빌드를 하였는데 lib파일이 생기는건 암시적 링킹(Implicit linking)을 하였기 때문입니다. 좀 더 상세한 내용은 아래 포스팅을 통해 확인 할 수 있습니다.

https://rurustory.com/8

DLL 사용하기

이제 DLL을 만들었으니 새로운 프로젝트를 만들어 테스트를 해봅시다.

빌드 설정

1. [프로젝트 속성 > C/C++ > 일반] 에서 추가 포함 디렉터리에 dll의 헤더(.h 파일)가 있는 폴더경로를 설정해줍니다.

2. [프로젝트 속성 > 링커 > 일반] 에서 추가 라이브러리 디렉터리에 dll파일과 lib파일이 있는 폴더경로를 설정해줍니다.

3. [프로젝트 속성 > 링커 > 입력]에서 추가 종속성에 lib파일 이름을 입력해줍니다. 

Main cpp파일

#include "ctestDLL.h"

void main()
{
	TestClass* obj = CreateTestClass();

	SetString(obj, "Ruru TestString");
	SetBool(obj, true);
	SetInt(obj, 200);

	cout << "[GetString] " << GetString(obj) << endl;
	cout << "[GetBool] " << GetBool(obj) << endl;
	cout << "[GetInt] " << GetInt(obj) << endl;
    
	DeleteTestClass(obj);
}

빌드 결과

이제 빌드를 하면 정상적으로 빌드가 되는것을 확인할 수 있습니다.

마무리

지금까지 C++ 클래스를 DLL로 만들고 사용하는 방법이였습니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

RSA 암호화 알고리즘 사용하기

Crypto++ 라이브러리로 RSA 개인키, 공개키를 생성하고 생성한 키로 암호화, 복호화하는 방법을 알아보겠습니다.

개인키, 공개키를 바이너리 키파일로 생성하기

샘플 코드

AutoSeededRandomPool rng;

RSA::PrivateKey privKey;
RSA::PublicKey pubKey;

privKey.GenerateRandomWithKeySize(rng, 2048);
pubKey = RSA::PublicKey(privKey);

ofstream privFile("private.key", ios::binary);
privKey.Save(FileSink(privFile).Ref() );
privFile.close();

ofstream pubFile("public.key", ios::binary);
pubKey.Save(FileSink(pubFile).Ref());
pubFile.close();

코드 설명

AutoSeededRandomPool rng;

RNG가 제공하는 OS를 사용하여 자체적으로 시드를 생성하는 함수입니다.

RSA::PrivateKey privKey;
RSA::PublicKey pubKey;

개인키, 공개키 객체를 생성합니다.

privKey.GenerateRandomWithKeySize(rng, 2048);

생성한 시드와 키 길이를 전달하여 개인키를 생성합니다.

pubKey = RSA::PublicKey(privKey);

개인키를 이용하여 공개키를 생성합니다.

ofstream privFile("private.key", ios::binary);
privKey.Save(FileSink(privFile).Ref() );
privFile.close();

ofstream pubFile("public.key", ios::binary);
pubKey.Save(FileSink(pubFile).Ref());
pubFile.close();

개인키와 공개키를 파일로 저장합니다.

개인키, 공개키를 Base64 키파일로 생성하기

샘플 코드

AutoSeededRandomPool rng;

RSA::PrivateKey privKey;
RSA::PublicKey pubKey;

privKey.GenerateRandomWithKeySize(rng, 2048);
pubKey = RSA::PublicKey(privKey);

ofstream privFile("private.key", ios::binary);
Base64Encoder privKeySink(new FileSink(privFile), true);
privKey.Save(privKeySink);
privKeySink.MessageEnd();
privFile.close();

ofstream pubFile("public.key", ios::binary);
Base64Encoder pubKeySink(new FileSink(pubFile), true);
pubKey.Save(pubKeySink);
pubKeySink.MessageEnd();
pubFile.close();

코드 설명

개인키, 공개키 생성 코드는 위와 동일하므로 설명을 생략하겠습니다.

ofstream privFile("private.key", ios::binary);
Base64Encoder privKeySink(new FileSink(privFile), true);
privKey.Save(privKeySink);
privKeySink.MessageEnd();
privFile.close();

ofstream pubFile("public.key", ios::binary);
Base64Encoder pubKeySink(new FileSink(pubFile), true);
pubKey.Save(pubKeySink);
pubKeySink.MessageEnd();
pubFile.close();

개인키와 공개키를 Base64로 인코딩하여 파일로 저장합니다.

Base64Encoder를 사용을 하면 반드시 MessageEnd() 함수를 사용해야합니다.

인코딩만 할때는 사용을 안해도 문제가 없었는데 나중에 디코딩할때 비정상적으로 디코딩이 되는 문제가 있었습니다. (이것때문에 엄청난 고생을.. ㅠㅠ) 

개인키, 공개키를 바이너리 문자열로 생성하기

샘플 코드

AutoSeededRandomPool rng;

RSA::PrivateKey privKey;
RSA::PublicKey pubKey;

privKey.GenerateRandomWithKeySize(rng, 2048);
pubKey = RSA::PublicKey(privKey);

string priv;
string pub;

privKey.Save(StringSink(priv).Ref());
pubKey.Save(StringSink(pub).Ref());

코드 설명

개인키, 공개키 생성 코드는 위와 동일하므로 설명을 생략하겠습니다.

string priv;
string pub;

privKey.Save(StringSink(priv).Ref());
pubKey.Save(StringSink(pub).Ref());

개인키와 공개키를 바이너리 문자열로 저장합니다.

string 타입의 변수이지만 바이너리 값이 들어갑니다.

개인키, 공개키를 Base64 문자열로 생성하기

샘플 코드

AutoSeededRandomPool rng;

RSA::PrivateKey privKey;
RSA::PublicKey pubKey;

privKey.GenerateRandomWithKeySize(rng, 2048);
pubKey = RSA::PublicKey(privKey);

string priv;
string pub;

Base64Encoder privKeySink(new StringSink(keyBuf.priv));
privKey.Save(privKeySink);
privKeySink.MessageEnd();

Base64Encoder pubKeySink(new StringSink(keyBuf.pub));
pubKey.Save(pubKeySink);
pubKeySink.MessageEnd();

코드 설명

개인키, 공개키 생성 코드는 위와 동일하므로 설명을 생략하겠습니다.

string priv;
string pub;

Base64Encoder privKeySink(new StringSink(keyBuf.priv));
privKey.Save(privKeySink);
privKeySink.MessageEnd();

Base64Encoder pubKeySink(new StringSink(keyBuf.pub));
pubKey.Save(pubKeySink);
pubKeySink.MessageEnd();

개인키와 공개키를 Base64 문자열로 저장합니다.

파일 생성때와 같은 이유로 꼭 MessageEnd() 함수를 사용해야합니다.

전체 예제 코드

#include <iostream>
using std::cout;
using std::endl;
using std::ofstream;
using std::ifstream;
using std::ios;

#include <string>
using std::string;

#include "rsa.h"
using CryptoPP::RSA;

#include "osrng.h"
using CryptoPP::AutoSeededRandomPool;

#include <files.h>
using CryptoPP::FileSink;
using CryptoPP::FileSource;

#include <filters.h>
using CryptoPP::StringSink;
using CryptoPP::StringSource;

#include <base64.h>
using CryptoPP::Base64Encoder;
using CryptoPP::Base64Decoder;

struct KeyString 
{
	string priv;
	string pub;
};

void GenKeyFile(string fileName) 
{
	AutoSeededRandomPool rng;

	RSA::PrivateKey privKey;
	RSA::PublicKey pubKey;

	/* 개인키 생성 */
	privKey.GenerateRandomWithKeySize(rng, 2048);
	/* 공개키 생성 */
	pubKey = RSA::PublicKey(privKey);

	/* 개인키 가져오기 */
	ofstream privFile(fileName + "_private.key", ios::binary);
	privKey.Save(FileSink(privFile).Ref());
	privFile.close();
	/* 공개키 가져오기 */
	ofstream pubFile(fileName + "_public.key", ios::binary);
	pubKey.Save(FileSink(pubFile).Ref());
	pubFile.close();
}

void GenKeyFileBase64(string fileName) 
{
	AutoSeededRandomPool rng;

	RSA::PrivateKey privKey;
	RSA::PublicKey pubKey;

	/* 개인키 생성 */
	privKey.GenerateRandomWithKeySize(rng, 2048);
	/* 공개키 생성 */
	pubKey = RSA::PublicKey(privKey);

	/* 개인키 가져오기 */
	ofstream privFile(fileName + "_private.key", ios::binary);
	Base64Encoder privKeySink(new FileSink(privFile), true);
	privKey.Save(privKeySink);
	privKeySink.MessageEnd();
	privFile.close();

	/* 공개키 가져오기 */
	ofstream pubFile(fileName + "_public.key", ios::binary);
	Base64Encoder pubKeySink(new FileSink(pubFile), true);
	pubKey.Save(pubKeySink);
	pubKeySink.MessageEnd();
	pubFile.close();
}

KeyString GenKey() 
{
	AutoSeededRandomPool rng;

	RSA::PrivateKey privKey;
	RSA::PublicKey pubKey;

	/* 개인키 생성 */
	privKey.GenerateRandomWithKeySize(rng, 2048);
	/* 공개키 생성 */
	pubKey = RSA::PublicKey(privKey);

	KeyString keyBuf;

	/* 개인키 가져오기 */
	privKey.Save(StringSink(keyBuf.priv).Ref());
	/* 공개키 가져오기 */
	pubKey.Save(StringSink(keyBuf.pub).Ref());

	return keyBuf;
}

KeyString GenKeyBase64() 
{
	AutoSeededRandomPool rng;

	RSA::PrivateKey privKey;
	RSA::PublicKey pubKey;

	/* 개인키 생성 */
	privKey.GenerateRandomWithKeySize(rng, 2048);
	/* 공개키 생성 */
	pubKey = RSA::PublicKey(privKey);

	KeyString keyBuf;

	/* 개인키 가져오기 */
	Base64Encoder privKeySink(new StringSink(keyBuf.priv));
	privKey.Save(privKeySink);
	privKeySink.MessageEnd();

	/* 공개키 가져오기 */
	Base64Encoder pubKeySink(new StringSink(keyBuf.pub));
	pubKey.Save(pubKeySink);
	pubKeySink.MessageEnd();

	return keyBuf;
}

int main()
{
	cout << "\n###############################\n" << endl;
    
	/* Binary 키파일 */
	cout << "Binary KeyFile Start" << endl;
	GenKeyFile("RuruTest");
    
	cout << "\n###############################\n" << endl;

	/* Base64 키파일 */
	cout << "Base64 KeyFile Start" << endl;
	GenKeyFileBase64("RuruTest_Base64");
    
	cout << "\n###############################\n" << endl;

	/* Binary 문자열 키 */
	cout << "Binary Key Start" << endl;
	cout << endl;
    
	KeyString key;
	key = GenKey();

	cout << "PrivateKey:" << endl << key.priv << endl;
	cout << endl;
	cout << "PublicKey:" << endl << key.pub << endl;

	cout << "\n###############################\n" << endl;
    
	/* Base64 문자열 키 */
	cout << "Base64 Key Start" << endl;
	cout << endl;

	KeyString keyBase64;
	keyBase64 = GenKeyBase64();

	cout << "PrivateKey:" << endl << keyBase64.priv << endl;
	cout << endl;
	cout << "PublicKey:" << endl << keyBase64.pub << endl;

	cout << "\n###############################\n" << endl;
    
    return 0;
}

마무리

지금까지 Crypto++ 라이브러리로 RSA 개인키, 공개키 생성하는 방법이였습니다. 다음에는 개인키와 공개키가지고 암호화 복호화하는 방법을 작성 할 예정입니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

Crypto++ 암호화 오픈 라이브러리

여러가지 암호화 알고리즘을 쉽게 사용할 수 있는 CryptoPP(Crypto++) 라이브러리에 대해 알아봅시다.

암호화 알고리즘 및 컴파일러 지원목록 (8.9 버전 기준)

컴파일러

- Visual Studio 2003 - 2022
GCC 3.3 - 13.1
Apple Clang 4.3 - 12.0
LLVM Clang 2.9 - 14.0
C++ Builder 2015
Intel C++ Compiler 9 - 16.0
Sun Studio 12u1 - 12.7
IBM XL C/C++ 10.0 - 14.0

암호화 알고리즘

좀 더 자세한 내용은 아래 링크에서 확인하시기 바랍니다.

https://cryptopp.com/index.html

라이브러리 소스파일 준비

https://cryptopp.com/downloads.html

홈페이지에서 cryptopp890.zip 파일을 다운받습니다.

Windows 버전

1. 라이브러리 빌드하기

압축해제를 하고 cryptest.sin 파일을 엽니다.

정적 라이브러리를 사용할꺼면 cryptlib, 동적 라이브러리를 사용할꺼면 cryptdll 프로젝트를 시작프로젝트로 설정후 빌드합니다.

저는 정적 라이브러리로 빌드하여 위와같이 cryptlib.lib 파일이 생성되었습니다.

2. 라이브러리 사용하기

이제 라이브러리 테스트를 해볼 프로젝트를 만들어 봅시다.

프로젝트를 만들었으면 아래와 같이 프로젝트 속성을 설정해 줍니다.

C/C++ -> 일반 -> 추가 포함 디렉터리: cryptopp 라이브러리 헤더파일이 있는곳으로 설정합니다.

C/C++ -> 코드 생성 -> 런타임 라이브러리를 다중 스레드(/MT)로 변경해줍니다.

링커 -> 일반 -> 추가 라이브러리 디렉터리를 Crypto++ 라이브러리를 빌드해서 생긴 lib파일이 있는곳으로 설정합니다.

링커 -> 입력 -> 추가 종속성에 lib파일 정보를 설정합니다.

#include <iostream>
using std::cout;
using std::endl;
#include <string>
using std::string;

typedef unsigned char byte;
typedef unsigned long long word64;

#include <base64.h>
using CryptoPP::Base64Encoder;
using CryptoPP::Base64Decoder;

void main()
{
	string stringTest = "Ruru TestString";
	string encTest, decTest;

	/* 인코딩 시작 */
	Base64Encoder encoder;

	encoder.Put((const byte*)stringTest.data(), stringTest.size());
	encoder.MessageEnd();

	word64 encSize = encoder.MaxRetrievable();
	if (encSize)
	{
		encTest.resize(encSize);
		encoder.Get((byte*)&encTest[0], encTest.size());
	}

	cout << "Base64 Encode: " << encTest << endl;

	/* 디코딩 시작 */
	Base64Decoder decoder;

	decoder.Put((byte*)encTest.data(), encTest.size());
	decoder.MessageEnd();

	word64 decSize = decoder.MaxRetrievable();
	if (decSize && decSize <= SIZE_MAX)
	{
		decTest.resize(decSize);
		decoder.Get((byte*)&decTest[0], decTest.size());
	}

	cout << "Base64 Decode: " << decTest << endl;
}

다음은 문자열을 Base64 인코딩, 디코딩 하는 코드입니다. Crypto++ 라이브러리의 네임스페이스는 CryptoPP를 사용합니다. 

빌드를 하면 정상적으로 동작하는것을 확인할 수 있습니다.

Linux 버전

리눅스는 윈도우와 달리 좀더 간편하게 라이브러리를 빌드하고 사용할 수 할수있습니다.

1. 라이브러리 빌드하기

# 압축 해제 #
unzip cryptopp890.zip -d ./cryptopp890

# 압축 해제 폴더로 이동 #
cd cryptopp890

# 정적 라이브러리, 동적 라이브러리, 테스트파일 빌드 #
# 방법 1 #
make static dynamic cryptest.exe

# 방법 2 #
make libcryptopp.a libcryptopp.so cryptest.exe

# 빌드 확인 #
ls *.so *.a *.exe

2. 라이브러리 사용하기

이제 라이브러리가 준비되었으니 테스트파일을 만들어 테스트 해봅시다.

# cryptopp890 폴더에서 뒤로가기 #
cd ..

# 테스트용 cpp파일 생성 #
vi CryptoTest.cpp

#include <iostream>
using std::cout;
using std::endl;
#include <string>
using std::string;

typedef unsigned char byte;
typedef unsigned long long word64;

#include <base64.h>
using CryptoPP::Base64Encoder;
using CryptoPP::Base64Decoder;

int main()
{
	string stringTest = "Ruru TestString";
	string encTest, decTest;

	/* 인코딩 시작 */
	Base64Encoder encoder;

	encoder.Put((const byte*)stringTest.data(), stringTest.size());
	encoder.MessageEnd();

	word64 encSize = encoder.MaxRetrievable();
	if (encSize)
	{
		encTest.resize(encSize);
		encoder.Get((byte*)&encTest[0], encTest.size());
	}

	cout << "Base64 Encode: " << encTest << endl;

	/* 디코딩 시작 */
	Base64Decoder decoder;

	decoder.Put((byte*)encTest.data(), encTest.size());
	decoder.MessageEnd();

	word64 decSize = decoder.MaxRetrievable();
	if (decSize && decSize <= SIZE_MAX)
	{
		decTest.resize(decSize);
		decoder.Get((byte*)&decTest[0], decTest.size());
	}

	cout << "Base64 Decode: " << decTest << endl;
    
    return 0;
}

# 테스트용 cpp파일 빌드 #
g++ -DNDEBUG -g3 -O2 -Wall -Wextra -o CryptoTest CryptoTest.cpp -I ./cryptopp890 ./cryptopp890/libcryptopp.a

윈도우와 똑같이 문자열을 Base64 인코딩, 디코딩 하는 코드입니다. Crypto++ 라이브러리의 네임스페이스는 CryptoPP를 사용합니다. 

빌드를 하면 정상적으로 동작하는것을 확인할 수 있습니다.

마무리

지금까지 Crypto++ 암호화 오픈 라이브러리에 대해 알아보았습니다. 추후 라이브러리를 통해 다양하게 암호화 하는 방법도 정리할 예정입니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

정적 라이브러리(Static Link Library)와 동적 라이브러리(Dynamic Link Library)

개발을 할 때 자주쓰는 함수가 많아 중복을 최소화 하기위해 또는 협업을 효율적으로 하기위해 등등 각종 여러가지 이유로 라이브러리를 사용하게 되는데 이번 시간에는 라이브러리가 어떤것들이 있는지 알아봅시다.

정적 라이브러리(Static Link Library)

정적 라이브러리는 컴파일을 하는 과정에서 애플리케이션이 필요로하는 라이브러리의 내용을 애플리케이션에다가 복사를 하여 사용하는 방법 입니다.

장단점

장점은 애플리케이션만 있으면 어디서든 실행을 시킬수 있다는 점이 있습니다.

단점은 애플리케이션에 라이브러리의 내용을 복사를 하였기 때문에 자체 용량이 커지며 라이브러리가 변동이 될 경우 애플리케이션을 전체 다시 빌드해야한다는 점이 있습니다.

정적 라이브러리의 확장자

Windows: .lib

Linux: .a

동적 라이브러리(Dynamic Link Library)

동적 라이브러리는 애플리케이션 실행할 떄 메모리에 위치하게 되며 라이브러리의 내용이 필요하게 되면 메모리에 있는 라이브러리를 사용하는 방법입니다.

장단점

장점은 정적 라이브러리를 사용하는 것보다 자체 용량이 작으며 라이브러리가 변동이 될 경우 애플리케이션 전체 빌드할 필요 없이 라이브러리만 바꾸면 된다는 점이 있습니다.

단점은 애플리케이션 실행할 때 라이브러리 파일이 필요하며 버전이 다르거나 호환이 되지 않는다면 사용하지 못하는 점이 있습니다.

동적 라이브러리의 확장자

Windows: .dll

Linux: .so

암시적 링킹(Implicit Linking)과 명시적 링킹(Explicit Linking)

윈도우에서 사용하는 동적 라이브러리(DLL) 에서는 애플리케이션에서 라이브러리를 호출하는 방법에 따라 암시적 링킹과 명시적 링킹으로 나누어집니다.

암시적 링킹(Implicit linking)

애플리케이션 자체에 DLL의 함수 정보를 포함시키는 방법이며 빌드 시 동적 라이브러리인 .dll 파일과 DLL이 제공하고자 하는 함수 정보가 포함되어 있는 .lib 파일이 생성됩니다.

이때 생성되는 .lib 파일은 정적 라이브러리로 생성한 .lib 파일과 확장자가 똑같아 같은 파일로 혼돈할 수 있지만 암시적 링킹으로 인해 생성된 .lib은 오로지 DLL의 제공 함수만 있기때문에 주의하시기 바랍니다.

명시적 링킹(Explicit linking)

애플리케이션이 실행할 때 .dll 파일의 존재만 확인을 하며 호출 할 함수의 주소를 얻어 함수를 실행시키는 방법 입니다.

암시적 링킹의 경우 컴파일러가 자동으로 해주는 경우가 많으며 사용하기 쉽기 때문에 편의성을 중시한다면 암시적 링킹을 사용하는것이 좋고 성능을 중시한다면 명시적 링킹을 사용하는것이 좋습니다.

마무리

지금까지 라이브러리 종류에 대해 알아보았습니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

extern "C"와 네임 맹글링

오픈소스같은 곳에 보면 extern "C"라는 문법이 종종 보이는데 처음에 보면 이게 뭐하는거지 C로 컴파일 해준다는건가? 아니면 C문법으로 바꾸어 쓰라는건가? 라고 의문이 생길겁니다. 이번엔 extern "C"가 뭐하는 녀석인지 알아봅시다. 

네임 맹글링

extern "C"를 알아보기 전에 네임 맹글링에 대해서 먼저 알아봅시다.

컴파일러들은 컴파일을 할때 다른곳에서 접근할수 있도록 심볼을 만드는 작업을 합니다. 
여기서 함수를 심볼로 만들때 심볼이름을 함수이름 그대로 생성하는 C컴파일러와 달리 C++컴파일러들은 각각 정해진 규칙에 따라 심볼이름을 변경하여 생성합니다. 
이러한 작업을 네임 맹글링이라고 하며 C와 달리 C++에서는 함수 오버로딩 같은 다형성을 지원할 수 있는 이유이기도 합니다. 

그러면 이제 실제로 네임 맹글링이 되고있는지 확인해봅시다.

test_c.c

/* C 코드 */
#include <stdio.h> 

void test()
{
	printf("extern c test!!\n");
}

int main()
{
	test();
	return 0;
}

test_cpp.cpp

/* C++ 코드 */
#include <iostream>
using std::cout;
using std::endl;

void test()
{
	cout << "extern c test!!" << endl;
}

int main()
{
	test();
	return 0;
}

컴파일

# C 컴파일 #
gcc -c test_c.c
gcc -o test_c test_c.o

# C++ 컴파일 #
g++ -c test_cpp.cpp
g++ -o test_cpp test_cpp.o

결과

readelf 명령어를 사용하여 확인해보면 실제로 C로 컴파일한 파일은 test 라는 이름으로 심볼이 생성되었고 C++로 컴파일한 파일은 _Z4testv 라는 이름으로 심볼이 생성된걸 확인할 수 있습니다.

extern "C"

자 그러면 이미 눈치채신 분들도 있을겁니다. 

extern "C"는 네임 맹글링을 사용하지 않는다. 라는 의미로 extern "C"를 선언하면 그 안에 모든 코드들은 네임 맹글링을 하지 않습니다.

그럼 실제로 네임 맹글링 작업을 안하는지 알아봅시다.

test_cpp_extern_c.cpp

/* C++ 코드 */
#include <iostream>
using std::cout;
using std::endl;

extern "C" 
{
	void test()
	{
		cout << "extern c test!!" << endl;
	}
}

int main()
{
	test();
	return 0;
}

컴파일

# C++ extern "C" 컴파일 # 
g++ -c test_cpp_extern_c.cpp
g++ -o test_cpp_extern_c.o

결과

extern "C"를 적용안한 파일에서는 _Z4testv 로 심볼이 생성되었고 extern "C"를 적용한 파일에는 C코드와 마찬가지로 test라는 이름으로 심볼이 생성된걸 확인할 수 있습니다.

마무리

지금까지 extern "C"와 네임 맹글링에 대해서 알아보았습니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

C++ 클래스 기본적인 사용법

객체지향 언어인 C++의 클래스 사용법에 대해 알아봅시다.

접근 제어 지시자

기본적인 클래스 모양

class 클래스 이름
{
접근 제어 지시자:
    멤버변수
    멤버함수
};

클래스 선언부와 구현부

클래스 선언부: 클래스의 모양을 정의하는 곳이며 보통 헤더파일(.h파일)에 많이 정의합니다.

class TestClass
{
private:
	string stringTest;
    
public:
	void SetString(string data);
};

클래스 구현부: 클래스 선언부에서 정의한 함수들을 실제로 구현하는 곳입니다.

void TestClass::SetString(string data)
{
	cout << "[SetString] " << data << endl;
	stringTest = data;
}

생성자와 소멸자

생성자: 클래스 객체를 생성할때 자동으로 호출되는 함수 입니다. 사용자가 따로 코드작성을 하지 않으면 컴파일러가 알아

생성자 선언부

class TestClass 
{
public:
	TestClass();
};

생성자 구현부

TestClass::TestClass() 
{
	cout << "Init TestClass!!" << endl;
}

소멸자: 생성자와 반대로 클래스 객체가 소멸할때 자동으로 호출되는 함수 입니다. 생성자와 마찬가지로 사용자가 따로  코드작성을 하지 않으면 컴파일러가 알아서 아무런기능이 없는 함수로 만들어 실행합니다.

소멸자 선언부

class TestClass 
{
public:
	~TestClass();
};

소멸자 구현부

TestClass::~TestClass() 
{
	cout << "End TestClass!!" << endl;
}

클래스 객체 생성 및 사용

이제 앞에서 생성한 클래스로 객체를 만들어 사용하는 방법을 알아보겠습니다.

void main() 
{
	/* TestClass 클래스를 obj 이름으로 객체 생성 */
	TestClass obj = TestClass();

	/* 객체 함수 호출 */
	obj.SetString("Ruru TestString");
}

전체 예제 코드

헤더파일(.h파일)

#include <iostream>
using std::cout;
using std::endl;
#include <string>
using std::string;

class TestClass 
{
private:
	string stringTest;
	bool boolTest;
	int intTest;

public:
	TestClass();
	~TestClass();

	void SetString(string data);
	void SetBool(bool data);
	void SetInt(int data);

	string GetString();
	bool GetBool();
	int GetInt();
};

.

cpp파일

#include "ctest.h"

TestClass::TestClass() 
{
	cout << "Init TestClass!!" << endl;
}
TestClass::~TestClass() 
{
	cout << "End TestClass!!" << endl;
}

void TestClass::SetString(string data) 
{
	cout << "[SetString] " << data << endl;
	stringTest = data;
}
void TestClass::SetBool(bool data) 
{
	cout << "[SetBool] " << data << endl;
	boolTest = data;
}
void TestClass::SetInt(int data) 
{
	cout << "[SetInt] " << data << endl;
	intTest = data;
}

string TestClass::GetString() 
{
	return stringTest;
}
bool TestClass::GetBool() 
{
	return boolTest;
}
int TestClass::GetInt() 
{
	return intTest;
}

void main() 
{
	/* TestClass 클래스를 obj 이름으로 객체 생성 */
	TestClass obj = TestClass();

	/* 객체 함수 호출 */
	obj.SetString("Ruru TestString");
	obj.SetBool(true);
	obj.SetInt(200);
    
	cout << "[GetString] " << obj.GetString() << endl;
	cout << "[GetBool] " << obj.GetBool() << endl;
	cout << "[GetInt] " << obj.GetInt() << endl;
}

마무리

이상 C++ 클래스 기본적인 사용법에 대해 알아보았습니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

다양한 방법으로 C++ DLL String 사용하기

C#에서 C++로 문자열을 전달을 해줄때 자동으로 데이터를 맞춰주지만 C++에서 C#으로 문자열을 전달 할때는 수동으로 데이터를 맞춰야 합니다.
지금부터 다양한 방법으로 C++문자열을 C#에서 사용하는 방법을알아봅시다.

방법 1. PtrToStringAnsi 함수를 사용하여 Marshalling 하기

C++

const char* stringTest() 
{
	string testStr = "Ruru Test C++ String !!!";
	return testStr.c_str();
}

C#

using System;
using System.Runtime.InteropServices;
class Program
{
    [DllImport("StringTest.dll", CallingConvention = CallingConvention.Cdecl)]
    static private extern IntPtr stringTest();

    static void Main(string[] args)
    {
    	IntPtr stringPtr = stringTest();
        string testStr = Marshal.PtrToStringAnsi(stringPtr);
        Console.WriteLine(testStr);
        Console.ReadKey();
        //초기화
        Marshal.FreeHGlobal(stringPtr);
    }
}

C++의 const char*를 IntPtr 형태로 받아 PtrToStringAnsi 함수를 사용하여 string으로 변환하는 방법입니다.

Marshal 클래스를 사용하기 위해서는 System.Runtime.InteropServices를 추가해야 사용할 수 있습니다.

메모리 누수 방지를 위해 문자열 사용이 끝났으면 꼭 FreeHGlobal 함수를 사용하여 초기화 해주어야합니다.

방법 2. PtrToStringUni 함수를 사용하여 Marshalling 하기

C++

const wchar_t* stringTest() 
{
	string testStr = "Ruru Test C++ String !!!";
	wstring testUni(testStr.begin(), testStr.end());
	return testUni.c_str();
}

C#

using System;
using System.Runtime.InteropServices;
class Program
{
    [DllImport("StringTest.dll", CallingConvention = CallingConvention.Cdecl)]
    static private extern IntPtr stringTest();

    static void Main(string[] args)
    {
    	IntPtr stringPtr = stringTest();
        string testStr = Marshal.PtrToStringUni(stringPtr);
        Console.WriteLine(testStr);
        //초기화
        Marshal.FreeHGlobal(stringPtr);
    }
}

C++의 const wchar_t*를 IntPtr 형태로 받아 PtrToStringUni 함수를 사용하여 string으로 변환하는 방법입니다.

Marshal 클래스를 사용하기 위해서는 System.Runtime.InteropServices를 추가해야 사용할 수 있습니다.

메모리 누수 방지를 위해 문자열 사용이 끝났으면 꼭 FreeHGlobal 함수를 사용하여 초기화 해주어야합니다.

방법 3. ICustomMarshaler를 사용하여 커스텀 Marshalling하기

C++

const char* stringTest() 
{
	string testStr = "Ruru Test C++ String !!!";
	return testStr.c_str();
}

C#

using System;
using System.Runtime.InteropServices;
internal class StringCustom : ICustomMarshaler
{
    #region ICustomMarshaler Members

    public void CleanUpManagedData(object ManagedObj) { }

    public void CleanUpNativeData(IntPtr pNativeData) { }

    public int GetNativeDataSize()
        => -1;

    public IntPtr MarshalManagedToNative(object ManagedObj)
    {
        throw new NotSupportedException();
    }

    public object MarshalNativeToManaged(IntPtr pNativeData)
        => Marshal.PtrToStringAnsi(pNativeData);

    #endregion

    public static ICustomMarshaler GetInstance(string cookie)
    {
        if (cookie == null)
        {
            throw new ArgumentNullException(nameof(cookie));
        }

        var result = new StringCustom();

        return result;
    }
}

class Program
{
    [DllImport("StringTest.dll", CallingConvention = CallingConvention.Cdecl)]
    [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StringCustom))]
    static private extern string stringTest();

    static void Main(string[] args)
    {
        string testStr = stringTest();
        Console.WriteLine(testStr);
        Console.ReadKey();
    }
}

사용자 커스텀 클래스인 ICustomMarshaler 를 사용하여 string으로 리턴받는 방법입니다.

속도가 느려 퍼포먼스가 필요한 코드라면 비추천하는 방법입니다.

방법 4. StringBuilder 함수를 사용하여 C++에서 직접 복사 하기

C++

int stringTest(char* buffer) 
{
	string testStr = "Ruru Test C++ String !!!";
	strcpy(buffer, testStr.c_str());
	return testStr.size();
}

C#

using System;
using System.Text;
class Program
{
    [DllImport("StringTest.dll", CallingConvention = CallingConvention.Cdecl)]
    static private extern int stringTest(StringBuilder buffer);

    static void Main(string[] args)
    {
        StringBuilder testBuffer = new StringBuilder(100);
        stringTest(testBuffer);
        Console.WriteLine(testBuffer.ToString());
        Console.ReadKey();
    }
}

StringBuilder를 이용하여 C++에 buffer를 전달하고 C++에서 문자열을 복사하여 사용하는 방법입니다.

StringBuilder를 사용하기 위해서는 System.Text 를 추가하여야 사용할 수 있습니다.

마무리

지금까지 다양한 방법으로 C++문자열을 C#에서 사용하는 방법을 알아보았습니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!