source: project/wiki/eggref/4/message-digest @ 33168

Last change on this file since 33168 was 33168, checked in by Kon Lovett, 4 years ago

rel 3.1.1

File size: 21.4 KB
Line 
1[[tags: egg]]
2
3
4== message-digest
5
6[[toc:]]
7
8
9== Documentation
10
11Message Digest provides support for message digest primitives. A message-digest is
12a function taking some input source and returning a fixed-length hash.
13
14For best results the source object(s) to be accumulated into the digest should be
15something easily treated as a {{byteblock}} or, even better, a {{bytevector}}.
16
17This extension is split into many modules. The extension module ''message-digest''
18exports every other modules except ''message-digest-port''.
19
20=== Message Digest Primitive
21
22==== Usage
23
24<enscript highlight=scheme>
25(use message-digest-primitive)
26</enscript>
27
28==== Common Argument Definitions
29
30{{PRIMITIVE}} is a {{message-digest-primitive}}
31
32==== message-digest-primitive?
33
34<procedure>(message-digest-primitive? OBJ) => boolean</procedure>
35<procedure>(check-message-digest-primitive LOC OBJ [NAM])</procedure>
36<procedure>(error-message-digest-primitive LOC OBJ [NAM])</procedure>
37
38==== message-digest-primitive Accessors
39
40<procedure>(message-digest-primitive-context-info PRIMITIVE)</procedure>
41<procedure>(message-digest-primitive-digest-length PRIMITIVE)</procedure>
42<procedure>(message-digest-primitive-init PRIMITIVE)</procedure>
43<procedure>(message-digest-primitive-update PRIMITIVE)</procedure>
44<procedure>(message-digest-primitive-final PRIMITIVE)</procedure>
45<procedure>(message-digest-primitive-block-length PRIMITIVE)</procedure>
46<procedure>(message-digest-primitive-name PRIMITIVE)</procedure>
47
48==== make-message-digest-primitive
49
50<procedure>(make-message-digest-primitive CONTEXT-INFO DIGEST-LENGTH INIT UPDATE FINAL [BLOCK-LENGTH [NAME]]) => message-digest-primitive</procedure>
51
52Create a {{message-digest-primitive}} object. The reification of a message digest
53algorithm.
54
55{{CONTEXT-INFO}} is either a {{(procedure () <context>)}}, or a
56{{positive-integer}}. When an {{integer}} a memory-block of length
57{{CONTEXT-INFO}} is allocated (and automatically free'ed).
58
59{{<context>}} is an opaque object, except when the {{CONTEXT-INFO}} is an
60{{integer}}. In which case it is known that the object is a {{pointer}} to a block
61of uninitialized memory.
62
63The {{<context>}} should be a unique object. At least the object cannot be shared
64with another ''activated'' primitive.
65
66{{DIGEST-LENGTH}} is the count of bytes in the result.
67
68The processing of a message digest is split into three phases: initialization,
69update & finalization. These are represented by three procedures: {{INIT}},
70{{UPDATE}} & {{FINAL}}, respectively.
71
72{{INIT}} is a {{(procedure (<CONTEXT>))}}. Sets up the {{<CONTEXT>}}. (Technically
73the creation of a new {{<CONTEXT>}} is part of the initialization phase but this
74detail is hidden from the user.)
75
76{{UPDATE}} is a {{(procedure (<CONTEXT> <BLOB> <COUNT>))}}. Must accumulate the
77{{<BLOB>}}. Will be called zero or more times.
78
79The foreign type specifier {{scheme-pointer}} is suitable as a foreign-lambda
80argument type for the {{<BLOB>}} argument since the data-region is a contiguous
81array of bytes.
82
83{{<COUNT>}} is the actual number of bytes in the {{<BLOB>}}. Since this value is
84supplied it means only the first {{<COUNT>}} bytes in the {{<BLOB>}} are valid.
85
86{{FINAL}} is a {{(procedure (<CONTEXT> <BLOB>))}}. Must build the message-digest
87result in the supplied result {{<BLOB>}}, which will have a length of at least
88{{DIGEST-LENGTH}}.
89
90('''Note''' that {{INIT}}, {{UPDATE}} & {{FINAL}} are side-effecting procedures!)
91
92{{BLOCK-LENGTH}} must be a positive {{fixnum}} and identifies the message
93digest algorithm accumulator length in bytes. The default is {{4}}.
94
95{{NAME}} must be a {{symbol}} or a {{string}} and identifies the message digest
96algorithm. The suggested form is {{<algorithm name>-primitive}}. Example:
97{{'md5-primitive}}. The default is a nearly useless generated, uninterned
98{{symbol}}.
99
100=== Message Digest Type
101
102==== Usage
103
104<enscript highlight=scheme>
105(use message-digest-type)
106</enscript>
107
108==== Common Argument Definitions
109
110{{RESULT-FORM}} is one of:
111
112; {{'string}} : the result bytes as a string; these are raw bytes, not characters!
113; {{'hex}} : the result bytes encoded as a string of lower-case hexadecimal digits.
114; {{'blob}} : the result bytes as a blob.
115; {{'u8vector}} : the result bytes as a u8vector.
116
117{{DIGEST}} is a {{message-digest}}.
118
119{{ENDIAN}} is one of {{'big-endian}}, {{'little-endian}}.
120
121{{SOURCE}} is a Scheme object.
122
123The {{<buffer>}} argument for the update phase is translated as:
124
125; {{string}} : {{<buffer>}} = {{SOURCE}}.
126; {{blob}} : {{<buffer>}} = {{SOURCE}}.
127; {{srfi-4-vector}} : {{<buffer>}} = {{(...vector->blob/shared SOURCE)}}.
128; {{procedure}} : updates with {{<buffer>}} = {{(procedure)}} until {{#f = (procedure)}}.
129; {{input-port}} : like {{procedure}} above but from {{((message-digest-chunk-read-maker) SOURCE)}}.
130; {{*}} : {{<buffer>}} = {{(message-digest-chunk-converter SOURCE)}}.
131
132Should none of the above interpretations be available then an error is
133signaled.
134
135A {{<byte-source>}} is one of {{string}}, {{blob}}, or {{srfi-4-vector}}.
136
137==== initialize-message-digest
138
139<procedure>(initialize-message-digest PRIMITIVE) => message-digest</procedure>
140
141Returns a new, initialized {{message-digest}} for the supplied algorithm
142{{PRIMITIVE}}.
143
144Initialized here means the intialization phase is completed.
145
146==== message-digest?
147
148<procedure>(message-digest? OBJ) => boolean</procedure>
149
150<procedure>(check-message-digest LOC OBJ [NAM])</procedure>
151<procedure>(error-message-digest LOC OBJ [NAM])</procedure>
152
153==== message-digest-algorithm
154
155<procedure>(message-digest-algorithm DIGEST) => message-digest-primitive</procedure>
156
157Returns the message digest algorithm used by this {{DIGEST}}.
158
159Mostly for use when developing an update operation.
160
161Do not mess with this object!
162
163==== finalize-message-digest
164
165<procedure>(finalize-message-digest DIGEST [RESULT-FORM]) => <result></procedure>
166
167Finalize the {{DIGEST}} and return the {{<result>}} in the {{RESULT-FORM}}.
168
169{{RESULT-FORM}} default is {{'hex}}.
170
171Finalize here means the finalization phase is completed. The {{DIGEST}} is not
172in a useful state.
173
174==== setup-message-digest-buffer!
175
176<procedure>(setup-message-digest-buffer! DIGEST SIZE)</procedure>
177
178Ensure the {{DIGEST}} has a buffer of at least {{SIZE}} bytes.
179
180=== Message Digest Parameters
181
182Common handlers.
183
184Not thread specific.
185
186==== Usage
187
188<enscript highlight=scheme>
189(use message-digest-parameters)
190</enscript>
191
192==== message-digest-chunk-read-maker
193
194<procedure>(message-digest-chunk-read-maker) => CONSTRUCTOR</procedure>
195<procedure>(message-digest-chunk-read-maker CONSTRUCTOR)</procedure>
196
197Supplies the procedure used to create an input procedure.
198
199{{CONSTRUCTOR}} is a {{(procedure (INPUT-PORT #!optional SIZE)
200(procedure () <byte-source>))}}. The first argument is the chunk source port
201and the second argument is the size of chunks.
202
203The default {{CONSTRUCTOR}} will return a procedure that reads from
204{{INPUT-PORT}} in {{(message-digest-chunk-size)}} bytes.
205
206==== message-digest-chunk-size
207
208<procedure>(message-digest-chunk-size) => SIZE</procedure>
209<procedure>(message-digest-chunk-size [SIZE])</procedure>
210
211The number of bytes to read from a binary-stream during the message-digest
212update phase. Used by the default {{message-digest-chunk-read-maker}}.
213
214{{SIZE}} is a {{positive-integer}}, with default {{1024}}.
215
216==== message-digest-chunk-converter
217
218<procedure>(message-digest-chunk-converter) => CONVERTER</procedure>
219<procedure>(message-digest-chunk-converter CONVERTER)</procedure>
220
221The procedure used to translate an arbitrary object into something
222suitable for an {{UPDATE}} procedure. See {{make-message-digest-primitive}}.
223
224{{CONVERTER}} is a {{(procedure (*) <byte-source>)}}.
225
226Should the {{CONVERTER}} be {{#f}} or return {{#f}} then no translation is attempted. The
227default {{CONVERTER}} is {{#f}}.
228
229=== Message Digest BV
230
231Digest routines for string & blob.
232
233==== Usage
234
235<enscript highlight=scheme>
236(use message-digest-bv)
237</enscript>
238
239==== message-digest-update-blob
240
241<procedure>(message-digest-update-blob DIGEST BLOB)</procedure>
242
243Update the {{DIGEST}} with a {{BLOB}}.
244
245==== message-digest-update-string
246
247<procedure>(message-digest-update-string DIGEST STRING)</procedure>
248
249Update the {{DIGEST}} with a {{STRING}}.
250
251==== message-digest-update-substring (DEPRECATED)
252
253<procedure>(message-digest-update-substring DIGEST STRING START END)</procedure>
254
255Update the {{DIGEST}} with a substring {{STRING START END}}.
256
257==== message-digest-string
258
259<procedure>(message-digest-string PRIMITIVE STRING [RESULT-FORM]) => <result></procedure>
260
261Returns the {{RESULT}} for the digest algorithm {{PRIMITIVE}} applied to
262{{STRING}} in the {{RESULT-FORM}}.
263
264{{RESULT-FORM}} default is {{'hex}}.
265
266Performs all three phases.
267
268==== message-digest-blob
269
270<procedure>(message-digest-blob PRIMITIVE BLOB [RESULT-FORM]) => <result></procedure>
271
272Returns the {{<result>}} for the digest algorithm {{PRIMITIVE}} applied to
273{{BLOB}} in the {{RESULT-FORM}}.
274
275{{RESULT-FORM}} default is {{'hex}}.
276
277Performs all three phases.
278
279=== Message Digest Int
280
281Provides digest update operations for character and integer datatypes.
282
283==== Usage
284
285<enscript highlight=scheme>
286(use message-digest-int)
287</enscript>
288
289==== message-digest-update-char-u8
290
291<procedure>(message-digest-update-char-u8 DIGEST CHAR)</procedure>
292
293Update the {{DIGEST}} with the low-order 8-bits of a character {{CHAR}}.
294
295==== message-digest-update-char
296
297<procedure>(message-digest-update-char DIGEST CHAR [ENDIAN])</procedure>
298
299Update the {{DIGEST}} with a the character {{CHAR}} 32-bit integer value
300treated as {{ENDIAN}}.
301
302{{ENDIAN}} default is {{(machine-byte-order)}}.
303
304==== message-digest-update-char-be
305
306<procedure>(message-digest-update-char-be DIGEST CHAR)</procedure>
307
308Update the {{DIGEST}} with a the character {{CHAR}} 32-bit integer value
309treated as big-endian.
310
311==== message-digest-update-char-le
312
313<procedure>(message-digest-update-char-le DIGEST CHAR)</procedure>
314
315Update the {{DIGEST}} with a the character {{CHAR}} 32-bit integer value
316treated as little-endian.
317
318==== message-digest-update-u8
319
320<procedure>(message-digest-update-u8 DIGEST U8)</procedure>
321
322Update the {{DIGEST}} with an 8-bit integer {{U8}}.
323
324==== message-digest-update-u16
325
326<procedure>(message-digest-update-u16 DIGEST U16 [ENDIAN])</procedure>
327
328Update the {{DIGEST}} with a 16-bit integer {{U16}} treated as {{ENDIAN}}.
329
330{{ENDIAN}} default is {{(machine-byte-order)}}.
331
332==== message-digest-update-u16-be
333
334<procedure>(message-digest-update-u16-be DIGEST U16)</procedure>
335
336Update the {{DIGEST}} with a 16-bit integer {{U16}} treated as big-endian.
337
338==== message-digest-update-u16-le
339
340<procedure>(message-digest-update-u16-le DIGEST U16)</procedure>
341
342Update the {{DIGEST}} with a 16-bit integer {{U16}} treated as little-endian.
343
344==== message-digest-update-u32
345
346<procedure>(message-digest-update-u32 DIGEST U32 [ENDIAN])</procedure>
347
348Update the {{DIGEST}} with a 32-bit integer {{U32}} treated as {{ENDIAN}}.
349
350{{ENDIAN}} default is {{(machine-byte-order)}}.
351
352==== message-digest-update-u32-be
353
354<procedure>(message-digest-update-u32-be DIGEST U32)</procedure>
355
356Update the {{DIGEST}} with a 32-bit integer {{U32}} treated as big-endian.
357
358==== message-digest-update-u32-le
359
360<procedure>(message-digest-update-u32-le DIGEST U32)</procedure>
361
362Update the {{DIGEST}} with a 32-bit integer {{U32}} treated as little-endian.
363
364==== message-digest-update-u64
365
366<procedure>(message-digest-update-u64 DIGEST U64 [ENDIAN])</procedure>
367
368Update the {{DIGEST}} with a 64-bit integer {{U64}} treated as {{ENDIAN}}.
369
370{{ENDIAN}} default is {{(machine-byte-order)}}.
371
372==== message-digest-update-u64-be
373
374<procedure>(message-digest-update-u64-be DIGEST U64)</procedure>
375
376Update the {{DIGEST}} with a 64-bit integer {{U64}} treated as big-endian.
377
378==== message-digest-update-u64-le
379
380<procedure>(message-digest-update-u64-le DIGEST U64)</procedure>
381
382Update the {{DIGEST}} with a 64-bit integer {{U64}} treated as little-endian.
383
384=== Message Digest Update Item
385
386Provides digest update operations for Scheme objects.
387
388==== Usage
389
390<enscript highlight=scheme>
391(use message-digest-update-item)
392</enscript>
393
394==== message-digest-update-file
395
396<procedure>(message-digest-update-file DIGEST FILENAME)</procedure>
397
398Update the {{DIGEST}} with the contents of file {{FILENAME}}.
399
400==== message-digest-update-procedure
401
402<procedure>(message-digest-update-procedure DIGEST THUNK)</procedure>
403
404Update the {{DIGEST}} with a {{THUNK}} until it returns {{#f}}.
405
406{{THUNK}} is a {{(procedure () <byte-source>)}}.
407
408==== message-digest-update-port
409
410<procedure>(message-digest-update-port DIGEST INPUT-PORT)</procedure>
411
412Update the {{DIGEST}} with {{<byte-source>}} from an {{INPUT-PORT}} until
413{{#!eof}} encountered.
414
415Uses the {{message-digest-chunk-read-maker}} to create a reader for the port.
416
417==== message-digest-update-object
418
419<procedure>(message-digest-update-object DIGEST SOURCE)</procedure>
420
421Update the {{DIGEST}} with some {{SOURCE}}.
422
423{{SOURCE}} maybe an {{input-port}} (as in {{message-digest-update-port}}),
424{{procedure}} (as in {{message-digest-update-procedure}}), {{string}}, {{blob}},
425{{srfi-4-vector}}, or anything a supplied {{message-digest-chunk-converter}} recognizes &
426can convert into a {{<byte-source>}}.
427
428=== Message Digest Item
429
430Provides digest operations for whole Scheme objects.
431
432==== Usage
433
434<enscript highlight=scheme>
435(use message-digest-item)
436</enscript>
437
438==== message-digest-object
439
440<procedure>(message-digest-object PRIMITIVE SOURCE [RESULT-FORM]) => <result></procedure>
441
442Returns the {{RESULT}} for the digest algorithm {{PRIMITIVE}} applied to
443{{SOURCE}} in the {{RESULT-FORM}}.
444
445{{RESULT-FORM}} default is {{'hex}}.
446
447Performs all three phases.
448
449==== message-digest-file
450
451<procedure>(message-digest-file PRIMITIVE FILENAME [RESULT-FORM]) => <result></procedure>
452
453Returns the {{<result>}} for the digest algorithm {{PRIMITIVE}} applied to
454the file {{FILENAME}} in the {{RESULT-FORM}}. Reads until {{#!eof}} encountered.
455
456{{RESULT-FORM}} default is {{'hex}}.
457
458Performs all three phases.
459
460==== message-digest-port
461
462<procedure>(message-digest-port PRIMITIVE INPUT-PORT [RESULT-FORM]) => <result></procedure>
463
464Returns the {{<result>}} for the digest algorithm {{PRIMITIVE}} applied to
465{{INPUT-PORT}} in the {{RESULT-FORM}}. Reads until {{#!eof}} encountered.
466
467{{RESULT-FORM}} default is {{'hex}}.
468
469=== Message Digest SRFI 4
470
471Provides digest operations for SRFI-4 packed-vectors.
472
473==== Usage
474
475<enscript highlight=scheme>
476(use message-digest-srfi-4)
477</enscript>
478
479==== message-digest-update-u8vector
480
481<procedure>(message-digest-update-u8vector DIGEST U8VECTOR)</procedure>
482
483Update the {{DIGEST}} with a {{U8VECTOR}}.
484
485==== message-digest-update-subu8vector (DEPRECATED)
486
487<procedure>(message-digest-update-subu8vector DIGEST U8VECTOR START END)</procedure>
488
489Update the {{DIGEST}} with a subvector {{U8VECTOR START END}}.
490
491==== message-digest-update-bytevector (DEPRECATED)
492
493<procedure>(message-digest-update-bytevector DIGEST BYTEVECTOR [LENGTH])</procedure>
494
495Update the {{DIGEST}} with the {{BYTEVECTOR}}, a {{blob}}, {{string}}, or
496{{srfi-4-vector}}.
497
498The {{LENGTH}} is the byte count. Default is the size in bytes of the
499{{BYTEVECTOR}}.
500
501==== message-digest-u8vector
502
503<procedure>(message-digest-u8vector PRIMITIVE U8VECTOR [RESULT-FORM]) => <result></procedure>
504
505Returns the {{<result>}} for the digest algorithm {{PRIMITIVE}} applied to
506{{U8VECTOR}} in the {{RESULT-FORM}}.
507
508{{RESULT-FORM}} default is {{'hex}}.
509
510Performs all three phases.
511
512=== Message Digest Port
513
514Provides a {{port}} abstraction for a {{message-digest-primitive}}.
515
516==== Usage
517
518<enscript highlight=scheme>
519(use message-digest-port)
520</enscript>
521
522==== Common Argument Definitions
523
524{{PORT}} is a {{digest-output-port}}.
525
526==== digest-output-port
527
528<procedure>(digest-output-port? OBJ) => boolean</procedure>
529<procedure>(check-digest-output-port LOC OBJ [NAM])</procedure>
530<procedure>(error-digest-output-port LOC OBJ [NAM])</procedure>
531<procedure>(digest-output-port-name PORT) => string</procedure>
532
533==== open-output-digest
534
535<procedure>(open-output-digest PRIMITIVE) => digest-output-port</procedure>
536
537Returns a message digest output port for the supplied algorithm {{PRIMITIVE}}.
538
539The initialization phase.
540
541==== get-output-digest
542
543<procedure>(get-output-digest PORT [RESULT-TYPE 'hex]) => string</procedure>
544
545Closes the {{PORT}} and returns the result as a {{RESULT-TYPE}}.
546
547The finalization phase.
548
549==== call-with-output-digest
550
551<procedure>(call-with-output-digest PRIMITIVE PROCEDURE/1 [RESULT-FORM]) => <result></procedure>
552
553Invoke the procedure {{PROCEDURE PORT}} with {{digest-output-port}} and return
554{{<result>}} in the {{RESULT-FORM}}.
555
556{{RESULT-FORM}} default is {{'hex}}.
557
558Performs all three phases.
559
560==== with-output-to-digest
561
562<procedure>(with-output-to-digest PRIMITIVE THUNK [RESULT-FORM]) => <result></procedure>
563
564Invoke the procedure {{THUNK}} with {{(current-output-port)}} bound to a
565{{digest-output-port}} and return {{<result>}} in the {{RESULT-FORM}}.
566
567{{RESULT-FORM}} default is {{'hex}}.
568
569Performs all three phases.
570
571
572== Usage
573
574message-digest-primitive, message-digest-type, message-digest-parameters,
575message-digest-bv, message-digest-int
576
577<enscript highlight=scheme>
578(use message-digest-basic)
579</enscript>
580
581Everything in message-digest-basic plus message-digest-srfi-4,
582message-digest-update-item, message-digest-item
583
584<enscript highlight=scheme>
585(use message-digest)
586</enscript>
587
588
589== Examples
590
591Uses the message-digest port abstraction to get an MD5 digest of a string:
592
593<enscript highlight=scheme>
594(use message-digest-port)
595(use md5)    ; Or sha1, or sha2, ...
596
597(call-with-output-digest (md5-primitive) (cut display "foo" <>))
598;=> "acbd18db4cc2f85cedef654fccc4a4d8"
599</enscript>
600
601
602== Bugs and Limitations
603
604* Only messages on a byte-boundary supported. Bit-boundary messages are not handled.
605
606* The number update routines will not process an {{integer}} represented
607as anything other than a {{fixnum}} or {{flonum}}.
608
609* Since Chicken does not really have a binary port the {{digest-output-port}} will
610only accumulate strings.
611
612For example, writing a 16-bit integer is actually writing the result of
613{{number->string}} and not the 16-bit value itself! To get this effect the
614value must first be packed into a {{string}} and then written.
615
616However, the {{extras#write-byte}} routine should function as expected with a
617{{digest-output-port}}.
618
619* The chunk-converter and port-reader interface is clumsy.
620
621
622== Notes
623
624* If someone needs to construct a {{message-digest}} phase procedure that
625cannot be built upon the existing public API please contact the maintainer.
626There are some routines that can be exported to aid in such a project.
627
628It must be pointed out, though, that the message-digest port API is implemented
629using only the existing public API.
630
631* Should the default message-digest result-form be held by a ''"parameter"''
632object?
633
634
635== Requirements
636
637[[miscmacros|miscmacros]]
638[[check-errors|check-errors]]
639
640
641== Author
642
643[[/users/kon-lovett|Kon Lovett]]
644
645
646== Version history
647
648; 3.1.1 : Fix {{check-u8vector}} import.
649; 3.1.0 : Added optional {{message-digest-primitive-block-length}}.
650; 3.0.5 : Reverted 64 bit support.
651; 3.0.4 : Removed 64 bit support.
652; 3.0.3 :
653; 3.0.2 : Use of compiled setup-helper.
654; 3.0.1 :
655; 3.0.0 : Removed deprecated procedures to own module. Removed integer packing procedures. Split into many modules. Deprecated some procedures.
656; 2.3.8 : Treat integers as unsigned. (Ticket #534) Uses blob for finalization result buffer.
657; 2.3.7 : Remove no checks optimization compier options.
658; 2.3.6 : Deprecated close-output-digest. Restricted no checks optimization compier option.
659; 2.3.5 : The {{'u8vector}} {{RESULT-FORM}} is slightly faster. Revert to allocated context memory.
660; 2.3.4 : Try w/o C-level memory allocation so no finalizer needed.
661; 2.3.3 : The {{'blob}} {{RESULT-FORM}} is slightly faster.
662; 2.3.2 : Deprecated {{byte-string->hexadecimal}}. Deprecated {{string->hex}}, use [[string-utils]] {{string-hexadecimal#string->hex}}. Fix for the default {{message-digest-chunk-read-maker}}, blob was always chunk-size.
663; 2.3.1 : Moved some utility routines into own egg(s).
664; 2.3.0 : Added {{message-digest-update-char-u8}}, {{message-digest-update-char-be}}, and {{message-digest-update-char-le}}. {{message-digest-update-char}} now treats the actual bit-width of char correctly.
665; 2.2.0 : Added [[Byte Packing]] API. Downgraded {{message-digest-chunk-read-maker}}, {{message-digest-chunk-size}} & {{message-digest-chunk-converter}} from {{parameter}}.
666; 2.1.1 : Bug fix for hexstring: must use lowercase.
667; 2.1.0 : Added message digest "phase" and port APIs. Deprecated old API.
668; 2.0.1 : Bug fix for {{(message-digest-chunk-converter)}} use by {{make-binary-message-digest}}.
669; 2.0.0 : Release for Chicken 4 [From a diff provided by Christian Kellermann]
670
671
672== License
673
674  Copyright (C) 2006-2014 Kon Lovett.  All rights reserved.
675
676  Permission is hereby granted, free of charge, to any person obtaining a
677  copy of this software and associated documentation files (the Software),
678  to deal in the Software without restriction, including without limitation
679  the rights to use, copy, modify, merge, publish, distribute, sublicense,
680  and/or sell copies of the Software, and to permit persons to whom the
681  Software is furnished to do so, subject to the following conditions:
682
683  The above copyright notice and this permission notice shall be included
684  in all copies or substantial portions of the Software.
685
686  THE SOFTWARE IS PROVIDED ASIS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
687  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
688  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
689  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
690  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
691  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
692  OTHER DEALINGS IN THE SOFTWARE.
Note: See TracBrowser for help on using the repository browser.