hanko_xml 0.1.0

data/sig/hanko_xml/policy.rbs

@@ -0,0 +1,83 @@
+module HankoXml
+  class Policy
+    type limit = Integer | Float
+
+    FIELDS: Array[Symbol]
+    STRICT_DEFAULTS: Hash[Symbol, untyped]
+
+    attr_reader signature_methods: Array[Symbol | String]
+    attr_reader digest_methods: Array[Symbol | String]
+    attr_reader canonicalization_methods: Array[Symbol | String]
+    attr_reader transforms: Array[Symbol | String]
+    attr_reader allow_external_references: bool
+    attr_reader allow_retrieval_method: bool
+    attr_reader allow_same_document_xpointer: bool
+    attr_reader max_references: limit
+    attr_reader require_references: bool
+    attr_reader require_signed_root: bool
+    attr_reader reject_duplicate_ids: bool
+    attr_reader max_document_size: limit
+    attr_reader max_transforms_per_reference: limit
+    attr_reader min_rsa_key_bits: Integer
+    attr_reader min_ec_key_bits: Integer
+    attr_reader min_dsa_key_bits: Integer
+    attr_reader allow_hmac: bool
+    attr_reader check_certificate_validity: bool
+    attr_reader clock_skew: Numeric
+    attr_reader require_signing_key_usage: bool
+    attr_reader schema: Symbol | String | Nokogiri::XML::Schema | nil
+
+    def self.strict: () -> instance
+    def self.fragment: () -> instance
+    def self.legacy_sha1: () -> instance
+    def self.xades: () -> instance
+    def self.interop: () -> instance
+    def self.permissive: () -> instance
+
+    def initialize: (
+      ?signature_methods: Array[Symbol | String],
+      ?digest_methods: Array[Symbol | String],
+      ?canonicalization_methods: Array[Symbol | String],
+      ?transforms: Array[Symbol | String],
+      ?allow_external_references: bool,
+      ?allow_retrieval_method: bool,
+      ?allow_same_document_xpointer: bool,
+      ?max_references: limit,
+      ?require_references: bool,
+      ?require_signed_root: bool,
+      ?reject_duplicate_ids: bool,
+      ?max_document_size: limit,
+      ?max_transforms_per_reference: limit,
+      ?min_rsa_key_bits: Integer,
+      ?min_ec_key_bits: Integer,
+      ?min_dsa_key_bits: Integer,
+      ?allow_hmac: bool,
+      ?check_certificate_validity: bool,
+      ?clock_skew: Numeric,
+      ?require_signing_key_usage: bool,
+      ?schema: Symbol | String | Nokogiri::XML::Schema | nil
+    ) -> void
+
+    def with: (**untyped overrides) -> instance
+    def to_h: () -> Hash[Symbol, untyped]
+
+    def violations: (
+      HankoXml::SignatureInfo signature_info,
+      ?document: Nokogiri::XML::Document?,
+      ?id_attributes: Array[String | [String, String]]?,
+      ?xml_bytes: String?
+    ) -> Array[HankoXml::PolicyError]
+
+    def enforce!: (
+      HankoXml::SignatureInfo signature_info,
+      ?document: Nokogiri::XML::Document?,
+      ?id_attributes: Array[String | [String, String]]?,
+      ?xml_bytes: String?
+    ) -> void
+
+    def enforce_document_size!: (Integer bytesize) -> void
+    def allows?: (Symbol slot, String | Symbol uri_or_name) -> bool
+    def enforce_algorithm!: (Symbol slot, String | Symbol uri_or_name) -> void
+    def enforce_key_size!: (Array[OpenSSL::PKey::PKey | OpenSSL::X509::Certificate] | OpenSSL::PKey::PKey | OpenSSL::X509::Certificate keys) -> void
+  end
+end

data/sig/hanko_xml/reference.rbs

