rucades 0.3.0

data/ext/rucades/rucades_private_key.cpp

@@ -0,0 +1,86 @@
+// 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_private_key.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_PrivateKey::pre_rb_PrivateKey(void):
+          m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPPrivateKeyObject>(new CPPCadesCPPrivateKeyObject())) { }
+
+pre_rb_PrivateKey::pre_rb_PrivateKey(boost::shared_ptr<CPPCadesCPPrivateKeyObject> other):
+      m_pCppCadesImpl(other) { }
+
+std::string pre_rb_PrivateKey::get_container_name(void)
+{
+    CAtlString sContName;
+    hr_method_check(m_pCppCadesImpl->get_ContainerName(sContName));
+    return std::string(sContName.GetString());
+}
+
+std::string pre_rb_PrivateKey::get_unique_container_name(void)
+{
+    CAtlString sUniqueContName;
+    hr_method_check(m_pCppCadesImpl->get_UniqueContainerName(sUniqueContName));
+    return std::string(sUniqueContName.GetString());
+}
+
+std::string pre_rb_PrivateKey::get_provider_name(void)
+{
+    CAtlString sProvName;
+    hr_method_check(m_pCppCadesImpl->get_ProviderName(sProvName));
+    return std::string(sProvName.GetString());
+}
+
+long pre_rb_PrivateKey::get_provider_type(void)
+{
+    CAPICOM_PROV_TYPE Type;
+    hr_method_check(m_pCppCadesImpl->get_ProviderType(&Type));
+    return static_cast<long>(Type);
+}
+
+long pre_rb_PrivateKey::get_key_spec(void)
+{
+    CAPICOM_KEY_SPEC spec;
+    hr_method_check(m_pCppCadesImpl->get_KeySpec(&spec));
+    return static_cast<long>(spec);
+}
+
+void pre_rb_PrivateKey::set_cache_pin(int pin)
+{
+    hr_method_check(m_pCppCadesImpl->set_CachePin(pin));
+}
+
+void pre_rb_PrivateKey::set_key_pin(std::string pin)
+{
+    CAtlString sKeyPin = CAtlString(pin.c_str());
+    hr_method_check(m_pCppCadesImpl->set_KeyPin(sKeyPin));
+}
+
+void pre_rb_PrivateKey::change_pin(void)
+{
+    hr_method_check(m_pCppCadesImpl->ChangePin());
+}
+
+void pre_rb_PrivateKey::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_PrivateKey> rb_cPrivateKey =
+    define_class_under<pre_rb_PrivateKey>(module, "PrivateKey")
+    .define_constructor(Constructor<pre_rb_PrivateKey>())
+    .define_method("container_name", &pre_rb_PrivateKey::get_container_name)
+    .define_method("unique_container_name", &pre_rb_PrivateKey::get_unique_container_name)
+    .define_method("provider_name", &pre_rb_PrivateKey::get_provider_name)
+    .define_method("provier_type", &pre_rb_PrivateKey::get_provider_type)
+    .define_method("key_spec", &pre_rb_PrivateKey::get_key_spec)
+    .define_method("cache_pin=", &pre_rb_PrivateKey::set_cache_pin)
+    .define_method("key_pin=", &pre_rb_PrivateKey::set_key_pin)
+    .define_method("change_pin", &pre_rb_PrivateKey::change_pin);
+}
+}

data/ext/rucades/rucades_private_key.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 "CPPCadesCPPrivateKey.h"
+
+namespace rucades {
+
+class pre_rb_PrivateKey {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPrivateKeyObject> m_pCppCadesImpl;
+  public:
+    pre_rb_PrivateKey(void);
+    pre_rb_PrivateKey(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPrivateKeyObject> other);
+    std::string get_container_name(void);
+    std::string get_unique_container_name(void);
+    std::string get_provider_name(void);
+    long get_provider_type(void);
+    long get_key_spec(void);
+    void set_cache_pin(int pin);
+    void set_key_pin(std::string pin);
+    void change_pin(void);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_Certificate;
+};
+}

data/ext/rucades/rucades_public_key.cpp

