rucades 0.3.0

data/ext/rucades/rucades_blobs.h

@@ -0,0 +1,25 @@
+// 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 "CPPCadesCollections.h"
+
+namespace rucades {
+class pre_rb_Blobs {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBlobsObject> m_pCppCadesImpl;
+  public:
+    pre_rb_Blobs(void);
+    pre_rb_Blobs(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPBlobsObject> other);
+    long get_count(void);
+    std::string get_item(long index);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_SignedData;
+    friend class pre_rb_Signer;
+};
+}

data/ext/rucades/rucades_certificate.cpp

@@ -0,0 +1,182 @@
+// 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_certificate.h"
+#include "rucades_store.h"
+
+#include "CPPCadesCollections.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_Certificate::pre_rb_Certificate(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPCertificateObject>(new CPPCadesCPCertificateObject())) { }
+
+pre_rb_Certificate::pre_rb_Certificate(boost::shared_ptr<CPPCadesCPCertificateObject> other):
+      m_pCppCadesImpl(other) { }
+
+std::string pre_rb_Certificate::get_subject_name(void)
+{
+    CAtlString sSubjectName;
+    hr_method_check(m_pCppCadesImpl->get_SubjectName(sSubjectName));
+    return std::string(sSubjectName.GetString());
+}
+
+std::string pre_rb_Certificate::get_issuer_name(void)
+{
+    CAtlString sIssuerName;
+    hr_method_check(m_pCppCadesImpl->get_IssuerName(sIssuerName));
+    return std::string(sIssuerName.GetString());
+}
+
+std::string pre_rb_Certificate::get_serial_number(void)
+{
+    CAtlString sSerialNumber;
+    hr_method_check(m_pCppCadesImpl->get_SerialNumber(sSerialNumber));
+    return std::string(sSerialNumber.GetString());
+}
+
+std::string pre_rb_Certificate::get_thumbprint(void)
+{
+    CAtlString sThumbprint;
+    hr_method_check(m_pCppCadesImpl->get_Thumbprint(sThumbprint));
+    return std::string(sThumbprint.GetString());
+}
+
+long pre_rb_Certificate::get_version(void)
+{
+    DWORD dwVersion;
+    hr_method_check(m_pCppCadesImpl->get_Version(&dwVersion));
+    return static_cast<long>(dwVersion);
+}
+
+std::string pre_rb_Certificate::get_valid_from_date(void)
+{
+    CryptoPro::CDateTime date;
+    CryptoPro::CStringProxy strProxyDate;
+    hr_method_check(m_pCppCadesImpl->get_ValidFromDate(date));
+    strProxyDate = date.tostring();
+    return std::string(strProxyDate.c_str());
+}
+
+std::string pre_rb_Certificate::get_valid_to_date(void)
+{
+    CryptoPro::CDateTime date;
+    CryptoPro::CStringProxy strProxyDate;
+    hr_method_check(m_pCppCadesImpl->get_ValidToDate(date));
+    strProxyDate = date.tostring();
+    return std::string(strProxyDate.c_str());
+}
+
+pre_rb_PrivateKey pre_rb_Certificate::get_private_key(void)
+{
+    pre_rb_PrivateKey pPrivateKey;
+    hr_method_check(m_pCppCadesImpl->PrivateKey(pPrivateKey.m_pCppCadesImpl));
+    return pPrivateKey;
+}
+
+pre_rb_PublicKey pre_rb_Certificate::get_public_key(void)
+{
+    pre_rb_PublicKey pPublicKey;
+    hr_method_check(m_pCppCadesImpl->PublicKey(pPublicKey.m_pCppCadesImpl));
+    return pPublicKey;
+}
+
+pre_rb_KeyUsage pre_rb_Certificate::get_key_usage(void)
+{
+    pre_rb_KeyUsage pKeyUsage;
+    hr_method_check(m_pCppCadesImpl->KeyUsage(pKeyUsage.m_pCppCadesImpl));
+    return pKeyUsage;
+}
+
+pre_rb_ExtendedKeyUsage pre_rb_Certificate::get_extended_key_usage(void)
+{
+    pre_rb_ExtendedKeyUsage pExtendedKeyUsage;
+    hr_method_check(m_pCppCadesImpl->ExtendedKeyUsage(pExtendedKeyUsage.m_pCppCadesImpl));
+    return pExtendedKeyUsage;
+}
+
+pre_rb_BasicConstraints  pre_rb_Certificate::get_basic_constraints(void)
+{
+    pre_rb_BasicConstraints pBasicConstraints;
+    hr_method_check(m_pCppCadesImpl->BasicConstraints(pBasicConstraints.m_pCppCadesImpl));
+    return pBasicConstraints;
+}
+
+pre_rb_CertificateStatus pre_rb_Certificate::get_certificate_status(void)
+{
+    pre_rb_CertificateStatus pCertificateStatus;
+    hr_method_check(m_pCppCadesImpl->IsValid(pCertificateStatus.m_pCppCadesImpl));
+    return pCertificateStatus;
+}
+
+std::string pre_rb_Certificate::get_info(long type)
+{
+    CAPICOM_CERT_INFO_TYPE Type = static_cast<CAPICOM_CERT_INFO_TYPE>(type);
+    CAtlString sInfo;
+    hr_method_check(m_pCppCadesImpl->GetInfo(Type, sInfo));
+    return std::string(sInfo.GetString());
+}
+
+bool pre_rb_Certificate::has_private_key(void)
+{
+    BOOL has = 0;
+    hr_method_check(m_pCppCadesImpl->HasPrivateKey(&has));
+    return (has != FALSE);
+}
+
+std::string pre_rb_Certificate::crt_export(long type)
+{
+    CryptoPro::CBlob value;
+    CAPICOM_ENCODING_TYPE Type = static_cast<CAPICOM_ENCODING_TYPE>(type);
+    hr_method_check(m_pCppCadesImpl->Export(Type, value));
+    return type == CAPICOM_ENCODE_BINARY ?
+        std::string(reinterpret_cast<const char *>(value.pbData()), value.cbData()) :
+        std::string(reinterpret_cast<const char *>(value.pbData()));
+}
+void pre_rb_Certificate::crt_import (std::string crt)
+{
+    CryptoPro::CBlob value;
+    value.assign(reinterpret_cast<const BYTE *>(crt.c_str()), crt.length());
+    hr_method_check(m_pCppCadesImpl->Import(value));
+}
+
+void pre_rb_Certificate::additional_store(pre_rb_Store& store)
+{
+    hr_method_check(m_pCppCadesImpl->AdditionalStore(store.m_pCppCadesImpl));
+}
+
+static Data_Type<pre_rb_Certificate> rb_cCertificate;
+void pre_rb_Certificate::define_ruby_class(VALUE module)
+{
+    rb_cCertificate =
+        define_class_under<pre_rb_Certificate>(module, "Certificate")
+        .define_constructor(Constructor<pre_rb_Certificate>())
+        .define_method("subject_name", &pre_rb_Certificate::get_subject_name)
+        .define_method("issuer_name", &pre_rb_Certificate::get_issuer_name)
+        .define_method("serial_number", &pre_rb_Certificate::get_serial_number)
+        .define_method("thumbprint", &pre_rb_Certificate::get_thumbprint)
+        .define_method("version", &pre_rb_Certificate::get_version)
+        .define_method("valid_from_date", &pre_rb_Certificate::get_valid_from_date)
+        .define_method("valid_to_date", &pre_rb_Certificate::get_valid_to_date)
+        .define_method("private_key", &pre_rb_Certificate::get_private_key)
+        .define_method("public_key", &pre_rb_Certificate::get_public_key)
+        .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("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);
+}
+void pre_rb_Certificate::extend_ruby_class(void)
+{
+    rb_cCertificate.define_method("additional_store", &pre_rb_Certificate::additional_store);
+}
+}

