rucades 0.3.0

data/ext/rucades/rucades_enveloped_data.cpp

@@ -0,0 +1,122 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include "rucades.h"
+#include "rucades_enveloped_data.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_EnvelopedData::pre_rb_EnvelopedData(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPEnvelopedDataObject>(new CPPCadesCPEnvelopedDataObject())) { }
+
+std::string pre_rb_EnvelopedData::get_content(void)
+{
+    CStringBlob content;
+    hr_method_check(m_pCppCadesImpl->get_Content(content));
+    return std::string(content);
+}
+
+void pre_rb_EnvelopedData::set_content(std::string content)
+{
+    CAtlString sContent = CAtlString(content.c_str());
+    hr_method_check(m_pCppCadesImpl->put_Content(sContent.GetString(), sContent.GetLength()));
+}
+
+long pre_rb_EnvelopedData::get_content_encoding(void)
+{
+    CADESCOM_CONTENT_ENCODING_TYPE enc;
+    hr_method_check(m_pCppCadesImpl->get_ContentEncoding(&enc));
+    return static_cast<long>(enc);
+}
+
+void pre_rb_EnvelopedData::set_content_encoding(long enc)
+{
+    hr_method_check(m_pCppCadesImpl->put_ContentEncoding(static_cast<CADESCOM_CONTENT_ENCODING_TYPE>(enc)));
+}
+
+pre_rb_Recipients pre_rb_EnvelopedData::get_recipients(void)
+{
+    pre_rb_Recipients pRecipients;
+    hr_method_check(m_pCppCadesImpl->get_Recipients(pRecipients.m_pCppCadesImpl));
+    return pRecipients;
+}
+
+pre_rb_Algorithm pre_rb_EnvelopedData::get_algorithm(void)
+{
+    pre_rb_Algorithm pAlgorithm;
+    hr_method_check(m_pCppCadesImpl->get_Algorithm(pAlgorithm.m_pCppCadesImpl));
+    return pAlgorithm;
+}
+
+std::string pre_rb_EnvelopedData::encrypt(long enc)
+{
+    CAPICOM_ENCODING_TYPE EncodingType = static_cast<CAPICOM_ENCODING_TYPE>(enc);
+    CryptoPro::CBlob blobData;
+    hr_method_check(m_pCppCadesImpl->Encrypt(EncodingType, blobData));
+    CAtlString sData = CAtlString(reinterpret_cast<const TCHAR *>(blobData.pbData()), blobData.cbData());
+    return std::string(sData.GetString());
+}
+
+void pre_rb_EnvelopedData::decrypt(std::string data)
+{
+    CryptoPro::CBlob blobData;
+    blobData.assign(reinterpret_cast<const unsigned char *>(data.c_str()), data.length());
+    hr_method_check(m_pCppCadesImpl->Decrypt(blobData));
+}
+
+std::string pre_rb_EnvelopedData::stream_encrypt(std::string content, int final)
+{
+    int bIsFinal = final ? TRUE : FALSE;
+    CAtlString sData = CAtlString(CA2CT(CAtlStringA(content.c_str()), CP_UTF8));
+    CryptoPro::CBlob blobResult;
+    hr_method_check(m_pCppCadesImpl->StreamEncrypt(
+            sData.GetString(), sData.GetLength(), bIsFinal, blobResult));
+
+    CAtlString sResult;
+    if (blobResult.cbData())
+    {
+        sResult = CAtlString(reinterpret_cast<const TCHAR *>(blobResult.pbData()), blobResult.cbData());
+    }
+    return std::string(sResult.GetString());
+}
+
+std::string pre_rb_EnvelopedData::stream_decrypt(std::string content, int final)
+{
+    int bIsFinal = final ? TRUE : FALSE;
+    CAtlString sData = CAtlString(CA2CT(CAtlStringA(content.c_str()), CP_UTF8));
+    CryptoPro::CBlob blobResult;
+    hr_method_check(m_pCppCadesImpl->StreamDecrypt(
+            sData.GetString(), sData.GetLength(), bIsFinal, blobResult));
+
+    CAtlString sResult;
+    if (blobResult.cbData())
+    {
+        sResult = CAtlString((const char *)blobResult.pbData(), blobResult.cbData());
+    }
+    return std::string(sResult.GetString());
+}
+
+void pre_rb_EnvelopedData::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_EnvelopedData> rb_cEnvelopedData =
+    define_class_under<pre_rb_EnvelopedData>(module, "EnvelopedData")
+    .define_constructor(Constructor<pre_rb_EnvelopedData>())
+    .define_method("content", &pre_rb_EnvelopedData::get_content)
+    .define_method("content=", &pre_rb_EnvelopedData::set_content)
+    .define_method("content_encoding", &pre_rb_EnvelopedData::get_content_encoding)
+    .define_method("content_encoding=", &pre_rb_EnvelopedData::set_content_encoding)
+    .define_method("recipients", &pre_rb_EnvelopedData::get_recipients)
+    .define_method("algorithm", &pre_rb_EnvelopedData::get_algorithm)
+    .define_method("encrypt", &pre_rb_EnvelopedData::encrypt,
+                   Arg("enc") = static_cast<long>(CADESCOM_STRING_TO_UCS2LE))
+    .define_method("decrypt", &pre_rb_EnvelopedData::decrypt)
+    .define_method("stream_encrypt", &pre_rb_EnvelopedData::stream_encrypt)
+    .define_method("stream_decrypt", &pre_rb_EnvelopedData::stream_decrypt);
+}
+}

