rucades 0.3.0

data/ext/rucades/rucades_signed_data.h

@@ -0,0 +1,41 @@
+// 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_hashed_data.h"
+#include "rucades_signer.h"
+#include "rucades_signers.h"
+#include "rucades_store.h"
+#include "CPPCadesCPSignedData.h"
+
+namespace rucades {
+class pre_rb_SignedData {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignedDataObject> m_pCppCadesImpl;
+  public:
+    pre_rb_SignedData(void);
+    long get_content_encoding(void);
+    void set_content_encoding(long enc);
+    std::string get_content(void);
+    void set_content(std::string content);
+    pre_rb_Signers get_signers(void);
+    pre_rb_Certificates get_certificates(void);
+
+    std::string sign_cades(pre_rb_Signer* signer, long type, bool detached, long enc);
+    std::string cosign_cades(pre_rb_Signer* signer, long type, long enc);
+    std::string sign_hash(pre_rb_HashedData& hash, pre_rb_Signer* signer, long type, long enc);
+    std::string cosign_hash(pre_rb_HashedData& hash, pre_rb_Signer* signer, long type, long enc);
+    std::string sign(pre_rb_Signer* signer, bool detached, long enc);
+    std::string cosign(pre_rb_Signer* signer, long enc);
+    std::string enhance_cades(long type, std::string addr, long enc);
+    void verify(std::string msg, bool detached, long verify_flag);
+    void verify_cades(std::string msg, long type, bool detached);
+    void verify_hash(pre_rb_HashedData& hash, std::string msg, long type);
+    void additional_store(pre_rb_Store& hash);
+
+    static void define_ruby_class(VALUE module);
+};
+}

data/ext/rucades/rucades_signed_xml.cpp

@@ -0,0 +1,87 @@
+// 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_signed_xml.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_SignedXML::pre_rb_SignedXML(void):
+    m_pCppCadesImpl(boost::shared_ptr<CPPCadesSignedXMLObject>(new CPPCadesSignedXMLObject())) { }
+
+std::string pre_rb_SignedXML::get_content(void)
+{
+    CStringBlob strBlobContent;
+    hr_method_check(m_pCppCadesImpl->get_Content(strBlobContent));
+    return std::string(strBlobContent.GetString());
+}
+
+void pre_rb_SignedXML::set_content(std::string content)
+{
+    CStringBlob strBlobContent(content.c_str());
+    hr_method_check(m_pCppCadesImpl->put_Content(strBlobContent));
+}
+
+void pre_rb_SignedXML::set_signature_type(long type)
+{
+    CADESCOM_XML_SIGNATURE_TYPE SignatureType = static_cast<CADESCOM_XML_SIGNATURE_TYPE>(type);
+    hr_method_check(m_pCppCadesImpl->put_SignatureType(SignatureType));
+}
+
+void pre_rb_SignedXML::set_digest_method(std::string method)
+{
+    CStringBlob strBlobMethod(method.c_str());
+    hr_method_check(m_pCppCadesImpl->put_DigestMethod(strBlobMethod));
+}
+
+void pre_rb_SignedXML::set_signature_method(std::string method)
+{
+    CStringBlob strBlobMethod(method.c_str());
+    hr_method_check(m_pCppCadesImpl->put_SignatureMethod(strBlobMethod));
+}
+
+pre_rb_Signers pre_rb_SignedXML::get_signers(void)
+{
+    boost::shared_ptr<CPPCadesCPSignersObject> pSigners = boost::shared_ptr<CPPCadesCPSignersObject>(new CPPCadesCPSignersObject());
+    hr_method_check(m_pCppCadesImpl->get_Signers(pSigners));
+    return pre_rb_Signers(pSigners);
+}
+
+std::string pre_rb_SignedXML::sign(pre_rb_Signer& signer, std::string xpath)
+{
+    CStringBlob strBlobXPath(xpath.c_str(), xpath.length());
+    CStringBlob strBlobResult;
+    hr_method_check(m_pCppCadesImpl->Sign(signer.m_pCppCadesImpl, strBlobXPath, strBlobResult));
+    return std::string(strBlobResult.GetString(), strBlobResult.GetLength());
+}
+
+void pre_rb_SignedXML::verify(std::string msg, std::string xpath)
+{
+    CStringBlob strBlobMessage(msg.c_str(), msg.length());
+    CStringBlob strBlobXPath(xpath.c_str(), xpath.length());
+    hr_method_check(m_pCppCadesImpl->Verify(strBlobMessage, strBlobXPath));
+}
+
+void pre_rb_SignedXML::define_ruby_class(VALUE module)
+{
+    Data_Type<pre_rb_SignedXML> rb_cSignedXML =
+        define_class_under<pre_rb_SignedXML>(module, "SignedXML")
+        .define_constructor(Constructor<pre_rb_SignedXML>())
+        .define_method("content", &pre_rb_SignedXML::get_content)
+        .define_method("content=", &pre_rb_SignedXML::set_content)
+        .define_method("signature_type=", &pre_rb_SignedXML::set_signature_type)
+        .define_method("digest_method=", &pre_rb_SignedXML::set_digest_method)
+        .define_method("signature_method=", &pre_rb_SignedXML::set_signature_method)
+        .define_method("signers", &pre_rb_SignedXML::get_signers)
+        .define_method("sign", &pre_rb_SignedXML::sign,
+                  Arg("signer"), Arg("xpath") = std::string(""))
+        .define_method("verify", &pre_rb_SignedXML::verify,
+                  Arg("msg"), Arg("xpath") = std::string(""));
+}
+}

