protocol-zmtp 0.10.3 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad013d03184eae1f5298d9ebbd5bc9a1fd2657ac7c45002a298547b36ad7f63d
-  data.tar.gz: 137204024322094d2e76ef7103444e27143c18176b8a19b06c7e978c0b1fccd1
+  metadata.gz: c8d53545d14bf02a264d165e08adb9ab22b1f948a614856644dea0a093dc1da5
+  data.tar.gz: cf71224105abc69d8cd6df5d2ab5e45cdcbed0c88ff257a6325fdd3deeb8312c
 SHA512:
-  metadata.gz: 8ddbde5122489f94110878c0854167627a39207aa3c428aafdbec536dbcbcd39e0c9522ab23a97dc464766c0a42f7b8d6cf4689322486355880b53aa1def6385
-  data.tar.gz: 6f069bf0af5fdff20496f376ed792bd2e3059cb64c1374674eaf7fbbbcaf2226b2f8cf69f9be9b49d994b7ab0a2e0fca26373248572b65db36653bba40846395
+  metadata.gz: 677c05b2057178c6c388805c53c9dd1b314c06a4c436cf448b1d0fa2f2cdc6515c7818e0f3995a398b336487bebf74f6c00f8380837f635fd9377e1c11d8b3b1
+  data.tar.gz: 912e32a6301493475a676952ad1ac1c9ddff7e1f68e0b5415b20fd344dfe32d3e887d51faa00a0dce1f8fe4fb219cd50f899517e21a5c0b47dfd33b1140b3cb9

data/CHANGELOG.md

