rack 2.2.3.1 → 3.0.0

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of rack might be problematic. Click here for more details.

Files changed (86) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +178 -69
  3. data/CONTRIBUTING.md +53 -47
  4. data/MIT-LICENSE +1 -1
  5. data/README.md +293 -0
  6. data/SPEC.rdoc +183 -131
  7. data/lib/rack/auth/abstract/handler.rb +3 -1
  8. data/lib/rack/auth/abstract/request.rb +3 -1
  9. data/lib/rack/auth/digest/md5.rb +1 -131
  10. data/lib/rack/auth/digest/nonce.rb +1 -54
  11. data/lib/rack/auth/digest/params.rb +1 -54
  12. data/lib/rack/auth/digest/request.rb +1 -43
  13. data/lib/rack/auth/digest.rb +256 -0
  14. data/lib/rack/body_proxy.rb +3 -1
  15. data/lib/rack/builder.rb +60 -42
  16. data/lib/rack/cascade.rb +2 -0
  17. data/lib/rack/chunked.rb +16 -13
  18. data/lib/rack/common_logger.rb +23 -18
  19. data/lib/rack/conditional_get.rb +18 -15
  20. data/lib/rack/constants.rb +63 -0
  21. data/lib/rack/content_length.rb +12 -16
  22. data/lib/rack/content_type.rb +8 -5
  23. data/lib/rack/deflater.rb +40 -26
  24. data/lib/rack/directory.rb +9 -3
  25. data/lib/rack/etag.rb +14 -21
  26. data/lib/rack/events.rb +4 -0
  27. data/lib/rack/file.rb +2 -0
  28. data/lib/rack/files.rb +15 -17
  29. data/lib/rack/head.rb +9 -8
  30. data/lib/rack/headers.rb +154 -0
  31. data/lib/rack/lint.rb +779 -684
  32. data/lib/rack/lock.rb +2 -5
  33. data/lib/rack/logger.rb +2 -0
  34. data/lib/rack/media_type.rb +1 -1
  35. data/lib/rack/method_override.rb +4 -0
  36. data/lib/rack/mime.rb +8 -0
  37. data/lib/rack/mock.rb +1 -271
  38. data/lib/rack/mock_request.rb +166 -0
  39. data/lib/rack/mock_response.rb +126 -0
  40. data/lib/rack/multipart/generator.rb +7 -5
  41. data/lib/rack/multipart/parser.rb +118 -61
  42. data/lib/rack/multipart/uploaded_file.rb +4 -0
  43. data/lib/rack/multipart.rb +20 -40
  44. data/lib/rack/null_logger.rb +9 -0
  45. data/lib/rack/query_parser.rb +80 -44
  46. data/lib/rack/recursive.rb +2 -0
  47. data/lib/rack/reloader.rb +0 -2
  48. data/lib/rack/request.rb +187 -89
  49. data/lib/rack/response.rb +131 -61
  50. data/lib/rack/rewindable_input.rb +24 -5
  51. data/lib/rack/runtime.rb +7 -6
  52. data/lib/rack/sendfile.rb +30 -25
  53. data/lib/rack/show_exceptions.rb +15 -2
  54. data/lib/rack/show_status.rb +17 -7
  55. data/lib/rack/static.rb +8 -8
  56. data/lib/rack/tempfile_reaper.rb +15 -4
  57. data/lib/rack/urlmap.rb +3 -1
  58. data/lib/rack/utils.rb +199 -170
  59. data/lib/rack/version.rb +9 -4
  60. data/lib/rack.rb +5 -76
  61. metadata +18 -38
  62. data/README.rdoc +0 -306
  63. data/Rakefile +0 -130
  64. data/bin/rackup +0 -5
  65. data/contrib/rack.png +0 -0
  66. data/contrib/rack.svg +0 -150
  67. data/contrib/rack_logo.svg +0 -164
  68. data/contrib/rdoc.css +0 -412
  69. data/example/lobster.ru +0 -6
  70. data/example/protectedlobster.rb +0 -16
  71. data/example/protectedlobster.ru +0 -10
  72. data/lib/rack/core_ext/regexp.rb +0 -14
  73. data/lib/rack/handler/cgi.rb +0 -59
  74. data/lib/rack/handler/fastcgi.rb +0 -100
  75. data/lib/rack/handler/lsws.rb +0 -61
  76. data/lib/rack/handler/scgi.rb +0 -71
  77. data/lib/rack/handler/thin.rb +0 -36
  78. data/lib/rack/handler/webrick.rb +0 -129
  79. data/lib/rack/handler.rb +0 -104
  80. data/lib/rack/lobster.rb +0 -70
  81. data/lib/rack/server.rb +0 -466
  82. data/lib/rack/session/abstract/id.rb +0 -523
  83. data/lib/rack/session/cookie.rb +0 -203
  84. data/lib/rack/session/memcache.rb +0 -10
  85. data/lib/rack/session/pool.rb +0 -85
  86. data/rack.gemspec +0 -46