@@ -0,0 +1,36 @@
+module HankoXml
+  class Transform
+    EXC_C14N_NS: String
+
+    attr_reader name: Symbol?
+    attr_reader uri: String
+    attr_reader xpath: String?
+    attr_reader inclusive_prefixes: Array[String]
+
+    def self.exc_c14n: (?inclusive_prefixes: Array[String | Symbol], ?with_comments: bool) -> instance
+    def self.c14n: () -> instance
+    def self.enveloped_signature: () -> instance
+    def self.coerce: (instance | Symbol | String input) -> instance
+
+    def initialize: (String | Symbol algorithm, ?xpath: String?, ?inclusive_prefixes: Array[String | Symbol]) -> void
+    def enveloped_signature?: () -> bool
+    def secure?: () -> bool
+  end
+
+  class Reference
+    attr_reader uri: String
+    attr_reader transforms: Array[Transform]
+    attr_reader digest_method: Symbol | String
+    attr_reader id: String?
+    attr_reader type: String?
+
+    def self.coerce: (instance | String | Hash[Symbol, untyped] input) -> instance
+
+    def initialize: (?uri: String?, ?transforms: Array[Transform | Symbol | String], ?digest_method: Symbol | String,
+                     ?id: String?, ?type: String?) -> void
+    def digest_method_uri: () -> String?
+    def enveloped?: () -> bool
+    def fragment?: () -> bool
+    def target_id: () -> String?
+  end
+end

data/sig/hanko_xml/signed_document.rbs

@@ -0,0 +1,66 @@
+module HankoXml
+  class SignedDocument
+    READ_METHODS: Array[Symbol]
+    MUTATORS: Array[Symbol]
+
+    # nil when signed without Nokogiri (bytes only).
+    attr_reader document: Nokogiri::XML::Document?
+
+    def self.from_bytes: (String bytes) -> instance
+    def initialize: (Nokogiri::XML::Document document) -> void
+    def to_xml: (?declaration: bool) -> String
+    def to_s: () -> String
+    def bytes: () -> String
+    def write_to: (_Writer io, ?declaration: bool) -> untyped
+    def signatures: () -> Nokogiri::XML::NodeSet
+    # Every keyword of Verifier#initialize (certificate:, store:, policy:, schema:, signature:, ...).
+    def valid?: (**untyped kwargs) -> bool
+    def inspect: () -> String
+
+    # Read-only Nokogiri methods, delegated to #document (READ_METHODS).
+    # Without Nokogiri they raise NokogiriRequired.
+    def at: (*untyped args, **untyped kwargs) ?{ (*untyped) -> untyped } -> untyped
+    def at_css: (*untyped args, **untyped kwargs) ?{ (*untyped) -> untyped } -> untyped
+    def at_xpath: (*untyped args, **untyped kwargs) ?{ (*untyped) -> untyped } -> untyped
+    def css: (*untyped args, **untyped kwargs) ?{ (*untyped) -> untyped } -> untyped
+    def search: (*untyped args, **untyped kwargs) ?{ (*untyped) -> untyped } -> untyped
+    def xpath: (*untyped args, **untyped kwargs) ?{ (*untyped) -> untyped } -> untyped
+    def root: () -> untyped
+    def encoding: () -> String?
+    def errors: () -> Array[untyped]
+    def namespaces: () -> Hash[String, String]
+    def children: () -> untyped
+    def version: () -> String?
+    def url: () -> String?
+
+    # Mutators (MUTATORS): each raises FrozenSignatureError (S-17).
+    def <<: (*untyped) -> bot
+    def add_child: (*untyped) -> bot
+    def add_next_sibling: (*untyped) -> bot
+    def add_previous_sibling: (*untyped) -> bot
+    def after: (*untyped) -> bot
+    def before: (*untyped) -> bot
+    def children=: (*untyped) -> bot
+    def content=: (*untyped) -> bot
+    def inner_html=: (*untyped) -> bot
+    def native_content=: (*untyped) -> bot
+    def parent=: (*untyped) -> bot
+    def remove: (*untyped) -> bot
+    def remove_attribute: (*untyped) -> bot
+    def replace: (*untyped) -> bot
+    def root=: (*untyped) -> bot
+    def set_attribute: (*untyped) -> bot
+    def []=: (*untyped) -> bot
+    def delete: (*untyped) -> bot
+    def encoding=: (*untyped) -> bot
+    def unlink: (*untyped) -> bot
+    def add_namespace: (*untyped) -> bot
+    def add_namespace_definition: (*untyped) -> bot
+    def default_namespace=: (*untyped) -> bot
+    def do_xinclude: (*untyped) -> bot
+    def canonicalize!: (*untyped) -> bot
+    def remove_namespaces!: (*untyped) -> bot
+    def swap: (*untyped) -> bot
+    def wrap: (*untyped) -> bot
+  end
+end

