rack 2.2.4 → 3.0.0.beta1

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 (84) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +152 -71
  3. data/CONTRIBUTING.md +53 -47
  4. data/MIT-LICENSE +1 -1
  5. data/README.md +287 -0
  6. data/Rakefile +40 -7
  7. data/SPEC.rdoc +175 -130
  8. data/contrib/LICENSE.md +7 -0
  9. data/contrib/logo.webp +0 -0
  10. data/lib/rack/auth/abstract/handler.rb +3 -1
  11. data/lib/rack/auth/abstract/request.rb +3 -1
  12. data/lib/rack/auth/digest/md5.rb +1 -131
  13. data/lib/rack/auth/digest/nonce.rb +1 -54
  14. data/lib/rack/auth/digest/params.rb +1 -54
  15. data/lib/rack/auth/digest/request.rb +1 -43
  16. data/lib/rack/auth/digest.rb +256 -0
  17. data/lib/rack/body_proxy.rb +3 -1
  18. data/lib/rack/builder.rb +60 -42
  19. data/lib/rack/cascade.rb +2 -0
  20. data/lib/rack/chunked.rb +16 -13
  21. data/lib/rack/common_logger.rb +23 -18
  22. data/lib/rack/conditional_get.rb +18 -15
  23. data/lib/rack/constants.rb +62 -0
  24. data/lib/rack/content_length.rb +12 -16
  25. data/lib/rack/content_type.rb +8 -5
  26. data/lib/rack/deflater.rb +40 -26
  27. data/lib/rack/directory.rb +9 -3
  28. data/lib/rack/etag.rb +14 -23
  29. data/lib/rack/events.rb +4 -0
  30. data/lib/rack/file.rb +2 -0
  31. data/lib/rack/files.rb +15 -17
  32. data/lib/rack/head.rb +9 -8
  33. data/lib/rack/headers.rb +154 -0
  34. data/lib/rack/lint.rb +764 -684
  35. data/lib/rack/lock.rb +2 -5
  36. data/lib/rack/logger.rb +2 -0
  37. data/lib/rack/media_type.rb +1 -1
  38. data/lib/rack/method_override.rb +4 -0
  39. data/lib/rack/mime.rb +8 -0
  40. data/lib/rack/mock.rb +1 -271
  41. data/lib/rack/mock_request.rb +166 -0
  42. data/lib/rack/mock_response.rb +124 -0
  43. data/lib/rack/multipart/generator.rb +7 -5
  44. data/lib/rack/multipart/parser.rb +118 -61
  45. data/lib/rack/multipart/uploaded_file.rb +4 -0
  46. data/lib/rack/multipart.rb +20 -40
  47. data/lib/rack/null_logger.rb +9 -0
  48. data/lib/rack/query_parser.rb +76 -44
  49. data/lib/rack/recursive.rb +2 -0
  50. data/lib/rack/reloader.rb +0 -2
  51. data/lib/rack/request.rb +187 -89
  52. data/lib/rack/response.rb +131 -61
  53. data/lib/rack/rewindable_input.rb +24 -5
  54. data/lib/rack/runtime.rb +7 -6
  55. data/lib/rack/sendfile.rb +30 -25
  56. data/lib/rack/show_exceptions.rb +15 -2
  57. data/lib/rack/show_status.rb +17 -7
  58. data/lib/rack/static.rb +8 -8
  59. data/lib/rack/tempfile_reaper.rb +15 -4
  60. data/lib/rack/urlmap.rb +3 -1
  61. data/lib/rack/utils.rb +199 -173
  62. data/lib/rack/version.rb +9 -4
  63. data/lib/rack.rb +5 -76
  64. data/rack.gemspec +6 -6
  65. metadata +22 -34
  66. data/README.rdoc +0 -306
  67. data/bin/rackup +0 -5
  68. data/contrib/rack.png +0 -0
  69. data/contrib/rack.svg +0 -150
  70. data/contrib/rack_logo.svg +0 -164
  71. data/lib/rack/core_ext/regexp.rb +0 -14
  72. data/lib/rack/handler/cgi.rb +0 -59
  73. data/lib/rack/handler/fastcgi.rb +0 -100
  74. data/lib/rack/handler/lsws.rb +0 -61
  75. data/lib/rack/handler/scgi.rb +0 -71
  76. data/lib/rack/handler/thin.rb +0 -36
  77. data/lib/rack/handler/webrick.rb +0 -129
  78. data/lib/rack/handler.rb +0 -104
  79. data/lib/rack/lobster.rb +0 -70
  80. data/lib/rack/server.rb +0 -466
  81. data/lib/rack/session/abstract/id.rb +0 -523
  82. data/lib/rack/session/cookie.rb +0 -203
  83. data/lib/rack/session/memcache.rb +0 -10
  84. data/lib/rack/session/pool.rb +0 -85
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,26 @@ 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
+
145
136
  === The Input Stream