data/SPEC.rdoc CHANGED
@@ -1,23 +1,27 @@
1
- This specification aims to formalize the Rack protocol. You
1
+ This specification aims to formalize the Rack protocol. You
2
2
  can (and should) use Rack::Lint to enforce it.
3
3
 
4
4
  When you develop middleware, be sure to add a Lint before and
5
5
  after to catch all mistakes.
6
+
6
7
  = Rack applications
8
+
7
9
  A Rack application is a Ruby object (not a class) that
8
10
  responds to +call+.
9
11
  It takes exactly one argument, the *environment*
10
- and returns an Array of exactly three values:
12
+ and returns a non-frozen Array of exactly three values:
11
13
  The *status*,
12
14
  the *headers*,
13
15
  and the *body*.
16
+
14
17
  == The Environment
18
+
15
19
  The environment must be an unfrozen instance of Hash that includes
16
- CGI-like headers. The application is free to modify the
20
+ CGI-like headers. The Rack application is free to modify the
17
21
  environment.
18
22
 
19
23
  The environment is required to include these variables
20
- (adopted from PEP333), except when they'd be empty, but see
24
+ (adopted from {PEP 333}[https://peps.python.org/pep-0333/]), except when they'd be empty, but see
21
25
  below.
22
26
  <tt>REQUEST_METHOD</tt>:: The HTTP request method, such as
23
27
  "GET" or "POST". This cannot ever
@@ -42,17 +46,20 @@ below.
42
46
  <tt>QUERY_STRING</tt>:: The portion of the request URL that
43
47
  follows the <tt>?</tt>, if any. May be
44
48
  empty, but is always required!
45
- <tt>SERVER_NAME</tt>, <tt>SERVER_PORT</tt>::
46
- When combined with <tt>SCRIPT_NAME</tt> and
49
+ <tt>SERVER_NAME</tt>:: When combined with <tt>SCRIPT_NAME</tt> and
47
50
  <tt>PATH_INFO</tt>, these variables can be
48
51
  used to complete the URL. Note, however,
49
52
  that <tt>HTTP_HOST</tt>, if present,
50
53
  should be used in preference to
51
54
  <tt>SERVER_NAME</tt> for reconstructing
52
55
  the request URL.
53
- <tt>SERVER_NAME</tt> and <tt>SERVER_PORT</tt>
54
- can never be empty strings, and so
55
- are always required.
56
+ <tt>SERVER_NAME</tt> can never be an empty
57
+ string, and so is always required.
58
+ <tt>SERVER_PORT</tt>:: An optional +Integer+ which is the port the
59
+ server is running on. Should be specified if
60
+ the server is running on a non-standard port.
61
+ <tt>SERVER_PROTOCOL</tt>:: A string representing the HTTP version used
62
+ for the request.
56
63
  <tt>HTTP_</tt> Variables:: Variables corresponding to the
57
64
  client-supplied HTTP request
58
65
  headers (i.e., variables whose
@@ -66,40 +73,19 @@ below.
66
73
  for specific behavior.
67
74
  In addition to this, the Rack environment must include these
68
75
  Rack-specific variables:
69
- <tt>rack.version</tt>:: The Array representing this version of Rack
70
- See Rack::VERSION, that corresponds to
71
- the version of this SPEC.
72
76
  <tt>rack.url_scheme</tt>:: +http+ or +https+, depending on the
73
77
  request URL.
74
78
  <tt>rack.input</tt>:: See below, the input stream.
75
79
  <tt>rack.errors</tt>:: See below, the error stream.
76
- <tt>rack.multithread</tt>:: true if the application object may be
77
- simultaneously invoked by another thread
78
- in the same process, false otherwise.
79
- <tt>rack.multiprocess</tt>:: true if an equivalent application object
80
- may be simultaneously invoked by another
81
- process, false otherwise.
82
- <tt>rack.run_once</tt>:: true if the server expects
83
- (but does not guarantee!) that the
84
- application will only be invoked this one
85
- time during the life of its containing
86
- process. Normally, this will only be true
87
- for a server based on CGI
88
- (or something similar).
89
- <tt>rack.hijack?</tt>:: present and true if the server supports
90
- connection hijacking. See below, hijacking.
91
- <tt>rack.hijack</tt>:: an object responding to #call that must be
92
- called at least once before using
93
- rack.hijack_io.
94
- It is recommended #call return rack.hijack_io
95
- as well as setting it in env if necessary.
96
- <tt>rack.hijack_io</tt>:: if rack.hijack? is true, and rack.hijack
97
- has received #call, this will contain
98
- an object resembling an IO. See hijacking.
80
+ <tt>rack.hijack?</tt>:: See below, if present and true, indicates
81
+ that the server supports partial hijacking.
82
+ <tt>rack.hijack</tt>:: See below, if present, an object responding
83
+ to +call+ that is used to perform a full
84
+ hijack.
99
85
  Additional environment specifications have approved to
100
- standardized middleware APIs. None of these are required to
86
+ standardized middleware APIs. None of these are required to
101
87
  be implemented by the server.
102
- <tt>rack.session</tt>:: A hash like interface for storing
88
+ <tt>rack.session</tt>:: A hash-like interface for storing
103
89
  request session data.
104
90
  The store must implement:
105
91
  store(key, value) (aliased as []=);
@@ -122,6 +108,11 @@ and should be prefixed uniquely. The prefix <tt>rack.</tt>
122
108
  is reserved for use with the Rack core distribution and other
123
109
  accepted specifications and must not be used otherwise.
124
110
 
111
+ The <tt>SERVER_PORT</tt> must be an Integer if set.
112
+ The <tt>SERVER_NAME</tt> must be a valid authority as defined by RFC7540.
113
+ The <tt>HTTP_HOST</tt> must be a valid authority as defined by RFC7540.
114
+ The <tt>SERVER_PROTOCOL</tt> must match the regexp <tt>HTTP/\d(\.\d)?</tt>.
115
+ If the <tt>HTTP_VERSION</tt> is present, it must equal the <tt>SERVER_PROTOCOL</tt>.
125
116
  The environment must not contain the keys
126
117
  <tt>HTTP_CONTENT_TYPE</tt> or <tt>HTTP_CONTENT_LENGTH</tt>
127
118
  (use the versions without <tt>HTTP_</tt>).
@@ -129,26 +120,32 @@ The CGI keys (named without a period) must have String values.
129
120
  If the string values for CGI keys contain non-ASCII characters,
130
121
  they should use ASCII-8BIT encoding.
131
122
  There are the following restrictions:
132
- * <tt>rack.version</tt> must be an array of Integers.
133
123
  * <tt>rack.url_scheme</tt> must either be +http+ or +https+.
134
124
  * There must be a valid input stream in <tt>rack.input</tt>.
135
125
  * There must be a valid error stream in <tt>rack.errors</tt>.
136
- * There may be a valid hijack stream in <tt>rack.hijack_io</tt>
126
+ * There may be a valid hijack callback in <tt>rack.hijack</tt>
137
127
  * The <tt>REQUEST_METHOD</tt> must be a valid token.
138
128
  * The <tt>SCRIPT_NAME</tt>, if non-empty, must start with <tt>/</tt>
139
129
  * The <tt>PATH_INFO</tt>, if non-empty, must start with <tt>/</tt>
140
130
  * The <tt>CONTENT_LENGTH</tt>, if given, must consist of digits only.
141
131
  * One of <tt>SCRIPT_NAME</tt> or <tt>PATH_INFO</tt> must be
142
- set. <tt>PATH_INFO</tt> should be <tt>/</tt> if
132
+ set. <tt>PATH_INFO</tt> should be <tt>/</tt> if
143
133
  <tt>SCRIPT_NAME</tt> is empty.
144
134
  <tt>SCRIPT_NAME</tt> never should be <tt>/</tt>, but instead be empty.
135
+ <tt>rack.response_finished</tt>:: An array of callables run by the server after the response has been
136
+ processed. This would typically be invoked after sending the response to the client, but it could also be
137
+ invoked if an error occurs while generating the response or sending the response; in that case, the error
138
+ argument will be a subclass of +Exception+.
139
+ The callables are invoked with +env, status, headers, error+ arguments and should not raise any
140
+ exceptions. They should be invoked in reverse order of registration.
141
+
145
142
  === The Input Stream
146
143
 
147
144
  The input stream is an IO-like object which contains the raw HTTP
148
145
  POST data.
149
146
  When applicable, its external encoding must be "ASCII-8BIT" and it
150
147
  must be opened in binary mode, for Ruby 1.9 compatibility.
151
- The input stream must respond to +gets+, +each+, +read+ and +rewind+.
148
+ The input stream must respond to +gets+, +each+, and +read+.
152
149
  * +gets+ must be called without arguments and return a string,
153
150
  or +nil+ on EOF.
154
151
  * +read+ behaves like IO#read.
@@ -169,120 +166,175 @@ The input stream must respond to +gets+, +each+, +read+ and +rewind+.
169
166
  If +buffer+ is given, then the read data will be placed
170
167
  into +buffer+ instead of a newly created String object.
171
168
  * +each+ must be called without arguments and only yield Strings.
172
- * +rewind+ must be called without arguments. It rewinds the input
173
- stream back to the beginning. It must not raise Errno::ESPIPE:
174
- that is, it may not be a pipe or a socket. Therefore, handler
175
- developers must buffer the input data into some rewindable object
176
- if the underlying input stream is not rewindable.
177
- * +close+ must never be called on the input stream.
169
+ * +close+ can be called on the input stream to indicate that the
170
+ any remaining input is not needed.
171
+
178
172
  === The Error Stream
173
+
179
174
  The error stream must respond to +puts+, +write+ and +flush+.
180
175
  * +puts+ must be called with a single argument that responds to +to_s+.
181
176
  * +write+ must be called with a single argument that is a String.
182
177
  * +flush+ must be called without arguments and must be called
183
178
  in order to make the error appear for sure.
184
179
  * +close+ must never be called on the error stream.
180
+
185
181
  === Hijacking
186
- ==== Request (before status)
187
- If rack.hijack? is true then rack.hijack must respond to #call.
188
- rack.hijack must return the io that will also be assigned (or is
189
- already present, in rack.hijack_io.
190
182
 
191
- rack.hijack_io must respond to:
192
- <tt>read, write, read_nonblock, write_nonblock, flush, close,
193
- close_read, close_write, closed?</tt>
183
+ The hijacking interfaces provides a means for an application to take
184
+ control of the HTTP connection. There are two distinct hijack
185
+ interfaces: full hijacking where the application takes over the raw
186
+ connection, and partial hijacking where the application takes over
187
+ just the response body stream. In both cases, the application is
188
+ responsible for closing the hijacked stream.
194
189
 
195
- The semantics of these IO methods must be a best effort match to
196
- those of a normal ruby IO or Socket object, using standard
197
- arguments and raising standard exceptions. Servers are encouraged
198
- to simply pass on real IO objects, although it is recognized that
199
- this approach is not directly compatible with SPDY and HTTP 2.0.
200
-
201
- IO provided in rack.hijack_io should preference the
202
- IO::WaitReadable and IO::WaitWritable APIs wherever supported.
203
-
204
- There is a deliberate lack of full specification around
205
- rack.hijack_io, as semantics will change from server to server.
206
- Users are encouraged to utilize this API with a knowledge of their
207
- server choice, and servers may extend the functionality of
208
- hijack_io to provide additional features to users. The purpose of
209
- rack.hijack is for Rack to "get out of the way", as such, Rack only
210
- provides the minimum of specification and support.
211
-
212
- If rack.hijack? is false, then rack.hijack should not be set.
213
-
214
- If rack.hijack? is false, then rack.hijack_io should not be set.
215
- ==== Response (after headers)
216
- It is also possible to hijack a response after the status and headers
217
- have been sent.
218
- In order to do this, an application may set the special header
219
- <tt>rack.hijack</tt> to an object that responds to <tt>call</tt>
220
- accepting an argument that conforms to the <tt>rack.hijack_io</tt>
221
- protocol.
222
-
223
- After the headers have been sent, and this hijack callback has been
224
- called, the application is now responsible for the remaining lifecycle
225
- of the IO. The application is also responsible for maintaining HTTP
226
- semantics. Of specific note, in almost all cases in the current SPEC,
227
- applications will have wanted to specify the header Connection:close in
228
- HTTP/1.1, and not Connection:keep-alive, as there is no protocol for
229
- returning hijacked sockets to the web server. For that purpose, use the
230
- body streaming API instead (progressively yielding strings via each).
231
-
232
- Servers must ignore the <tt>body</tt> part of the response tuple when
233
- the <tt>rack.hijack</tt> response API is in use.
234
-
235
- The special response header <tt>rack.hijack</tt> must only be set
236
- if the request env has <tt>rack.hijack?</tt> <tt>true</tt>.
237
- ==== Conventions
238
- * Middleware should not use hijack unless it is handling the whole
239
- response.
240
- * Middleware may wrap the IO object for the response pattern.
241
- * Middleware should not wrap the IO object for the request pattern. The
242
- request pattern is intended to provide the hijacker with "raw tcp".
190
+ Full hijacking only works with HTTP/1. Partial hijacking is functionally
191
+ equivalent to streaming bodies, and is still optionally supported for
192
+ backwards compatibility with older Rack versions.
193
+
194
+ ==== Full Hijack
195
+
196
+ Full hijack is used to completely take over an HTTP/1 connection. It
197
+ occurs before any headers are written and causes the request to
198
+ ignores any response generated by the application.
199
+
200
+ It is intended to be used when applications need access to raw HTTP/1
201
+ connection.
202
+
203
+ If +rack.hijack+ is present in +env+, it must respond to +call+
204
+ and return an +IO+ instance which can be used to read and write
205
+ to the underlying connection using HTTP/1 semantics and
206
+ formatting.
207
+
208
+ ==== Partial Hijack
209
+
210
+ Partial hijack is used for bi-directional streaming of the request and
211
+ response body. It occurs after the status and headers are written by
212
+ the server and causes the server to ignore the Body of the response.
213
+
214
+ It is intended to be used when applications need bi-directional
215
+ streaming.
216
+
217
+ If +rack.hijack?+ is present in +env+ and truthy,
218
+ an application may set the special response header +rack.hijack+
219
+ to an object that responds to +call+,
220
+ accepting a +stream+ argument.
221
+
222
+ After the response status and headers have been sent, this hijack
223
+ callback will be invoked with a +stream+ argument which follows the
224
+ same interface as outlined in "Streaming Body". Servers must
225
+ ignore the +body+ part of the response tuple when the
226
+ +rack.hijack+ response header is present. Using an empty +Array+
227
+ instance is recommended.
228
+
229
+ The special response header +rack.hijack+ must only be set
230
+ if the request +env+ has a truthy +rack.hijack?+.
243
231
  == The Response
232
+
244
233
  === The Status
245
- This is an HTTP status. When parsed as integer (+to_i+), it must be
246
- greater than or equal to 100.
234
+
235
+ This is an HTTP status. It must be an Integer greater than or equal to
236
+ 100.
237
+
247
238
  === The Headers
248
- The header must respond to +each+, and yield values of key and value.
239
+
240
+ The headers must be a unfrozen Hash.
249
241
  The header keys must be Strings.
250
242
  Special headers starting "rack." are for communicating with the
251
243
  server, and must not be sent back to the client.
252
244
  The header must not contain a +Status+ key.
253
- The header must conform to RFC7230 token specification, i.e. cannot
245
+ Header keys must conform to RFC7230 token specification, i.e. cannot
254
246
  contain non-printable ASCII, DQUOTE or "(),/:;<=>?@[\]{}".
255
- The values of the header must be Strings,
256
- consisting of lines (for multiple header values, e.g. multiple
257
- <tt>Set-Cookie</tt> values) separated by "\\n".
258
- The lines must not contain characters below 037.
259
- === The Content-Type
260
- There must not be a <tt>Content-Type</tt>, when the +Status+ is 1xx,
261
- 204 or 304.
262
- === The Content-Length
263
- There must not be a <tt>Content-Length</tt> header when the
264
- +Status+ is 1xx, 204 or 304.
247
+ Header keys must not contain uppercase ASCII characters (A-Z).
248
+ Header values must be either a String instance,
249
+ or an Array of String instances,
250
+ such that each String instance must not contain characters below 037.
251
+
252
+ === The content-type
253
+
254
+ There must not be a <tt>content-type</tt> header key when the +Status+ is 1xx,
255
+ 204, or 304.
256
+
257
+ === The content-length
258
+
259
+ There must not be a <tt>content-length</tt> header key when the
260
+ +Status+ is 1xx, 204, or 304.
261
+
265
262
  === The Body
266
- The Body must respond to +each+
263
+
264
+ The Body is typically an +Array+ of +String+ instances, an enumerable
265
+ that yields +String+ instances, a +Proc+ instance, or a File-like
266
+ object.
267
+
268
+ The Body must respond to +each+ or +call+. It may optionally respond
269
+ to +to_path+ or +to_ary+. A Body that responds to +each+ is considered
270
+ to be an Enumerable Body. A Body that responds to +call+ is considered
271
+ to be a Streaming Body.
272
+
273
+ A Body that responds to both +each+ and +call+ must be treated as an
274
+ Enumerable Body, not a Streaming Body. If it responds to +each+, you
275
+ must call +each+ and not +call+. If the Body doesn't respond to
276
+ +each+, then you can assume it responds to +call+.
277
+
278
+ The Body must either be consumed or returned. The Body is consumed by
279
+ optionally calling either +each+ or +call+.
280
+ Then, if the Body responds to +close+, it must be called to release
281
+ any resources associated with the generation of the body.
282
+ In other words, +close+ must always be called at least once; typically
283
+ after the web server has sent the response to the client, but also in
284
+ cases where the Rack application makes internal/virtual requests and
285
+ discards the response.
286
+
287
+
288
+ After calling +close+, the Body is considered closed and should not
289
+ be consumed again.
290
+ If the original Body is replaced by a new Body, the new Body must
291
+ also consume the original Body by calling +close+ if possible.
292
+
293
+ If the Body responds to +to_path+, it must return a +String+
294
+ path for the local file system whose contents are identical
295
+ to that produced by calling +each+; this may be used by the
296
+ server as an alternative, possibly more efficient way to
297
+ transport the response. The +to_path+ method does not consume
298
+ the body.
299
+
300
+ ==== Enumerable Body
301
+
302
+ The Enumerable Body must respond to +each+.
303
+ It must only be called once.
304
+ It must not be called after being closed.
267
305
  and must only yield String values.
268
306
 
269
307
  The Body itself should not be an instance of String, as this will
270
308
  break in Ruby 1.9.
271
309
 
272
- If the Body responds to +close+, it will be called after iteration. If
273
- the body is replaced by a middleware after action, the original body
274
- must be closed first, if it responds to close.
310
+ Middleware must not call +each+ directly on the Body.
311
+ Instead, middleware can return a new Body that calls +each+ on the
312
+ original Body, yielding at least once per iteration.
275
313
 
276
- If the Body responds to +to_path+, it must return a String
277
- identifying the location of a file whose contents are identical
278
- to that produced by calling +each+; this may be used by the
279
- server as an alternative, possibly more efficient way to
280
- transport the response.
314
+ If the Body responds to +to_ary+, it must return an +Array+ whose
315
+ contents are identical to that produced by calling +each+.
316
+ Middleware may call +to_ary+ directly on the Body and return a new
317
+ Body in its place. In other words, middleware can only process the
318
+ Body directly if it responds to +to_ary+. If the Body responds to both
319
+ +to_ary+ and +close+, its implementation of +to_ary+ must call
320
+ +close+.
321
+
322
+ ==== Streaming Body
323
+
324
+ The Streaming Body must respond to +call+.
325
+ It must only be called once.
326
+ It must not be called after being closed.
327
+ It takes a +stream+ argument.
328
+
329
+ The +stream+ argument must implement:
330
+ <tt>read, write, <<, flush, close, close_read, close_write, closed?</tt>
331
+
332
+ The semantics of these IO methods must be a best effort match to
333
+ those of a normal Ruby IO or Socket object, using standard arguments
334
+ and raising standard exceptions. Servers are encouraged to simply
335
+ pass on real IO objects, although it is recognized that this approach
336
+ is not directly compatible with HTTP/2.
281
337
 
282
- The Body commonly is an Array of Strings, the application
283
- instance itself, or a File-like object.
284
338
  == Thanks
285
- Some parts of this specification are adopted from PEP333: Python
286
- Web Server Gateway Interface
287
- v1.0 (http://www.python.org/dev/peps/pep-0333/). I'd like to thank
288
- everyone involved in that effort.
339
+ Some parts of this specification are adopted from {PEP 333 – Python Web Server Gateway Interface v1.0}[https://peps.python.org/pep-0333/]
340
+ I'd like to thank everyone involved in that effort.
@@ -1,5 +1,7 @@
1
1
  # frozen_string_literal: true
2
2
 
3
+ require_relative '../../constants'
4
+
3
5
  module Rack
4
6
  module Auth
5
7
  # Rack::Auth::AbstractHandler implements common authentication functionality.
@@ -21,7 +23,7 @@ module Rack
21
23
  return [ 401,
22
24
  { CONTENT_TYPE => 'text/plain',
23
25
  CONTENT_LENGTH => '0',
24
- 'WWW-Authenticate' => www_authenticate.to_s },
26
+ 'www-authenticate' => www_authenticate.to_s },
25
27
  []
26
28
  ]
27
29
  end
@@ -1,5 +1,7 @@
1
1
  # frozen_string_literal: true
2
2
 
3
+ require_relative '../../request'
4
+
3
5
  module Rack
4
6
  module Auth
5
7
  class AbstractRequest
@@ -25,7 +27,7 @@ module Rack
25
27
  end
26
28
 
27
29
  def scheme
28
- @scheme ||= parts.first && parts.first.downcase
30
+ @scheme ||= parts.first&.downcase
29
31
  end
30
32
 
31
33
  def params
@@ -1,131 +1 @@
1
- # frozen_string_literal: true
2
-
3
- require_relative '../abstract/handler'
4
- require_relative 'request'
5
- require_relative 'params'
6
- require_relative 'nonce'
7
- require 'digest/md5'
8
-
9
- module Rack
10
- module Auth
11
- module Digest
12
- # Rack::Auth::Digest::MD5 implements the MD5 algorithm version of
13
- # HTTP Digest Authentication, as per RFC 2617.
14
- #
15
- # Initialize with the [Rack] application that you want protecting,
16
- # and a block that looks up a plaintext password for a given username.
17
- #
18
- # +opaque+ needs to be set to a constant base64/hexadecimal string.
19
- #
20
- class MD5 < AbstractHandler
21
-
22
- attr_accessor :opaque
23
-
24
- attr_writer :passwords_hashed
25
-
26
- def initialize(app, realm = nil, opaque = nil, &authenticator)
27
- @passwords_hashed = nil
28
- if opaque.nil? and realm.respond_to? :values_at
29
- realm, opaque, @passwords_hashed = realm.values_at :realm, :opaque, :passwords_hashed
30
- end
31
- super(app, realm, &authenticator)
32
- @opaque = opaque
33
- end
34
-
35
- def passwords_hashed?
36
- !!@passwords_hashed
37
- end
38
-
39
- def call(env)
40
- auth = Request.new(env)
41
-
42
- unless auth.provided?
43
- return unauthorized
44
- end
45
-
46
- if !auth.digest? || !auth.correct_uri? || !valid_qop?(auth)
47
- return bad_request
48
- end
49
-
50
- if valid?(auth)
51
- if auth.nonce.stale?
52
- return unauthorized(challenge(stale: true))
53
- else
54
- env['REMOTE_USER'] = auth.username
55
-
56
- return @app.call(env)
57
- end
58
- end
59
-
60
- unauthorized
61
- end
62
-
63
-
64
- private
65
-
66
- QOP = 'auth'
67
-
68
- def params(hash = {})
69
- Params.new do |params|
70
- params['realm'] = realm
71
- params['nonce'] = Nonce.new.to_s
72
- params['opaque'] = H(opaque)
73
- params['qop'] = QOP
74
-
75
- hash.each { |k, v| params[k] = v }
76
- end
77
- end
78
-
79
- def challenge(hash = {})
80
- "Digest #{params(hash)}"
81
- end
82
-
83
- def valid?(auth)
84
- valid_opaque?(auth) && valid_nonce?(auth) && valid_digest?(auth)
85
- end
86
-
87
- def valid_qop?(auth)
88
- QOP == auth.qop
89
- end
90
-
91
- def valid_opaque?(auth)
92
- H(opaque) == auth.opaque
93
- end
94
-
95
- def valid_nonce?(auth)
96
- auth.nonce.valid?
97
- end
98
-
99
- def valid_digest?(auth)
100
- pw = @authenticator.call(auth.username)
101
- pw && Rack::Utils.secure_compare(digest(auth, pw), auth.response)
102
- end
103
-
104
- def md5(data)
105
- ::Digest::MD5.hexdigest(data)
106
- end
107
-
108
- alias :H :md5
109
-
110
- def KD(secret, data)
111
- H "#{secret}:#{data}"
112
- end
113
-
114
- def A1(auth, password)
115
- "#{auth.username}:#{auth.realm}:#{password}"
116
- end
117
-
118
- def A2(auth)
119
- "#{auth.method}:#{auth.uri}"
120
- end
121
-
122
- def digest(auth, password)
123
- password_hash = passwords_hashed? ? password : H(A1(auth, password))
124
-
125
- KD password_hash, "#{auth.nonce}:#{auth.nc}:#{auth.cnonce}:#{QOP}:#{H A2(auth)}"
126
- end
127
-
128
- end
129
- end
130
- end
131
- end
1
+ require_relative '../digest'
@@ -1,54 +1 @@
1
- # frozen_string_literal: true
2
-
3
- require 'digest/md5'
4
- require 'base64'
5
-
6
- module Rack
7
- module Auth
8
- module Digest
9
- # Rack::Auth::Digest::Nonce is the default nonce generator for the
10
- # Rack::Auth::Digest::MD5 authentication handler.
11
- #
12
- # +private_key+ needs to set to a constant string.
13
- #
14
- # +time_limit+ can be optionally set to an integer (number of seconds),
15
- # to limit the validity of the generated nonces.
16
-
17
- class Nonce
18
-
19
- class << self
20
- attr_accessor :private_key, :time_limit
21
- end
22
-
23
- def self.parse(string)
24
- new(*Base64.decode64(string).split(' ', 2))
25
- end
26
-
27
- def initialize(timestamp = Time.now, given_digest = nil)
28
- @timestamp, @given_digest = timestamp.to_i, given_digest
29
- end
30
-
31
- def to_s
32
- Base64.encode64("#{@timestamp} #{digest}").strip
33
- end
34
-
35
- def digest
36
- ::Digest::MD5.hexdigest("#{@timestamp}:#{self.class.private_key}")
37
- end
38
-
39
- def valid?
40
- digest == @given_digest
41
- end
42
-
43
- def stale?
44
- !self.class.time_limit.nil? && (Time.now.to_i - @timestamp) > self.class.time_limit
45
- end
46
-
47
- def fresh?
48
- !stale?
49
- end
50
-
51
- end
52
- end
53
- end
54
- end
1
+ require_relative '../digest'