data/ext/rucades/rucades_certificate.h

@@ -0,0 +1,59 @@
+// 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_basic_constraints.h"
+#include "rucades_certificate_status.h"
+#include "rucades_extended_key_usage.h"
+#include "rucades_key_usage.h"
+#include "rucades_private_key.h"
+#include "rucades_public_key.h"
+#include "CPPCadesCPCertificate.h"
+
+namespace rucades {
+
+class pre_rb_Store;
+
+class pre_rb_Certificate {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateObject> m_pCppCadesImpl;
+  public:
+    pre_rb_Certificate(void);
+    pre_rb_Certificate(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateObject> other);
+
+    std::string get_subject_name(void);
+    std::string get_issuer_name(void);
+    std::string get_serial_number(void);
+    std::string get_thumbprint(void);
+    long get_version(void);
+    std::string get_valid_from_date(void);
+    std::string get_valid_to_date(void);
+
+    pre_rb_PrivateKey          get_private_key(void);
+    pre_rb_PublicKey           get_public_key(void);
+    pre_rb_KeyUsage            get_key_usage(void);
+    pre_rb_ExtendedKeyUsage    get_extended_key_usage(void);
+    pre_rb_BasicConstraints    get_basic_constraints(void);
+    pre_rb_CertificateStatus   get_certificate_status(void);     //aka IsValid
+
+    std::string get_info(long type);
+    bool has_private_key(void);
+
+    std::string crt_export(long type);
+    void crt_import (std::string crt);
+    void additional_store(pre_rb_Store& store);
+
+    static void define_ruby_class(VALUE module);
+    static void extend_ruby_class(void);
+
+    friend class pre_rb_Certificates;
+    friend class pre_rb_Recipients;
+    friend class pre_rb_RawSignature;
+    friend class pre_rb_Signer;
+    friend class pre_rb_Store;
+    friend class pre_rb_SymmetricAlgorithm;
+};
+}