146
137
 
147
138
  The input stream is an IO-like object which contains the raw HTTP
148
139
  POST data.
149
140
  When applicable, its external encoding must be "ASCII-8BIT" and it
150
141
  must be opened in binary mode, for Ruby 1.9 compatibility.
151
- The input stream must respond to +gets+, +each+, +read+ and +rewind+.
142
+ The input stream must respond to +gets+, +each+, and +read+.
152
143
  * +gets+ must be called without arguments and return a string,
153
144
  or +nil+ on EOF.
154
145
  * +read+ behaves like IO#read.
@@ -169,120 +160,174 @@ The input stream must respond to +gets+, +each+, +read+ and +rewind+.
169
160
  If +buffer+ is given, then the read data will be placed
170
161
  into +buffer+ instead of a newly created String object.
171
162
  * +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
163
  * +close+ must never be called on the input stream.
164
+
178
165
  === The Error Stream
166
+
179
167
  The error stream must respond to +puts+, +write+ and +flush+.
180
168
  * +puts+ must be called with a single argument that responds to +to_s+.
181
169
  * +write+ must be called with a single argument that is a String.
182
170
  * +flush+ must be called without arguments and must be called
183
171
  in order to make the error appear for sure.
184
172
  * +close+ must never be called on the error stream.
173
+
185
174
  === 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
175
 
191
- rack.hijack_io must respond to:
192
- <tt>read, write, read_nonblock, write_nonblock, flush, close,
193
- close_read, close_write, closed?</tt>
176
+ The hijacking interfaces provides a means for an application to take
177
+ control of the HTTP connection. There are two distinct hijack
178
+ interfaces: full hijacking where the application takes over the raw
179
+ connection, and partial hijacking where the application takes over
180
+ just the response body stream. In both cases, the application is
181
+ responsible for closing the hijacked stream.
194
182
 
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".
183
+ Full hijacking only works with HTTP/1. Partial hijacking is functionally
184
+ equivalent to streaming bodies, and is still optionally supported for
185
+ backwards compatibility with older Rack versions.
186
+
187
+ ==== Full Hijack
188
+
189
+ Full hijack is used to completely take over an HTTP/1 connection. It
190
+ occurs before any headers are written and causes the request to
191
+ ignores any response generated by the application.
192
+
193
+ It is intended to be used when applications need access to raw HTTP/1
194
+ connection.
195
+
196
+ If +rack.hijack+ is present in +env+, it must respond to +call+
197
+ and return an +IO+ instance which can be used to read and write
198
+ to the underlying connection using HTTP/1 semantics and
199
+ formatting.
200
+
201
+ ==== Partial Hijack
202
+
203
+ Partial hijack is used for bi-directional streaming of the request and
204
+ response body. It occurs after the status and headers are written by
205
+ the server and causes the server to ignore the Body of the response.
206
+
207
+ It is intended to be used when applications need bi-directional
208
+ streaming.
209
+
210
+ If +rack.hijack?+ is present in +env+ and truthy,
211
+ an application may set the special response header +rack.hijack+
212
+ to an object that responds to +call+,
213
+ accepting a +stream+ argument.
214
+
215
+ After the response status and headers have been sent, this hijack
216
+ callback will be invoked with a +stream+ argument which follows the
217
+ same interface as outlined in "Streaming Body". Servers must
218
+ ignore the +body+ part of the response tuple when the
219
+ +rack.hijack+ response header is present. Using an empty +Array+
220
+ instance is recommended.
221
+
222
+ The special response header +rack.hijack+ must only be set
223
+ if the request +env+ has a truthy +rack.hijack?+.
243
224
  == The Response
225
+
244
226
  === The Status
245
- This is an HTTP status. When parsed as integer (+to_i+), it must be
246
- greater than or equal to 100.
227
+
228
+ This is an HTTP status. It must be an Integer greater than or equal to
229
+ 100.
230
+
247
231
  === The Headers
248
- The header must respond to +each+, and yield values of key and value.
232
+
233
+ The headers must be a unfrozen Hash.
249
234
  The header keys must be Strings.
250
235
  Special headers starting "rack." are for communicating with the
251
236
  server, and must not be sent back to the client.
252
237
  The header must not contain a +Status+ key.
253
- The header must conform to RFC7230 token specification, i.e. cannot
238
+ Header keys must conform to RFC7230 token specification, i.e. cannot
254
239
  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.