data/ext/rucades/rucades_enveloped_data.h

@@ -0,0 +1,33 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#pragma once
+
+#include "rucades.h"
+#include "rucades_algorithm.h"
+#include "rucades_recipients.h"
+#include "CPPCadesCPEnvelopedData.h"
+
+namespace rucades {
+class pre_rb_EnvelopedData {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEnvelopedDataObject> m_pCppCadesImpl;
+  public:
+    pre_rb_EnvelopedData(void);
+
+    std::string get_content(void);
+    void set_content(std::string content);
+    long get_content_encoding(void);
+    void set_content_encoding(long enc);
+    pre_rb_Recipients get_recipients(void);
+    pre_rb_Algorithm get_algorithm(void);
+
+    std::string encrypt(long enc);
+    void decrypt(std::string);
+    std::string stream_encrypt(std::string content, int final);
+    std::string stream_decrypt(std::string content, int final);
+
+    static void define_ruby_class(VALUE module);
+};
+}

data/ext/rucades/rucades_extended_key_usage.cpp

@@ -0,0 +1,53 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include "rucades.h"
+#include "rucades_extended_key_usage.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_ExtendedKeyUsage::pre_rb_ExtendedKeyUsage(void):
+  m_pCppCadesImpl(new CPPCadesCPExtendedKeyUsageObject()) { }
+
+pre_rb_ExtendedKeyUsage::pre_rb_ExtendedKeyUsage(boost::shared_ptr<CPPCadesCPExtendedKeyUsageObject> other):
+      m_pCppCadesImpl(other) { }
+
+bool pre_rb_ExtendedKeyUsage::is_present(void)
+{
+    BOOL bIsPresent;
+    m_pCppCadesImpl->get_IsPresent(&bIsPresent);
+    return (bIsPresent != FALSE);
+}
+
+bool pre_rb_ExtendedKeyUsage::is_critical(void)
+{
+    BOOL bIsCritical;
+    m_pCppCadesImpl->get_IsCritical(&bIsCritical);
+    return (bIsCritical != FALSE);
+}
+
+pre_rb_EKUs pre_rb_ExtendedKeyUsage::get_ekus(void)
+{
+
+    boost::shared_ptr<CPPCadesCPEKUsObject> pCppCadesEKUs(new CPPCadesCPEKUsObject());
+    hr_method_check(m_pCppCadesImpl->get_EKUs(pCppCadesEKUs));
+
+    return pre_rb_EKUs(pCppCadesEKUs);
+}
+
+void pre_rb_ExtendedKeyUsage::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_ExtendedKeyUsage> rb_cExtendedKeyUsage =
+    define_class_under<pre_rb_ExtendedKeyUsage>(module, "ExtendedKeyUsage")
+    .define_constructor(Constructor<pre_rb_ExtendedKeyUsage>())
+    .define_method("present?", &pre_rb_ExtendedKeyUsage::is_present)
+    .define_method("critical?", &pre_rb_ExtendedKeyUsage::is_critical)
+    .define_method("ekus", &pre_rb_ExtendedKeyUsage::get_ekus);
+}
+}

