rucades 0.3.0

data/ext/rucades/rucades.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_about.h"
+#include "rucades_algorithm.h"
+#include "rucades_attribute.h"
+#include "rucades_attributes.h"
+#include "rucades_basic_constraints.h"
+#include "rucades_blobs.h"
+#include "rucades_certificate.h"
+#include "rucades_certificates.h"
+#include "rucades_certificate_status.h"
+#include "rucades_crl.h"
+#include "rucades_eku.h"
+#include "rucades_ekus.h"
+#include "rucades_encoded_data.h"
+#include "rucades_enveloped_data.h"
+#include "rucades_extended_key_usage.h"
+#include "rucades_hashed_data.h"
+#include "rucades_key_usage.h"
+#include "rucades_oid.h"
+#include "rucades_private_key.h"
+#include "rucades_public_key.h"
+#include "rucades_raw_signature.h"
+#include "rucades_recipients.h"
+#include "rucades_signature_status.h"
+#include "rucades_signed_data.h"
+#include "rucades_signed_xml.h"
+#include "rucades_signer.h"
+#include "rucades_signers.h"
+#include "rucades_store.h"
+#include "rucades_symmetric_algorithm.h"
+#include "rucades_version.h"
+
+using namespace Rice;
+using namespace rucades;
+
+extern "C"
+void Init_rucades(void)
+{
+  VALUE rb_mRucades = rb_define_module("Rucades");
+  define_constants(rb_mRucades);
+
+// The order of initialization matters
+// Dependencies shall be initialized before dependents.
+
+  pre_rb_Version::define_ruby_class(rb_mRucades);
+  pre_rb_About::define_ruby_class(rb_mRucades);
+
+  pre_rb_OID::define_ruby_class(rb_mRucades);
+
+  pre_rb_Algorithm::define_ruby_class(rb_mRucades);
+  pre_rb_Attribute::define_ruby_class(rb_mRucades);
+  pre_rb_Attributes::define_ruby_class(rb_mRucades);
+  pre_rb_BasicConstraints::define_ruby_class(rb_mRucades);
+  pre_rb_Blobs::define_ruby_class(rb_mRucades);
+  pre_rb_CertificateStatus::define_ruby_class(rb_mRucades);
+  pre_rb_CRL::define_ruby_class(rb_mRucades);
+  pre_rb_EKU::define_ruby_class(rb_mRucades);
+  pre_rb_EKUs::define_ruby_class(rb_mRucades);
+  pre_rb_EncodedData::define_ruby_class(rb_mRucades);
+  pre_rb_ExtendedKeyUsage::define_ruby_class(rb_mRucades);
+  pre_rb_KeyUsage::define_ruby_class(rb_mRucades);
+  pre_rb_PrivateKey::define_ruby_class(rb_mRucades);
+  pre_rb_PublicKey::define_ruby_class(rb_mRucades);
+
+  pre_rb_Certificate::define_ruby_class(rb_mRucades);
+  pre_rb_Certificates::define_ruby_class(rb_mRucades);
+  pre_rb_Store::define_ruby_class(rb_mRucades);
+// *** Cyclic dependency ***
+// pre_rb_Certificate <-- pre_rb_Certificates <-- pre_rb_Store <-- pre_rb_Certificate
+  pre_rb_Certificate::extend_ruby_class();
+
+  pre_rb_Recipients::define_ruby_class(rb_mRucades);
+  pre_rb_EnvelopedData::define_ruby_class(rb_mRucades);
+  pre_rb_HashedData::define_ruby_class(rb_mRucades);
+  pre_rb_RawSignature::define_ruby_class(rb_mRucades);
+  pre_rb_SignatureStatus::define_ruby_class(rb_mRucades);
+  pre_rb_Signer::define_ruby_class(rb_mRucades);
+  pre_rb_Signers::define_ruby_class(rb_mRucades);
+  pre_rb_SignedData::define_ruby_class(rb_mRucades);
+  pre_rb_SignedXML::define_ruby_class(rb_mRucades);
+
+  pre_rb_SymmetricAlgorithm::define_ruby_class(rb_mRucades);
+}

data/ext/rucades/rucades.h

@@ -0,0 +1,14 @@
+// Copyright (c) 2023 Maxim [maxirmx] Samsonov (https://sw.consulting)
+// All rights reserved.
+// This file is a part of rucades
+
+#pragma once
+
+#include "stdafx.h"
+#include "cppcades.h"
+#include "ruby.h"
+
+namespace rucades {
+void define_constants(VALUE module);
+void hr_method_check(HRESULT hr);
+}

data/ext/rucades/rucades_about.cpp

