epics 2.10.0 → 3.0.0.rc1

data/spec/upload_digest_spec.rb

@@ -0,0 +1,69 @@
+RSpec.describe 'upload order data digests' do
+  let(:key_file) { File.open(File.join(File.dirname(__FILE__), 'fixtures', 'SIZBN001.key')) }
+  let(:document) { File.read(File.join(File.dirname(__FILE__), 'fixtures', 'xml', 'cd1.xml')) }
+  let(:client) do
+    Epics::Client.new(key_file, 'secret', 'https://194.180.18.30/ebicsweb/ebicsweb',
+                      'SIZBN001', 'EBIX', 'EBICS', version:)
+  end
+
+  describe '#document_digest' do
+    let(:version) { Epics::Keyring::VERSION_25 }
+
+    subject { Epics::CCT.new(client, document) }
+
+    # Pinned: the hash basis determines the ES for every upload.
+    it 'hashes the document with CR and LF removed' do
+      expect(subject.document_digest)
+        .to eq(OpenSSL::Digest.digest('sha256', document.gsub(/\n|\r/, '')))
+    end
+
+    it 'does not hash the raw document' do
+      expect(subject.document_digest)
+        .not_to eq(OpenSSL::Digest.digest('sha256', document))
+    end
+
+    # Hashed bytes must equal transmitted bytes.
+    it 'normalizes once, so the digest covers exactly what is transmitted' do
+      expect(subject.document).not_to include("\n")
+      expect(subject.document_digest)
+        .to eq(OpenSSL::Digest.digest('sha256', subject.document))
+    end
+
+    it 'is identical for CRLF and LF encodings of the same document' do
+      lf   = "<Doc>\n  <A>1</A>\n</Doc>"
+      crlf = "<Doc>\r\n  <A>1</A>\r\n</Doc>"
+
+      expect(Epics::CCT.new(client, crlf).document_digest)
+        .to eq(Epics::CCT.new(client, lf).document_digest)
+    end
+  end
+
+  describe 'H005 DataDigest' do
+    let(:version) { Epics::Keyring::VERSION_30 }
+    let(:ns) { { 'e' => 'urn:org:ebics:H005' } }
+
+    def data_digest_of(order)
+      Nokogiri::XML(order.to_xml).at_xpath('//e:DataDigest', ns)
+    end
+
+    # EBICS 3.0.2 §5.5.1.1: DataDigest is the "Hashwert der Auftragsdaten";
+    # @SignatureVersion names the hash algorithm, not a signature.
+    it 'carries the SHA-256 hash of the order data, not a signature' do
+      order = Epics::CCT.new(client, document)
+
+      expect(Base64.decode64(data_digest_of(order).text).bytesize).to eq(32)
+      expect(Base64.strict_encode64(order.document_digest))
+        .to eq(data_digest_of(order).text)
+    end
+
+    it 'is reproducible across two builds of the same document' do
+      expect(data_digest_of(Epics::CCT.new(client, document)).text)
+        .to eq(data_digest_of(Epics::CCT.new(client, document)).text)
+    end
+
+    it 'names the signature version used to form it' do
+      expect(data_digest_of(Epics::CCT.new(client, document))['SignatureVersion'])
+        .to eq(client.keyring.user_signature.version)
+    end
+  end
+end

data/spec/user_signature_handler_spec.rb

@@ -0,0 +1,25 @@
+RSpec.describe Epics::Handlers::UserSignatureHandler do
+  let(:client) { Epics::Client.new( File.open(File.join( File.dirname(__FILE__), 'fixtures', 'SIZBN001.key')), 'secret' , 'https://194.180.18.30/ebicsweb/ebicsweb', 'SIZBN001', 'EBIX', 'EBICS') }
+  let(:document) { "\x01" * 12 }
+  let(:cct) { Epics::CCT.new(client, document) }
+
+  before { allow_any_instance_of(OpenSSL::Cipher::AES).to receive(:random_key).and_return(Base64.strict_decode64('NoG3dD6eHqtYTYrJn6TIzA==')) }
+
+  let(:crypt_service) { cct.instance_variable_get(:@crypt_service) }
+  let(:digest) { crypt_service.hash(document) }
+  subject { Nokogiri::XML(cct.to_xml) }
+  let(:signature_data_encrypted_node) { subject.xpath("//ebics:SignatureData", ebics: 'urn:org:ebics:H004').first }
+  let(:signature_data_node) { Nokogiri::XML(Zlib::Inflate.inflate(crypt_service.decrypt_by_key(cct.transaction_key, Base64.strict_decode64(signature_data_encrypted_node.content)))) }
+  let(:signature_value_node) { signature_data_node.xpath("//ebics:SignatureValue", ebics: 'http://www.ebics.org/S001').first }
+
+  describe '#signature_value' do
+
+    # it 'will be the signed document' do
+    #   expect(signature_value_node.content).to eq('cD3DF2ytthmdj/7m53JWZK6IOo26nmaGP4LHdwUqMh3zRTlc7EiidC8oxKqVIFWC3dq7/EaZvKUFrAEc/h64IwlBFyFHOBUW9Xfl...I5KXr1dmWD1mhWYotpdIFXzORS1Bd14C2zh0vpDBhSz7rWu1uNaFy2CxfjEg0tyeapMKsaO8P9MX0SL6dEWE2cOL12hVJu+0Q==')
+    # end
+
+    it 'can be verified with the same key' do
+      expect(client.keyring.user_signature.key.verify(signature_value_node.content, digest)).to eq(true)
+    end
+  end
+end