data/sig/hanko_xml/signer.rbs

@@ -0,0 +1,50 @@
+module HankoXml
+  class Signer
+    # The setters work only inside the Signer.new block: the Signer is frozen
+    # when #initialize returns, after which they raise FrozenError.
+    attr_accessor key: Key
+    attr_accessor certificate: Key?
+    attr_accessor certificates: Array[Key]
+    attr_accessor signature_method: Symbol | String
+    attr_accessor digest_method: Symbol | String
+    attr_accessor canonicalization_method: Symbol | String
+    attr_accessor placement: Placement
+    attr_accessor references: Array[Reference]
+    def key_info=: (Array[KeyInfo::Clause] clauses) -> Array[KeyInfo::Clause]
+    attr_accessor id_attributes: Array[String | [String, String]]
+    attr_accessor namespaces: Hash[String | Symbol, String]
+    attr_accessor signature_id: String?
+    attr_accessor policy: Policy
+    attr_reader template_mode: Symbol
+
+    def initialize: (
+      key: Key | OpenSSL::PKey::PKey | String | _ToPath,
+      ?certificate: (Key | OpenSSL::X509::Certificate | String | _ToPath)?,
+      ?certificates: Array[Key | OpenSSL::X509::Certificate | String | _ToPath],
+      ?signature_method: Symbol | String,
+      ?canonicalization_method: Symbol | String,
+      ?digest_method: Symbol | String,
+      ?references: Array[Reference | String | Hash[Symbol, untyped]],
+      ?key_info: Array[Symbol | Hash[Symbol, String]],
+      ?placement: Placement | Symbol,
+      ?id_attributes: Array[String | [String, String]],
+      ?namespaces: Hash[String | Symbol, String],
+      ?signature_id: String?,
+      ?policy: Policy,
+      ?template: Symbol
+    ) ?{ (self) -> void } -> void
+
+    def sign: (HankoXml::input doc_or_xml, ?force: bool, ?signature: Integer?) -> HankoXml::SignedDocument
+    def sign!: (Nokogiri::XML::Node | Nokogiri::XML::Document doc_or_xml, ?force: bool, ?signature: Integer?) -> (Nokogiri::XML::Node | Nokogiri::XML::Document)
+    def template: (HankoXml::input doc_or_xml) -> Nokogiri::XML::Node
+    def reference: (?String? uri, **untyped kwargs) -> Array[Reference]
+    def key_info: (*Symbol | Hash[Symbol, String] clauses, ?name: String?) -> Array[KeyInfo::Clause]
+             | () -> Array[KeyInfo::Clause]
+    def to_h: () -> Hash[Symbol, untyped]
+    def inspect: () -> String
+
+    private
+    def node_signed?: (Nokogiri::XML::Node sig_node) -> bool
+    def write_back_signature: (Nokogiri::XML::Document doc, String signed_bytes, Integer index, Nokogiri::XML::Node caller_sig_node) -> void
+  end
+end

data/sig/hanko_xml/template.rbs