data/ext/rucades/rucades_extended_key_usage.h

@@ -0,0 +1,27 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#pragma once
+
+#include "rucades.h"
+#include "rucades_ekus.h"
+
+#include "CPPCadesCPExtendedKeyUsage.h"
+
+namespace rucades {
+class pre_rb_ExtendedKeyUsage {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPExtendedKeyUsageObject> m_pCppCadesImpl;
+  public:
+    pre_rb_ExtendedKeyUsage(void);
+    pre_rb_ExtendedKeyUsage(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPExtendedKeyUsageObject> other);
+    bool is_present(void);
+    bool is_critical(void);
+    pre_rb_EKUs get_ekus(void);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_Certificate;
+};
+}

data/ext/rucades/rucades_hashed_data.cpp

@@ -0,0 +1,90 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include "rucades.h"
+#include "rucades_hashed_data.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_HashedData::pre_rb_HashedData(void)
+      : m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPHashedDataObject>(new CPPCadesCPHashedDataObject())) { }
+
+std::string pre_rb_HashedData::get_key(void)
+{
+    CAtlString sKey;
+    hr_method_check(m_pCppCadesImpl->get_Key(sKey));
+    return std::string(sKey.GetString());
+}
+
+void pre_rb_HashedData::set_key(std::string key)
+{
+    CAtlString sKey = CAtlString(key.c_str());
+    hr_method_check(m_pCppCadesImpl->put_Key(sKey));
+}
+
+long pre_rb_HashedData::get_algorithm(void)
+{
+    CAPICOM_HASH_ALGORITHM Algorithm;
+    hr_method_check(m_pCppCadesImpl->get_Algorithm(&Algorithm));
+    return static_cast<long>(Algorithm);
+}
+
+void pre_rb_HashedData::set_algorithm(long alg)
+{
+    CAPICOM_HASH_ALGORITHM Algorithm = static_cast<CAPICOM_HASH_ALGORITHM>(alg);
+    hr_method_check(m_pCppCadesImpl->put_Algorithm(Algorithm));
+}
+
+long pre_rb_HashedData::get_data_encoding(void)
+{
+    CADESCOM_CONTENT_ENCODING_TYPE Encoding;
+    hr_method_check(m_pCppCadesImpl->get_DataEncoding(&Encoding));
+    return static_cast<long>(Encoding);
+}
+
+void pre_rb_HashedData::set_data_encoding(long enc)
+{
+    CADESCOM_CONTENT_ENCODING_TYPE Encoding = static_cast<CADESCOM_CONTENT_ENCODING_TYPE>(enc);
+    hr_method_check(m_pCppCadesImpl->put_DataEncoding(Encoding));
+}
+
+std::string pre_rb_HashedData::get_value(void)
+{
+    CAtlString sValue;
+    hr_method_check(m_pCppCadesImpl->get_Value(sValue));
+    return std::string(sValue.GetString());
+}
+
+void pre_rb_HashedData::hash(std::string data)
+{
+    CAtlString sValue = CAtlString(data.c_str());
+    hr_method_check(m_pCppCadesImpl->put_Hash(sValue.GetString(), sValue.GetLength()));
+}
+
+void pre_rb_HashedData::set_hash_value(std::string data)
+{
+    CAtlString sValue = CAtlString(data.c_str());
+    hr_method_check(m_pCppCadesImpl->put_HashValue(sValue));
+}
+
+void pre_rb_HashedData::define_ruby_class(VALUE module)
+{
+    define_class_under<pre_rb_HashedData>(module, "HashedData")
+        .define_constructor(Constructor<pre_rb_HashedData>())
+        .define_method("key", &pre_rb_HashedData::get_key)
+        .define_method("key=", &pre_rb_HashedData::set_key)
+        .define_method("algorithm", &pre_rb_HashedData::get_algorithm)
+        .define_method("algorithm=", &pre_rb_HashedData::set_algorithm)
+        .define_method("data_encoding", &pre_rb_HashedData::get_data_encoding)
+        .define_method("data_encoding=", &pre_rb_HashedData::set_data_encoding)
+        .define_method("value", &pre_rb_HashedData::get_value)
+        .define_method("hash", &pre_rb_HashedData::hash)
+        .define_method("hash_value=", &pre_rb_HashedData::set_hash_value);
+}
+}