@@ -0,0 +1,75 @@
+// 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_about.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_About::pre_rb_About(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesAboutObject>(new CPPCadesAboutObject())) { }
+
+unsigned int pre_rb_About::major_version(void)
+{
+  unsigned int version = 0;
+  hr_method_check(m_pCppCadesImpl->get_MajorVersion(&version));
+  return version;
+}
+
+unsigned int pre_rb_About::minor_version(void)
+{
+  unsigned int version = 0;
+  hr_method_check(m_pCppCadesImpl->get_MinorVersion(&version));
+  return version;
+}
+
+unsigned int pre_rb_About::build_version(void)
+{
+  unsigned int version = 0;
+  hr_method_check(m_pCppCadesImpl->get_BuildVersion(&version));
+  return version;
+}
+
+std::string pre_rb_About::version(void)
+{
+  CAtlString AtlVersion;
+  hr_method_check(m_pCppCadesImpl->get_Version(AtlVersion));
+  return AtlVersion.GetString();
+}
+
+pre_rb_Version pre_rb_About::plugin_version(void)
+{
+  boost::shared_ptr<CryptoPro::PKI::CAdES::CPPVersionObject> p_version;
+  hr_method_check(m_pCppCadesImpl->get_PluginVersion(p_version));
+  return pre_rb_Version(p_version);
+}
+
+pre_rb_Version pre_rb_About::csp_version(std::string prov_name, long prov_type)
+{
+  boost::shared_ptr<CryptoPro::PKI::CAdES::CPPVersionObject> p_version;
+  CAtlString provName = CAtlString(CA2CT(CAtlStringA(prov_name.c_str()), CP_UTF8));
+
+  hr_method_check(m_pCppCadesImpl->get_CSPVersion(provName, prov_type, p_version));
+  return pre_rb_Version(p_version);
+}
+
+void pre_rb_About::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_About> rb_cAbout =
+    define_class_under<pre_rb_About>(module, "About")
+    .define_constructor(Constructor<pre_rb_About>())
+    .define_method("major_version", &pre_rb_About::major_version)
+    .define_method("minor_version", &pre_rb_About::minor_version)
+    .define_method("build_version", &pre_rb_About::build_version)
+    .define_method("version", &pre_rb_About::version)
+    .define_method("plugin_version", &pre_rb_About::plugin_version)
+    .define_method("csp_version", &pre_rb_About::csp_version,
+                   Arg("prov_name") = (std::string)"", Arg("prov_type") = (long)75);
+}
+}

data/ext/rucades/rucades_about.h

@@ -0,0 +1,26 @@
+// 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_version.h"
+#include "CPPCadesAbout.h"
+
+namespace rucades {
+class pre_rb_About {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesAboutObject> m_pCppCadesImpl;
+  public:
+    pre_rb_About(void);
+    unsigned int major_version(void);
+    unsigned int minor_version(void);
+    unsigned int build_version(void);
+    std::string version(void);
+    pre_rb_Version plugin_version(void);
+    pre_rb_Version csp_version(std::string prov_name, long prov_type);
+
+    static void define_ruby_class(VALUE module);
+};
+}

data/ext/rucades/rucades_algorithm.cpp

@@ -0,0 +1,54 @@
+// 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_algorithm.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_Algorithm::pre_rb_Algorithm(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPAlgorithmObject>(new CPPCadesCPAlgorithmObject())) { }
+
+pre_rb_Algorithm::pre_rb_Algorithm(boost::shared_ptr<CPPCadesCPAlgorithmObject> other):
+      m_pCppCadesImpl(other) { }
+
+long pre_rb_Algorithm::get_name(void)
+{
+  CADESCOM_ENCRYPTION_ALGORITHM name;
+  hr_method_check(m_pCppCadesImpl->get_Name(&name));
+  return static_cast<long>(name);
+}
+
+void pre_rb_Algorithm::set_name (long name)
+{
+  hr_method_check(m_pCppCadesImpl->put_Name(static_cast<CADESCOM_ENCRYPTION_ALGORITHM>(name)));
+}
+
+long pre_rb_Algorithm::get_key_length(void) {
+  CAPICOM_ENCRYPTION_KEY_LENGTH len;
+  hr_method_check(m_pCppCadesImpl->get_KeyLength(&len));
+  return static_cast<long>(len);
+}
+
+void pre_rb_Algorithm::set_key_length(long len)
+{
+  hr_method_check(m_pCppCadesImpl->put_KeyLength(static_cast<CAPICOM_ENCRYPTION_KEY_LENGTH>(len)));
+}
+
+void pre_rb_Algorithm::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_Algorithm> rb_cAlgorithm =
+    define_class_under<pre_rb_Algorithm>(module, "Algorithm")
+    .define_constructor(Constructor<pre_rb_Algorithm>())
+    .define_method("name", &pre_rb_Algorithm::get_name)
+    .define_method("name=", &pre_rb_Algorithm::set_name)
+    .define_method("key_length", &pre_rb_Algorithm::get_key_length)
+    .define_method("key_length=", &pre_rb_Algorithm::set_key_length);
+}
+}