data/ext/rucades/rucades_certificate_status.cpp

@@ -0,0 +1,36 @@
+// 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_certificate_status.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_CertificateStatus::pre_rb_CertificateStatus(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPCertificateStatusObject>(new CPPCadesCPCertificateStatusObject())) { }
+
+pre_rb_CertificateStatus::pre_rb_CertificateStatus(boost::shared_ptr<CPPCadesCPCertificateStatusObject> other):
+      m_pCppCadesImpl(other) { }
+
+bool pre_rb_CertificateStatus::result(void)
+{
+    BOOL bResult = 0;
+    hr_method_check(m_pCppCadesImpl->get_Result(&bResult));
+    return (bResult != 0);
+}
+
+void pre_rb_CertificateStatus::define_ruby_class(VALUE module)
+{
+    Data_Type<pre_rb_CertificateStatus> rb_cCertificateStatus =
+        define_class_under<pre_rb_CertificateStatus>(module, "CertificateStatus")
+        .define_constructor(Constructor<pre_rb_CertificateStatus>())
+        .define_method("result?", &pre_rb_CertificateStatus::result);
+}
+
+}

data/ext/rucades/rucades_certificate_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 "CPPCadesCPCertificateStatus.h"
+
+namespace rucades {
+class pre_rb_CertificateStatus {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateStatusObject> m_pCppCadesImpl;
+  public:
+    pre_rb_CertificateStatus(void);
+    pre_rb_CertificateStatus(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificateStatusObject> other);
+    bool result(void);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_Certificate;
+};
+}

data/ext/rucades/rucades_certificates.cpp

