rucades 0.3.0 → 0.4.0

data/ext/rucades/cplib/cpstldll.h

@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2026, компания КриптоПро
+ *
+ * Разрешается повторное распространение и использование как в виде исходного
+ * кода, так и в двоичной форме, с изменениями или без, при соблюдении
+ * следующих условий:
+ *
+ * 1) При повторном распространении исходного кода должно оставаться
+ *    указанное выше уведомление об авторском праве, этот список условий
+ *    и последующий отказ от гарантий.
+ *
+ * 2) При повторном распространении двоичного кода должна сохраняться
+ *    указанная выше информация об авторском праве, этот список условий
+ *    и последующий отказ от гарантий в документации и/или в других материалах,
+ *    поставляемых при распространении.
+ *
+ * ЭТА ПРОГРАММА ПРЕДОСТАВЛЕНА БЕСПЛАТНО ВЛАДЕЛЬЦАМИ АВТОРСКИХ ПРАВ И/ИЛИ
+ * ДРУГИМИ СТОРОНАМИ "КАК ОНА ЕСТЬ" БЕЗ КАКОГО-ЛИБО ВИДА ГАРАНТИЙ, ВЫРАЖЕННЫХ
+ * ЯВНО ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ, ПОДРАЗУМЕВАЕМЫЕ
+ * ГАРАНТИИ КОММЕРЧЕСКОЙ ЦЕННОСТИ И ПРИГОДНОСТИ ДЛЯ КОНКРЕТНОЙ ЦЕЛИ. НИ В КОЕМ
+ * СЛУЧАЕ, ЕСЛИ НЕ ТРЕБУЕТСЯ СООТВЕТСТВУЮЩИМ ЗАКОНОМ, ИЛИ НЕ УСТАНОВЛЕНО В
+ * УСТНОЙ ФОРМЕ, НИ ОДИН ВЛАДЕЛЕЦ АВТОРСКИХ ПРАВ И НИ ОДНО ДРУГОЕ ЛИЦО, КОТОРОЕ
+ * МОЖЕТ ИЗМЕНЯТЬ И/ИЛИ ПОВТОРНО РАСПРОСТРАНЯТЬ ПРОГРАММУ, КАК БЫЛО СКАЗАНО
+ * ВЫШЕ, НЕ НЕСЁТ ОТВЕТСТВЕННОСТИ, ВКЛЮЧАЯ ЛЮБЫЕ ОБЩИЕ, СЛУЧАЙНЫЕ, СПЕЦИАЛЬНЫЕ
+ * ИЛИ ПОСЛЕДОВАВШИЕ УБЫТКИ, ВСЛЕДСТВИЕ ИСПОЛЬЗОВАНИЯ ИЛИ НЕВОЗМОЖНОСТИ
+ * ИСПОЛЬЗОВАНИЯ ПРОГРАММЫ (ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ ПОТЕРЕЙ ДАННЫХ,
+ * ИЛИ ДАННЫМИ, СТАВШИМИ НЕПРАВИЛЬНЫМИ, ИЛИ ПОТЕРЯМИ, ПРИНЕСЕННЫМИ ИЗ-ЗА ВАС ИЛИ
+ * ТРЕТЬИХ ЛИЦ, ИЛИ ОТКАЗОМ ПРОГРАММЫ РАБОТАТЬ СОВМЕСТНО С ДРУГИМИ ПРОГРАММАМИ),
+ * ДАЖЕ ЕСЛИ ТАКОЙ ВЛАДЕЛЕЦ ИЛИ ДРУГОЕ ЛИЦО БЫЛИ ИЗВЕЩЕНЫ О ВОЗМОЖНОСТИ
+ * ТАКИХ УБЫТКОВ.
+ *
+ * Copyright (c) 2026, CryptoPro Company All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1) Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2) Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+ /*!
+  * \file $RCSfile$
+  * \version $Revision$
+  * \date $Date::                           $
+  * \author $Author$
+  *
+  * \brief Обертки для stl классов, позволяющие их экспортировать в dll.
+  */
+
+#ifndef _CPSTLDLL_H_INCLUDED
+#define _CPSTLDLL_H_INCLUDED
+
+#include <list>
+
+#if defined UNIX
+#   define CDllList std::list
+#   define EXPIMP_CDLLLIST_ITERATORS(...)
+#else // !defined UNIX
+
+#ifdef NO_EXPIMP_CDLLLIST_ITERATORS
+#   define EXPIMP_CDLLLIST_ITERATORS(...)
+#else
+#   define EXPIMP_CDLLLIST_ITERATORS(Type, Extern, Declspec) \
+	__pragma(warning(push)); \
+	__pragma(warning(disable: 4231)); \
+	Extern template class Declspec CDllList<Type>::_Const_iterator; \
+	Extern template class Declspec CDllList<Type>::_Iterator; \
+	__pragma(warning(pop));
+#endif
+
+namespace CryptoPro {
+
+    /**
+     * \class CDllList cpstldll.h <cpstldll.h>
+     * \brief Класс списка аналогичный по интерфейсу классу std::list из библиотеки
+     * стандартных шаблонов.
+     */
+    template<class _Ty>
+    class CDllList
+    {
+        typedef typename std::list<_Ty> stlContainer;
+        typedef CDllList<_Ty> _Myt;
+        typedef typename stlContainer::pointer _Tptr;
+        typedef typename stlContainer::reference _Reft;
+#ifdef _STL70_
+        typedef typename stlContainer::iterator cont_const_iterator;
+#else
+        typedef typename stlContainer::const_iterator cont_const_iterator;
+#endif
+        typedef typename stlContainer::iterator cont_iterator;
+    public:
+        typedef typename stlContainer::allocator_type allocator_type;
+        typedef typename stlContainer::size_type size_type;
+        typedef typename stlContainer::difference_type difference_type;
+        typedef typename stlContainer::pointer pointer;
+        typedef typename stlContainer::const_pointer const_pointer;
+        typedef typename stlContainer::reference reference;
+        typedef typename stlContainer::const_reference const_reference;
+        typedef typename stlContainer::value_type value_type;
+        typedef typename stlContainer::const_reverse_iterator const_reverse_iterator;
+        typedef typename stlContainer::reverse_iterator reverse_iterator;
+
+        class _Const_iterator
+#if defined(_MSC_VER) && (_MSC_VER >= 1500) && (_MSC_VER < 1600) && !defined ( _STL70_ )
+            // Чтобы VS2008 считала итератор за checked
+            : public std::_Iterator_base_universal
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1500) && (_MSC_VER < 1700)
+        {
+        friend CDllList;
+
+        cont_const_iterator* pImpl_;
+
+        _Const_iterator(const cont_const_iterator it);
+
+        public:
+    #if defined(_MSC_VER) && (_MSC_VER >= 1500) && (_MSC_VER < 1600)
+        typedef std::_Range_checked_iterator_tag _Checked_iterator_category;
+    #endif //defined(_MSC_VER) && (_MSC_VER >= 1500) && (_MSC_VER < 1700)
+
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef _Ty value_type;
+        typedef typename stlContainer::difference_type difference_type;
+        typedef typename stlContainer::const_pointer pointer;
+        typedef typename stlContainer::const_reference reference;
+
+        _Const_iterator();
+        ~_Const_iterator();
+
+        _Const_iterator(const _Const_iterator& _Right);
+        _Const_iterator& operator=(const _Const_iterator& _Right);
+
+        const_reference operator*() const;
+        const_pointer operator->() const;
+        _Const_iterator& operator++();
+        _Const_iterator operator++(int);
+        _Const_iterator& operator--();
+        _Const_iterator operator--(int);
+        bool operator==(const _Const_iterator& _Right) const;
+        bool operator!=(const _Const_iterator& _Right) const;
+        };
+
+        class _Iterator : public _Const_iterator
+        {
+            friend CDllList;
+
+            _Iterator(const cont_iterator it);
+
+        public:
+            _Iterator();
+
+            _Reft operator*() const;
+            _Tptr operator->() const;
+            _Iterator& operator++();
+            _Iterator operator++(int);
+            _Iterator& operator--();
+            _Iterator operator--(int);
+        };
+
+        typedef _Const_iterator const_iterator;
+        typedef _Iterator iterator;
+
+        CDllList();
+        CDllList(const _Myt& _Right);
+        ~CDllList();
+
+        const_iterator begin() const;
+        const_iterator end() const;
+        iterator begin();
+        iterator end();
+        const_reverse_iterator rbegin() const;
+        const_reverse_iterator rend() const;
+        reverse_iterator rbegin();
+        reverse_iterator rend();
+        _Myt& operator=(const _Myt& _Right);
+        void resize(size_type _Newsize);
+        void resize(size_type _Newsize, _Ty _Val);
+        size_type size() const;
+        size_type max_size() const;
+        bool empty() const;
+        reference front();
+        const_reference front() const;
+        reference back();
+        const_reference back() const;
+        void push_front(const _Ty& _Val);
+        void push_back(const _Ty& _Val);
+        void pop_front();
+        void pop_back();
+        void assign(size_type _Count, const _Ty& _Val);
+        iterator insert(iterator _Where, const _Ty& _Val);
+        void insert(iterator _Where, iterator _First, iterator _Last);
+        void insert(iterator _Where, size_type _Count, const _Ty& _Val);
+        iterator erase(iterator _Where);
+        iterator erase(iterator _First, iterator _Last);
+        void clear();
+        void swap(_Myt& _Right);
+        //    void sort();
+        //    void reverse();
+    protected:
+        void* impl();
+        const void* impl() const;
+    private:
+        void* pImpl_;
+    };
+
+} // namespace CryptoPro
+
+#endif // !defined UNIX
+
+#endif // _CPSTLDLL_H_INCLUDED