data/ext/rucades/rucades_algorithm.h

@@ -0,0 +1,28 @@
+// 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 "CPPCadesCPAlgorithm.h"
+
+namespace rucades {
+
+class pre_rb_Algorithm {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAlgorithmObject> m_pCppCadesImpl;
+  public:
+    pre_rb_Algorithm(void);
+    pre_rb_Algorithm(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAlgorithmObject> other);
+    long get_name(void);
+    void set_name(long name);
+    long get_key_length(void);
+    void set_key_length(long len);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_EnvelopedData;
+};
+
+}

data/ext/rucades/rucades_attribute.cpp

@@ -0,0 +1,112 @@
+// 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_attribute.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+
+pre_rb_Attribute::pre_rb_Attribute(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPAttributeObject>(new CPPCadesCPAttributeObject())) { }
+
+pre_rb_Attribute::pre_rb_Attribute(boost::shared_ptr<CPPCadesCPAttributeObject> other):
+      m_pCppCadesImpl(other) { }
+
+pre_rb_OID pre_rb_Attribute::get_OID(void)
+{
+    boost::shared_ptr<CPPCadesCPOIDObject> pCPPCadesCPOID(new CPPCadesCPOIDObject());
+    hr_method_check(m_pCppCadesImpl->get_OID(pCPPCadesCPOID));
+
+    return pre_rb_OID(pCPPCadesCPOID);
+}
+
+std::string pre_rb_Attribute::get_value(void)
+{
+    CryptoPro::CBlob blobValue;
+    CADESCOM_ATTRIBUTE Name;
+    hr_method_check(m_pCppCadesImpl->get_Value(blobValue));
+    hr_method_check(m_pCppCadesImpl->get_Name(&Name));
+
+    DWORD dwLen = blobValue.cbData();
+    std::vector<BYTE> vbValue(dwLen + 1, 0);
+    if (Name != CADESCOM_AUTHENTICATED_ATTRIBUTE_SIGNING_TIME)
+    {
+        memcpy(&vbValue[0], blobValue.pbData(), dwLen);
+    }
+    else
+    {
+        FILETIME fTime;
+        DWORD fTimeSize = sizeof(FILETIME);
+        CryptStringToBinary(reinterpret_cast<TCHAR *>(blobValue.pbData()), dwLen,
+                            CRYPT_STRING_BASE64, &vbValue[0], &dwLen, NULL, NULL);
+        CryptDecodeObject(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
+                          (LPCSTR)szOID_RSA_signingTime, &vbValue[0], dwLen, 0, &fTime,
+                          &fTimeSize);
+        CryptoPro::CDateTime Time(fTime);
+        CryptoPro::CStringProxy strProxyTime = Time.tostring();
+        return std::string(strProxyTime.c_str());
+    }
+    return reinterpret_cast<TCHAR *>(vbValue.data());
+}
+
+void pre_rb_Attribute::set_value(std::string val){
+    CADESCOM_ATTRIBUTE name;
+    hr_method_check(m_pCppCadesImpl->get_Name(&name));
+    if (name == CADESCOM_AUTHENTICATED_ATTRIBUTE_SIGNING_TIME)
+    {
+        CryptoPro::CDateTime time(val.c_str());
+        hr_method_check(m_pCppCadesImpl->put_DateTimeValue(time));
+    }
+    else
+    {
+        CryptoPro::CBlob blobValue;
+        blobValue.assign(reinterpret_cast<const BYTE*>(val.c_str()), val.length());
+        hr_method_check(m_pCppCadesImpl->put_Value(blobValue));
+    }
+}
+
+long pre_rb_Attribute::get_name(void)
+{
+      CADESCOM_ATTRIBUTE name;
+      hr_method_check(m_pCppCadesImpl->get_Name(&name));
+      return static_cast<long>(name);
+}
+
+void pre_rb_Attribute::set_name(long name)
+{
+      hr_method_check(m_pCppCadesImpl->put_Name(static_cast<CADESCOM_ATTRIBUTE>(name)));
+}
+
+long pre_rb_Attribute::get_value_encoding(void)
+{
+      CAPICOM_ENCODING_TYPE type;
+      hr_method_check(m_pCppCadesImpl->get_ValueEncoding(&type));
+      return static_cast<long>(type);
+}
+
+void pre_rb_Attribute::set_value_encoding(long type)
+{
+    hr_method_check(m_pCppCadesImpl->put_ValueEncoding(static_cast<CAPICOM_ENCODING_TYPE>(type)));
+}
+
+void pre_rb_Attribute::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_Attribute> rb_cAttribute =
+    define_class_under<pre_rb_Attribute>(module, "Attribute")
+    .define_constructor(Constructor<pre_rb_Attribute>())
+    .define_method("oid", &pre_rb_Attribute::get_OID)
+    .define_method("name", &pre_rb_Attribute::get_name)
+    .define_method("name=", &pre_rb_Attribute::set_name)
+    .define_method("value", &pre_rb_Attribute::get_value)
+    .define_method("value=", &pre_rb_Attribute::set_value)
+    .define_method("value_type", &pre_rb_Attribute::get_value_encoding)
+    .define_method("value_type=", &pre_rb_Attribute::set_value_encoding);
+}
+}