data/ext/rucades/rucades_signed_xml.h

@@ -0,0 +1,29 @@
+// 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_signer.h"
+#include "rucades_signers.h"
+#include "CPPCadesSignedXML.h"
+
+namespace rucades {
+class pre_rb_SignedXML {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignedXMLObject> m_pCppCadesImpl;
+  public:
+    pre_rb_SignedXML(void);
+    std::string get_content(void);
+    void set_content(std::string content);
+    void set_signature_type(long type);
+    void set_digest_method(std::string method);
+    void set_signature_method(std::string method);
+    pre_rb_Signers get_signers(void);
+    std::string sign(pre_rb_Signer& signer, std::string xpath);
+    void verify(std::string msg, std::string xpath);
+
+    static void define_ruby_class(VALUE module);
+};
+}

data/ext/rucades/rucades_signer.cpp

@@ -0,0 +1,157 @@
+// 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_signer.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_Signer::pre_rb_Signer(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPSignerObject>(new CPPCadesCPSignerObject())) { }
+
+pre_rb_Signer::pre_rb_Signer(boost::shared_ptr<CPPCadesCPSignerObject> other):
+        m_pCppCadesImpl(other) { }
+
+pre_rb_Certificate* pre_rb_Signer::get_certificate(void)
+{
+    boost::shared_ptr<CPPCadesCPCertificateObject> pCert = boost::shared_ptr<CPPCadesCPCertificateObject>(new CPPCadesCPCertificateObject());
+    hr_method_check(m_pCppCadesImpl->get_Certificate(pCert));
+    return new pre_rb_Certificate(pCert);
+}
+
+void pre_rb_Signer::set_certificate(pre_rb_Certificate& cert)
+{
+    CCertContext certContext;
+    hr_method_check(cert.m_pCppCadesImpl->get_CertContext(certContext));
+    boost::shared_ptr<CPPCadesCPCertificateObject> pCPPCadesCPCert(new CPPCadesCPCertificateObject());
+    pCPPCadesCPCert->put_CertContext(certContext);
+    hr_method_check(m_pCppCadesImpl->put_Certificate(pCPPCadesCPCert));
+}
+
+bool pre_rb_Signer::get_check_certificate(void)
+{
+    BOOL bValue = 0;
+    hr_method_check(m_pCppCadesImpl->get_CheckCertificate(bValue));
+    return bValue != FALSE;
+}
+
+void pre_rb_Signer::set_check_certificate(bool value)
+{
+    hr_method_check(m_pCppCadesImpl->put_CheckCertificate(value ? TRUE : FALSE));
+}
+long pre_rb_Signer::get_options(void)
+{
+    CAPICOM_CERTIFICATE_INCLUDE_OPTION option;
+    hr_method_check(m_pCppCadesImpl->get_Options(&option));
+    return static_cast<long>(option);
+}
+
+void pre_rb_Signer::set_options(long opts)
+{
+    hr_method_check(m_pCppCadesImpl->put_Options(static_cast<CAPICOM_CERTIFICATE_INCLUDE_OPTION>(opts)));
+}
+
+std::string pre_rb_Signer::get_tsa_address(void)
+{
+    CAtlString sTSAAddress;
+    hr_method_check(m_pCppCadesImpl->get_TSAAddress(sTSAAddress));
+    return std::string(sTSAAddress.GetString());
+}
+
+void pre_rb_Signer::set_tsa_address(std::string addr)
+{
+    hr_method_check(m_pCppCadesImpl->put_TSAAddress(CAtlString(addr.c_str())));
+}
+
+pre_rb_Attributes pre_rb_Signer::get_unauthenticated_attributes(void)
+{
+    boost::shared_ptr<CPPCadesCPAttributesObject> pAttrs = boost::shared_ptr<CPPCadesCPAttributesObject>(new CPPCadesCPAttributesObject());
+    hr_method_check(m_pCppCadesImpl->get_UnauthenticatedAttributes(pAttrs));
+    return pre_rb_Attributes(pAttrs);
+}
+
+void pre_rb_Signer::set_unauthenticated_attributes(pre_rb_Attributes& attrb)
+{
+    hr_method_check(m_pCppCadesImpl->put_UnauthenticatedAttributes(attrb.m_pCppCadesImpl));
+}
+
+pre_rb_Attributes pre_rb_Signer::get_authenticated_attributes(void)
+{
+    boost::shared_ptr<CPPCadesCPAttributesObject> pAttrs = boost::shared_ptr<CPPCadesCPAttributesObject>(new CPPCadesCPAttributesObject());
+    hr_method_check(m_pCppCadesImpl->get_AuthenticatedAttributes(pAttrs));
+    return pre_rb_Attributes(pAttrs);
+}
+
+void pre_rb_Signer::set_authenticated_attributes(pre_rb_Attributes& attrb)
+{
+    hr_method_check(m_pCppCadesImpl->put_AuthenticatedAttributes(attrb.m_pCppCadesImpl));
+}
+
+pre_rb_Blobs pre_rb_Signer::get_crls(void)
+{
+    boost::shared_ptr<CPPCadesCPBlobsObject> pBlobs = boost::shared_ptr<CPPCadesCPBlobsObject>(new CPPCadesCPBlobsObject());
+    hr_method_check(m_pCppCadesImpl->get_CRLs(pBlobs));
+    return pre_rb_Blobs(pBlobs);
+}
+
+pre_rb_Blobs pre_rb_Signer::get_ocsp_responses(void)
+{
+    boost::shared_ptr<CPPCadesCPBlobsObject> pBlobs = boost::shared_ptr<CPPCadesCPBlobsObject>(new CPPCadesCPBlobsObject());
+    hr_method_check(m_pCppCadesImpl->get_OCSPResponses(pBlobs));
+    return pre_rb_Blobs(pBlobs);
+}
+
+std::string pre_rb_Signer::get_signing_time(void)
+{
+    CryptoPro::CDateTime Time;
+    CryptoPro::CStringProxy strProxySigningTime;
+    hr_method_check(m_pCppCadesImpl->get_SigningTime(Time));
+    strProxySigningTime = Time.tostring();
+    return std::string(strProxySigningTime.c_str());
+}
+
+std::string pre_rb_Signer::get_signature_time_stamp_time(void)
+{
+    CryptoPro::CDateTime Time;
+    CryptoPro::CStringProxy strProxySigningTime;
+    hr_method_check(m_pCppCadesImpl->get_SignatureTimeStampTime(Time));
+    strProxySigningTime = Time.tostring();
+    return std::string(strProxySigningTime.c_str());
+}
+
+void pre_rb_Signer::set_key_pin(std::string pin)
+{
+    CAtlStringA sKeyPin(CA2CA(CAtlStringA(pin.c_str()), CP_UTF8));
+    hr_method_check(m_pCppCadesImpl->put_KeyPin(sKeyPin));
+}
+
+ void pre_rb_Signer::define_ruby_class(VALUE module)
+ {
+      Data_Type<pre_rb_Signer> rb_cSigner =
+          define_class_under<pre_rb_Signer>(module, "Signer")
+          .define_constructor(Constructor<pre_rb_Signer>())
+          .define_method("certificate", &pre_rb_Signer::get_certificate)
+          .define_method("certificate=", &pre_rb_Signer::set_certificate)
+          .define_method("check_certificate", &pre_rb_Signer::get_check_certificate)
+          .define_method("check_certificate=", &pre_rb_Signer::set_check_certificate)
+          .define_method("options", &pre_rb_Signer::get_options)
+          .define_method("options=", &pre_rb_Signer::set_options)
+          .define_method("tsa_address", &pre_rb_Signer::get_tsa_address)
+          .define_method("tsa_address=", &pre_rb_Signer::set_tsa_address)
+          .define_method("unauthenticated_attributes", &pre_rb_Signer::get_unauthenticated_attributes)
+          .define_method("unauthenticated_attributes=", &pre_rb_Signer::set_unauthenticated_attributes)
+          .define_method("authenticated_attributes", &pre_rb_Signer::get_authenticated_attributes)
+          .define_method("authenticated_attributes=", &pre_rb_Signer::set_authenticated_attributes)
+          .define_method("crls", &pre_rb_Signer::get_crls)
+          .define_method("ocsp_responses", &pre_rb_Signer::get_ocsp_responses)
+          .define_method("signing_time", &pre_rb_Signer::get_signing_time)
+          .define_method("signature_time_stamp_time", &pre_rb_Signer::get_signature_time_stamp_time)
+          .define_method("key_pin=", &pre_rb_Signer::set_key_pin);
+ }
+}