data/ext/rucades/rucades_hashed_data.h

@@ -0,0 +1,31 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#pragma once
+
+#include "rucades.h"
+#include "CPPCadesCPHashedData.h"
+
+namespace rucades {
+class pre_rb_HashedData {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPHashedDataObject> m_pCppCadesImpl;
+  public:
+    pre_rb_HashedData(void);
+    std::string get_key(void);
+    void set_key(std::string key);
+    long get_algorithm(void);
+    void set_algorithm(long alg);
+    long get_data_encoding(void);
+    void set_data_encoding(long enc);
+    std::string get_value(void);
+    void hash(std::string data);
+    void set_hash_value(std::string data);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_RawSignature;
+    friend class pre_rb_SignedData;
+};
+}

data/ext/rucades/rucades_key_usage.cpp

@@ -0,0 +1,116 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include "rucades.h"
+#include "rucades_key_usage.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_KeyUsage::pre_rb_KeyUsage(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPKeyUsageObject>(new CPPCadesCPKeyUsageObject())) { }
+
+pre_rb_KeyUsage::pre_rb_KeyUsage(boost::shared_ptr<CPPCadesCPKeyUsageObject> other):
+      m_pCppCadesImpl(other) { }
+
+bool pre_rb_KeyUsage::is_present(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsPresent(&bVal));
+    return (bVal != 0);
+}
+
+bool pre_rb_KeyUsage::is_critical(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsCritical(&bVal));
+    return (bVal != 0);
+}
+
+bool pre_rb_KeyUsage::is_digital_signature_enabled(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsDigitalSignatureEnabled(&bVal));
+    return (bVal != 0);
+}
+
+bool pre_rb_KeyUsage::is_non_repudiation_enabled(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsNonRepudiationEnabled(&bVal));
+    return (bVal != 0);
+}
+
+bool pre_rb_KeyUsage::is_key_encipherment_enabled(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsKeyEnciphermentEnabled(&bVal));
+    return (bVal != 0);
+}
+
+bool pre_rb_KeyUsage::is_key_agreement_enabled(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsKeyAgreementEnabled(&bVal));
+    return (bVal != 0);
+}
+
+bool pre_rb_KeyUsage::is_key_cert_sign_enabled(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsKeyCertSignEnabled(&bVal));
+    return (bVal != 0);
+}
+
+bool pre_rb_KeyUsage::is_data_encipherment_enabled(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsDataEnciphermentEnabled(&bVal));
+    return (bVal != 0);
+}
+
+bool pre_rb_KeyUsage::is_crl_sign_enabled(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsCRLSignEnabled(&bVal));
+    return (bVal != 0);
+}
+
+bool pre_rb_KeyUsage::is_encipher_only_enabled(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsEncipherOnlyEnabled(&bVal));
+    return (bVal != 0);
+}
+
+bool pre_rb_KeyUsage::is_decipher_only_enabled(void)
+{
+    BOOL bVal = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsDecipherOnlyEnabled(&bVal));
+    return (bVal != 0);
+}
+
+void pre_rb_KeyUsage::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_KeyUsage> rb_cKeyUsage =
+    define_class_under<pre_rb_KeyUsage>(module, "KeyUsage")
+    .define_constructor(Constructor<pre_rb_KeyUsage>())
+    .define_method("present?", &pre_rb_KeyUsage::is_present)
+    .define_method("critical?", &pre_rb_KeyUsage::is_critical)
+    .define_method("digital_ignature_enabled?", &pre_rb_KeyUsage::is_digital_signature_enabled)
+    .define_method("non_repudiation_enabled?", &pre_rb_KeyUsage::is_non_repudiation_enabled)
+    .define_method("key_encipherment_enabled?", &pre_rb_KeyUsage::is_key_encipherment_enabled)
+    .define_method("key_agreement_enabled?", &pre_rb_KeyUsage::is_key_agreement_enabled)
+    .define_method("key_cert_sign_enabled?", &pre_rb_KeyUsage::is_key_cert_sign_enabled)
+    .define_method("data_encipherment_enabled?", &pre_rb_KeyUsage::is_data_encipherment_enabled)
+    .define_method("crl_sign_enabled?", &pre_rb_KeyUsage::is_crl_sign_enabled)
+    .define_method("encipher_only_enabled?", &pre_rb_KeyUsage::is_encipher_only_enabled)
+    .define_method("decipher_only_enabled?", &pre_rb_KeyUsage::is_decipher_only_enabled);
+}
+
+}

