saro-dat 1.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a79bc8cd93aba476a9f69fef214dd4a0ba9275a4bc93bebb4e1e4e78f36bb19
-  data.tar.gz: 8a16197d29b030c965f8a9e30d80fc7decad1d94be60272b3ef22734e1eeb042
+  metadata.gz: a1981b6c7f0f207f6388f95f4cafaee56a44c49209b0961567f8f37dc3cb2187
+  data.tar.gz: 0e96927af41f3fb6c387a5ffceec5065f8ff6d2e723b8ed6dce41068e7c523fd
 SHA512:
-  metadata.gz: b9fa121db64bb0f59429e543ef49efa921afdd8a87eeb52a232352a9bc09dcd77f33898fa89dbe1031adc1d28bdd575f8c997deaf15265c804668a4e9ac2ea7b
-  data.tar.gz: fc15628f82a197628bb41e686392d7b815bb1b39d2146fbd27bab85209ab8351362239dd6c98aa2de3ef214db943e6b0112b0c0a20de693481241e2e788da8b9
+  metadata.gz: c4c8b7d3730883f2056841f0018ae4783223ffe417c35861a62ae56d6f0010a5b3d9687adbd6aeb7a87f358d9182af396df007313a493e0073681b4e4b474d72
+  data.tar.gz: 7af21459544e31f18c9edcae209fcb3181cdc40d6609e80b65ff8c4b002502c1687e7631e4ae2cd224d01a017447ee421a5ee754602e11d95f4616a792c06169

data/.gitignore

@@ -1,6 +1,7 @@
 
 /.bundle/
 /vendor/bundle/
+
 /Gemfile.lock
 /saro-dat-*.gem
 

data/.idea/saro-dat.iml

@@ -13,7 +13,7 @@
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" scope="PROVIDED" name="base64 (v0.3.0, rbenv: 4.0.5) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="benchmark (v0.5.0, rbenv: 4.0.5) [gem]" level="application" />
-    <orderEntry type="library" scope="PROVIDED" name="bundler (v4.0.10, rbenv: 4.0.5) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="bundler (v4.0.12, rbenv: 4.0.5) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="concurrent-ruby (v1.3.6, rbenv: 4.0.5) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="minitest (v5.27.0, rbenv: 4.0.5) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="openssl (v4.0.2, rbenv: 4.0.5) [gem]" level="application" />

data/PUBLISH.md

@@ -9,7 +9,7 @@ bundle install
 ```
 gem build saro-dat.gemspec
 gem signin
-gem push saro-dat-1.0.0.gem
+gem push saro-dat-4.0.0.gem
 ```
 
 ## install
@@ -23,10 +23,16 @@ source ~/.zshrc
 # - mac
 
 rbenv install -l
-rbenv install 2.7.8
 rbenv install 4.0.5
 rbenv local 4.0.5
 rbenv rehash
 
 ruby -v
 ```
+
+
+## install test
+```
+bundle add saro-dat
+bundle install
+```

data/README.md

@@ -8,18 +8,23 @@
 
 ### [Example](https://dat.saro.me/--/libs/gems-saro-dat)
 
-## support signature algorithm
-| name   | algorithm  |
-|--------|------------|
-| P256   | secp256r1  |
-| P384   | secp384r1  |
-| P521   | secp521r1  |
+## Support algorithm
+### Signature
+| name            | note                  |
+|-----------------|-----------------------|
+| ECDSA-P256      | = secp256r1           |
+| ECDSA-P384      | = secp384r1           |
+| ECDSA-P521      | = secp521r1           |
+| HMAC-SHA256-MFS | = 256Bit Fixed Secret |
+| HMAC-SHA384-MFS | = 384Bit Fixed Secret |
+| HMAC-SHA512-MFS | = 512Bit Fixed Secret |
+- MFS : Maximum(Same Bit) Fixed Secret
 
-## support crypto algorithm
-| name       | algorithm                   |
-|------------|-----------------------------|
-| AES128GCMN | aes-128-gcm n(nonce + body) |
-| AES256GCMN | aes-256-cbc n(nonce + body) |
+### Crypto
+| name       | note                          |
+|------------|-------------------------------|
+| IV-AES128-GCM | (IV=NONCE:96BIT) + AES128 GCM |
+| IV-AES256-GCM | (IV=NONCE:96BIT) + AES256 GCM |
 
 
 # Performance
@@ -29,34 +34,58 @@
 ```
 Testing started at ...
 Performance Test (Plain, Secure)
