[
https://issues.apache.org/jira/browse/THRIFT-6126?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Dmytro Shteflyuk resolved THRIFT-6126.
--------------------------------------
Fix Version/s: 0.25.0
Resolution: Fixed
> Ruby SimpleServer stops accepting clients after unknown Compact or JSON types
> -----------------------------------------------------------------------------
>
> Key: THRIFT-6126
> URL: https://issues.apache.org/jira/browse/THRIFT-6126
> Project: Thrift
> Issue Type: Bug
> Components: Ruby - Library
> Reporter: Dmytro Shteflyuk
> Assignee: Dmytro Shteflyuk
> Priority: Major
> Fix For: 0.25.0
>
> Time Spent: 20m
> Remaining Estimate: 0h
>
> h3. Problem
> The Ruby Compact and JSON protocol implementations do not consistently
> classify unknown wire type identifiers as protocol errors.
> Compact Protocol raises a generic runtime error for an unknown field or
> container type. JSON Protocol raises {{NotImplementedError}} for an unknown
> type name or identifier. These exceptions fall outside the per-connection
> protocol error handling used by {{SimpleServer}}. As a result, a malformed
> request can escape the connection-processing path and stop the server's
> accept loop instead of only closing that client connection.
> The native and pure-Ruby Compact implementations also differ when reporting
> an invalid type supplied by a writer: the pure implementation masks the value
> before constructing its error message. The Ruby fuzz harness consequently
> relies on matching several error-message strings that now represent typed
> protocol errors.
> h3. Client impact
> A Ruby {{SimpleServer}} may stop accepting new clients after receiving a
> request containing an unknown Compact or JSON field or container type.
> Existing applications then need to restart the server before later clients
> can connect successfully.
> The inconsistent exception classes and Compact error values also make
> malformed-input handling depend on the selected protocol implementation and
> whether the native extension is loaded.
> h3. Reproduction
> Compact Protocol:
> {code:ruby}
> require "thrift"
> transport = Thrift::MemoryBufferTransport.new([0x1e].pack("C"))
> protocol = Thrift::CompactProtocol.new(transport)
> protocol.read_field_begin
> {code}
> The invalid Compact type {{14}} currently raises a generic error such as:
> {noformat}
> StandardError: don't know what type: 14
> {noformat}
> JSON Protocol:
> {code:ruby}
> require "thrift"
> payload = '[1,"unknown",1,1,{"1":{"wat":0}}]'
> transport = Thrift::MemoryBufferTransport.new(payload)
> protocol = Thrift::JsonProtocol.new(transport)
> protocol.read_message_begin
> protocol.read_struct_begin
> protocol.read_field_begin
> {code}
> The unknown JSON type {{wat}} currently raises {{NotImplementedError}}.
> When either payload reaches {{SimpleServer}}, the exception can escape its
> per-connection handling and terminate the accept loop. A later valid client
> is therefore not processed.
> h3. Expected behavior
> Unknown Compact and JSON field or container types should raise
> {{Thrift::ProtocolException}} with type {{INVALID_DATA}} and a useful message.
> {{SimpleServer}} should treat that exception as belonging to the malformed
> connection, close that connection, and continue accepting later clients.
> Native and pure-Ruby Compact implementations should expose the same exception
> metadata and preserve the original invalid writer type in the message.
> The fuzz harness should rely on the typed protocol exception rather than
> matching obsolete error-message strings.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