240
+ Header keys must not contain uppercase ASCII characters (A-Z).
241
+ Header values must be either a String instance,
242
+ or an Array of String instances,
243
+ such that each String instance must not contain characters below 037.
244
+
245
+ === The content-type
246
+
247
+ There must not be a <tt>content-type</tt> header key when the +Status+ is 1xx,
248
+ 204, or 304.
249
+
250
+ === The content-length
251
+
252
+ There must not be a <tt>content-length</tt> header key when the
253
+ +Status+ is 1xx, 204, or 304.
254
+
265
255
  === The Body
266
- The Body must respond to +each+
256
+
257
+ The Body is typically an +Array+ of +String+ instances, an enumerable
258
+ that yields +String+ instances, a +Proc+ instance, or a File-like
259
+ object.
260
+
261
+ The Body must respond to +each+ or +call+. It may optionally respond
262
+ to +to_path+ or +to_ary+. A Body that responds to +each+ is considered
263
+ to be an Enumerable Body. A Body that responds to +call+ is considered
264
+ to be a Streaming Body.
265
+
266
+ A Body that responds to both +each+ and +call+ must be treated as an
267
+ Enumerable Body, not a Streaming Body. If it responds to +each+, you
268
+ must call +each+ and not +call+. If the Body doesn't respond to
269
+ +each+, then you can assume it responds to +call+.
270
+
271
+ The Body must either be consumed or returned. The Body is consumed by
272
+ optionally calling either +each+ or +call+.
273
+ Then, if the Body responds to +close+, it must be called to release
274
+ any resources associated with the generation of the body.
275
+ In other words, +close+ must always be called at least once; typically
276
+ after the web server has sent the response to the client, but also in
277
+ cases where the Rack application makes internal/virtual requests and
278
+ discards the response.
279
+
280
+
281
+ After calling +close+, the Body is considered closed and should not
282
+ be consumed again.
283
+ If the original Body is replaced by a new Body, the new Body must
284
+ also consume the original Body by calling +close+ if possible.
285
+
286
+ If the Body responds to +to_path+, it must return a +String+
287
+ path for the local file system whose contents are identical
288
+ to that produced by calling +each+; this may be used by the
289
+ server as an alternative, possibly more efficient way to
290
+ transport the response. The +to_path+ method does not consume
291
+ the body.
292
+
293
+ ==== Enumerable Body
294
+
295
+ The Enumerable Body must respond to +each+.
296
+ It must only be called once.
297
+ It must not be called after being closed.
267
298
  and must only yield String values.
268
299
 
269
300
  The Body itself should not be an instance of String, as this will
270
301
  break in Ruby 1.9.
271
302
 
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.
303
+ Middleware must not call +each+ directly on the Body.
304
+ Instead, middleware can return a new Body that calls +each+ on the
305
+ original Body, yielding at least once per iteration.
275
306
 
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.
307
+ If the Body responds to +to_ary+, it must return an +Array+ whose
308
+ contents are identical to that produced by calling +each+.
309
+ Middleware may call +to_ary+ directly on the Body and return a new
310
+ Body in its place. In other words, middleware can only process the
311
+ Body directly if it responds to +to_ary+. If the Body responds to both
312
+ +to_ary+ and +close+, its implementation of +to_ary+ must call
313
+ +close+.
314
+
315
+ ==== Streaming Body
316
+
317
+ The Streaming Body must respond to +call+.
318
+ It must only be called once.
319
+ It must not be called after being closed.
320
+ It takes a +stream+ argument.
321
+
322
+ The +stream+ argument must implement:
323
+ <tt>read, write, flush, close, close_read, close_write, closed?</tt>
324
+
325
+ The semantics of these IO methods must be a best effort match to
326
+ those of a normal Ruby IO or Socket object, using standard arguments
327
+ and raising standard exceptions. Servers are encouraged to simply
328
+ pass on real IO objects, although it is recognized that this approach
329
+ is not directly compatible with HTTP/2.
281
330
 
282
- The Body commonly is an Array of Strings, the application
283
- instance itself, or a File-like object.
284
331
  == 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.
332
+ Some parts of this specification are adopted from {PEP 333 – Python Web Server Gateway Interface v1.0}[https://peps.python.org/pep-0333/]
333
+ I'd like to thank everyone involved in that effort.
@@ -0,0 +1,7 @@
1
+ # Contributed Materials
2
+
3
+ ## Logo
4
+
5
+ Copyright, 2022, by Malene Laugesen.
6
+
7
+ This work is licensed under a [Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License](https://creativecommons.org/licenses/by-nc-nd/4.0/).
data/contrib/logo.webp ADDED
Binary file
@@ -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'