data/ext/rucades/rucades_signer.h

@@ -0,0 +1,45 @@
+// 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_attributes.h"
+#include "rucades_blobs.h"
+#include "rucades_certificates.h"
+#include "CPPCadesCPSigner.h"
+
+namespace rucades {
+class pre_rb_Signer {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignerObject> m_pCppCadesImpl;
+  public:
+    pre_rb_Signer(void);
+    pre_rb_Signer(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignerObject> other);
+
+    pre_rb_Certificate* get_certificate(void);
+    void set_certificate(pre_rb_Certificate& crt);
+    bool get_check_certificate(void);
+    void set_check_certificate(bool value);
+    long get_options(void);
+    void set_options(long opts);
+    std::string get_tsa_address(void);
+    void set_tsa_address(std::string addr);
+    pre_rb_Attributes get_unauthenticated_attributes(void);
+    void set_unauthenticated_attributes(pre_rb_Attributes& attrb);
+    pre_rb_Attributes get_authenticated_attributes(void);
+    void set_authenticated_attributes(pre_rb_Attributes& attrb);
+    pre_rb_Blobs get_crls(void);
+    pre_rb_Blobs get_ocsp_responses(void);
+    std::string get_signing_time(void);
+    std::string get_signature_time_stamp_time(void);
+    void set_key_pin(std::string pin);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_SignedData;
+    friend class pre_rb_Signers;
+    friend class pre_rb_SignedXML;
+};
+}