data/ext/rucades/extconf.rb

@@ -8,15 +8,27 @@ require "mkmf-rice"
 require "fiddle"
 
 # rubocop:disable Style/GlobalVars
+PLATFROM_DARWIN = RUBY_PLATFORM =~ /darwin/
+PLATFORM_DARWIN_ARM64 = RUBY_PLATFORM =~ /arm64-darwin/
+PLATFORM_LINUX_ARM64 = RUBY_PLATFORM =~ /aarch64-linux/
+
+LIBDIR = PLATFROM_DARWIN ? "/Applications/CryptoPro_ECP.app/Contents/Resources" : "/opt/cprocsp"
+BOOSTDIR = if PLATFROM_DARWIN
+             PLATFORM_DARWIN_ARM64 ? "/opt/homebrew/include" : "/usr/local/include"
+           else
+             "/usr/include"
+           end
 
 INCDIRS = [
-  "/usr/include/boost",
+  "#{BOOSTDIR}/boost",
   "/opt/cprocsp/include",
   "/opt/cprocsp/include/cpcsp",
   "/opt/cprocsp/include/pki/atl",
-  "/opt/cprocsp/include/pki/cppcades",
-  "/opt/cprocsp/include/pki/cplib",
-  "/opt/cprocsp/include/pki"
+  "#{LIBDIR}/include/pki/cppcades",
+  "#{LIBDIR}/include/pki/cplib",
+  "/opt/cprocsp/include/pki",
+  "#{LIBDIR}/include/pki",
+  "#{__dir__}/cplib",
 ].freeze
 
 CXXDEFS = [
@@ -25,7 +37,8 @@ CXXDEFS = [
   " -Wno-narrowing",
   " -Wno-deprecated-declarations",
   " -Wno-write-strings",
-  " -DLEGACY_FORMAT_MESSAGE_IMPL"
+  " -DLEGACY_FORMAT_MESSAGE_IMPL",
+  " -D_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR"
 ].freeze
 
 ARM64_CXXDEFS = [
@@ -40,13 +53,17 @@ INCDIRS.each { |dir| $INCFLAGS << " -I#{dir}" }
 $defs << " -DSIZEOF_VOID_P=#{Fiddle::SIZEOF_VOIDP}"
 
 CXXDEFS.each { |df| $defs << df }
-ARM64_CXXDEFS.each { |df| $defs << df } if RUBY_PLATFORM =~ /aarch64-linux/
+ARM64_CXXDEFS.each { |df| $defs << df } if PLATFORM_LINUX_ARM64
+$defs << " -DDARWIN" if PLATFROM_DARWIN
 
-$DLDFLAGS << if RUBY_PLATFORM =~ /aarch64-linux/
-               " -L/opt/cprocsp/lib/aarch64"
-             else
-               " -L/opt/cprocsp/lib/amd64"
-             end
+if PLATFROM_DARWIN
+  $DLDFLAGS << " -L/Applications/CryptoPro_ECP.app/Contents/MacOS/lib"
+  $DLDFLAGS << " -Wl,-rpath,/Applications/CryptoPro_ECP.app/Contents/MacOS/lib"
+elsif PLATFORM_LINUX_ARM64
+  $DLDFLAGS << " -L/opt/cprocsp/lib/aarch64"
+else
+  $DLDFLAGS << " -L/opt/cprocsp/lib/amd64"
+end
 
 $LOCAL_LIBS << " -lcppcades"
 
@@ -54,7 +71,6 @@ $srcs = [
   "rucades.cpp",
   "rucades_const.cpp",
   "rucades_tools.cpp",
-  "errormsg.cpp",
   "rucades_about.cpp",
   "rucades_algorithm.cpp",
   "rucades_attribute.cpp",

data/ext/rucades/rucades_about.cpp

@@ -13,7 +13,7 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_About::pre_rb_About(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesAboutObject>(new CPPCadesAboutObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesAboutObject>(new CPPCadesAboutObject())) { }
 
 unsigned int pre_rb_About::major_version(void)
 {
@@ -45,14 +45,14 @@ std::string pre_rb_About::version(void)
 
 pre_rb_Version pre_rb_About::plugin_version(void)
 {
-  boost::shared_ptr<CryptoPro::PKI::CAdES::CPPVersionObject> p_version;
+  NS_SHARED_PTR::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;
+  NS_SHARED_PTR::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));

data/ext/rucades/rucades_about.h

@@ -11,7 +11,7 @@
 namespace rucades {
 class pre_rb_About {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesAboutObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesAboutObject> m_pCppCadesImpl;
   public:
     pre_rb_About(void);
     unsigned int major_version(void);

data/ext/rucades/rucades_algorithm.cpp

@@ -13,9 +13,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_Algorithm::pre_rb_Algorithm(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPAlgorithmObject>(new CPPCadesCPAlgorithmObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPAlgorithmObject>(new CPPCadesCPAlgorithmObject())) { }
 
-pre_rb_Algorithm::pre_rb_Algorithm(boost::shared_ptr<CPPCadesCPAlgorithmObject> other):
+pre_rb_Algorithm::pre_rb_Algorithm(NS_SHARED_PTR::shared_ptr<CPPCadesCPAlgorithmObject> other):
       m_pCppCadesImpl(other) { }
 
 long pre_rb_Algorithm::get_name(void)

data/ext/rucades/rucades_algorithm.h

@@ -11,10 +11,10 @@ namespace rucades {
 
 class pre_rb_Algorithm {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAlgorithmObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAlgorithmObject> m_pCppCadesImpl;
   public:
     pre_rb_Algorithm(void);
-    pre_rb_Algorithm(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAlgorithmObject> other);
+    pre_rb_Algorithm(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAlgorithmObject> other);
     long get_name(void);
     void set_name(long name);
     long get_key_length(void);

data/ext/rucades/rucades_attribute.cpp

@@ -14,14 +14,14 @@ using namespace CryptoPro::PKI::CAdES;
 namespace rucades {
 
 pre_rb_Attribute::pre_rb_Attribute(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPAttributeObject>(new CPPCadesCPAttributeObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPAttributeObject>(new CPPCadesCPAttributeObject())) { }
 
-pre_rb_Attribute::pre_rb_Attribute(boost::shared_ptr<CPPCadesCPAttributeObject> other):
+pre_rb_Attribute::pre_rb_Attribute(NS_SHARED_PTR::shared_ptr<CPPCadesCPAttributeObject> other):
       m_pCppCadesImpl(other) { }
 
 pre_rb_OID pre_rb_Attribute::get_OID(void)
 {
-    boost::shared_ptr<CPPCadesCPOIDObject> pCPPCadesCPOID(new CPPCadesCPOIDObject());
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPOIDObject> pCPPCadesCPOID(new CPPCadesCPOIDObject());
     hr_method_check(m_pCppCadesImpl->get_OID(pCPPCadesCPOID));
 
     return pre_rb_OID(pCPPCadesCPOID);

data/ext/rucades/rucades_attribute.h

@@ -11,10 +11,10 @@
 namespace rucades {
 class pre_rb_Attribute {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAttributeObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::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_Attribute(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAttributeObject> other);
     pre_rb_OID get_OID(void);
     std::string get_value(void);
     void set_value(std::string val);

data/ext/rucades/rucades_attributes.cpp

@@ -13,9 +13,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_Attributes::pre_rb_Attributes(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPAttributesObject>(new CPPCadesCPAttributesObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPAttributesObject>(new CPPCadesCPAttributesObject())) { }
 
-pre_rb_Attributes::pre_rb_Attributes(boost::shared_ptr<CPPCadesCPAttributesObject> other):
+pre_rb_Attributes::pre_rb_Attributes(NS_SHARED_PTR::shared_ptr<CPPCadesCPAttributesObject> other):
       m_pCppCadesImpl(other) { }
 
 void pre_rb_Attributes::add(pre_rb_Attribute& attrb)

data/ext/rucades/rucades_attributes.h

@@ -11,10 +11,10 @@
 namespace rucades {
 class pre_rb_Attributes {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAttributesObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAttributesObject> m_pCppCadesImpl;
   public:
     pre_rb_Attributes(void);
-    pre_rb_Attributes(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAttributesObject> other);
+    pre_rb_Attributes(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPAttributesObject> other);
     void add(pre_rb_Attribute& attrb);
     void clear(void);
     long get_count(void);

data/ext/rucades/rucades_basic_constraints.cpp

@@ -13,9 +13,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_BasicConstraints::pre_rb_BasicConstraints(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPBasicConstraintsObject>(new CPPCadesCPBasicConstraintsObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPBasicConstraintsObject>(new CPPCadesCPBasicConstraintsObject())) { }
 
-pre_rb_BasicConstraints::pre_rb_BasicConstraints(boost::shared_ptr<CPPCadesCPBasicConstraintsObject> other):
+pre_rb_BasicConstraints::pre_rb_BasicConstraints(NS_SHARED_PTR::shared_ptr<CPPCadesCPBasicConstraintsObject> other):
       m_pCppCadesImpl(other) { }
 
 bool pre_rb_BasicConstraints::is_ceritficate_authority(void)
@@ -58,7 +58,7 @@ 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("certificate_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)

data/ext/rucades/rucades_basic_constraints.h

@@ -10,10 +10,10 @@
 namespace rucades {
 class pre_rb_BasicConstraints {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBasicConstraintsObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBasicConstraintsObject> m_pCppCadesImpl;
   public:
     pre_rb_BasicConstraints(void);
-    pre_rb_BasicConstraints(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBasicConstraintsObject> other);
+    pre_rb_BasicConstraints(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBasicConstraintsObject> other);
     bool is_ceritficate_authority(void);
     bool is_critical(void);
     bool is_path_len_constraint_present(void);

data/ext/rucades/rucades_blobs.cpp

@@ -14,9 +14,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_Blobs::pre_rb_Blobs(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPBlobsObject>(new CPPCadesCPBlobsObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPBlobsObject>(new CPPCadesCPBlobsObject())) { }
 
-pre_rb_Blobs::pre_rb_Blobs(boost::shared_ptr<CPPCadesCPBlobsObject> other):
+pre_rb_Blobs::pre_rb_Blobs(NS_SHARED_PTR::shared_ptr<CPPCadesCPBlobsObject> other):
         m_pCppCadesImpl(other) { }
 
 long pre_rb_Blobs::get_count(void){
@@ -27,7 +27,7 @@ long pre_rb_Blobs::get_count(void){
 
 std::string pre_rb_Blobs::get_item(long index)
 {
-    boost::shared_ptr<CBlob> pEncValueBlob = boost::shared_ptr<CBlob>(new CBlob());
+    NS_SHARED_PTR::shared_ptr<CBlob> pEncValueBlob = NS_SHARED_PTR::shared_ptr<CBlob>(new CBlob());
     hr_method_check(m_pCppCadesImpl->get_Item(index, pEncValueBlob));
 
     CAtlString sValue;

data/ext/rucades/rucades_blobs.h

@@ -10,10 +10,10 @@
 namespace rucades {
 class pre_rb_Blobs {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBlobsObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBlobsObject> m_pCppCadesImpl;
   public:
     pre_rb_Blobs(void);
-    pre_rb_Blobs(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBlobsObject> other);
+    pre_rb_Blobs(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBlobsObject> other);
     long get_count(void);
     std::string get_item(long index);
 

data/ext/rucades/rucades_certificate.cpp

@@ -16,9 +16,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_Certificate::pre_rb_Certificate(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPCertificateObject>(new CPPCadesCPCertificateObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificateObject>(new CPPCadesCPCertificateObject())) { }
 
-pre_rb_Certificate::pre_rb_Certificate(boost::shared_ptr<CPPCadesCPCertificateObject> other):
+pre_rb_Certificate::pre_rb_Certificate(NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificateObject> other):
       m_pCppCadesImpl(other) { }
 
 std::string pre_rb_Certificate::get_subject_name(void)
@@ -170,7 +170,7 @@ void pre_rb_Certificate::define_ruby_class(VALUE module)
         .define_method("key_usage", &pre_rb_Certificate::get_key_usage)
         .define_method("extended_key_usage", &pre_rb_Certificate::get_extended_key_usage)
         .define_method("basic_constraints", &pre_rb_Certificate::get_basic_constraints)
-        .define_method("cerificate_status", &pre_rb_Certificate::get_certificate_status)
+        .define_method("certificate_status", &pre_rb_Certificate::get_certificate_status)
         .define_method("import", &pre_rb_Certificate::crt_import)
         .define_method("export", &pre_rb_Certificate::crt_export)
         .define_method("has_private_key?", &pre_rb_Certificate::has_private_key);

data/ext/rucades/rucades_certificate.h

@@ -19,10 +19,10 @@ class pre_rb_Store;
 
 class pre_rb_Certificate {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateObject> m_pCppCadesImpl;
   public:
     pre_rb_Certificate(void);
-    pre_rb_Certificate(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateObject> other);
+    pre_rb_Certificate(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateObject> other);
 
     std::string get_subject_name(void);
     std::string get_issuer_name(void);

data/ext/rucades/rucades_certificate_status.cpp

@@ -13,9 +13,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_CertificateStatus::pre_rb_CertificateStatus(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPCertificateStatusObject>(new CPPCadesCPCertificateStatusObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificateStatusObject>(new CPPCadesCPCertificateStatusObject())) { }
 
-pre_rb_CertificateStatus::pre_rb_CertificateStatus(boost::shared_ptr<CPPCadesCPCertificateStatusObject> other):
+pre_rb_CertificateStatus::pre_rb_CertificateStatus(NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificateStatusObject> other):
       m_pCppCadesImpl(other) { }
 
 bool pre_rb_CertificateStatus::result(void)

data/ext/rucades/rucades_certificate_status.h

@@ -10,10 +10,10 @@
 namespace rucades {
 class pre_rb_CertificateStatus {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateStatusObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateStatusObject> m_pCppCadesImpl;
   public:
     pre_rb_CertificateStatus(void);
-    pre_rb_CertificateStatus(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateStatusObject> other);
+    pre_rb_CertificateStatus(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateStatusObject> other);
     bool result(void);
 
     static void define_ruby_class(VALUE module);

data/ext/rucades/rucades_certificates.cpp

@@ -15,9 +15,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_Certificates::pre_rb_Certificates(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPCertificatesObject>(new CPPCadesCPCertificatesObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificatesObject>(new CPPCadesCPCertificatesObject())) { }
 
-pre_rb_Certificates::pre_rb_Certificates(boost::shared_ptr<CPPCadesCPCertificatesObject> other):
+pre_rb_Certificates::pre_rb_Certificates(NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificatesObject> other):
       m_pCppCadesImpl(other) { }
 
 long pre_rb_Certificates::get_count(void)
@@ -34,8 +34,8 @@ bool pre_rb_Certificates::has_any(void)
 
 pre_rb_Certificate pre_rb_Certificates::get_item(long index)
 {
-  boost::shared_ptr<CPPCadesCPCertificateObject> pCppCadesCertificate =
-                    boost::shared_ptr<CPPCadesCPCertificateObject>(new CPPCadesCPCertificateObject());
+  NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificateObject> pCppCadesCertificate =
+                    NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificateObject>(new CPPCadesCPCertificateObject());
   hr_method_check(m_pCppCadesImpl->Item(index, pCppCadesCertificate));
   return pre_rb_Certificate(pCppCadesCertificate);
 }
@@ -55,8 +55,8 @@ pre_rb_Certificates pre_rb_Certificates::internal_find_query_long(long type, lon
           FindCriteria findCriteria;
           findCriteria.dwCriteriaFlag = FIND_CRITERIA_DWORD;
           findCriteria.dword = query;
-          boost::shared_ptr<CPPCadesCPCertificatesObject> pCppCadesCertificates =
-                    boost::shared_ptr<CPPCadesCPCertificatesObject>(new CPPCadesCPCertificatesObject());
+          NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificatesObject> pCppCadesCertificates =
+                    NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificatesObject>(new CPPCadesCPCertificatesObject());
           hr_method_check(m_pCppCadesImpl->Find(Type, &findCriteria, bValidOnly, pCppCadesCertificates));
           res = pre_rb_Certificates(pCppCadesCertificates);
         }
@@ -120,8 +120,8 @@ pre_rb_Certificates pre_rb_Certificates::internal_find_query_string(long type, s
         throw std::invalid_argument("Invalid CERTIFICATE_FIND_TYPE");
     }
 
-    boost::shared_ptr<CPPCadesCPCertificatesObject> pCppCadesCertificates =
-                    boost::shared_ptr<CPPCadesCPCertificatesObject>(new CPPCadesCPCertificatesObject());
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificatesObject> pCppCadesCertificates =
+                    NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificatesObject>(new CPPCadesCPCertificatesObject());
     hr_method_check(m_pCppCadesImpl->Find(Type, &findCriteria, bValidOnly, pCppCadesCertificates));
     return pre_rb_Certificates(pCppCadesCertificates);
 }

data/ext/rucades/rucades_certificates.h

@@ -12,10 +12,10 @@
 namespace rucades {
 class pre_rb_Certificates {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificatesObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificatesObject> m_pCppCadesImpl;
   public:
     pre_rb_Certificates(void);
-    pre_rb_Certificates(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificatesObject> pCppCadesCertificates);
+    pre_rb_Certificates(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificatesObject> pCppCadesCertificates);
     long get_count(void);
     bool has_any(void);
     pre_rb_Certificate get_item(long index);

data/ext/rucades/rucades_crl.cpp

@@ -14,7 +14,7 @@ using namespace CryptoPro::PKI::CAdES;
 namespace rucades {
 
 pre_rb_CRL::pre_rb_CRL(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPCRLObject>(new CPPCadesCPCRLObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPCRLObject>(new CPPCadesCPCRLObject())) { }
 
 std::string pre_rb_CRL::get_auth_key_id(void)
 {

data/ext/rucades/rucades_crl.h

@@ -11,7 +11,7 @@ namespace rucades {
 
 class pre_rb_CRL {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCRLObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCRLObject> m_pCppCadesImpl;
   public:
     pre_rb_CRL(void);
     std::string get_auth_key_id(void);

data/ext/rucades/rucades_eku.cpp

@@ -14,9 +14,9 @@ using namespace CryptoPro::PKI::CAdES;
 namespace rucades {
 
 pre_rb_EKU::pre_rb_EKU(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPEKUObject>(new CPPCadesCPEKUObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPEKUObject>(new CPPCadesCPEKUObject())) { }
 
-pre_rb_EKU::pre_rb_EKU(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEKUObject> other):
+pre_rb_EKU::pre_rb_EKU(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEKUObject> other):
       m_pCppCadesImpl(other) { }
 
 long pre_rb_EKU::get_name(void)