-Plain: orSsnyfSfREmqzSp25qVE0XEXHBa1FgprEq75OBss5MH61jnWXMYypt4GOOLC6ZF29XUJapVv5X3p2gzBG5fLREFRqJdMaKrZoFi
-Secure: 8SkeUWIcp3Q2I104LgCpDZ4CZ6Uwd21j2QPerHtw5RRN2kPns6wwxjdipCCt5l9QdforbqqjQu5BfevfeC1id6OlBjPPHcF9oMpb
+Plain: CcMjua0RA8I27be6W2lYMBmk5OcPrV8mu3ybrVwBOB2pEPbtfrvH0h0Z0VBhG1ID4zu51sDKxZZGFoku9TzrcPJLbb0ObRiF3NIF
+Secure: EEYEOjriFkidJ8lKpYPkt1fwS01sZuJ7ysgCWd7XyarZfP6yrxkR9rciiJSUpuPZlBt0moFlKb0n2ZDivhvxLNjmO1eT8KjzhLlA
 
 --- Multi-Thread ---
-P256 AES128GCMN Issue * 10000 : 158ms
-P256 AES128GCMN Parse * 10000 : 201ms
-P256 AES256GCMN Issue * 10000 : 154ms
-P256 AES256GCMN Parse * 10000 : 187ms
-P384 AES128GCMN Issue * 10000 : 288ms
-P384 AES128GCMN Parse * 10000 : 450ms
-P384 AES256GCMN Issue * 10000 : 268ms
-P384 AES256GCMN Parse * 10000 : 613ms
-P521 AES128GCMN Issue * 10000 : 405ms
-P521 AES128GCMN Parse * 10000 : 553ms
-P521 AES256GCMN Issue * 10000 : 370ms
-P521 AES256GCMN Parse * 10000 : 609ms
+HMAC-SHA256-MFS IV-AES128-GCM Issue * 10000 : 141ms
+HMAC-SHA256-MFS IV-AES128-GCM Parse * 10000 : 148ms
+HMAC-SHA256-MFS IV-AES256-GCM Issue * 10000 : 126ms
+HMAC-SHA256-MFS IV-AES256-GCM Parse * 10000 : 161ms
+HMAC-SHA384-MFS IV-AES128-GCM Issue * 10000 : 162ms
+HMAC-SHA384-MFS IV-AES128-GCM Parse * 10000 : 155ms
+HMAC-SHA384-MFS IV-AES256-GCM Issue * 10000 : 126ms
+HMAC-SHA384-MFS IV-AES256-GCM Parse * 10000 : 146ms
+HMAC-SHA512-MFS IV-AES128-GCM Issue * 10000 : 124ms
+HMAC-SHA512-MFS IV-AES128-GCM Parse * 10000 : 132ms
+HMAC-SHA512-MFS IV-AES256-GCM Issue * 10000 : 128ms
+HMAC-SHA512-MFS IV-AES256-GCM Parse * 10000 : 149ms
+ECDSA-P256 IV-AES128-GCM Issue * 10000 : 171ms
+ECDSA-P256 IV-AES128-GCM Parse * 10000 : 188ms
+ECDSA-P256 IV-AES256-GCM Issue * 10000 : 158ms
+ECDSA-P256 IV-AES256-GCM Parse * 10000 : 188ms
+ECDSA-P384 IV-AES128-GCM Issue * 10000 : 260ms
+ECDSA-P384 IV-AES128-GCM Parse * 10000 : 422ms
+ECDSA-P384 IV-AES256-GCM Issue * 10000 : 259ms
+ECDSA-P384 IV-AES256-GCM Parse * 10000 : 415ms
+ECDSA-P521 IV-AES128-GCM Issue * 10000 : 307ms
+ECDSA-P521 IV-AES128-GCM Parse * 10000 : 475ms
+ECDSA-P521 IV-AES256-GCM Issue * 10000 : 311ms
+ECDSA-P521 IV-AES256-GCM Parse * 10000 : 481ms
 
 --- Single-Thread ---