data/ext/rucades/rucades_signers.cpp

@@ -0,0 +1,43 @@
+// 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_signers.h"
+
+using namespace Rice;
+using namespace CryptoPro;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_Signers::pre_rb_Signers(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPSignersObject>(new CPPCadesCPSignersObject())) { }
+
+pre_rb_Signers::pre_rb_Signers(boost::shared_ptr<CPPCadesCPSignersObject> other):
+      m_pCppCadesImpl(other) { }
+
+long pre_rb_Signers::get_count(void){
+    unsigned int count = 0;
+    hr_method_check(m_pCppCadesImpl->get_Count(&count));
+    return count;
+}
+
+pre_rb_Signer pre_rb_Signers::get_item(long index)
+{
+    pre_rb_Signer attrb;
+    hr_method_check(m_pCppCadesImpl->get_Item(index, attrb.m_pCppCadesImpl));
+    return attrb;
+}
+
+void pre_rb_Signers::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_Signers> rb_cSigners =
+    define_class_under<pre_rb_Signers>(module, "Signers")
+    .define_constructor(Constructor<pre_rb_Signers>())
+    .define_method("count", &pre_rb_Signers::get_count)
+    .define_method("[]", &pre_rb_Signers::get_item);
+}
+}

data/ext/rucades/rucades_signers.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_signers.h"
+#include "rucades_signer.h"
+#include "CPPCadesCollections.h"
+
+namespace rucades {
+class pre_rb_Signers {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignersObject> m_pCppCadesImpl;
+  public:
+    pre_rb_Signers(void);
+    pre_rb_Signers(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignersObject> other);
+    void add(pre_rb_Signers& signer);
+    long get_count(void);
+    pre_rb_Signer get_item(long index);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_SignedData;
+};
+}