@@ -0,0 +1,59 @@
+// 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_public_key.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_PublicKey::pre_rb_PublicKey(void):
+          m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPPublicKeyObject>(new CPPCadesCPPublicKeyObject())) { }
+
+pre_rb_PublicKey::pre_rb_PublicKey(boost::shared_ptr<CPPCadesCPPublicKeyObject> other):
+      m_pCppCadesImpl(other) { }
+
+pre_rb_OID* pre_rb_PublicKey::get_algorithm(void)
+{
+    pre_rb_OID* pOID = new pre_rb_OID();
+    hr_method_check(m_pCppCadesImpl->get_Algorithm(pOID->m_pCppCadesImpl));
+    return pOID;
+}
+
+pre_rb_EncodedData pre_rb_PublicKey::get_encoded_key(void)
+{
+    pre_rb_EncodedData pEncodedData;
+    hr_method_check(m_pCppCadesImpl->get_EncodedKey(pEncodedData.m_pCppCadesImpl));
+    return pEncodedData;
+}
+
+pre_rb_EncodedData pre_rb_PublicKey::get_encoded_parameters(void)
+{
+    pre_rb_EncodedData pEncodedData;
+    hr_method_check(m_pCppCadesImpl->get_EncodedParameters(pEncodedData.m_pCppCadesImpl));
+    return pEncodedData;
+}
+
+long pre_rb_PublicKey::get_length(void)
+{
+    DWORD dwLen = 0;
+    hr_method_check(m_pCppCadesImpl->get_Length(&dwLen));
+    return dwLen;
+}
+
+void pre_rb_PublicKey::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_PublicKey> rb_cPublicKey =
+    define_class_under<pre_rb_PublicKey>(module, "PublicKey")
+    .define_constructor(Constructor<pre_rb_PublicKey>())
+    .define_method("algorithm", &pre_rb_PublicKey::get_algorithm)
+    .define_method("encoded_key", &pre_rb_PublicKey::get_encoded_key)
+    .define_method("encoded_parameters", &pre_rb_PublicKey::get_encoded_parameters)
+    .define_method("length", &pre_rb_PublicKey::get_length);
+}
+}

data/ext/rucades/rucades_public_key.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_encoded_data.h"
+#include "rucades_oid.h"
+#include "CPPCadesCPPublicKey.h"
+
+namespace rucades {
+class pre_rb_PublicKey {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPublicKeyObject> m_pCppCadesImpl;
+  public:
+    pre_rb_PublicKey(void);
+    pre_rb_PublicKey(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPublicKeyObject> other);
+    pre_rb_OID* get_algorithm(void);
+    pre_rb_EncodedData get_encoded_key(void);
+    pre_rb_EncodedData get_encoded_parameters(void);
+    long get_length(void);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_Certificate;
+};
+}

data/ext/rucades/rucades_raw_signature.cpp

@@ -0,0 +1,42 @@
+// 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_raw_signature.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_RawSignature::pre_rb_RawSignature(void):
+    m_pCppCadesImpl(boost::shared_ptr<CPPCadesRawSignatureObject>(new CPPCadesRawSignatureObject())) { }
+
+pre_rb_RawSignature::pre_rb_RawSignature(boost::shared_ptr<CPPCadesRawSignatureObject> other):
+    m_pCppCadesImpl(other) { }
+
+std::string pre_rb_RawSignature::sign_hash(pre_rb_HashedData& data, pre_rb_Certificate& cert)
+{
+    CAtlString sSignature;
+    hr_method_check(m_pCppCadesImpl->SignHash(data.m_pCppCadesImpl, cert.m_pCppCadesImpl, sSignature));
+    return std::string(sSignature.GetString());
+}
+
+void pre_rb_RawSignature::verify_hash(pre_rb_HashedData& data, pre_rb_Certificate& cert, std::string signature)
+{
+    CAtlString sSignature(signature.c_str());
+    hr_method_check(m_pCppCadesImpl->VerifyHash(data.m_pCppCadesImpl, sSignature, cert.m_pCppCadesImpl));
+}
+
+void pre_rb_RawSignature::define_ruby_class(VALUE module)
+{
+    Data_Type<pre_rb_RawSignature> rb_cRawSignature =
+        define_class_under<pre_rb_RawSignature>(module, "RawSignature")
+        .define_constructor(Constructor<pre_rb_RawSignature>())
+        .define_method("sign_hash", &pre_rb_RawSignature::sign_hash)
+        .define_method("verify_hash", &pre_rb_RawSignature::verify_hash);
+}
+}