data/ext/rucades/rucades_attribute.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 "rucades_oid.h"
+#include "CPPCadesCPAttribute.h"
+
+namespace rucades {
+class pre_rb_Attribute {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAttributeObject> m_pCppCadesImpl;
+  public:
+    pre_rb_Attribute(void);
+    pre_rb_Attribute(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAttributeObject> other);
+    pre_rb_OID get_OID(void);
+    std::string get_value(void);
+    void set_value(std::string val);
+    long get_name(void);
+    void set_name(long name);
+    long get_value_encoding(void);
+    void set_value_encoding(long enc);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_Attributes;
+};
+}

data/ext/rucades/rucades_attributes.cpp

@@ -0,0 +1,62 @@
+// 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_attributes.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_Attributes::pre_rb_Attributes(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPAttributesObject>(new CPPCadesCPAttributesObject())) { }
+
+pre_rb_Attributes::pre_rb_Attributes(boost::shared_ptr<CPPCadesCPAttributesObject> other):
+      m_pCppCadesImpl(other) { }
+
+void pre_rb_Attributes::add(pre_rb_Attribute& attrb)
+{
+    hr_method_check(m_pCppCadesImpl->Add(attrb.m_pCppCadesImpl));
+}
+
+void pre_rb_Attributes::clear(void){
+    hr_method_check(m_pCppCadesImpl->Clear());
+}
+
+long pre_rb_Attributes::get_count(void){
+    long count = 0;
+    hr_method_check(m_pCppCadesImpl->get_Count(&count));
+    return count;
+}
+
+pre_rb_Attribute pre_rb_Attributes::get_item(long index)
+{
+    pre_rb_Attribute attrb;
+    hr_method_check(m_pCppCadesImpl->get_Item(index, attrb.m_pCppCadesImpl));
+    return attrb;
+}
+
+void pre_rb_Attributes::remove(long index)
+{
+    hr_method_check(m_pCppCadesImpl->Remove(index));
+}
+
+void pre_rb_Attributes::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_Attributes> rb_cAttributes =
+    define_class_under<pre_rb_Attributes>(module, "Attributes")
+    .define_constructor(Constructor<pre_rb_Attributes>())
+    .define_method("clear", &pre_rb_Attributes::clear)
+    .define_method("count", &pre_rb_Attributes::get_count)
+    .define_method("remove",&pre_rb_Attributes::remove)
+    .define_method("add", &pre_rb_Attributes::add)
+    .define_method("<<", [](pre_rb_Attributes& self, pre_rb_Attribute& item) -> pre_rb_Attributes&
+                  /* Allow chaining */  { self.add(item);  return self;  })
+    .define_method("[]", &pre_rb_Attributes::get_item);
+}
+
+}

data/ext/rucades/rucades_attributes.h

@@ -0,0 +1,28 @@
+// 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_attribute.h"
+#include "CPPCadesCPAttributes.h"
+
+namespace rucades {
+class pre_rb_Attributes {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAttributesObject> m_pCppCadesImpl;
+  public:
+    pre_rb_Attributes(void);
+    pre_rb_Attributes(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAttributesObject> other);
+    void add(pre_rb_Attribute& attrb);
+    void clear(void);
+    long get_count(void);
+    pre_rb_Attribute get_item(long index);
+    void remove(long index);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_Signer;
+};
+}

data/ext/rucades/rucades_basic_constraints.cpp