data/ext/rucades/rucades_key_usage.h

@@ -0,0 +1,33 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#pragma once
+
+#include "rucades.h"
+#include "CPPCadesCPKeyUsage.h"
+
+namespace rucades {
+class pre_rb_KeyUsage {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPKeyUsageObject> m_pCppCadesImpl;
+  public:
+    pre_rb_KeyUsage(void);
+    pre_rb_KeyUsage(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPKeyUsageObject> other);
+    bool is_present(void);
+    bool is_critical(void);
+    bool is_digital_signature_enabled(void);
+    bool is_non_repudiation_enabled(void);
+    bool is_key_encipherment_enabled(void);
+    bool is_key_agreement_enabled(void);
+    bool is_key_cert_sign_enabled(void);
+    bool is_data_encipherment_enabled(void);
+    bool is_crl_sign_enabled(void);
+    bool is_encipher_only_enabled(void);
+    bool is_decipher_only_enabled(void);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_Certificate;
+};
+}

data/ext/rucades/rucades_oid.cpp

@@ -0,0 +1,70 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include "rucades.h"
+#include "rucades_oid.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+
+pre_rb_OID::pre_rb_OID(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPOIDObject>(new CPPCadesCPOIDObject())) { }
+
+pre_rb_OID::pre_rb_OID(boost::shared_ptr<CPPCadesCPOIDObject> other):
+      m_pCppCadesImpl(other) { }
+
+std::string pre_rb_OID::get_value(void)
+{
+  boost::shared_ptr<CAtlStringA> pValue;
+  hr_method_check(m_pCppCadesImpl->get_Value(pValue));
+  return std::string((*pValue).GetString());
+}
+
+void pre_rb_OID::set_value(std::string& value)
+{
+  hr_method_check(m_pCppCadesImpl->put_Value(CAtlStringA(value.c_str())));
+}
+
+long pre_rb_OID::get_name(void)
+{
+  CAPICOM_OID name;
+  hr_method_check(m_pCppCadesImpl->get_Name(&name));
+  return static_cast<long>(name);
+}
+
+void pre_rb_OID::set_name (long name)
+{
+  hr_method_check(m_pCppCadesImpl->put_Name(static_cast<CAPICOM_OID>(name)));
+}
+
+std::string pre_rb_OID::get_friendly_name(void)
+{
+  CAtlString sFriendlyName;
+  hr_method_check(m_pCppCadesImpl->get_FriendlyName(sFriendlyName));
+  return std::string(sFriendlyName.GetString());
+}
+
+void pre_rb_OID::set_friendly_name(std::string& sFriendlyName)
+{
+  hr_method_check(m_pCppCadesImpl->put_FriendlyName(CAtlStringA(sFriendlyName.c_str())));
+}
+
+void pre_rb_OID::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_OID> rb_cOID =
+    define_class_under<pre_rb_OID>(module, "OID")
+    .define_constructor(Constructor<pre_rb_OID>())
+    .define_method("name", &pre_rb_OID::get_name)
+    .define_method("name=", &pre_rb_OID::set_name)
+    .define_method("value", &pre_rb_OID::get_value)
+    .define_method("value=", &pre_rb_OID::set_value)
+    .define_method("friendly_name", &pre_rb_OID::get_friendly_name)
+    .define_method("friendly_name=", &pre_rb_OID::set_friendly_name);
+}
+};

data/ext/rucades/rucades_oid.h

@@ -0,0 +1,30 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#pragma once
+
+#include "rucades.h"
+#include "CPPCadesCPOID.h"
+
+namespace rucades {
+
+class pre_rb_OID {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPOIDObject> m_pCppCadesImpl;
+  public:
+    pre_rb_OID(void);
+    pre_rb_OID(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPOIDObject> other);
+    std::string get_value(void);
+    void set_value(std::string& value);
+    long get_name(void);
+    void set_name (long name);
+    std::string get_friendly_name(void);
+    void set_friendly_name(std::string& sFriendlyName);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_PublicKey;
+};
+
+}