@@ -0,0 +1,41 @@
+module HankoXml
+  class Template
+    # Builds the unsigned <ds:Signature> for +config+ (a Signer), in +doc+'s
+    # namespace context. Needs Nokogiri.
+    def self.build: (Nokogiri::XML::Document doc, Signer config) -> Nokogiri::XML::Node
+    def initialize: (Nokogiri::XML::Document doc, Signer config) -> void
+    def build: () -> Nokogiri::XML::Node
+  end
+
+  module Algorithms
+    type slot = :canonicalization | :digest | :signature | :transform
+
+    class Entry < Struct[untyped]
+      attr_accessor slot: Symbol
+      attr_accessor name: Symbol
+      attr_accessor uri: String
+      attr_accessor secure: bool
+      def secure?: () -> bool
+    end
+
+    # Name/URI lookup for one algorithm slot.
+    class Table
+      def register: (Symbol | String name, String uri, secure: bool, ?replace: bool) -> Entry
+      def []: (Symbol | String name_or_uri) -> Entry?
+      def uri_for: (Symbol | String name_or_uri) -> String?
+      def name_for: (String uri) -> Symbol?
+      def secure?: (Symbol | String name_or_uri) -> bool
+      def names: () -> Array[Symbol]
+    end
+
+    def self.canonicalization: () -> Table
+    def self.digest: () -> Table
+    def self.signature: () -> Table
+    def self.transform: () -> Table
+
+    def self.register: (slot | String slot, Symbol | String name, String uri, secure: bool, ?replace: bool) -> Entry
+    def self.uri_for: (slot | String slot, Symbol | String name_or_uri) -> String?
+    def self.name_for: (slot | String slot, String uri) -> Symbol?
+    def self.secure?: (slot | String slot, Symbol | String name_or_uri) -> bool
+  end
+end

data/sig/hanko_xml/verification.rbs

@@ -0,0 +1,100 @@
+module HankoXml
+  # What <SignedInfo> claims, from Native.inspect_sig: URIs as Strings.
+  # Only its readers are listed: it reaches callers as Verification#signed_info
+  # / #signature_info and as Policy#violations' argument, and its constructors
+  # are @api private.
+  class SignatureInfo
+    class ReferenceInfo < Struct[untyped]
+      attr_accessor uri: String?
+      attr_accessor digest_method: String?
+      attr_accessor transforms: Array[String]
+      attr_accessor id: String?
+      attr_accessor type: String?
+      attr_accessor xpath_filters: Array[Hash[Symbol, untyped]]
+
+      def digest_method_name: () -> Symbol?
+      def transform_names: () -> Array[Symbol?]
+      def fragment?: () -> bool
+      def external?: () -> bool
+      def document_uri: () -> String
+      def same_document_xpointer?: () -> bool
+      def xpath_filter2?: () -> bool
+      def signature_exclusion: () -> (:all | :root_children)?
+    end
+
+    attr_reader signature_method: String?
+    attr_reader canonicalization_method: String?
+    attr_reader signature_count: Integer
+    attr_reader key_names: Array[String]
+    attr_reader certificates: Array[String]
+    attr_reader references: Array[ReferenceInfo]
+
+    def retrieval_method?: () -> bool
+    def signature_method_name: () -> Symbol?
+    def canonicalization_method_name: () -> Symbol?
+  end
+
+  class Verification
+    class Reference
+      attr_reader uri: String
+      attr_reader node: Nokogiri::XML::Node?
+      attr_reader digest_method: Symbol?
+      attr_reader transforms: Array[Symbol?]
+      attr_reader errors: Array[DigestMismatch]
+      attr_reader signature_exclusion: (:all | :root_children)?
+      def valid?: () -> bool
+      def enveloped?: () -> bool
+      def signature_exclusions: () -> Array[:this | :all | :root_children]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    type algorithm = Symbol | String
+
+    attr_reader valid: bool
+    attr_reader errors: Array[Error]
+    attr_reader signature_info: SignatureInfo?
+    attr_reader signature_node: Nokogiri::XML::Node?
+    attr_reader document: Nokogiri::XML::Document?
+    attr_reader signature_element_index: Integer?
+    attr_reader certificate: OpenSSL::X509::Certificate?
+    attr_reader id_attributes: Array[String | [String, String]]
+    attr_reader namespaces: Hash[String, String]
+    attr_reader resolver: untyped
+    attr_reader references: Array[Reference]
+    attr_reader reference_element_indexes: Array[Integer?]?
+    attr_reader reference_valid: Array[bool?]?
+
+    def initialize: (
+      valid: bool,
+      errors: Array[Error],
+      signature_info: SignatureInfo?,
+      signature_node: Nokogiri::XML::Node?,
+      document: Nokogiri::XML::Document?,
+      ?certificate: OpenSSL::X509::Certificate?,
+      ?id_attributes: Array[String | [String, String]]?,
+      ?resolver: untyped,
+      ?reference_element_indexes: Array[Integer?]?,
+      ?reference_valid: Array[bool?]?,
+      ?namespaces: Hash[String | Symbol, String]?,
+      ?signature_element_index: Integer?,
+      ?certificate_chain: Array[OpenSSL::X509::Certificate]?,
+      ?root_signature: bool?,
+      ?trusted: bool
+    ) -> void
+
+    def valid?: () -> bool
+    def signature_method: () -> algorithm?
+    def canonicalization_method: () -> algorithm?
+    def digest_methods: () -> Array[algorithm]
+    def signed?: (Nokogiri::XML::Node node) -> bool
+    def signed_nodes: () -> Array[Nokogiri::XML::Node]
+    def trusted?: () -> bool
+    def signed_info: () -> SignatureInfo?
+    def certificate_chain: () -> Array[OpenSSL::X509::Certificate]
+    def key_info: () -> KeyInfo::Parsed?
+    def covers_root?: () -> bool
+    def partial?: () -> bool
+    def at_signed: (String xpath, ?Hash[String | Symbol, String]? ns) -> Nokogiri::XML::Node
+    def signed: (String xpath, ?Hash[String | Symbol, String]? ns) -> Array[Nokogiri::XML::Node]
+  end
+end