@@ -0,0 +1,67 @@
+// 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_basic_constraints.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_BasicConstraints::pre_rb_BasicConstraints(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPBasicConstraintsObject>(new CPPCadesCPBasicConstraintsObject())) { }
+
+pre_rb_BasicConstraints::pre_rb_BasicConstraints(boost::shared_ptr<CPPCadesCPBasicConstraintsObject> other):
+      m_pCppCadesImpl(other) { }
+
+bool pre_rb_BasicConstraints::is_ceritficate_authority(void)
+{
+    BOOL bIsCA = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsCertificateAuthority(&bIsCA));
+    return (bIsCA != 0);
+}
+
+bool pre_rb_BasicConstraints::is_critical(void)
+{
+    BOOL bIsCritical = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsCritical(&bIsCritical));
+    return (bIsCritical != 0);
+}
+
+bool pre_rb_BasicConstraints::is_path_len_constraint_present(void)
+{
+    BOOL bIsPathLenConstr = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsPathLenConstraintPresent(&bIsPathLenConstr));
+    return (bIsPathLenConstr != 0);
+}
+
+bool pre_rb_BasicConstraints::is_present(void)
+{
+    BOOL bIsPresent = 0;
+    hr_method_check(m_pCppCadesImpl->get_IsPresent(&bIsPresent));
+    return (bIsPresent != 0);
+}
+
+long pre_rb_BasicConstraints::get_path_len_constraint(void)
+{
+    DWORD dwPathLenConst;
+    hr_method_check(m_pCppCadesImpl->get_PathLenConstraint(&dwPathLenConst));
+    return dwPathLenConst;
+}
+
+void pre_rb_BasicConstraints::define_ruby_class(VALUE module)
+{
+    Data_Type<pre_rb_BasicConstraints> rb_cBasicConstraints =
+        define_class_under<pre_rb_BasicConstraints>(module, "BasicConstraints")
+        .define_constructor(Constructor<pre_rb_BasicConstraints>())
+        .define_method("ceritficate_authority?", &pre_rb_BasicConstraints::is_ceritficate_authority)
+        .define_method("critical?", &pre_rb_BasicConstraints::is_critical)
+        .define_method("pathlen_constraint_present?", &pre_rb_BasicConstraints::is_path_len_constraint_present)
+        .define_method("present?", &pre_rb_BasicConstraints::is_present)
+        .define_method("path_len_constraint", &pre_rb_BasicConstraints::get_path_len_constraint);
+}
+}

data/ext/rucades/rucades_basic_constraints.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 "CPPCadesCPBasicConstraints.h"
+
+namespace rucades {
+class pre_rb_BasicConstraints {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBasicConstraintsObject> m_pCppCadesImpl;
+  public:
+    pre_rb_BasicConstraints(void);
+    pre_rb_BasicConstraints(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBasicConstraintsObject> other);
+    bool is_ceritficate_authority(void);
+    bool is_critical(void);
+    bool is_path_len_constraint_present(void);
+    bool is_present(void);
+    long get_path_len_constraint(void);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_Certificate;
+};
+}

data/ext/rucades/rucades_blobs.cpp

@@ -0,0 +1,46 @@
+// 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_blobs.h"
+
+using namespace Rice;
+using namespace CryptoPro;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_Blobs::pre_rb_Blobs(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPBlobsObject>(new CPPCadesCPBlobsObject())) { }
+
+pre_rb_Blobs::pre_rb_Blobs(boost::shared_ptr<CPPCadesCPBlobsObject> other):
+        m_pCppCadesImpl(other) { }
+
+long pre_rb_Blobs::get_count(void){
+    DWORD count = 0;
+    hr_method_check(m_pCppCadesImpl->get_Count(&count));
+    return count;
+}
+
+std::string pre_rb_Blobs::get_item(long index)
+{
+    boost::shared_ptr<CBlob> pEncValueBlob = boost::shared_ptr<CBlob>(new CBlob());
+    hr_method_check(m_pCppCadesImpl->get_Item(index, pEncValueBlob));
+
+    CAtlString sValue;
+    sValue = CAtlString((const TCHAR *)pEncValueBlob->pbData(), pEncValueBlob->cbData() / sizeof(TCHAR));
+    return std::string(sValue.GetString());
+}
+
+void pre_rb_Blobs::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_Blobs> rb_cBlobs =
+    define_class_under<pre_rb_Blobs>(module, "Blobs")
+    .define_constructor(Constructor<pre_rb_Blobs>())
+    .define_method("count", &pre_rb_Blobs::get_count)
+    .define_method("[]", &pre_rb_Blobs::get_item);
+}
+}