@@ -0,0 +1,311 @@
+# Changelog
+
+## Unreleased
+
+## [0.10.5] - 2026-10-15
+
+### Added
+
+- Allow updating `Connection#max_message_size` after the handshake so
+  compressed transports can bound wire envelopes separately from messages.
+
+### Fixed
+
+- Reject invalid frame flags, lengths above 2^63-1, and malformed PING commands.
+- Match handshake metadata names case-insensitively for NULL, PLAIN, and CURVE.
+- Raise `FatalHandshakeError` on handshake ERROR responses and send ERROR when
+  PLAIN authentication rejects credentials.
+
+## 0.10.4 - 2026-07-23
+
+### Changed
+
+- Release source is now the `zeromq/omq.rb` monorepo.
+
+## 0.10.3 — 2026-05-30
+
+### Fixed
+
+- **CURVE: COMMAND flag in encrypted inner byte must be 0x02, not 0x04.**
+  CurveZMQ's inner plaintext flags byte uses a compact layout where
+  bit 1 (0x02) means COMMAND, but encrypt/decrypt used the wire-level
+  COMMAND bit (0x04). This broke interop with libzmq: a CURVE-encrypted
+  SUBSCRIBE from a libzmq SUB was treated as data and silently dropped,
+  so the PUB never registered the subscription.
+
+## 0.10.2 — 2026-05-28
+
+- Bump version (was missed in 0.10.1).
+
+## 0.10.1 — 2026-05-28
+
+### Added
+
+- **`Connection#write_wire_batch`** writes multiple pre-encoded wire
+  byte strings under a single mutex acquisition, amortizing lock
+  overhead for fan-out send pumps.
+
+### Changed
+
+- **Single-write short frames.** Frames with bodies <= 255 bytes now
+  combine the 2-byte header and body into one `@io.write` call,
+  halving per-frame io-stream mutex overhead (+5-7% small-message
+  TCP throughput).
+
+### Fixed
+
+- **NULL mechanism greeting: `as-server` field is now always 0.**
+  RFC 23 requires `as-server = 0` for the NULL mechanism, but the
+  server side was forwarding the caller's flag (`0x01`). This broke
+  interoperability with strict ZMTP 3.x peers that validate the field.
+
+## 0.10.0 — 2026-04-20
+
+### Added
+
+- **`PeerInfo` extended with `identity`.** `PeerInfo = Data.define(:public_key, :identity)`
+  now bundles both post-handshake peer anchors. CURVE authenticators
+  still receive a `PeerInfo` during auth (with `identity: ""`, since
+  identity arrives post-auth).
+- **`Connection#peer_info`.** After a successful handshake, returns a
+  frozen `PeerInfo` combining the peer's CURVE public key (if any) and
+  `ZMQ_IDENTITY`. Usable directly as a Hash key. Nil before handshake.
+  Upper layers (e.g. omq-qos levels 2/3) use the whole value as a
+  stable per-peer identifier across reconnects.
+- **Mechanism return hashes carry `peer_public_key`.** Both
+  `Mechanism::Null#handshake!` and `Mechanism::Curve` handshake paths now
+  return `peer_public_key:` alongside `peer_identity:` etc. (nil for
+  NULL; the peer's long-term `crypto::PublicKey` for CURVE).
+
+### Changed
+
+- **Drop hot-path binary-encoding coercion and frame-body freezes.**
+  `Frame#initialize` and `Frame.encode_message` no longer copy non-binary
+  bodies via `String#b` — callers (OMQ's `Writable#send`, ZMTP command
+  builders) already hand in binary bytes, and for an outgoing message the
+  receiver (`String.new(capacity:) << body`) treats any encoding as raw
+  bytes once the buffer itself is binary. `Connection#receive_message`
+  also stops freezing each frame body and the returned parts array; the
+  caller decides what to freeze. Net effect: fewer allocations per
+  message and no per-part `.freeze` on the receive path.
+
+## 0.9.0 — 2026-04-18
+
+### Changed
+
+- **`Frame.read_from` uses `io.peek` to collapse the long-frame read
+  path.** The previous implementation issued 2 `read_exactly` calls for
+  short frames (header + body) and 3 for long frames (2-byte header,
+  remaining 7 size bytes, body). It now peeks just enough header bytes
+  (2 for short, 9 for long), decodes the size from the peek buffer, and
+  drains header + body in a single `read_exactly(header_size + size)`.
+  Long frames drop to the same 2-call read path as short frames; the
+  `read_long_size` helper is gone. A speculative `read_exactly(9)` would
+  not be safe here — a <7-byte short frame at idle would hang waiting
+  for bytes that never arrive, or steal bytes from the next frame on a
+  mixed stream.
+
+- **Transport IO must now also respond to `#peek`** in addition to
+  `#read_exactly`, `#write`, `#flush`, and `#close`. `io-stream`'s
+  `Async::IO::Stream` already provides this; custom transport wrappers
+  need a `#peek(&block)` that yields the current read buffer and fills
+  it until the block returns truthy.
+
+## 0.8.1 — 2026-04-16
+
+### Changed
+
+- **`Frame#initialize` skips redundant `.b` copy.** Body is now kept
+  as-is when it is already `Encoding::BINARY`, avoiding a per-frame
+  String allocation on the read path (`read_exactly` and `byteslice`
+  already return binary strings).
+
+- **`Frame#to_wire` uses `String.new(capacity:)` with `<<` appends**
+  instead of `+` concatenation, reducing from 3 intermediate String
+  allocations per frame to 1 pre-sized buffer.
+
+- **`Frame.encode_message` pre-computes wire size** for the output
+  buffer `capacity:` hint, avoiding re-allocations during fan-out.
+  Single-part messages (the common case) skip the iteration and
+  inline the size calculation.
+
+- **`Command.ping` / `.pong` default to `EMPTY_BINARY`** instead of
+  `"".b`, which allocated a mutable copy on every call despite
+  `frozen_string_literal: true`. `#ping_ttl_and_context` uses
+  `EMPTY_BINARY` for the empty-context fallback.
+
+- **`Subscription.body` drops redundant outer `.b`** — both operands
+  are already binary, so the concatenation result is binary without
+  a second encoding conversion.
+
+## 0.8.0 — 2026-04-15
+
+### Added
+
+- **`Codec::Subscription`** — helper module that unifies ZMTP 3.0
+  message-form (`\x01`/`\x00` + prefix data frame) and ZMTP 3.1
+  command-form (`SUBSCRIBE`/`CANCEL` command frame) subscription
+  encodings. `.body(prefix, cancel:)` builds the message-form body;
+  `.parse(frame)` returns `[:subscribe|:cancel, prefix]` for either
+  form, letting upper layers accept both without branching.
+- **`Connection#peer_major` / `#peer_minor`** — ZMTP wire revision of
+  the peer, captured from the greeting. Lets upper layers pick the
+  subscription wire form (and other version-gated features) per peer.
+  Populated by `Mechanism::Null`, `Mechanism::Plain`, and
+  `Mechanism::Curve` via their handshake result hash.
+- **`Codec::Greeting.read_from(io)`** — reads the 11-byte signature
+  phase first, validates the revision byte, then reads the rest of
+  the 64-byte greeting. A ZMTP/2.0 peer (revision `0x01`) is now
+  rejected loudly with `unsupported ZMTP revision 0x01 (ZMTP/2.x);
+  need revision >= 3`, instead of hanging forever in `read_exactly`
+  waiting for bytes that never arrive.
+
+### Changed
+
+- **Greeting error messages** refer to the ZMTP *revision byte*
+  (`0x03`) rather than a "version #{major}.#{minor}" — the byte at
+  offset 10 is the wire revision, which only accidentally matches the
+  spec major in ZMTP/3.x.
+
+## 0.7.1 — 2026-04-14
+
+### Changed
+
+- **Short-frame read fast path.** `Frame.read_from` now fetches the
+  2-byte header (flags + first size byte) in a single `read_exactly`
+  call instead of two separate 1-byte reads. Short frames (≤255 bytes,
+  the vast majority of ZMTP traffic) now hit a 2-call read path
+  (header + body) instead of 3. Long frames read the remaining 7 size
+  bytes via the extracted `read_long_size` helper.
+
+## 0.7.0 — 2026-04-13
+
+### Added
+
+- **Extension metadata hook on the handshake mechanisms.** `Mechanism::Null`,
+  `Mechanism::Plain`, and `Mechanism::Curve` expose a `metadata` accessor
+  (`Hash{String => String}`) that upper layers can populate before
+  `#handshake!`. Any entries are merged into the outgoing READY properties
+  (and INITIATE, for CURVE/PLAIN client side). `Codec::Command.ready` gained
+  a matching `metadata:` kwarg. Used by `omq-rfc-zstd` to advertise the
+  `X-Compression` property without forking the handshake code path.
+
+- **`Connection#peer_properties`.** The full peer READY property hash is
+  now retained after a successful handshake (previously only Socket-Type,
+  Identity, and the X-QoS pair were extracted). Extensions can inspect
+  the peer's advertised properties to negotiate optional features.
+  Returned by all three mechanisms as `peer_properties:` in the
+  handshake result hash.
+
+## 0.6.0 — 2026-04-12
+
+### Changed
+
+- **Consolidated empty-binary constant.** `Codec::Frame::EMPTY_BODY`
+  and `Codec::Command::EMPTY_DATA` are gone, replaced by a single
+  `Codec::EMPTY_BINARY` shared across the codec module. Anything
+  referencing the old constants needs to switch to
+  `Protocol::ZMTP::Codec::EMPTY_BINARY`.
+
+## 0.5.1 — 2026-04-10
+
+### Changed
+
+- **Reduced allocations on hot paths.** Pre-computed `FLAG_BYTES` lookup
+  table eliminates `Integer#chr` + `String#b` per frame. `encode_message`
+  inlines wire encoding instead of creating throwaway Frame objects per
+  part. `write_frames` and `Command#to_body` skip redundant `.b` when
+  strings are already binary. `EMPTY_BODY` and `EMPTY_DATA` constants
+  replace per-call `"".b` allocations.
+
+## 0.5.0 — 2026-04-10
+
+### Fixed
+
+- **Wire writes are now cancellation-safe.** `Connection#send_message`,
+  `#write_message`, `#write_messages`, `#write_wire`, and `#send_command`
+  each wrap their `@mutex.synchronize` block in
+  `Async::Task#defer_cancel`. A ZMTP frame is two `@io.write` calls
+  (header then body); under a socket-level barrier cascade (`barrier.stop`)
+  an `Async::Cancel` could previously land between those two writes,
+  leaving the peer with a header pointing at a body that never arrives
+  and an unrecoverable framer desync. `defer_cancel` holds the
+  cancellation until the write finishes, so cascading teardown only
+  unwinds at frame boundaries. Mutex protection is unchanged — it
+  guards against thread races; `defer_cancel` guards against fiber
+  cancellation. Non-Async callers (e.g. tests) fall through to the
+  unwrapped path.
+
+## 0.4.0 — 2026-04-09
+
+### Added
+
+- **`Connection#write_messages`** — batched multipart send for work-stealing
+  send pumps. Dequeue a batch at once and write it under a single mutex
+  acquisition instead of one lock per message. Amortizes lock overhead on
+  high-throughput paths.
+
+### Changed
+
+- **Zero-alloc frame headers on the unencrypted hot send path.**
+  `#write_frames` used to allocate, per part, a `Codec::Frame` object, a
+  `.b` body copy, a 1-or-9-byte header String, and a concatenated wire
+  String (a copy of the entire body just to glue the header on). The body
+  copy was the dominant allocation — every 64 KB send produced a 64 KB
+  throwaway String, feeding the GC at ~1.2 GB/s under sustained load.
+  Headers are now packed into a reusable `@header_buf` via
+  `Array#pack(buffer:)`, header and body are written separately
+  (io-stream buffers them into one syscall per batch), the `Frame`
+  object is gone, and the body is no longer copied. `@mechanism.encrypted?`
+  is hoisted out of the per-frame loop. The encrypted path is unchanged —
+  CURVE/BLAKE3ZMQ still authenticate over the full encoded frame and need
+  a single wire String per part.
+
+  Bench impact downstream in omq (push_pull + router_dealer, 1 and 3 peers,
+  all transports): 48 improvements, 0 regressions across 72 measurements.
+  Peaks: `router_dealer tcp 3p 64B +40.7%`, `push_pull ipc 1p 64 KB +28.8%`
+  (crosses 1.3 GB/s).
+
+## 0.3.0 — 2026-04-07
+
+- Replace `[Async {}].each(&:wait)` with `Barrier` in tests.
+- YARD documentation on all public methods and classes.
+- Code style: two blank lines between methods and constants.
+- Fix `#read_frame` decryption for non-CURVE encrypted mechanisms
+  (e.g. BLAKE3ZMQ). Previously only CURVE's `\x07MESSAGE`-wrapped command
+  frames were decrypted; inline-encrypted command frames (SUBSCRIBE, PING,
+  etc.) were silently dropped, breaking PUB/SUB over BLAKE3ZMQ.
+
+- **Breaking:** `Mechanism::Curve` API is now kwargs-only:
+  `Curve.server(public_key:, secret_key:, crypto:)` and
+  `Curve.client(server_key:, crypto:)`. Client keys are optional — when
+  omitted, an ephemeral permanent keypair is auto-generated. INITIATE
+  always contains `C + vouch + metadata` per RFC 26.
+- **Breaking:** Authenticator now receives a `Protocol::ZMTP::PeerInfo`
+  (with a `crypto::PublicKey`) via `#call`. The `#include?` duck-typing
+  is removed. Sends an ERROR command to the client on rejection.
+- Add `Protocol::ZMTP::PeerInfo` shared across mechanisms.
+- Add `#maintenance` to `Mechanism::Curve` for automatic cookie key rotation.
+  Returns `{ interval: 60, task: <Proc> }` on server-side mechanisms so the
+  host application can rotate the cookie key every 60 seconds, limiting the
+  forward secrecy exposure window.
+
+## 0.2.0
+
+- Add `Mechanism::Plain` — PLAIN authentication (RFC 24). Carries username and
+  password in a `HELLO` command during the handshake; no frame encryption.
+  Accepts an optional `authenticator:` callable on the server side for
+  credential validation.
+
+## 0.1.2
+
+- Check frame size against `max_message_size` before reading the body from the
+  wire. Previously, the entire frame was allocated into memory before the size
+  check, allowing a malicious peer to cause arbitrary memory allocation with a
+  single oversized frame header.
+- Size limit applies to all frames including commands — an attacker cannot bypass
+  the check by setting the command flag.
+
+## 0.1.1
+
+- Initial public release.

data/README.md

@@ -1,27 +1,27 @@
 # Protocol::ZMTP
 
 [![Gem Version](https://img.shields.io/gem/v/protocol-zmtp)](https://rubygems.org/gems/protocol-zmtp)
-[![CI](https://github.com/paddor/protocol-zmtp/actions/workflows/ci.yml/badge.svg)](https://github.com/paddor/protocol-zmtp/actions/workflows/ci.yml)
+[![CI](https://github.com/zeromq/omq.rb/actions/workflows/ci.yml/badge.svg)](https://github.com/zeromq/omq.rb/actions/workflows/ci.yml)
 
-ZMTP 3.1 wire protocol — codec, connection, NULL and CURVE mechanisms.
+ZMTP 3.1 wire protocol: codec, connection, NULL and CURVE mechanisms.
 No runtime dependencies.
 
 ## What's in the box
 
-- **Codec::Frame** — ZMTP frame encode/decode (flags, size, body)
-- **Codec::Greeting** — 64-byte greeting exchange
-- **Codec::Command** — READY, PING/PONG, SUBSCRIBE, etc.
-- **Connection** — per-connection frame I/O, handshake, PING/PONG
-- **Mechanism::Null** — NULL security (no encryption)
-- **Mechanism::Curve** — CurveZMQ (RFC 26) with pluggable crypto backend
-- **Z85** — ZeroMQ RFC 32 encoding
+- **Codec::Frame**: ZMTP frame encode/decode (flags, size, body)
+- **Codec::Greeting**: 64-byte greeting exchange
+- **Codec::Command**: READY, PING/PONG, SUBSCRIBE, etc.
+- **Connection**: per-connection frame I/O, handshake, PING/PONG
+- **Mechanism::Null**: NULL security (no encryption)
+- **Mechanism::Curve**: CurveZMQ (RFC 26) with pluggable crypto backend
+- **Z85**: ZeroMQ RFC 32 encoding
 
 ## Usage
 
 ```ruby
 require "protocol/zmtp"
 
-# NULL mechanism — no encryption
+# NULL mechanism, no encryption
 conn = Protocol::ZMTP::Connection.new(
   io,
   socket_type: "REQ",
@@ -31,7 +31,7 @@ conn.handshake!
 conn.send_message(["hello"])
 msg = conn.receive_message
 
-# CURVE mechanism — pass any NaCl-compatible backend
+# CURVE mechanism, pass any NaCl-compatible backend
 require "protocol/zmtp/mechanism/curve"
 require "nuckle"  # or: require "rbnacl"
 
@@ -42,7 +42,7 @@ server_mech = Protocol::ZMTP::Mechanism::Curve.server(
 
 ## CURVE crypto backend
 
-`Mechanism::Curve` accepts a `crypto:` parameter — any module that
+`Mechanism::Curve` accepts a `crypto:` parameter. Any module that
 provides the NaCl API:
 
 ```ruby

data/lib/protocol/zmtp/codec/command.rb

@@ -72,7 +72,7 @@ module Protocol
 
         # Builds a READY command with Socket-Type, Identity, and any
         # extra properties supplied by upper layers (e.g. an extension
-        # that injects +X-QoS+ or +X-Compression+).
+        # that injects +X-Compression+).
         #
         # @param metadata [Hash{String => String}, nil] additional READY properties
         # @return [Command]
@@ -83,6 +83,27 @@ module Protocol
         end
 
 
+        # Builds a fatal handshake refusal.
+        def self.error(reason)
+          raise Error, "ERROR reason exceeds 255 bytes" if reason.bytesize > 255
+
+          new("ERROR", reason.bytesize.chr.b + reason.b)
+        end
+
+
+        # ERROR is fatal even if its reason is malformed.
+        def raise_if_error!
+          return self unless @name == "ERROR"
+
+          length = @data.getbyte(0)
+          unless length && @data.bytesize == length + 1
+            raise FatalHandshakeError, "malformed ERROR command"
+          end
+
+          raise FatalHandshakeError, "peer rejected handshake: #{@data.byteslice(1, length).inspect}"
+        end
+
+
         # Builds a SUBSCRIBE command.
         #
         # @param prefix [String] subscription prefix to match
@@ -125,6 +146,9 @@ module Protocol
         # @param context [String] optional context bytes (up to 16 bytes)
         # @return [Command]
         def self.ping(ttl: 0, context: EMPTY_BINARY)
+          raise Error, "PING TTL must be between 0 and 6553.5 seconds" unless (0..6553.5).cover?(ttl)
+          raise Error, "PING context exceeds 16 bytes" if context.bytesize > 16
+
           ttl_ds = (ttl * 10).to_i
           new("PING", [ttl_ds].pack("n") + (context.encoding == Encoding::BINARY ? context : context.b))
         end
@@ -135,6 +159,8 @@ module Protocol
         # @param context [String] context bytes echoed from the PING
         # @return [Command]
         def self.pong(context: EMPTY_BINARY)
+          raise Error, "PONG context exceeds 16 bytes" if context.bytesize > 16
+
           new("PONG", context.encoding == Encoding::BINARY ? context : context.b)
         end
 
@@ -143,6 +169,8 @@ module Protocol
         #
         # @return [Array(Numeric, String)] [ttl_seconds, context_bytes]
         def ping_ttl_and_context
+          raise Error, "PING data must contain a TTL and at most 16 context bytes" unless (2..18).cover?(@data.bytesize)
+
           ttl_ds  = @data.unpack1("n")
           context = @data.bytesize > 2 ? @data.byteslice(2..) : EMPTY_BINARY
           [ttl_ds / 10.0, context]
@@ -157,6 +185,16 @@ module Protocol
         end
 
 
+        # Property names are case-insensitive; retain their original spelling
+        # in the public metadata hash for callers that enumerate it.
+        def self.property(props, name)
+          props.each_pair do |key, value|
+            return value if key.casecmp?(name)
+          end
+          nil
+        end
+
+
         # Encodes a hash of properties into ZMTP property list format.
         #
         # @param props [Hash{String => String}] property name-value pairs

data/lib/protocol/zmtp/codec/frame.rb

@@ -23,6 +23,7 @@ module Protocol
 
         # Short frame: 1-byte size, max body 255 bytes.
         SHORT_MAX = 255
+        LONG_MAX  = (1 << 63) - 1
 
         # Pre-computed single-byte flag strings (avoids Integer#chr + String#b per frame).
         FLAG_BYTES = Array.new(256) { |i| i.chr.b.freeze }.freeze
@@ -102,6 +103,9 @@ module Protocol
           long    = (flags & FLAGS_LONG) != 0
           command = (flags & FLAGS_COMMAND) != 0
 
+          raise Error, "reserved frame flags must be zero" unless (flags & 0xF8).zero?
+          raise Error, "command frames cannot have MORE set" if command && more
+
           if long
             raise EOFError, "Stream finished before reading long frame size" if buf.bytesize < 9
 
@@ -119,6 +123,8 @@ module Protocol
             header_size = 2
           end
 
+          raise Error, "frame size exceeds ZMTP's 63-bit limit" if size > LONG_MAX
+
           if max_message_size && size > max_message_size
             raise Error, "frame size #{size} exceeds max_message_size #{max_message_size}"
           end
@@ -141,6 +147,8 @@ module Protocol
         # @param more [Boolean] more frames follow
         # @param command [Boolean] this is a command frame
         def initialize(body, more: false, command: false)
+          raise Error, "command frames cannot have MORE set" if command && more
+
           @body    = body
           @more    = more
           @command = command

data/lib/protocol/zmtp/connection.rb

@@ -47,6 +47,10 @@ module Protocol
       # @return [Float, nil] monotonic timestamp of last received frame
       attr_reader :last_received_at
 
+      # Transport wrappers may need room for bounded wire envelopes in
+      # addition to the application message limit they enforce after decoding.
+      attr_writer :max_message_size
+
 
       # @param io [#peek, #read_exactly, #write, #flush, #close] transport IO
       # @param socket_type [String] our socket type name (e.g. "REQ")
@@ -55,7 +59,7 @@ module Protocol
       # @param mechanism [Mechanism::Null, Mechanism::Curve] security mechanism
       # @param max_message_size [Integer, nil] max frame size in bytes, nil = unlimited
       # @param opts [Hash{String => String}] extra READY properties to
-      #   advertise (e.g. +"X-QoS" => "1"+). Upper-layer extensions use
+      #   advertise (e.g. +"X-Compression" => "lz4"+). Upper-layer extensions use
       #   this to inject their own negotiated properties without the
       #   codec needing to know about them.
       def initialize(io, socket_type:, identity: "", as_server: false,
@@ -278,12 +282,7 @@ module Protocol
       # @raise [EOFError] if connection is closed
       def read_frame
         loop do
-          begin
-            frame = Codec::Frame.read_from(@io, max_message_size: @max_message_size)
-          rescue Error
-            close
-            raise
-          end
+          frame = Codec::Frame.read_from(@io, max_message_size: @max_message_size)
 
           touch_heartbeat
 
@@ -297,12 +296,16 @@ module Protocol
               send_command(Codec::Command.pong(context: context))
               next
             when "PONG"
+              raise Error, "PONG context exceeds 16 bytes" if cmd.data.bytesize > 16
               next
             end
           end
 
           return frame
         end
+      rescue Error
+        close
+        raise
       end
 
 

data/lib/protocol/zmtp/error.rb

@@ -5,5 +5,10 @@ module Protocol
     # Raised on ZMTP protocol violations.
     class Error < RuntimeError
     end
+
+
+    # An explicit handshake refusal. Do not retry with the same credentials.
+    class FatalHandshakeError < Error
+    end
   end
 end

data/lib/protocol/zmtp/mechanism/curve.rb

@@ -153,6 +153,8 @@ module Protocol
         # @param command [Boolean] whether this is a command frame
         # @return [String] binary wire bytes ready for writing
         def encrypt(body, more: false, command: false)
+          raise Error, "command frames cannot have MORE set" if command && more
+
           flags = 0
           flags |= 0x01 if more
           flags |= 0x02 if command
@@ -211,6 +213,8 @@ module Protocol
           end
 
           flags = plaintext.getbyte(0)
+          raise Error, "invalid MESSAGE flags" unless flags && (flags & 0xFC).zero?
+
           body  = plaintext.byteslice(1..) || "".b
           Codec::Frame.new(body, more: (flags & 0x01) != 0, command: (flags & 0x02) != 0)
         end
@@ -255,7 +259,7 @@ module Protocol
           # --- Read WELCOME ---
           welcome_frame = Codec::Frame.read_from(io)
           raise Error, "expected command frame" unless welcome_frame.command?
-          welcome_cmd = Codec::Command.from_body(welcome_frame.body)
+          welcome_cmd = Codec::Command.from_body(welcome_frame.body).raise_if_error!
           raise Error, "expected WELCOME, got #{welcome_cmd.name}" unless welcome_cmd.name == "WELCOME"
 
           wdata = welcome_cmd.data
@@ -307,7 +311,7 @@ module Protocol
           # --- Read READY ---
           ready_frame = Codec::Frame.read_from(io)
           raise Error, "expected command frame" unless ready_frame.command?
-          ready_cmd = Codec::Command.from_body(ready_frame.body)
+          ready_cmd = Codec::Command.from_body(ready_frame.body).raise_if_error!
           raise Error, "expected READY, got #{ready_cmd.name}" unless ready_cmd.name == "READY"
 
           rdata = ready_cmd.data
@@ -324,8 +328,8 @@ module Protocol
           end
 
           props            = Codec::Command.decode_properties(r_plaintext)
-          peer_socket_type = props["Socket-Type"]
-          peer_identity    = props["Identity"] || ""
+          peer_socket_type = Codec::Command.property(props, "Socket-Type")
+          peer_identity    = Codec::Command.property(props, "Identity") || ""
 
           @session_box = session
           @send_nonce  = 1
@@ -361,7 +365,7 @@ module Protocol
           # --- Read HELLO ---
           hello_frame = Codec::Frame.read_from(io)
           raise Error, "expected command frame" unless hello_frame.command?
-          hello_cmd = Codec::Command.from_body(hello_frame.body)
+          hello_cmd = Codec::Command.from_body(hello_frame.body).raise_if_error!
           raise Error, "expected HELLO, got #{hello_cmd.name}" unless hello_cmd.name == "HELLO"
 
           hdata = hello_cmd.data
@@ -407,7 +411,7 @@ module Protocol
           # --- Read INITIATE ---
           init_frame = Codec::Frame.read_from(io)
           raise Error, "expected command frame" unless init_frame.command?
-          init_cmd = Codec::Command.from_body(init_frame.body)
+          init_cmd = Codec::Command.from_body(init_frame.body).raise_if_error!
           raise Error, "expected INITIATE, got #{init_cmd.name}" unless init_cmd.name == "INITIATE"
 
           idata = init_cmd.data
@@ -468,7 +472,7 @@ module Protocol
             peer = PeerInfo.new(public_key: client_permanent, identity: "")
             unless @authenticator.call(peer)
               send_error(io, "client key not authorized")
-              raise Error, "client key not authorized"
+              raise FatalHandshakeError, "client key not authorized"
             end
           end
 
@@ -498,8 +502,8 @@ module Protocol
           init_nonce_buffers!
 
           {
-            peer_socket_type: props["Socket-Type"],
-            peer_identity:    props["Identity"] || "",
+            peer_socket_type: Codec::Command.property(props, "Socket-Type"),
+            peer_identity:    Codec::Command.property(props, "Identity") || "",
             peer_public_key:  client_permanent,
             peer_properties:  props,
             peer_major:       @peer_major,

data/lib/protocol/zmtp/mechanism/null.rb

@@ -48,14 +48,14 @@ module Protocol
             raise Error, "expected command frame, got data frame"
           end
 
-          peer_cmd = Codec::Command.from_body(frame.body)
+          peer_cmd = Codec::Command.from_body(frame.body).raise_if_error!
           unless peer_cmd.name == "READY"
             raise Error, "expected READY command, got #{peer_cmd.name}"
           end
 
           props            = peer_cmd.properties
-          peer_socket_type = props["Socket-Type"]
-          peer_identity    = props["Identity"] || ""
+          peer_socket_type = Codec::Command.property(props, "Socket-Type")
+          peer_identity    = Codec::Command.property(props, "Identity") || ""
 
           unless peer_socket_type
             raise Error, "peer READY missing Socket-Type"

data/lib/protocol/zmtp/mechanism/plain.rb

@@ -92,7 +92,8 @@ module Protocol
           username, password = decode_credentials(cmd.data)
 
           if @authenticator && !@authenticator.call(username, password)
-            raise Error, "authentication failed"
+            send_command(io, Codec::Command.error("authentication failed"))
+            raise FatalHandshakeError, "authentication failed"
           end
 
           send_command(io, Codec::Command.new("WELCOME"))
@@ -143,13 +144,13 @@ module Protocol
 
         def extract_peer_info(cmd)
           props            = cmd.properties
-          peer_socket_type = props["Socket-Type"]
+          peer_socket_type = Codec::Command.property(props, "Socket-Type")
 
           raise Error, "peer command missing Socket-Type" unless peer_socket_type
 
           {
             peer_socket_type: peer_socket_type,
-            peer_identity:    props["Identity"] || "",
+            peer_identity:    Codec::Command.property(props, "Identity") || "",
             peer_properties:  props,
           }
         end
@@ -165,7 +166,7 @@ module Protocol
           frame = Codec::Frame.read_from(io)
           raise Error, "expected command frame, got data frame" unless frame.command?
 
-          Codec::Command.from_body(frame.body)
+          Codec::Command.from_body(frame.body).raise_if_error!
         end
       end
     end

data/lib/protocol/zmtp/peer_info.rb

@@ -9,7 +9,7 @@ module Protocol
     # - +identity+ is the peer's +ZMQ_IDENTITY+ string, or +""+ when no
     #   identity was advertised in the READY metadata.
     #
-    # Used as a peer key by upper layers (e.g. omq-qos levels 2/3): the
+    # Used as a peer key by upper layers: the
     # whole value object is frozen and equality-comparable, so it can be
     # stored directly in a Hash without picking one anchor over the other.
     #

data/lib/protocol/zmtp/version.rb

@@ -2,6 +2,6 @@
 
 module Protocol
   module ZMTP
-    VERSION = "0.10.3"
+    VERSION = "0.10.5"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-zmtp
 version: !ruby/object:Gem::Version
-  version: 0.10.3
+  version: 0.10.5
 platform: ruby
 authors:
 - Patrik Wenger
@@ -18,6 +18,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/protocol/zmtp.rb
@@ -35,7 +36,7 @@ files:
 - lib/protocol/zmtp/valid_peers.rb
 - lib/protocol/zmtp/version.rb
 - lib/protocol/zmtp/z85.rb
-homepage: https://github.com/paddor/protocol-zmtp
+homepage: https://github.com/zeromq/omq.rb/tree/main/gems/protocol-zmtp
 licenses:
 - ISC
 metadata: {}
@@ -53,7 +54,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
 summary: ZMTP 3.1 wire protocol codec and connection
 test_files: []