data/sig/hanko_xml/verifier.rbs

@@ -0,0 +1,45 @@
+module HankoXml
+  class Verifier
+    DEFAULT_SCHEMA_PATH: String
+
+    # §6.2: a String, a path-like object, an IO, or a Nokogiri document or node.
+    type input = HankoXml::input
+
+    def self.default_schema: () -> Nokogiri::XML::Schema
+
+    # #103: integrity only; takes every keyword of #initialize but the trust sources.
+    def self.without_trust_verification: (**untyped options) -> Verifier
+    def without_trust?: () -> bool
+
+    attr_reader policy: Policy
+    attr_reader id_attributes: Array[String | [String, String]]
+    attr_reader namespaces: Hash[String, String]
+    attr_reader signature: Symbol | Integer | String | nil
+    attr_reader verification_time: Time?
+    attr_reader schema: Symbol | String | Nokogiri::XML::Schema | nil
+    attr_reader referenced_documents: Hash[String, String]
+    attr_reader resolver: untyped
+
+    def initialize: (
+      ?certificate: (Key | OpenSSL::X509::Certificate | String | _ToPath)?,
+      ?certificates: Array[Key | OpenSSL::X509::Certificate | String | _ToPath]?,
+      ?store: OpenSSL::X509::Store?,
+      ?key: (Key | OpenSSL::PKey::PKey | String | _ToPath)?,
+      ?keys: Hash[String, Key | OpenSSL::X509::Certificate | String | _ToPath]?,
+      ?policy: Policy,
+      ?id_attributes: Array[String | [String, String]],
+      ?resolver: untyped,
+      ?namespaces: Hash[String, String],
+      ?signature: Symbol | Integer | String | nil,
+      ?verification_time: Time?,
+      ?schema: Symbol | String | Nokogiri::XML::Schema | nil,
+      ?referenced_documents: Hash[String, String | Nokogiri::XML::Document],
+      ?certificate_subject: (String | OpenSSL::X509::Name)?
+    ) -> void
+
+    def verify: (input xml) -> Verification
+    def verify!: (input xml, ?allow_untrusted: bool) -> Verification
+    def valid?: (input xml) -> bool
+    def verify_all: (input xml) -> Array[Verification]
+  end
+end

data/sig/hanko_xml/xades.rbs