data/ext/rucades/rucades_store.cpp

@@ -0,0 +1,78 @@
+// 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_store.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_Store::pre_rb_Store(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPStoreObject>(new CPPCadesCPStoreObject())) { }
+
+std::string pre_rb_Store::get_name(void)
+{
+    CAtlString sName;
+    hr_method_check(m_pCppCadesImpl->get_Name(sName));
+    return std::string(sName.GetString());
+}
+
+pre_rb_Certificates pre_rb_Store::get_certificates(void)
+{
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificatesObject> pCertificates;
+    hr_method_check(m_pCppCadesImpl->get_Certificates(pCertificates));
+    return pre_rb_Certificates(pCertificates);
+}
+
+long pre_rb_Store::get_location(void)
+{
+    CADESCOM_STORE_LOCATION Location;
+    hr_method_check(m_pCppCadesImpl->get_Location(&Location));
+    return static_cast<long>(Location);
+}
+
+void pre_rb_Store::open(long location, std::string& name, long mode)
+{
+    CADESCOM_STORE_LOCATION Location = static_cast<CADESCOM_STORE_LOCATION>(location);
+    CAPICOM_STORE_OPEN_MODE Mode = static_cast<CAPICOM_STORE_OPEN_MODE>(mode);
+    CAtlStringW sName = CAtlStringW(name.c_str());
+    hr_method_check(m_pCppCadesImpl->Open(Location, sName, Mode));
+}
+
+void pre_rb_Store::close(void)
+{
+    hr_method_check(m_pCppCadesImpl->Close());
+}
+
+void pre_rb_Store::add(pre_rb_Certificate& cert)
+{
+    hr_method_check(m_pCppCadesImpl->Add(cert.m_pCppCadesImpl));
+}
+
+void pre_rb_Store::add_crl(pre_rb_CRL& crl)
+{
+    hr_method_check(m_pCppCadesImpl->AddCRL(crl.m_pCppCadesImpl));
+}
+
+void pre_rb_Store::define_ruby_class(VALUE module)
+{
+    Data_Type<pre_rb_Store> rb_cStore =
+        define_class_under<pre_rb_Store>(module, "Store")
+        .define_constructor(Constructor<pre_rb_Store>())
+        .define_method("name", &pre_rb_Store::get_name)
+        .define_method("certificates", &pre_rb_Store::get_certificates)
+        .define_method("location", &pre_rb_Store::get_location)
+        .define_method("open", &pre_rb_Store::open,
+                        Arg("location") = static_cast<long>(CADESCOM_CURRENT_USER_STORE),
+                        Arg("name") = std::string("My"),
+                        Arg("mode") = static_cast<long>(CAPICOM_STORE_OPEN_READ_ONLY))
+        .define_method("close", &pre_rb_Store::close)
+        .define_method("add", &pre_rb_Store::add)
+        .define_method("add_crl", &pre_rb_Store::add_crl);
+}
+}