data/ext/rucades/rucades_raw_signature.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_hashed_data.h"
+#include "rucades_certificate.h"
+#include "CPPCadesRawSignature.h"
+
+namespace rucades {
+
+class pre_rb_RawSignature {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesRawSignatureObject> m_pCppCadesImpl;
+  public:
+    pre_rb_RawSignature(void);
+    pre_rb_RawSignature(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesRawSignatureObject> other);
+    std::string sign_hash(pre_rb_HashedData& data, pre_rb_Certificate& cert);
+    void verify_hash(pre_rb_HashedData& data, pre_rb_Certificate& cert, std::string signature);
+
+    static void define_ruby_class(VALUE module);
+};
+
+}

data/ext/rucades/rucades_recipients.cpp

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

data/ext/rucades/rucades_recipients.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_certificate.h"
+#include "CPPCadesCollections.h"
+
+namespace rucades {
+class pre_rb_Recipients {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPRecipientsObject> m_pCppCadesImpl;
+  public:
+    pre_rb_Recipients(void);
+    pre_rb_Recipients(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPRecipientsObject> other);
+    void add(pre_rb_Certificate& attrb);
+    void clear(void);
+    long get_count(void);
+    pre_rb_Certificate get_item(long index);
+    void remove(long index);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_EnvelopedData;
+};
+}

data/ext/rucades/rucades_signature_status.cpp

@@ -0,0 +1,35 @@
+// 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_signature_status.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_SignatureStatus::pre_rb_SignatureStatus(void):
+    m_pCppCadesImpl(boost::shared_ptr<CPPCadesSignatureStatusObject>(new CPPCadesSignatureStatusObject())) { }
+
+pre_rb_SignatureStatus::pre_rb_SignatureStatus(boost::shared_ptr<CPPCadesSignatureStatusObject> other):
+    m_pCppCadesImpl(other) { }
+
+bool pre_rb_SignatureStatus::is_valid(void)
+{
+    bool valid;
+    hr_method_check(m_pCppCadesImpl->IsValid(valid));
+    return valid;
+}
+
+void pre_rb_SignatureStatus::define_ruby_class(VALUE module)
+{
+    Data_Type<pre_rb_SignatureStatus> rb_cSignatureStatus =
+        define_class_under<pre_rb_SignatureStatus>(module, "SignatureStatus")
+        .define_constructor(Constructor<pre_rb_SignatureStatus>())
+        .define_method("valid?", &pre_rb_SignatureStatus::is_valid);
+}
+}

data/ext/rucades/rucades_signature_status.h

@@ -0,0 +1,23 @@
+// 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 "CPPCadesSignatureStatus.h"
+
+namespace rucades {
+class pre_rb_SignatureStatus {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignatureStatusObject> m_pCppCadesImpl;
+  public:
+    pre_rb_SignatureStatus(void);
+    pre_rb_SignatureStatus(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignatureStatusObject> other);
+    bool is_valid(void);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_Signer;
+};
+}

data/ext/rucades/rucades_signed_data.cpp