@@ -0,0 +1,70 @@
+module HankoXml
+  module Xades
+    NS: String
+    LEGACY_NAMESPACES: Array[String]
+    NAMESPACES: Array[String]
+    SIGNED_PROPERTIES_TYPE: String
+    VERSIONED_SIGNED_PROPERTIES_TYPES: Hash[String, String]
+
+    class SignaturePolicy
+      attr_reader identifier: String
+      attr_reader digest_value: String
+      attr_reader digest_method: Symbol | String
+      attr_reader description: String?
+
+      def initialize: (identifier: String, digest_value: String, ?digest_method: Symbol | String, ?description: String?) -> void
+    end
+
+    class DataObjectFormat
+      attr_reader mime_type: String?
+      attr_reader description: String?
+      attr_reader encoding: String?
+
+      def initialize: (?mime_type: String?, ?description: String?, ?encoding: String?) -> void
+    end
+
+    class Signer < HankoXml::Signer
+      attr_reader signing_time: Time?
+      attr_reader signature_policy: (SignaturePolicy | :implied)?
+      attr_reader claimed_roles: Array[String]
+      attr_reader data_object_format: DataObjectFormat?
+
+      def initialize: (
+        ?certificate: (Key | OpenSSL::X509::Certificate | String | _ToPath)?,
+        ?signing_time: Time?,
+        ?signature_policy: (SignaturePolicy | Hash[Symbol, untyped] | :implied)?,
+        ?claimed_roles: Array[String],
+        ?data_object_format: (DataObjectFormat | Hash[Symbol, untyped])?,
+        ?signature_id: String?,
+        ?template: Symbol,
+        **untyped
+      ) ?{ (self) -> void } -> void
+
+      def signed_properties_id: () -> String
+    end
+  end
+end
+
+module HankoXml
+  class XadesError < VerificationError
+  end
+
+  module Xades
+    class SignedProperties
+      attr_reader signing_time: Time?
+      attr_reader signature_policy: (SignaturePolicy | :implied)?
+      attr_reader claimed_roles: Array[String]
+      attr_reader data_object_formats: Array[Hash[Symbol, String?]]
+    end
+
+    class Verification < HankoXml::Verification
+      attr_reader signed_properties: SignedProperties?
+    end
+
+    class Verifier < HankoXml::Verifier
+      def initialize: (?signature_policy: (SignaturePolicy | Hash[Symbol, untyped] | :implied)?, **untyped) -> void
+      def verify: (untyped xml) -> Verification
+      def verify_all: (untyped xml) -> Array[Verification]
+    end
+  end
+end

data/sig/hanko_xml.rbs