@@ -0,0 +1,140 @@
+// 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_certificate.h"
+#include "rucades_certificates.h"
+#include "rucades_store.h"
+
+using namespace Rice;
+using namespace CryptoPro::PKI::CAdES;
+
+namespace rucades {
+pre_rb_Certificates::pre_rb_Certificates(void):
+      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPCertificatesObject>(new CPPCadesCPCertificatesObject())) { }
+
+pre_rb_Certificates::pre_rb_Certificates(boost::shared_ptr<CPPCadesCPCertificatesObject> other):
+      m_pCppCadesImpl(other) { }
+
+long pre_rb_Certificates::get_count(void)
+{
+  unsigned int count = 0;
+  hr_method_check(m_pCppCadesImpl->Count(&count));
+  return count;
+}
+
+bool pre_rb_Certificates::has_any(void)
+{
+  return get_count() > 0;
+}
+
+pre_rb_Certificate pre_rb_Certificates::get_item(long index)
+{
+  boost::shared_ptr<CPPCadesCPCertificateObject> pCppCadesCertificate =
+                    boost::shared_ptr<CPPCadesCPCertificateObject>(new CPPCadesCPCertificateObject());
+  hr_method_check(m_pCppCadesImpl->Item(index, pCppCadesCertificate));
+  return pre_rb_Certificate(pCppCadesCertificate);
+}
+
+pre_rb_Certificates pre_rb_Certificates::internal_find_query_long(long type, long query, bool valid_only)
+{
+    CAPICOM_CERTIFICATE_FIND_TYPE Type = static_cast<CAPICOM_CERTIFICATE_FIND_TYPE>(type);
+    pre_rb_Certificates res = pre_rb_Certificates();
+
+    switch (Type) {
+      case CAPICOM_CERTIFICATE_FIND_EXTENDED_PROPERTY:
+      case CAPICOM_CERTIFICATE_FIND_KEY_USAGE:
+      case CAPICOM_CERTIFICATE_FIND_EXTENSION:
+      case CAPICOM_CERTIFICATE_FIND_APPLICATION_POLICY:
+        {
+          BOOL bValidOnly = valid_only ? TRUE:FALSE;
+          FindCriteria findCriteria;
+          findCriteria.dwCriteriaFlag = FIND_CRITERIA_DWORD;
+          findCriteria.dword = query;
+          boost::shared_ptr<CPPCadesCPCertificatesObject> pCppCadesCertificates =
+                    boost::shared_ptr<CPPCadesCPCertificatesObject>(new CPPCadesCPCertificatesObject());
+          hr_method_check(m_pCppCadesImpl->Find(Type, &findCriteria, bValidOnly, pCppCadesCertificates));
+          res = pre_rb_Certificates(pCppCadesCertificates);
+        }
+        break;
+      case CAPICOM_CERTIFICATE_FIND_SHA1_HASH:
+      case CAPICOM_CERTIFICATE_FIND_SUBJECT_NAME:
+      case CAPICOM_CERTIFICATE_FIND_ISSUER_NAME:
+      case CAPICOM_CERTIFICATE_FIND_ROOT_NAME:
+      case CAPICOM_CERTIFICATE_FIND_TEMPLATE_NAME:
+      case CAPICOM_CERTIFICATE_FIND_CERTIFICATE_POLICY:
+      case CAPICOM_CERTIFICATE_FIND_TIME_VALID:
+      case CAPICOM_CERTIFICATE_FIND_TIME_NOT_YET_VALID:
+      case CAPICOM_CERTIFICATE_FIND_TIME_EXPIRED:
+          break;
+      default:
+        throw std::invalid_argument("Invalid CERTIFICATE_FIND_TYPE");
+        break;
+    }
+    return res;
+}
+
+pre_rb_Certificates pre_rb_Certificates::internal_find_query_string(long type, std::string query, bool valid_only)
+{
+    CAPICOM_CERTIFICATE_FIND_TYPE Type = static_cast<CAPICOM_CERTIFICATE_FIND_TYPE>(type);
+    BOOL bValidOnly = valid_only ? TRUE:FALSE;
+    FindCriteria findCriteria;
+    CryptoPro::CDateTime utcDate;
+
+    switch (Type) {
+      case CAPICOM_CERTIFICATE_FIND_SHA1_HASH:
+      case CAPICOM_CERTIFICATE_FIND_SUBJECT_NAME:
+      case CAPICOM_CERTIFICATE_FIND_ISSUER_NAME:
+      case CAPICOM_CERTIFICATE_FIND_ROOT_NAME:
+      case CAPICOM_CERTIFICATE_FIND_TEMPLATE_NAME:
+      case CAPICOM_CERTIFICATE_FIND_CERTIFICATE_POLICY:
+      case CAPICOM_CERTIFICATE_FIND_EXTENSION:
+      case CAPICOM_CERTIFICATE_FIND_APPLICATION_POLICY:
+        findCriteria.dwCriteriaFlag = FIND_CRITERIA_STRING;
+        findCriteria.str = CAtlString(query.c_str());
+        break;
+      case CAPICOM_CERTIFICATE_FIND_TIME_VALID:
+      case CAPICOM_CERTIFICATE_FIND_TIME_NOT_YET_VALID:
+      case CAPICOM_CERTIFICATE_FIND_TIME_EXPIRED:
+        if (query != "") {
+          try {
+            utcDate = CryptoPro::CDateTime(query.c_str());
+          }
+          catch (...) {
+            throw std::invalid_argument("Invalid Date/Time");
+          }
+        }
+        else {
+          utcDate = CryptoPro::CDateTime::Now();
+        }
+        findCriteria.dwCriteriaFlag = FIND_CRITERIA_DATE;
+        findCriteria.date = utcDate;
+      case CAPICOM_CERTIFICATE_FIND_EXTENDED_PROPERTY:
+      case CAPICOM_CERTIFICATE_FIND_KEY_USAGE:
+        return pre_rb_Certificates();
+      default:
+        throw std::invalid_argument("Invalid CERTIFICATE_FIND_TYPE");
+    }
+
+    boost::shared_ptr<CPPCadesCPCertificatesObject> pCppCadesCertificates =
+                    boost::shared_ptr<CPPCadesCPCertificatesObject>(new CPPCadesCPCertificatesObject());
+    hr_method_check(m_pCppCadesImpl->Find(Type, &findCriteria, bValidOnly, pCppCadesCertificates));
+    return pre_rb_Certificates(pCppCadesCertificates);
+}
+
+void pre_rb_Certificates::define_ruby_class(VALUE module)
+{
+  Data_Type<pre_rb_Certificates> rb_cCertificates =
+    define_class_under<pre_rb_Certificates>(module, "Certificates")
+    .define_constructor(Constructor<pre_rb_Certificates>())
+    .define_method("count", &pre_rb_Certificates::get_count)
+    .define_method("any?", &pre_rb_Certificates::has_any)
+    .define_method("[]", &pre_rb_Certificates::get_item)
+    .define_method("internal_find_query_long", &pre_rb_Certificates::internal_find_query_long)
+    .define_method("internal_find_query_string", &pre_rb_Certificates::internal_find_query_string);
+}
+}

data/ext/rucades/rucades_certificates.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 "rucades_certificate.h"
+
+#include "CPPCadesCPCertificates.h"
+
+namespace rucades {
+class pre_rb_Certificates {
+  protected:
+    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificatesObject> m_pCppCadesImpl;
+  public:
+    pre_rb_Certificates(void);
+    pre_rb_Certificates(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificatesObject> pCppCadesCertificates);
+    long get_count(void);
+    bool has_any(void);
+    pre_rb_Certificate get_item(long index);
+
+    pre_rb_Certificates internal_find_query_long(long type, long query, bool valid_only);
+    pre_rb_Certificates internal_find_query_string(long type, std::string query, bool valid_only);
+
+    static void define_ruby_class(VALUE module);
+
+    friend class pre_rb_SignedData;
+    friend class pre_rb_Store;
+};
+}