-P256 AES128GCMN Issue * 10000 : 200ms
-P256 AES128GCMN Parse * 10000 : 415ms
-P256 AES256GCMN Issue * 10000 : 199ms
-P256 AES256GCMN Parse * 10000 : 406ms
-P384 AES128GCMN Issue * 10000 : 1054ms
-P384 AES128GCMN Parse * 10000 : 2151ms
-P384 AES256GCMN Issue * 10000 : 1053ms
-P384 AES256GCMN Parse * 10000 : 2163ms
-P521 AES128GCMN Issue * 10000 : 1420ms
-P521 AES128GCMN Parse * 10000 : 2414ms
-P521 AES256GCMN Issue * 10000 : 1420ms
-P521 AES256GCMN Parse * 10000 : 2458ms
+HMAC-SHA256-MFS IV-AES128-GCM Issue * 10000 : 64ms
+HMAC-SHA256-MFS IV-AES128-GCM Parse * 10000 : 65ms
+HMAC-SHA256-MFS IV-AES256-GCM Issue * 10000 : 60ms
+HMAC-SHA256-MFS IV-AES256-GCM Parse * 10000 : 68ms
+HMAC-SHA384-MFS IV-AES128-GCM Issue * 10000 : 66ms
+HMAC-SHA384-MFS IV-AES128-GCM Parse * 10000 : 83ms
+HMAC-SHA384-MFS IV-AES256-GCM Issue * 10000 : 64ms
+HMAC-SHA384-MFS IV-AES256-GCM Parse * 10000 : 67ms
+HMAC-SHA512-MFS IV-AES128-GCM Issue * 10000 : 62ms
+HMAC-SHA512-MFS IV-AES128-GCM Parse * 10000 : 67ms
+HMAC-SHA512-MFS IV-AES256-GCM Issue * 10000 : 66ms
+HMAC-SHA512-MFS IV-AES256-GCM Parse * 10000 : 68ms
+ECDSA-P256 IV-AES128-GCM Issue * 10000 : 192ms
+ECDSA-P256 IV-AES128-GCM Parse * 10000 : 403ms
+ECDSA-P256 IV-AES256-GCM Issue * 10000 : 188ms
+ECDSA-P256 IV-AES256-GCM Parse * 10000 : 404ms
+ECDSA-P384 IV-AES128-GCM Issue * 10000 : 1049ms
+ECDSA-P384 IV-AES128-GCM Parse * 10000 : 2157ms
+ECDSA-P384 IV-AES256-GCM Issue * 10000 : 1060ms
+ECDSA-P384 IV-AES256-GCM Parse * 10000 : 2155ms
+ECDSA-P521 IV-AES128-GCM Issue * 10000 : 1374ms
+ECDSA-P521 IV-AES128-GCM Parse * 10000 : 2428ms
+ECDSA-P521 IV-AES256-GCM Issue * 10000 : 1368ms
+ECDSA-P521 IV-AES256-GCM Parse * 10000 : 2417ms
 ```

data/lib/saro/dat/crypto.rb

@@ -7,8 +7,8 @@ require_relative 'util'
 module Saro
   module Dat
     class DatCryptoAlgorithm
-      AES128GCMN = "AES128GCMN"
-      AES256GCMN = "AES256GCMN"
+      AES128GCMN = "IV-AES128-GCM"
+      AES256GCMN = "IV-AES256-GCM"
 
       def self.all
         [AES128GCMN, AES256GCMN]
@@ -16,8 +16,8 @@ module Saro
     end
 
     CRYPTO_CONFIG = {
-      "AES128GCMN" => { name: "aes-128-gcm", length: 16 },
-      "AES256GCMN" => { name: "aes-256-gcm", length: 32 }
+      "IV-AES128-GCM" => { name: "aes-128-gcm", length: 16 },
+      "IV-AES256-GCM" => { name: "aes-256-gcm", length: 32 }
     }.freeze
 
     def self.get_crypto_config(algorithm)
@@ -26,7 +26,7 @@ module Saro
       raise ArgumentError, "Unsupported DAT Crypto Algorithm: #{algorithm}"
     end
 
-    class DatCryptoKey
+    class DatCrypto
       attr_reader :algorithm
 
       def initialize(algorithm, key_bytes, config = nil)
@@ -41,12 +41,13 @@ module Saro
         new(algorithm, key_bytes, config)
       end
 
-      def self.imports(algorithm, raw)
-        new(algorithm, raw)
+      def self.imports(algorithm, base64_str)
+        key_bytes = Saro::Dat::Util.decode_base64_url(base64_str)
+        new(algorithm, key_bytes)
       end
 
       def exports
-        @key_bytes
+        Saro::Dat::Util.encode_base64_url_str(@key_bytes)
       end
 
       def encrypt(data)
@@ -87,13 +88,9 @@ module Saro
         cipher.iv = nonce
         cipher.auth_tag = tag
 
-        begin
-          res = cipher.update(ciphertext) + cipher.final
-          res.force_encoding('BINARY')
-          res
-        rescue OpenSSL::Cipher::CipherError => e
-          raise ArgumentError, "Decryption failed: #{e.message}"
-        end
+        res = cipher.update(ciphertext) + cipher.final
+        res.force_encoding('BINARY')
+        res
       end
     end
   end

data/lib/saro/dat/dat.rb

@@ -38,11 +38,13 @@ module Saro
         new(value)
       end
 
-      def expired?
+      def expired
         return true unless @format
         Time.now.to_i > @expire
       end
 
+      alias_method :expired?, :expired
+
       def body_string
         return "" unless @dat.include?('.')
         @dat.rpartition('.').first

data/lib/saro/dat/dat_certificate.rb

@@ -9,51 +9,74 @@ module Saro
     class DatCertificate
       attr_reader :cid, :signature_key, :crypto_key, :dat_issue_begin, :dat_issue_end, :dat_ttl
 
-      def initialize(cid, signature_key, crypto_key, dat_issue_begin, dat_issue_end, dat_ttl)
+      def initialize(cid, issued_at, issuance_duration, dat_ttl, signature_key, crypto_key)
         @cid = cid
+        @dat_issue_begin = issued_at
+        @dat_issue_end = issued_at + issuance_duration
+        @dat_ttl = dat_ttl
         @signature_key = signature_key
         @crypto_key = crypto_key
-        @dat_issue_begin = dat_issue_begin
-        @dat_issue_end = dat_issue_end
-        @dat_ttl = dat_ttl
       end
 
-      def exports(option)
+      def exports(verify_only = false)
         cid_hex = @cid.to_s(16)
+        issued_at = @dat_issue_begin.to_s
+        issuance_duration = (@dat_issue_end - @dat_issue_begin).to_s
+        ttl = @dat_ttl.to_s
         sig_alg = @signature_key.algorithm
-        sig_key = @signature_key.exports(option)
         cry_alg = @crypto_key.algorithm
-        cry_key = Saro::Dat::Util.encode_base64_url_str(@crypto_key.exports)
+        sig_key = @signature_key.exports(verify_only)
+        cry_key = @crypto_key.exports
+
+        "#{cid_hex}.#{issued_at}.#{issuance_duration}.#{ttl}.#{sig_alg}.#{cry_alg}.#{sig_key}.#{cry_key}"
+      end
 
-        "#{cid_hex}.#{sig_alg}.#{sig_key}.#{cry_alg}.#{cry_key}.#{@dat_issue_begin}.#{@dat_issue_end}.#{@dat_ttl}"
+      def self.generate(cid, issued_at, issuance_duration, dat_ttl, signature_algorithm, crypto_algorithm)
+        new(
+          cid, issued_at, issuance_duration, dat_ttl,
+          Saro::Dat::DatSignature.generate(signature_algorithm),
+          Saro::Dat::DatCrypto.generate(crypto_algorithm)
+        )
       end
 
       def self.imports(format_str)
-        split = format_str.split(".")
-        raise ArgumentError, "Invalid Certificate format" if split.length != 8
+        parts = format_str.split(".")
+        raise ArgumentError, "Invalid Certificate format" if parts.length != 8
 
-        cid = split[0].to_i(16)
-        sig_key = Saro::Dat::DatSignatureKey.imports(split[1], split[2])
-        cry_key = Saro::Dat::DatCryptoKey.imports(split[3], Saro::Dat::Util.decode_base64_url(split[4]))
+        cid = parts[0].to_i(16)
+        issued_at = parts[1].to_i
+        issuance_duration = parts[2].to_i
+        ttl = parts[3].to_i
+        sig_algo = parts[4]
+        cry_algo = parts[5]
+        signature_key = Saro::Dat::DatSignature.imports(sig_algo, parts[6])
+        crypto_key = Saro::Dat::DatCrypto.imports(cry_algo, parts[7])
 
-        new(
-          cid, sig_key, cry_key,
-          split[5].to_i, split[6].to_i, split[7].to_i
-        )
+        new(cid, issued_at, issuance_duration, ttl, signature_key, crypto_key)
       end
 
-      def issuable?
+      def issuable
         now = Time.now.to_i
-        has_signing_key? && @dat_issue_begin <= now && now <= @dat_issue_end
+        signable && @dat_issue_begin <= now && now <= @dat_issue_end
       end
 
-      def expired?
+      def expired
         Time.now.to_i > (@dat_issue_end + @dat_ttl)
       end
 
-      def has_signing_key?
-        @signature_key.has_signing_key?
+      def signable
+        @signature_key.signable
       end
+
+      def pair
+        @signature_key.pair
+      end
+
+      # For Ruby conventions
+      alias_method :issuable?, :issuable
+      alias_method :expired?, :expired
+      alias_method :signable?, :signable
+      alias_method :pair?, :pair
     end
   end
 end

data/lib/saro/dat/dat_manager.rb

@@ -26,7 +26,7 @@ module Saro
           input_certs.each do |cert|
             raise ArgumentError, "Duplicate CID: #{cert.cid}" if seen_cids.include?(cert.cid)
             seen_cids.add(cert.cid)
-            next if cert.expired?
+            next if cert.expired
             next if before_cids.include?(cert.cid)
             
             certificates << cert
@@ -35,7 +35,7 @@ module Saro
           certificates.sort_by!(&:dat_issue_end)
           
           # Find latest issuable certificate as issuer
-          issuer = certificates.reverse_each.find(&:issuable?)
+          issuer = certificates.reverse_each.find(&:issuable)
 
           @issuer = issuer
           @certificates = certificates
@@ -52,9 +52,9 @@ module Saro
         import_certificates(certs, clear: clear)
       end
 
-      def exports(option)
+      def exports(verify_only = false)
         @lock.with_read_lock do
-          @certificates.map { |cert| cert.exports(option) }.join("\n")
+          @certificates.map { |cert| cert.exports(verify_only) }.join("\n")
         end
       end
 

data/lib/saro/dat/signature.rb

@@ -6,25 +6,25 @@ require_relative 'util'
 module Saro
   module Dat
     class DatSignatureAlgorithm
-      P256 = "P256"
-      P384 = "P384"
-      P521 = "P521"
+      HMAC_SHA256_MFS = "HMAC-SHA256-MFS"
+      HMAC_SHA384_MFS = "HMAC-SHA384-MFS"
+      HMAC_SHA512_MFS = "HMAC-SHA512-MFS"
+      P256 = "ECDSA-P256"
+      P384 = "ECDSA-P384"
+      P521 = "ECDSA-P521"
 
       def self.all
-        [P256, P384, P521]
+        [HMAC_SHA256_MFS, HMAC_SHA384_MFS, HMAC_SHA512_MFS, P256, P384, P521]
       end
     end
 
-    class DatSignatureKeyExportOption
-      PAIR = "PAIR"
-      SIGNING = "SIGNING"
-      VERIFYING = "VERIFYING"
-    end
-
     SIGNATURE_CONFIG = {
-      "P256" => { curve: "prime256v1", hash: "SHA256" },
-      "P384" => { curve: "secp384r1", hash: "SHA384" },
-      "P521" => { curve: "secp521r1", hash: "SHA512" }
+      "HMAC-SHA256-MFS" => { name: "HMAC", hash: "SHA256", hmac_len: 32 },
+      "HMAC-SHA384-MFS" => { name: "HMAC", hash: "SHA384", hmac_len: 48 },
+      "HMAC-SHA512-MFS" => { name: "HMAC", hash: "SHA512", hmac_len: 64 },
+      "ECDSA-P256" => { name: "ECDSA", curve: "prime256v1", hash: "SHA256", private_len: 32, public_len: 65 },
+      "ECDSA-P384" => { name: "ECDSA", curve: "secp384r1", hash: "SHA384", private_len: 48, public_len: 97 },
+      "ECDSA-P521" => { name: "ECDSA", curve: "secp521r1", hash: "SHA512", private_len: 66, public_len: 133 }
     }.freeze
 
     def self.get_signature_config(algorithm)
@@ -33,13 +33,7 @@ module Saro
       raise ArgumentError, "Unsupported DAT Crypto Algorithm: #{algorithm}"
     end
 
-    CURVE_OIDS = {
-      "prime256v1" => "1.2.840.10045.3.1.7",
-      "secp384r1" => "1.3.132.0.34",
-      "secp521r1" => "1.3.132.0.35"
-    }.freeze
-
-    class DatSignatureKey
+    class DatSignature
       attr_reader :algorithm, :signing_key, :verifying_key
 
       def initialize(algorithm, signing_key, verifying_key, config = nil)
@@ -51,13 +45,6 @@ module Saro
 
       private_class_method def self.create_ec_key(curve_name, priv_bn = nil, pub_octet = nil)
         if priv_bn
-          # EC Private Key structure (SEC1)
-          # ECPrivateKey ::= SEQUENCE {
-          #   version        INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),
-          #   privateKey     OCTET STRING,
-          #   parameters [0] EXPLICIT ECParameters {{ NamedCurve }} OPTIONAL,
-          #   publicKey  [1] EXPLICIT BIT STRING OPTIONAL
-          # }
           group = OpenSSL::PKey::EC::Group.new(curve_name)
           pub_octet ||= group.generator.mul(priv_bn).to_octet_string(:uncompressed)
           
@@ -69,14 +56,6 @@ module Saro
           ])
           OpenSSL::PKey::EC.new(asn1.to_der)
         elsif pub_octet
-          # SubjectPublicKeyInfo
-          # SEQUENCE {
-          #   SEQUENCE {
-          #     OBJECT IDENTIFIER id-ecPublicKey (1.2.840.10045.2.1)
-          #     OBJECT IDENTIFIER namedCurve
-          #   }
-          #   BIT STRING publicKey
-          # }
           spki = OpenSSL::ASN1::Sequence.new([
             OpenSSL::ASN1::Sequence.new([
               OpenSSL::ASN1::ObjectId.new("id-ecPublicKey"),
@@ -92,75 +71,64 @@ module Saro
 
       def self.generate(algorithm)
         config = Saro::Dat.get_signature_config(algorithm)
-        key = OpenSSL::PKey::EC.generate(config[:curve])
-        new(algorithm, key, key, config)
+        if config[:name] == "HMAC"
+          key = OpenSSL::Random.random_bytes(config[:hmac_len])
+          new(algorithm, key, key, config)
+        else
+          key = OpenSSL::PKey::EC.generate(config[:curve])
+          new(algorithm, key, key, config)
+        end
       end
 
-      def self.imports(algorithm, format_str)
+      def self.imports(algorithm, base64_str)
         config = Saro::Dat.get_signature_config(algorithm)
-        parts = format_str.split("~", -1)
-        
-        unless (1..2).cover?(parts.length)
-          raise ArgumentError, "Invalid DAT Signature Key Format: No keys found"
-        end
-
-        signing_key = nil
-        verifying_key = nil
+        bytes_data = Saro::Dat::Util.decode_base64_url(base64_str)
 
-        if parts[0] && !parts[0].empty?
-          d_bytes = Saro::Dat::Util.decode_base64_url(parts[0])
-          d_value = OpenSSL::BN.new(d_bytes, 2)
-          
-          # Handle public key if provided in parts[1] for signing key as well
-          v_octet = if parts.length == 2 && parts[1] && !parts[1].empty?
-                      Saro::Dat::Util.decode_base64_url(parts[1])
-                    end
-
-          signing_key = create_ec_key(config[:curve], d_value, v_octet)
-          verifying_key = signing_key
-        end
-
-        if parts.length == 2 && parts[1] && !parts[1].empty?
-          unless signing_key
-            public_bytes = Saro::Dat::Util.decode_base64_url(parts[1])
-            verifying_key = create_ec_key(config[:curve], nil, public_bytes)
+        if config[:name] == "HMAC"
+          if bytes_data.bytesize != config[:hmac_len]
+            raise ArgumentError, "Invalid HMAC key length: expected #{config[:hmac_len]}, got #{bytes_data.bytesize}"
+          end
+          new(algorithm, bytes_data, bytes_data, config)
+        else
+          private_len = config[:private_len]
+          public_len = config[:public_len]
+
+          signing_key = nil
+          verifying_key = nil
+
+          if bytes_data.bytesize == private_len + public_len
+            private_bytes = bytes_data[0, private_len]
+            public_bytes = bytes_data[private_len, public_len]
+            
+            d_value = OpenSSL::BN.new(private_bytes, 2)
+            signing_key = create_ec_key(config[:curve], d_value, public_bytes)
+            verifying_key = signing_key
+          elsif bytes_data.bytesize == public_len
+            verifying_key = create_ec_key(config[:curve], nil, bytes_data)
+          else
+            raise ArgumentError, "Invalid ECDSA key length"
           end
-        elsif !signing_key
-          raise ArgumentError, "Invalid DAT Signature Key Format: No keys found"
-        end
 
-        new(algorithm, signing_key, verifying_key, config)
+          new(algorithm, signing_key, verifying_key, config)
+        end
       end
 
-      def exports(option)
-        rv_parts = ["", ""]
-
-        if [DatSignatureKeyExportOption::PAIR, DatSignatureKeyExportOption::SIGNING].include?(option)
-          if @signing_key&.private_key
+      def exports(verify_only = false)
+        if @config[:name] == "HMAC"
+          Saro::Dat::Util.encode_base64_url_str(@verifying_key)
+        else
+          if verify_only || !@signing_key&.private_key
+            public_bytes = @verifying_key.public_key.to_octet_string(:uncompressed)
+            Saro::Dat::Util.encode_base64_url_str(public_bytes)
+          else
             d_value = @signing_key.private_key
-            # Ensure fixed length padding
             curve_size = (@signing_key.group.degree + 7) / 8
             d_bytes = d_value.to_s(2).rjust(curve_size, "\x00".b)
-            rv_parts[0] = Saro::Dat::Util.encode_base64_url_str(d_bytes)
-          elsif option == DatSignatureKeyExportOption::SIGNING
-            raise ArgumentError, "Signature key is not supported - verifying only key"
+            
+            public_bytes = @verifying_key.public_key.to_octet_string(:uncompressed)
+            Saro::Dat::Util.encode_base64_url_str(d_bytes + public_bytes)
           end
         end
-
-        if [DatSignatureKeyExportOption::PAIR, DatSignatureKeyExportOption::VERIFYING].include?(option)
-          # Uncompressed point: 0x04 + R + S
-          public_bytes = @verifying_key.public_key.to_octet_string(:uncompressed)
-          rv_parts[1] = Saro::Dat::Util.encode_base64_url_str(public_bytes)
-        end
-
-        case option
-        when DatSignatureKeyExportOption::SIGNING
-          rv_parts[0]
-        when DatSignatureKeyExportOption::VERIFYING
-          "~#{rv_parts[1]}"
-        else
-          "#{rv_parts[0]}~#{rv_parts[1]}"
-        end
       end
 
       def sign(body)
@@ -168,10 +136,13 @@ module Saro
         body = body.encode('utf-8') if body.is_a?(String) && body.encoding != Encoding::BINARY
         raise ArgumentError, "Sign Error - body is empty" if body.nil? || body.empty?
 
-        digest = OpenSSL::Digest.new(@config[:hash])
-        signature_der = @signing_key.dsa_sign_asn1(digest.digest(body))
-        
-        der_to_raw_signature(signature_der)
+        if @config[:name] == "HMAC"
+          OpenSSL::HMAC.digest(@config[:hash], @signing_key, body)
+        else
+          digest = OpenSSL::Digest.new(@config[:hash])
+          signature_der = @signing_key.dsa_sign_asn1(digest.digest(body))
+          der_to_raw_signature(signature_der)
+        end
       end
 
       def verify(body, signature)
@@ -184,19 +155,33 @@ module Saro
                       signature
                     end
 
-        begin
-          der_sig = raw_to_der_signature(sig_bytes)
-          digest = OpenSSL::Digest.new(@config[:hash])
-          @verifying_key.dsa_verify_asn1(digest.digest(body), der_sig)
-        rescue StandardError
-          false
+        if @config[:name] == "HMAC"
+          begin
+            actual_sig = OpenSSL::HMAC.digest(@config[:hash], @verifying_key, body)
+            # Use fixed-time comparison if possible
+            return actual_sig == sig_bytes
+          rescue StandardError
+            return false
+          end
+        else
+          begin
+            der_sig = raw_to_der_signature(sig_bytes)
+            digest = OpenSSL::Digest.new(@config[:hash])
+            @verifying_key.dsa_verify_asn1(digest.digest(body), der_sig)
+          rescue StandardError
+            false
+          end
         end
       end
 
-      def has_signing_key?
+      def signable
         !@signing_key.nil?
       end
 
+      def pair
+        @config[:name] == "ECDSA"
+      end
+
       private
 
       def der_to_raw_signature(signature_der)

data/saro-dat.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "saro-dat"
-  spec.version       = "1.0.0"
+  spec.version       = "4.0.0"
   spec.authors       = ["marker"]
   spec.email         = ["j@saro.me"]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: saro-dat
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - marker
@@ -106,7 +106,6 @@ files:
 - ".idea/saro-dat.iml"
 - ".ruby-version"
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - PUBLISH.md
 - README.md
@@ -140,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.12
 specification_version: 4
 summary: DAT (Data Access Token) Ruby implementation
 test_files: []

data/Gemfile.lock

@@ -1,39 +0,0 @@
-PATH
-  remote: .
-  specs:
-    saro-dat (1.0.0)
-      base64
-      concurrent-ruby (~> 1.3.6)
-      openssl (~> 4.0.2)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    base64 (0.3.0)
-    benchmark (0.5.0)
-    concurrent-ruby (1.3.6)
-    minitest (5.27.0)
-    openssl (4.0.2)
-    parallel (2.1.0)
-
-PLATFORMS
-  arm64-darwin-25
-  ruby
-
-DEPENDENCIES
-  benchmark
-  minitest (~> 5.0)
-  parallel
-  saro-dat!
-
-CHECKSUMS
-  base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  benchmark (0.5.0) sha256=465df122341aedcb81a2a24b4d3bd19b6c67c1530713fd533f3ff034e419236c
-  concurrent-ruby (1.3.6) sha256=6b56837e1e7e5292f9864f34b69c5a2cbc75c0cf5338f1ce9903d10fa762d5ab
-  minitest (5.27.0) sha256=2d3b17f8a36fe7801c1adcffdbc38233b938eb0b4966e97a6739055a45fa77d5
-  openssl (4.0.2) sha256=1037ad2868ae58df9ad917891c0c0f9815a1172f6846d4bcdd508e4c2ee747c2
-  parallel (2.1.0) sha256=b35258865c2e31134c5ecb708beaaf6772adf9d5efae28e93e99260877b09356
-  saro-dat (1.0.0)
-
-BUNDLED WITH
-  4.0.10