@@ -0,0 +1,62 @@
+module HankoXml
+  VERSION: String
+  NS: Hash[String, String]
+
+  class Error < StandardError
+    PRIVATE_KEY_PEM: Regexp
+    FILTERED: String
+
+    attr_reader xmlsec_errors: Array[String]
+    attr_accessor signature_node: Nokogiri::XML::Node?
+
+    def self.filter: (untyped value) -> String?
+    def initialize: (?untyped message, ?xmlsec_errors: Array[String], ?signature_node: Nokogiri::XML::Node?) -> void
+    def xmlsec_errors=: (Array[String] lines) -> Array[String]
+  end
+
+  class ConfigurationError < Error end
+  class PolicyError < ConfigurationError end
+  class PlacementError < ConfigurationError end
+  class NokogiriRequired < ConfigurationError end
+  class SchemaError < ConfigurationError end
+  class ParseError < Error end
+  class KeyLoadError < Error end
+  class ReferenceError < Error
+    attr_accessor reference_uri: String?
+  end
+  class SigningError < Error end
+
+  class VerificationError < Error end
+  class SignatureInvalid < VerificationError end
+  class SignatureMissing < VerificationError end
+  class MultipleSignatures < VerificationError end
+  class UntrustedCertificate < VerificationError end
+  class CertificateExpired < VerificationError end
+  class DigestMismatch < VerificationError
+    attr_accessor reference_uri: String?
+  end
+  class ResolutionMismatch < VerificationError end
+
+  class NotSignedError < Error end
+  class FrozenSignatureError < Error end
+  class NativeError < Error end
+  class NativeVersionMismatch < NativeError end
+
+  def self.nokogiri?: () -> bool
+  def self.capabilities: () -> Hash[Symbol, bool]
+  # §6.2: a String of markup, a path-like object, an IO, or a Nokogiri document or node.
+  type input = String | _ToPath | _Reader | Nokogiri::XML::Node | Nokogiri::XML::Document
+
+  def self.sign: (input doc_or_xml, **untyped kwargs) -> HankoXml::SignedDocument
+  def self.sign!: (Nokogiri::XML::Node | Nokogiri::XML::Document doc, **untyped kwargs) -> (Nokogiri::XML::Node | Nokogiri::XML::Document)
+  def self.valid?: (input xml, **untyped kwargs) -> bool
+  def self.verify!: (input xml, **untyped kwargs) -> HankoXml::Verification
+  def self.signature_present?: (input xml) -> bool
+  def self.zero_copy_available?: () -> bool
+  def self.parse: (String | IO | _ToPath source) -> Nokogiri::XML::Document
+  def self.serialize: (Nokogiri::XML::Document | Nokogiri::XML::Node doc) -> String
+end
+
+# Alias
+Xmlsec: singleton(HankoXml)
+

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: hanko_xml
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Danimar Ribeiro
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: hanko_xml signs and verifies XML-DSig signatures by binding to libxmlsec1
+  through a Rust extension built with Magnus and rb-sys. It works with Nokogiri documents
+  when Nokogiri is loaded, and verifies plain bytes without it.
+email:
+- danimaribeiro@gmail.com
+executables: []
+extensions:
+- ext/hanko_xml/Cargo.toml
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Cargo.lock
+- Cargo.toml
+- LICENSE.txt
+- README.md
+- THIRD_PARTY_LICENSES.md
+- dependencies.yml
+- ext/hanko_xml/Cargo.toml
+- ext/hanko_xml/build.rs
+- ext/hanko_xml/build/vendor.rs
+- ext/hanko_xml/extconf.rb
+- ext/hanko_xml/src/dsig.rs
+- ext/hanko_xml/src/errors.rs
+- ext/hanko_xml/src/lib.rs
+- ext/hanko_xml/src/sys.rs
+- lib/hanko_xml.rb
+- lib/hanko_xml/algorithms.rb
+- lib/hanko_xml/dom.rb
+- lib/hanko_xml/errors.rb
+- lib/hanko_xml/exc-c14n.xsd
+- lib/hanko_xml/input.rb
+- lib/hanko_xml/key.rb
+- lib/hanko_xml/key_info.rb
+- lib/hanko_xml/native_version.rb
+- lib/hanko_xml/nokogiri_ext.rb
+- lib/hanko_xml/placement.rb
+- lib/hanko_xml/policy.rb
+- lib/hanko_xml/reference.rb
+- lib/hanko_xml/signature_info.rb
+- lib/hanko_xml/signed_document.rb
+- lib/hanko_xml/signer.rb
+- lib/hanko_xml/template.rb
+- lib/hanko_xml/transform.rb
+- lib/hanko_xml/verification.rb
+- lib/hanko_xml/verifier.rb
+- lib/hanko_xml/version.rb
+- lib/hanko_xml/xades.rb
+- lib/hanko_xml/xades/verifier.rb
+- lib/hanko_xml/xml.rb
+- lib/hanko_xml/xmldsig-core-schema.xsd
+- sig/hanko_xml.rbs
+- sig/hanko_xml/key.rbs
+- sig/hanko_xml/native.rbs
+- sig/hanko_xml/native_version.rbs
+- sig/hanko_xml/nokogiri_ext.rbs
+- sig/hanko_xml/placement.rbs
+- sig/hanko_xml/policy.rbs
+- sig/hanko_xml/reference.rbs
+- sig/hanko_xml/signed_document.rbs
+- sig/hanko_xml/signer.rbs
+- sig/hanko_xml/template.rbs
+- sig/hanko_xml/verification.rbs
+- sig/hanko_xml/verifier.rbs
+- sig/hanko_xml/xades.rbs
+homepage: https://github.com/danimaribeiro/HankoXml
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/danimaribeiro/HankoXml
+  source_code_uri: https://github.com/danimaribeiro/HankoXml
+  changelog_uri: https://github.com/danimaribeiro/HankoXml/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/danimaribeiro/HankoXml/issues
+  documentation_uri: https://github.com/danimaribeiro/HankoXml#readme
+  rubygems_mfa_required: 'true'
+  xmlsec1_version_requirement: ">= 1.2.30, < 1.4"
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 4.0.23
+specification_version: 4
+summary: XML digital signature signing and verification for Ruby via a Rust extension
+  calling libxmlsec1.
+test_files: []