data/spec/version_support_error_spec.rb

@@ -0,0 +1,76 @@
+RSpec.describe Epics::VersionSupportError do
+  let(:client) do
+    Epics::Client.new(File.open(File.join(File.dirname(__FILE__), 'fixtures', 'SIZBN001.key')),
+                      'secret', 'https://194.180.18.30/ebicsweb/ebicsweb', 'SIZBN001', 'EBIX', 'EBICS',
+                      version: version)
+  end
+  let(:document) { File.read(File.join(File.dirname(__FILE__), 'fixtures', 'xml', 'cd1.xml')) }
+
+  describe 'a 2.x-only order type on H005' do
+    let(:version) { Epics::Keyring::VERSION_30 }
+
+    it 'reports the direction it means' do
+      expect { Epics::FUL.new(client, document, file_format: 'x').to_xml }
+        .to raise_error(described_class, 'Support for versions below 3.0')
+    end
+
+    # `raise Class, arg, backtrace` puts a third argument in the backtrace slot, so a
+    # direction passed that way is silently dropped and the trace destroyed.
+    it 'keeps its backtrace' do
+      Epics::FUL.new(client, document, file_format: 'x').to_xml
+    rescue described_class => e
+      expect(e.backtrace.first).to include('request_factory/v3.rb')
+    end
+  end
+
+  # "below 3.0" is only accurate if these work on 2.4 as well as 2.5.
+  describe 'the 2.x-only order types' do
+    builders = {
+      'FUL' => ->(c, doc) { Epics::FUL.new(c, doc, file_format: 'pain.001') },
+      'FDL' => ->(c, _doc) { Epics::FDL.new(c, file_format: 'camt.053') },
+      'CD1' => ->(c, doc) { Epics::CD1.new(c, doc) },
+      'WSS' => ->(c, _doc) { Epics::WSS.new(c) },
+      'XDS' => ->(c, doc) { Epics::XDS.new(c, doc) },
+      'XCT' => ->(c, doc) { Epics::XCT.new(c, doc) }
+    }
+
+    builders.each do |type, build|
+      [Epics::Keyring::VERSION_24, Epics::Keyring::VERSION_25].each do |supported|
+        context "#{type} on #{supported}" do
+          let(:version) { supported }
+
+          it 'builds a request' do
+            expect { build.call(client, document).to_xml }.not_to raise_error
+          end
+        end
+      end
+
+      context "#{type} on #{Epics::Keyring::VERSION_30}" do
+        let(:version) { Epics::Keyring::VERSION_30 }
+
+        it 'raises' do
+          expect { build.call(client, document).to_xml }
+            .to raise_error(described_class, 'Support for versions below 3.0')
+        end
+      end
+    end
+  end
+
+  describe 'an H005-only concept on 2.x' do
+    let(:version) { Epics::Keyring::VERSION_25 }
+
+    it 'reports the direction it means' do
+      expect { Epics::CCT.new(client, document).request_factory.create_btd }
+        .to raise_error(described_class, 'Supported from version 3.0')
+    end
+  end
+
+  describe 'an unknown direction' do
+    let(:version) { Epics::Keyring::VERSION_25 }
+
+    it 'raises rather than rendering a wrong message' do
+      expect { described_class.new(3.0, 'sideways') }
+        .to raise_error(ArgumentError, /Invalid direction/)
+    end
+  end
+end

data/spec/xsd/H003/ebics.xsd

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:ebics="http://www.ebics.org/H003" targetNamespace="http://www.ebics.org/H003" elementFormDefault="qualified" attributeFormDefault="unqualified" version="1.0">
+	<annotation>
+		<documentation xml:lang="de">ebics.xsd inkludiert alle Schemadateien des EBICS-Protokolls, um die Eindeutigkeit von Element- und Typnamen im EBCIS Namespace zu erzwingen.</documentation>
+		<documentation xml:lang="en">ebics.xsd includes all schema files for the EBICS protocol in order to enforce unique element and type names in the EBICS namespace.</documentation>
+	</annotation>
+	<include schemaLocation="ebics_request.xsd"/>
+	<include schemaLocation="ebics_response.xsd"/>
+	<include schemaLocation="ebics_keymgmt_request.xsd"/>
+	<include schemaLocation="ebics_keymgmt_response.xsd"/>
+</schema>