@@ -0,0 +1,253 @@
+// 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_data.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_SignedData::pre_rb_SignedData(void):
+    m_pCppCadesImpl(boost::shared_ptr<CPPCadesSignedDataObject>(new CPPCadesSignedDataObject())) { }
+
+long pre_rb_SignedData::get_content_encoding(void)
+{
+    CADESCOM_CONTENT_ENCODING_TYPE Type;
+    hr_method_check(m_pCppCadesImpl->get_ContentEncoding(&Type));
+    return static_cast<long>(Type);
+}
+
+void pre_rb_SignedData::set_content_encoding(long enc)
+{
+    CADESCOM_CONTENT_ENCODING_TYPE Type = static_cast<CADESCOM_CONTENT_ENCODING_TYPE>(enc);
+    hr_method_check(m_pCppCadesImpl->put_ContentEncoding(Type));
+}
+
+std::string pre_rb_SignedData::get_content(void)
+{
+
+    CStringBlob strBlobValue;
+    hr_method_check(m_pCppCadesImpl->get_Content(strBlobValue));
+    CAtlString sValue = CAtlString(reinterpret_cast<const char *>(strBlobValue.GetString()), strBlobValue.GetLength());
+    return std::string(sValue.GetString());
+}
+
+void pre_rb_SignedData::set_content(std::string content)
+{
+    CAtlString sContent = CAtlString(content.c_str());
+    hr_method_check(m_pCppCadesImpl->put_Content(sContent.GetString(), sContent.GetLength()));
+}
+
+pre_rb_Signers pre_rb_SignedData::get_signers(void)
+{
+    pre_rb_Signers pSigners;
+    hr_method_check(m_pCppCadesImpl->get_Signers(pSigners.m_pCppCadesImpl));
+    return pSigners;
+}
+
+pre_rb_Certificates pre_rb_SignedData::get_certificates(void)
+{
+    pre_rb_Certificates pCertificates;
+    hr_method_check(m_pCppCadesImpl->get_Certificates(pCertificates.m_pCppCadesImpl));
+    return pCertificates;
+}
+
+std::string pre_rb_SignedData::sign_cades(pre_rb_Signer* signer, long type, bool detached, long enc)
+{
+    CAPICOM_ENCODING_TYPE EncodingType = static_cast<CAPICOM_ENCODING_TYPE>(enc);
+    CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
+    CryptoPro::CBlob blobSignedMessage;
+
+    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    if (signer) {
+        pSignerCppCadesImpl = signer->m_pCppCadesImpl;
+    }
+
+    hr_method_check(m_pCppCadesImpl->SignCades(pSignerCppCadesImpl,
+                                               CadesType,
+                                               detached ? TRUE : FALSE,
+                                               EncodingType,
+                                               &blobSignedMessage));
+    return std::string(reinterpret_cast<const char *>(blobSignedMessage.pbData()), blobSignedMessage.cbData());
+}
+
+std::string pre_rb_SignedData::cosign_cades(pre_rb_Signer* signer, long type, long enc)
+{
+    CAPICOM_ENCODING_TYPE EncodingType = static_cast<CAPICOM_ENCODING_TYPE>(enc);
+    CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
+    CryptoPro::CBlob blobSignedMessage;
+
+    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    if (signer) {
+        pSignerCppCadesImpl = signer->m_pCppCadesImpl;
+    }
+    hr_method_check(m_pCppCadesImpl->CoSignCades(pSignerCppCadesImpl,
+                                                 CadesType,
+                                                 EncodingType,
+                                                 &blobSignedMessage));
+    return std::string(reinterpret_cast<const char *>(blobSignedMessage.pbData()), blobSignedMessage.cbData());
+}
+
+std::string pre_rb_SignedData::sign_hash(pre_rb_HashedData& hash, pre_rb_Signer* signer, long type, long enc)
+{
+    CAPICOM_ENCODING_TYPE EncodingType = static_cast<CAPICOM_ENCODING_TYPE>(enc);
+    CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
+    CryptoPro::CBlob blobSignedMessage;
+
+    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    if (signer) {
+        pSignerCppCadesImpl = signer->m_pCppCadesImpl;
+    }
+    hr_method_check(m_pCppCadesImpl->SignHash(pSignerCppCadesImpl,
+                                              hash.m_pCppCadesImpl,
+                                              CadesType,
+                                              EncodingType,
+                                              &blobSignedMessage));
+    return std::string(reinterpret_cast<const char *>(blobSignedMessage.pbData()), blobSignedMessage.cbData());
+}
+
+std::string pre_rb_SignedData::cosign_hash(pre_rb_HashedData& hash, pre_rb_Signer* signer, long type, long enc)
+{
+    CAPICOM_ENCODING_TYPE EncodingType = static_cast<CAPICOM_ENCODING_TYPE>(enc);
+    CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
+    CryptoPro::CBlob blobSignedMessage;
+
+    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    if (signer) {
+        pSignerCppCadesImpl = signer->m_pCppCadesImpl;
+    }
+    hr_method_check(m_pCppCadesImpl->CoSignHash(pSignerCppCadesImpl,
+                                                hash.m_pCppCadesImpl,
+                                                CadesType,
+                                                EncodingType,
+                                                &blobSignedMessage));
+    return std::string(reinterpret_cast<const char *>(blobSignedMessage.pbData()), blobSignedMessage.cbData());
+}
+
+std::string pre_rb_SignedData::sign(pre_rb_Signer* signer, bool detached, long enc)
+{
+    CAPICOM_ENCODING_TYPE EncodingType = static_cast<CAPICOM_ENCODING_TYPE>(enc);
+    CryptoPro::CBlob blobSignedMessage;
+
+    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    if (signer) {
+        pSignerCppCadesImpl = signer->m_pCppCadesImpl;
+    }
+    hr_method_check(m_pCppCadesImpl->Sign(pSignerCppCadesImpl,
+                                          detached ? TRUE : FALSE,
+                                          EncodingType,
+                                          &blobSignedMessage));
+    return std::string(reinterpret_cast<const char *>(blobSignedMessage.pbData()), blobSignedMessage.cbData());
+}
+
+std::string pre_rb_SignedData::cosign(pre_rb_Signer* signer, long enc)
+{
+    CAPICOM_ENCODING_TYPE EncodingType = static_cast<CAPICOM_ENCODING_TYPE>(enc);
+    CryptoPro::CBlob blobSignedMessage;
+
+    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    if (signer) {
+        pSignerCppCadesImpl = signer->m_pCppCadesImpl;
+    }
+    hr_method_check(m_pCppCadesImpl->CoSign(pSignerCppCadesImpl,
+                                            EncodingType,
+                                            &blobSignedMessage));
+    return std::string(reinterpret_cast<const char *>(blobSignedMessage.pbData()), blobSignedMessage.cbData());
+}
+
+std::string pre_rb_SignedData::enhance_cades(long type, std::string addr, long enc)
+{
+    CryptoPro::CBlob blobValue;
+    CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
+    CAPICOM_ENCODING_TYPE EncodingType = static_cast<CAPICOM_ENCODING_TYPE>(enc);
+
+    hr_method_check(m_pCppCadesImpl->EnhanceCades(CadesType, CAtlString(addr.c_str()), EncodingType, &blobValue));
+    return std::string(reinterpret_cast<const char *>(blobValue.pbData()), blobValue.cbData());
+}
+
+void pre_rb_SignedData::verify(std::string msg, bool detached, long verify_flag)
+{
+    CAPICOM_SIGNED_DATA_VERIFY_FLAG VerifyFlag = static_cast<CAPICOM_SIGNED_DATA_VERIFY_FLAG>(verify_flag);
+    CryptoPro::CBlob blobSignedMessage;
+    blobSignedMessage.assign(reinterpret_cast<const unsigned char *>(msg.c_str()), msg.length());
+    hr_method_check(m_pCppCadesImpl->Verify(blobSignedMessage, detached ? TRUE : FALSE, VerifyFlag));
+}
+void pre_rb_SignedData::verify_cades(std::string msg, long type, bool detached)
+{
+    CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
+    CryptoPro::CBlob blobSignedMessage;
+    blobSignedMessage.assign(reinterpret_cast<const unsigned char *>(msg.c_str()), msg.length());
+    hr_method_check(m_pCppCadesImpl->VerifyCades(blobSignedMessage, CadesType, detached ? TRUE : FALSE));
+}
+
+void pre_rb_SignedData::verify_hash(pre_rb_HashedData& hash, std::string msg, long type)
+{
+    CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
+    CryptoPro::CBlob blobSignedMessage;
+    blobSignedMessage.assign(reinterpret_cast<const unsigned char *>(msg.c_str()), msg.length());
+
+    hr_method_check(m_pCppCadesImpl->VerifyHash(hash.m_pCppCadesImpl, blobSignedMessage, CadesType));
+}
+
+void pre_rb_SignedData::additional_store(pre_rb_Store& store)
+{
+    hr_method_check(m_pCppCadesImpl->AdditionalStore(store.m_pCppCadesImpl));
+}
+
+void pre_rb_SignedData::define_ruby_class(VALUE module)
+{
+    Data_Type<pre_rb_SignedData> rb_cSignedData = define_class_under<pre_rb_SignedData>(module, "SignedData")
+        .define_constructor(Constructor<pre_rb_SignedData>())
+        .define_method("content_encoding", &pre_rb_SignedData::get_content_encoding)
+        .define_method("content_encoding=", &pre_rb_SignedData::set_content_encoding)
+        .define_method("content", &pre_rb_SignedData::get_content)
+        .define_method("content=", &pre_rb_SignedData::set_content)
+        .define_method("signers", &pre_rb_SignedData::get_signers)
+        .define_method("certificates", &pre_rb_SignedData::get_certificates)
+        .define_method("sign_cades", &pre_rb_SignedData::sign_cades,
+                      Arg("signer") =  nullptr,
+                      Arg("type") = static_cast<long>(CADESCOM_CADES_DEFAULT),
+                      Arg("detached") = false,
+                      Arg("enc") = static_cast<long>(CAPICOM_ENCODE_BASE64))
+        .define_method("cosign_cades", &pre_rb_SignedData::cosign_cades,
+                      Arg("signer") =  nullptr,
+                      Arg("type") = static_cast<long>(CADESCOM_CADES_DEFAULT),
+                      Arg("enc") = static_cast<long>(CAPICOM_ENCODE_BASE64))
+        .define_method("sign_hash", &pre_rb_SignedData::sign_hash,
+                      Arg("hash"),
+                      Arg("signer") =  nullptr,
+                      Arg("type") = static_cast<long>(CADESCOM_CADES_DEFAULT),
+                      Arg("enc") = static_cast<long>(CAPICOM_ENCODE_BASE64))
+        .define_method("cosign_hash", &pre_rb_SignedData::cosign_hash,
+                      Arg("hash"),
+                      Arg("signer") =  nullptr,
+                      Arg("type") = static_cast<long>(CADESCOM_CADES_DEFAULT),
+                      Arg("enc") = static_cast<long>(CAPICOM_ENCODE_BASE64))
+        .define_method("sign", &pre_rb_SignedData::sign,
+                      Arg("signer") =  nullptr,
+                      Arg("detached") = false,
+                      Arg("enc") = static_cast<long>(CAPICOM_ENCODE_BASE64))
+        .define_method("cosign", &pre_rb_SignedData::cosign,
+                      Arg("signer") =  nullptr,
+                      Arg("enc") = static_cast<long>(CAPICOM_ENCODE_BASE64))
+        .define_method("enhance_cades", &pre_rb_SignedData::enhance_cades,
+                      Arg("type") = static_cast<long>(CADESCOM_CADES_DEFAULT),
+                      Arg("addr") = std::string(""),
+                      Arg("enc") = static_cast<long>(CAPICOM_ENCODE_BASE64))
+        .define_method("verify", &pre_rb_SignedData::verify,
+                      Arg("msg"),
+                      Arg("detached") = false,
+                      Arg("verify_flag") = static_cast<long>(CAPICOM_VERIFY_SIGNATURE_ONLY))
+        .define_method("verify_cades", &pre_rb_SignedData::verify_cades,
+                      Arg("msg"),
+                      Arg("type") = static_cast<long>(CADESCOM_CADES_DEFAULT),
+                      Arg("detached") = false)
+        .define_method("verify_hash", &pre_rb_SignedData::verify_hash)
+        .define_method("additional_store", &pre_rb_SignedData::additional_store);
+}
+}