data/ext/rucades/rucades_store.h

@@ -0,0 +1,34 @@
+// 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_certificate.h"
+#include "rucades_certificates.h"
+#include "rucades_crl.h"
+
+#include "CPPCadesCPStore.h"
+
+namespace rucades {
+class pre_rb_Store {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPStoreObject> m_pCppCadesImpl;
+  public:
+    pre_rb_Store(void);
+
+    std::string get_name(void);
+    pre_rb_Certificates get_certificates(void);
+    long get_location(void);
+    void open(long location, std::string& name, long mode);
+    void close(void);
+    void add(pre_rb_Certificate& cert);
+    void add_crl(pre_rb_CRL& crl);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_Certificate;
+    friend class pre_rb_SignedData;
+};
+}

data/ext/rucades/rucades_symmetric_algorithm.cpp

@@ -0,0 +1,107 @@
+// 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_symmetric_algorithm.h"
+
+using namespace Rice;
+using namespace CryptoPro;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_SymmetricAlgorithm::pre_rb_SymmetricAlgorithm(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesSymmetricAlgorithmObject>(new CPPCadesSymmetricAlgorithmObject())) { }
+
+pre_rb_SymmetricAlgorithm::pre_rb_SymmetricAlgorithm(boost::shared_ptr<CPPCadesSymmetricAlgorithmObject> other):
+      m_pCppCadesImpl(other) { }
+
+std::string pre_rb_SymmetricAlgorithm::get_divers_data(void)
+{
+    CBlob blobValue;
+    hr_method_check(m_pCppCadesImpl->get_DiversData(blobValue));
+    return std::string(reinterpret_cast<const char *>(blobValue.pbData()), blobValue.cbData());
+}
+
+void pre_rb_SymmetricAlgorithm::set_divers_data(std::string data)
+{
+    hr_method_check(m_pCppCadesImpl->put_DiversData(data.c_str(), data.length()));
+}
+std::string pre_rb_SymmetricAlgorithm::get_iv(void)
+{
+    CBlob blobValue;
+    hr_method_check(m_pCppCadesImpl->get_IV(blobValue));
+    return std::string(reinterpret_cast<const char *>(blobValue.pbData()), blobValue.cbData());
+}
+void pre_rb_SymmetricAlgorithm::set_iv(std::string iv)
+{
+    hr_method_check(m_pCppCadesImpl->put_IV(iv.c_str(), iv.length()));
+}
+
+std::string pre_rb_SymmetricAlgorithm::encrypt(std::string data, bool final)
+{
+    CAtlString sData = CAtlString(data.c_str());
+    CStringProxy retval;
+    hr_method_check(m_pCppCadesImpl->Encrypt(sData, sData.GetLength(), final ? TRUE : FALSE, retval));
+    return std::string(retval.c_str());
+}
+
+std::string pre_rb_SymmetricAlgorithm::decrypt(std::string data, bool final)
+{
+    CAtlString sData = CAtlString(data.c_str());
+    CBlob blobValue;
+    hr_method_check(m_pCppCadesImpl->Decrypt(sData, sData.GetLength(), final ? TRUE : FALSE, blobValue));
+    return std::string(reinterpret_cast<const char *>(blobValue.pbData()), blobValue.cbData());
+}
+
+pre_rb_SymmetricAlgorithm pre_rb_SymmetricAlgorithm::diversify_key(void)
+{
+    boost::shared_ptr<CPPCadesSymmetricAlgorithmObject> pCPPCadesSymAlg;
+    hr_method_check(m_pCppCadesImpl->DiversifyKey(pCPPCadesSymAlg));
+    return pre_rb_SymmetricAlgorithm(pCPPCadesSymAlg);
+}
+
+void pre_rb_SymmetricAlgorithm::generate_key(long alg)
+{
+    CADESCOM_ENCRYPTION_ALGORITHM Algorithm = static_cast<CADESCOM_ENCRYPTION_ALGORITHM>(alg);
+    hr_method_check(m_pCppCadesImpl->GenerateKey(Algorithm));
+}
+
+std::string pre_rb_SymmetricAlgorithm::export_key(pre_rb_Certificate& cert)
+{
+    CBlob blobValue;
+    hr_method_check(m_pCppCadesImpl->ExportKey(cert.m_pCppCadesImpl, blobValue));
+    return std::string(reinterpret_cast<const char *>(blobValue.pbData()), blobValue.cbData());
+}
+
+void pre_rb_SymmetricAlgorithm::import_key(std::string key, pre_rb_Certificate& cert, std::string password)
+{
+    CAtlString sData = CAtlString(key.c_str());
+    CAtlString sPassword = CAtlString(password.c_str());
+    hr_method_check(m_pCppCadesImpl->ImportKey(key.c_str(),key.length(), cert.m_pCppCadesImpl, password.c_str(), password.length()));
+}
+
+void pre_rb_SymmetricAlgorithm::define_ruby_class(VALUE module)
+{
+    Data_Type<pre_rb_SymmetricAlgorithm> rb_cSymmetricAlgorithm =
+        define_class_under<pre_rb_SymmetricAlgorithm>(module, "SymmetricAlgorithm")
+        .define_constructor(Constructor<pre_rb_SymmetricAlgorithm>())
+        .define_method("divers_data", &pre_rb_SymmetricAlgorithm::get_divers_data)
+        .define_method("divers_data=", &pre_rb_SymmetricAlgorithm::set_divers_data)
+        .define_method("iv", &pre_rb_SymmetricAlgorithm::get_iv)
+        .define_method("iv=", &pre_rb_SymmetricAlgorithm::set_iv)
+        .define_method("encrypt", &pre_rb_SymmetricAlgorithm::encrypt,
+                Arg("data"), Arg("final") = true)
+        .define_method("decrypt", &pre_rb_SymmetricAlgorithm::decrypt,
+                Arg("data"), Arg("final") = true)
+        .define_method("diversify_key", &pre_rb_SymmetricAlgorithm::diversify_key)
+        .define_method("generate_key", &pre_rb_SymmetricAlgorithm::generate_key,
+                Arg("alg") = static_cast<long>(CADESCOM_ENCRYPTION_ALGORITHM_GOST_28147_89))
+        .define_method("export_key", &pre_rb_SymmetricAlgorithm::export_key)
+        .define_method("import_key", &pre_rb_SymmetricAlgorithm::import_key,
+                Arg("key"), Arg("cert"), Arg("password") = std::string(""));
+}
+}

data/ext/rucades/rucades_symmetric_algorithm.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_certificate.h"
+#include "CPPCadesSymmetricAlgorithm.h"
+
+namespace rucades {
+class pre_rb_SymmetricAlgorithm {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSymmetricAlgorithmObject> m_pCppCadesImpl;
+  public:
+    pre_rb_SymmetricAlgorithm(void);
+    pre_rb_SymmetricAlgorithm(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSymmetricAlgorithmObject> other);
+    std::string get_divers_data(void);
+    void set_divers_data(std::string data);
+    std::string get_iv(void);
+    void set_iv(std::string iv);
+    std::string encrypt(std::string data, bool final);
+    std::string decrypt(std::string data, bool final);
+    pre_rb_SymmetricAlgorithm diversify_key(void);
+    void generate_key(long alg);
+    std::string export_key(pre_rb_Certificate& cert);
+    void import_key(std::string key, pre_rb_Certificate& cert, std::string password);
+    static void define_ruby_class(VALUE module);
+};
+}