ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- PKq]FppBase/reset-i.rinu[U:RDoc::AnyMethod[iI" reset:ETI"Digest::Base#reset;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"=Reset the digest to its initial state and return +self+.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"&digest_base.reset -> digest_base ;T0[I"();T@FI" Base;TcRDoc::NormalClass00PKq]~Base/update-i.rinu[U:RDoc::AnyMethod[iI" update:ETI"Digest::Base#update;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I">Update the digest using given _string_ and return +self+.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"Tdigest_base.update(string) -> digest_base digest_base << string -> digest_base ;T0[[I"<<;T@ I" (p1);T@FI" Base;TcRDoc::NormalClass00PKq]yyBase/digest_length-i.rinu[U:RDoc::AnyMethod[iI"digest_length:ETI"Digest::Base#digest_length;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"2Return the length of the hash value in bytes.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"*digest_base.digest_length -> Integer ;T0[I"();T@FI" Base;TcRDoc::NormalClass00PKq]>4FFBase/cdesc-Base.rinu[U:RDoc::NormalClass[iI" Base:ETI"Digest::Base;TI"Digest::Class;To:RDoc::Markup::Document: @parts[o;;[o:RDoc::Markup::Paragraph;[I"GThis abstract class provides a common interface to message digest ;TI")implementation classes written in C.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[[[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[; [[; [[;[[[U:RDoc::Context::Section[i0o;;[; 0; 0[I"+ext/digest/bubblebabble/bubblebabble.c;TI" Digest;TcRDoc::NormalModulePKq]^ $xxBase/block_length-i.rinu[U:RDoc::AnyMethod[iI"block_length:ETI"Digest::Base#block_length;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"4Return the block length of the digest in bytes.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I")digest_base.block_length -> Integer ;T0[I"();T@FI" Base;TcRDoc::NormalClass00PKq]I"hhBase/%3c%3c-i.rinu[U:RDoc::AnyMethod[iI"<<:ETI"Digest::Base#<<;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I">Update the digest using given _string_ and return +self+.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below000[I" (p1);T@FI" Base;TcRDoc::NormalClass0[I"Digest::Base;TFI" update;TPKq]l)SHA1/cdesc-SHA1.rinu[U:RDoc::NormalClass[iI" SHA1:ETI"Digest::SHA1;TI"cDigest_Base;To:RDoc::Markup::Document: @parts[o;;[: @fileI"ext/digest/sha1/sha1init.c;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[[[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[; [[; [[; [[[U:RDoc::Context::Section[i0o;;[; 0; 0[I"+ext/digest/bubblebabble/bubblebabble.c;TI" Digest;TcRDoc::NormalModulePKq]tkژInstance/digest%21-i.rinu[U:RDoc::AnyMethod[iI" digest!:ETI"Digest::Instance#digest!;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"CReturns the resulting hash value and resets the digest to the ;TI"initial state.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I""digest_obj.digest! -> string ;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]```Instance/length-i.rinu[U:RDoc::AnyMethod[iI" length:ETI"Digest::Instance#length;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"(Returns digest_obj.digest_length().;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"!digest_obj.length -> integer;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]JyJJInstance/cdesc-Instance.rinu[U:RDoc::NormalModule[iI" Instance:ETI"Digest::Instance;T0o:RDoc::Markup::Document: @parts[o;;[: @fileI"+ext/digest/bubblebabble/bubblebabble.c;T:0@omit_headings_from_table_of_contents_below0o;;[o:RDoc::Markup::Paragraph;[I"GThis module provides instance methods for a digest implementation ;TI"/object to calculate message digest values.;T; I"ext/digest/digest.c;T; 0o;;[; I"ext/digest/lib/digest.rb;T; 0; 0; 0[[[[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[; [[I"<<;TI"ext/digest/digest.c;T[I"==;T@,[I"base64digest;FI"ext/digest/lib/digest.rb;T[I"base64digest!;F@1[I"block_length;T@,[I"bubblebabble;TI"+ext/digest/bubblebabble/bubblebabble.c;T[I" digest;T@,[I" digest!;T@,[I"digest_length;T@,[I" file;F@1[I"hexdigest;T@,[I"hexdigest!;T@,[I" inspect;T@,[I" length;T@,[I"new;T@,[I" reset;T@,[I" size;T@,[I" to_s;T@,[I" update;T@,[; [[;[[I" finish;T@,[[U:RDoc::Context::Section[i0o;;[; 0; 0[@ @I" Digest;TcRDoc::NormalModulePKq]<Instance/reset-i.rinu[U:RDoc::AnyMethod[iI" reset:ETI"Digest::Instance#reset;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"=Resets the digest to the initial state and returns self.;To:RDoc::Markup::BlankLineo; ; [I"?This method is overridden by each implementation subclass.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"$digest_obj.reset -> digest_obj ;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]e?qqInstance/inspect-i.rinu[U:RDoc::AnyMethod[iI" inspect:ETI"Digest::Instance#inspect;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"6Creates a printable version of the digest object.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I""digest_obj.inspect -> string ;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]l Instance/hexdigest-i.rinu[U:RDoc::AnyMethod[iI"hexdigest:ETI"Digest::Instance#hexdigest;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"IIf none is given, returns the resulting hash value of the digest in ;TI"4a hex-encoded form, keeping the digest's state.;To:RDoc::Markup::BlankLineo; ; [I"BIf a _string_ is given, returns the hash value for the given ;TI"I_string_ in a hex-encoded form, resetting the digest to the initial ;TI"(state before and after the process.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"Kdigest_obj.hexdigest -> string digest_obj.hexdigest(string) -> string ;T0[I"(p1 = v1);T@FI" Instance;TcRDoc::NormalModule00PKq]DUInstance/base64digest%21-i.rinu[U:RDoc::AnyMethod[iI"base64digest!:EFI"#Digest::Instance#base64digest!;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"CReturns the resulting hash value and resets the digest to the ;TI"initial state.;T: @fileI"ext/digest/lib/digest.rb;T:0@omit_headings_from_table_of_contents_below000[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]Instance/new-i.rinu[U:RDoc::AnyMethod[iI"new:ETI"Digest::Instance#new;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"GReturns a new, initialized copy of the digest object. Equivalent ;TI"#to digest_obj.clone().reset().;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"*digest_obj.new -> another_digest_obj ;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq].CCInstance/update-i.rinu[U:RDoc::AnyMethod[iI" update:ETI"Digest::Instance#update;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"@Updates the digest using a given _string_ and returns self.;To:RDoc::Markup::BlankLineo; ; [I"GThe update() method and the left-shift operator are overridden by ;TI"Ceach implementation subclass. (One should be an alias for the ;TI" other);T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I",digest_obj.update(string) -> digest_obj;T0[I" (p1);T@FI" Instance;TcRDoc::NormalModule00PKq]pttInstance/file-i.rinu[U:RDoc::AnyMethod[iI" file:EFI"Digest::Instance#file;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"EUpdates the digest with the contents of a given file _name_ and ;TI"returns self.;T: @fileI"ext/digest/lib/digest.rb;T:0@omit_headings_from_table_of_contents_below000[I" (name);T@FI" Instance;TcRDoc::NormalModule00PKq]"e**Instance/digest_length-i.rinu[U:RDoc::AnyMethod[iI"digest_length:ETI"#Digest::Instance#digest_length;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"8Returns the length of the hash value of the digest.;To:RDoc::Markup::BlankLineo; ; [I"GThis method should be overridden by each implementation subclass. ;TI"6If not, digest_obj.digest().length() is returned.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I")digest_obj.digest_length -> integer ;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]MtZZInstance/size-i.rinu[U:RDoc::AnyMethod[iI" size:ETI"Digest::Instance#size;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"(Returns digest_obj.digest_length().;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"digest_obj.size -> integer;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]uInstance/base64digest-i.rinu[U:RDoc::AnyMethod[iI"base64digest:EFI""Digest::Instance#base64digest;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"FIf none is given, returns the resulting hash value of the digest ;TI":in a base64 encoded form, keeping the digest's state.;To:RDoc::Markup::BlankLineo; ; [I"BIf a +string+ is given, returns the hash value for the given ;TI"D+string+ in a base64 encoded form, resetting the digest to the ;TI"0initial state before and after the process.;T@o; ; [I"FIn either case, the return value is properly padded with '=' and ;TI"contains no line feeds.;T: @fileI"ext/digest/lib/digest.rb;T:0@omit_headings_from_table_of_contents_below000[I"(str = nil);T@FI" Instance;TcRDoc::NormalModule00PKq]*Q'VVInstance/to_s-i.rinu[U:RDoc::AnyMethod[iI" to_s:ETI"Digest::Instance#to_s;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"$Returns digest_obj.hexdigest().;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"digest_obj.to_s -> string ;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]\TInstance/finish-i.rinu[U:RDoc::AnyMethod[iI" finish:ETI"Digest::Instance#finish;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I">Finishes the digest and returns the resulting hash value.;To:RDoc::Markup::BlankLineo; ; [ I"IThis method is overridden by each implementation subclass and often ;TI"Gmade private, because some of those subclasses may leave internal ;TI"Edata uninitialized. Do not call this method from outside. Use ;TI"G#digest!() instead, which ensures that internal data be reset for ;TI"security reasons.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"7digest_obj.instance_eval { finish } -> digest_obj ;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]81Instance/digest-i.rinu[U:RDoc::AnyMethod[iI" digest:ETI"Digest::Instance#digest;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"GIf none is given, returns the resulting hash value of the digest, ;TI" keeping the digest's state.;To:RDoc::Markup::BlankLineo; ; [I"BIf a _string_ is given, returns the hash value for the given ;TI"D_string_, resetting the digest to the initial state before and ;TI"after the process.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"Edigest_obj.digest -> string digest_obj.digest(string) -> string ;T0[I"(p1 = v1);T@FI" Instance;TcRDoc::NormalModule00PKq]aVInstance/hexdigest%21-i.rinu[U:RDoc::AnyMethod[iI"hexdigest!:ETI" Digest::Instance#hexdigest!;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"GReturns the resulting hash value in a hex-encoded form and resets ;TI"%the digest to the initial state.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"%digest_obj.hexdigest! -> string ;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]+ZInstance/block_length-i.rinu[U:RDoc::AnyMethod[iI"block_length:ETI""Digest::Instance#block_length;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I",Returns the block length of the digest.;To:RDoc::Markup::BlankLineo; ; [I"?This method is overridden by each implementation subclass.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"(digest_obj.block_length -> integer ;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]SۧInstance/bubblebabble-i.rinu[U:RDoc::AnyMethod[iI"bubblebabble:ETI""Digest::Instance#bubblebabble;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"EReturns the resulting hash value in a Bubblebabble encoded form.;T: @fileI"+ext/digest/bubblebabble/bubblebabble.c;T:0@omit_headings_from_table_of_contents_below0I",digest_obj.bubblebabble -> hash_string ;T0[I"();T@FI" Instance;TcRDoc::NormalModule00PKq]AQ66Instance/%3c%3c-i.rinu[U:RDoc::AnyMethod[iI"<<:ETI"Digest::Instance#<<;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"@Updates the digest using a given _string_ and returns self.;To:RDoc::Markup::BlankLineo; ; [I"GThe update() method and the left-shift operator are overridden by ;TI"Ceach implementation subclass. (One should be an alias for the ;TI" other);T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"'digest_obj << string -> digest_obj;T0[I" (p1);T@FI" Instance;TcRDoc::NormalModule00PKq]זNNInstance/%3d%3d-i.rinu[U:RDoc::AnyMethod[iI"==:ETI"Digest::Instance#==;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"IIf a string is given, checks whether it is equal to the hex-encoded ;TI"Ehash value of the digest object. If another digest instance is ;TI"Egiven, checks whether they have the same hash value. Otherwise ;TI"returns false.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"Qdigest_obj == another_digest_obj -> boolean digest_obj == string -> boolean ;T0[I" (p1);T@FI" Instance;TcRDoc::NormalModule00PKq]ԅRMD160/cdesc-RMD160.rinu[U:RDoc::NormalClass[iI" RMD160:ETI"Digest::RMD160;TI"cDigest_Base;To:RDoc::Markup::Document: @parts[o;;[: @fileI"#ext/digest/rmd160/rmd160init.c;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[[[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[; [[; [[; [[[U:RDoc::Context::Section[i0o;;[; 0; 0[I"+ext/digest/bubblebabble/bubblebabble.c;TI" Digest;TcRDoc::NormalModulePKq]zOhexencode-c.rinu[U:RDoc::AnyMethod[iI"hexencode:ETI"Digest::hexencode;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"9Generates a hex-encoded version of a given _string_.;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I"3Digest.hexencode(string) -> hexencoded_string ;T0[I" (p1);T@FI" Digest;TcRDoc::NormalModule00PKq] dcdesc-Digest.rinu[U:RDoc::NormalModule[iI" Digest:ET@0o:RDoc::Markup::Document: @parts[ o;;[: @fileI"+ext/digest/bubblebabble/bubblebabble.c;T:0@omit_headings_from_table_of_contents_below0o;;[o:RDoc::Markup::Paragraph;[I"CThis module provides a framework for message digest libraries.;To:RDoc::Markup::BlankLineo; ;[I"LYou may want to look at OpenSSL::Digest as it supports more algorithms.;T@o; ;[ I"PA cryptographic hash function is a procedure that takes data and returns a ;TI"Nfixed bit string: the hash value, also known as _digest_. Hash functions ;TI"Lare also called one-way functions, it is easy to compute a digest from ;TI"Ia message, but it is infeasible to generate a message from a digest.;T@S:RDoc::Markup::Heading: leveli: textI" Examples;T@o:RDoc::Markup::Verbatim;[I"require 'digest' ;TI" ;TI"!# Compute a complete digest ;TI"EDigest::SHA256.digest 'message' #=> "\xABS\n\x13\xE4Y..." ;TI" ;TI"!sha256 = Digest::SHA256.new ;TI"Esha256.digest 'message' #=> "\xABS\n\x13\xE4Y..." ;TI" ;TI"# Other encoding formats ;TI"ADigest::SHA256.hexdigest 'message' #=> "ab530a13e459..." ;TI"ADigest::SHA256.base64digest 'message' #=> "q1MKE+RZFJgr..." ;TI" ;TI" # Compute digest by chunks ;TI"md5 = Digest::MD5.new ;TI"md5.update 'message1' ;TI"Gmd5 << 'message2' # << is an alias for update ;TI" ;TI"Amd5.hexdigest #=> "94af09c09bb9..." ;TI" ;TI"!# Compute digest for a file ;TI"-sha256 = Digest::SHA256.file 'testfile' ;TI"sha256.hexdigest ;T: @format0o; ;[I"QAdditionally digests can be encoded in "bubble babble" format as a sequence ;TI"Oof consonants and vowels which is more recognizable and comparable than a ;TI"hexadecimal digest.;T@o;;[I"#require 'digest/bubblebabble' ;TI" ;TI"GDigest::SHA256.bubblebabble 'message' #=> "xopoh-fedac-fenyh-..." ;T;0o; ;[I",See the bubble babble specification at ;TI"Thttp://web.mit.edu/kenta/www/one/bubblebabble/spec/jrtrjwzi/draft-huima-01.txt.;T@S; ;i;I"Digest algorithms;T@o; ;[I"CDifferent digest algorithms (or hash functions) are available:;T@o:RDoc::Markup::List: @type: NOTE: @items[ o:RDoc::Markup::ListItem: @label[I" HMAC;T;[o; ;[I"HSee FIPS PUB 198 The Keyed-Hash Message Authentication Code (HMAC).;To;;[I"RIPEMD-160;T;[o; ;[I"As Digest::RMD160. ;TI"@See http://homes.esat.kuleuven.be/~bosselae/ripemd160.html.;To;;[I" SHA1;T;[o; ;[I"'See FIPS 180 Secure Hash Standard.;To;;[I"SHA2 family;T;[o; ;[I"NSee FIPS 180 Secure Hash Standard which defines the following algorithms:;To;;: BULLET;[o;;0;[o; ;[I" SHA512;To;;0;[o; ;[I" SHA384;To;;0;[o; ;[I" SHA256;T@o; ;[I"EThe latest versions of the FIPS publications can be found here: ;TI"5http://csrc.nist.gov/publications/PubsFIPS.html.;T; I"ext/digest/digest.c;T; 0o;;[; I"ext/digest/lib/digest.rb;T; 0o;;[; I""ext/digest/lib/digest/hmac.rb;T; 0o;;[; I"ext/digest/md5/md5init.c;T; 0o;;[; I"#ext/digest/rmd160/rmd160init.c;T; 0o;;[; I"ext/digest/sha1/sha1init.c;T; 0; 0; 0[[[[[I" class;T[[: public[[I"bubblebabble;TI"+ext/digest/bubblebabble/bubblebabble.c;T[I"hexencode;TI"ext/digest/digest.c;T[:protected[[: private[[I" instance;T[[;[[;[[;[[[U:RDoc::Context::Section[i0o;;[; 0; 0[@ @}@{@~@@@I"lib/cgi/session.rb;TI"lib/cgi/session/pstore.rb;TI"lib/net/imap.rb;TI"lib/net/pop.rb;TI"lib/net/smtp.rb;TI"lib/pstore.rb;TI"'lib/rubygems/package/tar_writer.rb;TI"lib/rubygems/source/git.rb;TI"'lib/webrick/httpauth/digestauth.rb;T@cRDoc::TopLevelPKq]T4bubblebabble-c.rinu[U:RDoc::AnyMethod[iI"bubblebabble:ETI"Digest::bubblebabble;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"@Returns a BubbleBabble encoded version of a given _string_.;T: @fileI"+ext/digest/bubblebabble/bubblebabble.c;T:0@omit_headings_from_table_of_contents_below0I"8Digest.bubblebabble(string) -> bubblebabble_string ;T0[I" (p1);T@FI" Digest;TcRDoc::NormalModule00PKq]DZxMD5/cdesc-MD5.rinu[U:RDoc::NormalClass[iI"MD5:ETI"Digest::MD5;TI"cDigest_Base;To:RDoc::Markup::Document: @parts[o;;[: @fileI"ext/digest/md5/md5init.c;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[[[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[; [[; [[; [[[U:RDoc::Context::Section[i0o;;[; 0; 0[I"+ext/digest/bubblebabble/bubblebabble.c;TI"lib/cgi/session.rb;TI"'lib/webrick/httpauth/digestauth.rb;TI" Digest;TcRDoc::NormalModulePKq]~ttSHA2/reset-i.rinu[U:RDoc::AnyMethod[iI" reset:ETI"Digest::SHA2#reset;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I";Reset the digest to the initial state and return self.;T: @fileI" ext/digest/sha2/lib/sha2.rb;T:0@omit_headings_from_table_of_contents_below0I"$digest_obj.reset -> digest_obj ;T0[I"();T@FI" SHA2;TcRDoc::NormalClass00PKq]W  SHA2/new-c.rinu[U:RDoc::AnyMethod[iI"new:ETI"Digest::SHA2::new;TT: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I";Create a new SHA2 hash object with a given bit length.;To:RDoc::Markup::BlankLineo; ; [I",Valid bit lengths are 256, 384 and 512.;T: @fileI" ext/digest/sha2/lib/sha2.rb;T:0@omit_headings_from_table_of_contents_below0I"2Digest::SHA2.new(bitlen = 256) -> digest_obj ;T0[I"(bitlen = 256);T@FI" SHA2;TcRDoc::NormalClass00PKq]SYSHA2/update-i.rinu[U:RDoc::AnyMethod[iI" update:ETI"Digest::SHA2#update;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I">Update the digest using a given _string_ and return self.;T: @fileI" ext/digest/sha2/lib/sha2.rb;T:0@omit_headings_from_table_of_contents_below0I"Pdigest_obj.update(string) -> digest_obj digest_obj << string -> digest_obj ;T0[[I"<<;To;; [; @; 0I" (str);T@FI" SHA2;TcRDoc::NormalClass00PKq]1{SHA2/digest_length-i.rinu[U:RDoc::AnyMethod[iI"digest_length:ETI"Digest::SHA2#digest_length;TF: privateo:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"?Return the length of the hash value (the digest) in bytes.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"*Digest::SHA256.new.digest_length * 8 ;TI"# => 256 ;TI"*Digest::SHA384.new.digest_length * 8 ;TI"# => 384 ;TI"*Digest::SHA512.new.digest_length * 8 ;TI"# => 512 ;T: @format0o; ; [I"MFor example, digests produced by Digest::SHA256 will always be 32 bytes ;TI"(256 bits) in size.;T: @fileI" ext/digest/sha2/lib/sha2.rb;T:0@omit_headings_from_table_of_contents_below0I")digest_obj.digest_length -> Integer ;T0[I"();T@FI" SHA2;TcRDoc::NormalClass00PKq]<7 }SHA2/cdesc-SHA2.rinu[U:RDoc::NormalClass[iI" SHA2:ETI"Digest::SHA2;TI"Digest::Class;To:RDoc::Markup::Document: @parts[o;;[ o:RDoc::Markup::Paragraph;[I"@A meta digest provider class for SHA256, SHA384 and SHA512.;To:RDoc::Markup::BlankLineo; ;[I"GFIPS 180-2 describes SHA2 family of digest algorithms. It defines ;TI"three algorithms:;To:RDoc::Markup::List: @type: BULLET: @items[o:RDoc::Markup::ListItem: @label0;[o; ;[I"Aone which works on chunks of 512 bits and returns a 256-bit ;TI"digest (SHA256),;To;;0;[o; ;[I"Bone which works on chunks of 1024 bits and returns a 384-bit ;TI"digest (SHA384),;To;;0;[o; ;[I"Fand one which works on chunks of 1024 bits and returns a 512-bit ;TI"digest (SHA512).;T@S:RDoc::Markup::Heading: leveli: textI" Examples;To:RDoc::Markup::Verbatim;[I"require 'digest' ;TI" ;TI"!# Compute a complete digest ;TI"?Digest::SHA2.hexdigest 'abc' # => "ba7816bf8..." ;TI"?Digest::SHA2.new(256).hexdigest 'abc' # => "ba7816bf8..." ;TI"?Digest::SHA256.hexdigest 'abc' # => "ba7816bf8..." ;TI" ;TI"?Digest::SHA2.new(384).hexdigest 'abc' # => "cb00753f4..." ;TI"?Digest::SHA384.hexdigest 'abc' # => "cb00753f4..." ;TI" ;TI"?Digest::SHA2.new(512).hexdigest 'abc' # => "ddaf35a19..." ;TI"?Digest::SHA512.hexdigest 'abc' # => "ddaf35a19..." ;TI" ;TI" # Compute digest by chunks ;TI"Csha2 = Digest::SHA2.new # =># ;TI"sha2.update "ab" ;TI"?sha2 << "c" # alias for #update ;TI"?sha2.hexdigest # => "ba7816bf8..." ;TI" ;TI"5# Use the same object to compute another digest ;TI"sha2.reset ;TI"sha2 << "message" ;TI">sha2.hexdigest # => "ab530a13e...";T: @format0: @fileI" ext/digest/sha2/lib/sha2.rb;T:0@omit_headings_from_table_of_contents_below0;0;0[[[[[I" class;T[[: public[[:protected[[: private[[I"new;TI" ext/digest/sha2/lib/sha2.rb;T[I" instance;T[[;[[;[[;[ [I"<<;T@U[I"block_length;T@U[I"digest_length;T@U[I" reset;T@U[I" update;T@U[[U:RDoc::Context::Section[i0o;;[;0;0[I" ext/digest/sha2/lib/sha2.rb;TI" Digest;TcRDoc::NormalModulePKq]̣ttSHA2/block_length-i.rinu[U:RDoc::AnyMethod[iI"block_length:ETI"Digest::SHA2#block_length;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"4Return the block length of the digest in bytes.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I")Digest::SHA256.new.block_length * 8 ;TI"# => 512 ;TI")Digest::SHA384.new.block_length * 8 ;TI"# => 1024 ;TI")Digest::SHA512.new.block_length * 8 ;TI"# => 1024;T: @format0: @fileI" ext/digest/sha2/lib/sha2.rb;T:0@omit_headings_from_table_of_contents_below0I"(digest_obj.block_length -> Integer ;T0[I"();T@FI" SHA2;TcRDoc::NormalClass00PKq]NSHA2/%3c%3c-i.rinu[U:RDoc::AnyMethod[iI"<<:ETI"Digest::SHA2#<<;TF: privateo:RDoc::Markup::Document: @parts[: @fileI" ext/digest/sha2/lib/sha2.rb;T:0@omit_headings_from_table_of_contents_below000[I" (str);T@ FI" SHA2;TcRDoc::NormalClass0[I"Digest::SHA2;TFI" update;TPKq]:::Class/cdesc-Class.rinu[U:RDoc::NormalClass[iI" Class:ETI"Digest::Class;TI" Object;To:RDoc::Markup::Document: @parts[o;;[: @fileI"+ext/digest/bubblebabble/bubblebabble.c;T:0@omit_headings_from_table_of_contents_below0o;;[o:RDoc::Markup::Paragraph;[I"BThis module stands as a base class for digest implementation ;TI" classes.;T; I"ext/digest/digest.c;T; 0o;;[; I"ext/digest/lib/digest.rb;T; 0; 0; 0[[[[I"Digest::Instance;To;;[; @; 0I"ext/digest/digest.c;T[[I" class;T[[: public[ [I"base64digest;FI"ext/digest/lib/digest.rb;T[I"bubblebabble;TI"+ext/digest/bubblebabble/bubblebabble.c;T[I" digest;T@ [I" file;F@)[I"hexdigest;T@ [:protected[[: private[[I" instance;T[[; [[; [[;[[[U:RDoc::Context::Section[i0o;;[; 0; 0[@@@cRDoc::TopLevelPKq]:}}Class/file-c.rinu[U:RDoc::AnyMethod[iI" file:EFI"Digest::Class::file;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"=Creates a digest object and reads a given file, _name_. ;TI"DOptional arguments are passed to the constructor of the digest ;TI" class.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I">p Digest::SHA256.file("X11R6.8.2-src.tar.bz2").hexdigest ;TI"L# => "f02e3c85572dc9ad7cb77c2a638e3be24cc1b5bea9fdbb0b0299c9668475c534";T: @format0: @fileI"ext/digest/lib/digest.rb;T:0@omit_headings_from_table_of_contents_below000[I"(name, *args);T@FI" Class;TcRDoc::NormalClass00PKq]I3DPPClass/digest-c.rinu[U:RDoc::AnyMethod[iI" digest:ETI"Digest::Class::digest;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"HReturns the hash value of a given _string_. This is equivalent to ;TI"@Digest::Class.new(*parameters).digest(string), where extra ;TI"I_parameters_, if any, are passed through to the constructor and the ;TI"%_string_ is passed to #digest().;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I">Digest::Class.digest(string, *parameters) -> hash_string ;T0[I" (*args);T@FI" Class;TcRDoc::NormalClass00PKq]Y,vClass/bubblebabble-c.rinu[U:RDoc::AnyMethod[iI"bubblebabble:ETI" Digest::Class::bubblebabble;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"EReturns the BubbleBabble encoded hash value of a given _string_.;T: @fileI"+ext/digest/bubblebabble/bubblebabble.c;T:0@omit_headings_from_table_of_contents_below0I" hash_string ;T0[I" (*args);T@FI" Class;TcRDoc::NormalClass00PKq]=GClass/base64digest-c.rinu[U:RDoc::AnyMethod[iI"base64digest:EFI" Digest::Class::base64digest;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"EReturns the base64 encoded hash value of a given _string_. The ;TI"Creturn value is properly padded with '=' and contains no line ;TI" feeds.;T: @fileI"ext/digest/lib/digest.rb;T:0@omit_headings_from_table_of_contents_below000[I"(str, *args);T@FI" Class;TcRDoc::NormalClass00PKq]BClass/hexdigest-c.rinu[U:RDoc::AnyMethod[iI"hexdigest:ETI"Digest::Class::hexdigest;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"FReturns the hex-encoded hash value of a given _string_. This is ;TI"almost equivalent to ;TI"EDigest.hexencode(Digest::Class.new(*parameters).digest(string)).;T: @fileI"ext/digest/digest.c;T:0@omit_headings_from_table_of_contents_below0I";Digest::Class.hexdigest(string[, ...]) -> hash_string ;T0[I" (*args);T@FI" Class;TcRDoc::NormalClass00PK ]  base.pmnu[package Digest::base; use strict; use vars qw($VERSION); $VERSION = "1.16"; # subclass is supposed to implement at least these sub new; sub clone; sub add; sub digest; sub reset { my $self = shift; $self->new(@_); # ugly } sub addfile { my ($self, $handle) = @_; my $n; my $buf = ""; while (($n = read($handle, $buf, 4*1024))) { $self->add($buf); } unless (defined $n) { require Carp; Carp::croak("Read failed: $!"); } $self; } sub add_bits { my $self = shift; my $bits; my $nbits; if (@_ == 1) { my $arg = shift; $bits = pack("B*", $arg); $nbits = length($arg); } else { ($bits, $nbits) = @_; } if (($nbits % 8) != 0) { require Carp; Carp::croak("Number of bits must be multiple of 8 for this algorithm"); } return $self->add(substr($bits, 0, $nbits/8)); } sub hexdigest { my $self = shift; return unpack("H*", $self->digest(@_)); } sub b64digest { my $self = shift; require MIME::Base64; my $b64 = MIME::Base64::encode($self->digest(@_), ""); $b64 =~ s/=+$//; return $b64; } 1; __END__ =head1 NAME Digest::base - Digest base class =head1 SYNOPSIS package Digest::Foo; use base 'Digest::base'; =head1 DESCRIPTION The C class provide implementations of the methods C and C in terms of C, and of the methods C and C in terms of C. Digest implementations might want to inherit from this class to get this implementations of the alternative I and I methods. A minimal subclass needs to implement the following methods by itself: new clone add digest The arguments and expected behaviour of these methods are described in L. =head1 SEE ALSO L PK ][QZZ HMAC_MD5.pmnu[package Digest::HMAC_MD5; $VERSION="1.01"; use strict; use Digest::MD5 qw(md5); use Digest::HMAC qw(hmac); # OO interface use vars qw(@ISA); @ISA=qw(Digest::HMAC); sub new { my $class = shift; $class->SUPER::new($_[0], "Digest::MD5", 64); } # Functional interface require Exporter; *import = \&Exporter::import; use vars qw(@EXPORT_OK); @EXPORT_OK=qw(hmac_md5 hmac_md5_hex); sub hmac_md5 { hmac($_[0], $_[1], \&md5, 64); } sub hmac_md5_hex { unpack("H*", &hmac_md5) } 1; __END__ =head1 NAME Digest::HMAC_MD5 - Keyed-Hashing for Message Authentication =head1 SYNOPSIS # Functional style use Digest::HMAC_MD5 qw(hmac_md5 hmac_md5_hex); $digest = hmac_md5($data, $key); print hmac_md5_hex($data, $key); # OO style use Digest::HMAC_MD5; $hmac = Digest::HMAC_MD5->new($key); $hmac->add($data); $hmac->addfile(*FILE); $digest = $hmac->digest; $digest = $hmac->hexdigest; $digest = $hmac->b64digest; =head1 DESCRIPTION This module provide HMAC-MD5 hashing. =head1 SEE ALSO L, L, L =head1 AUTHOR Gisle Aas =cut PK ]@I I HMAC.pmnu[package Digest::HMAC; $VERSION = "1.03"; use strict; # OO interface sub new { my($class, $key, $hasher, $block_size) = @_; $block_size ||= 64; $key = $hasher->new->add($key)->digest if length($key) > $block_size; my $self = bless {}, $class; $self->{k_ipad} = $key ^ (chr(0x36) x $block_size); $self->{k_opad} = $key ^ (chr(0x5c) x $block_size); $self->{hasher} = $hasher->new->add($self->{k_ipad}); $self; } sub reset { my $self = shift; $self->{hasher}->reset->add($self->{k_ipad}); $self; } sub add { my $self = shift; $self->{hasher}->add(@_); $self; } sub addfile { my $self = shift; $self->{hasher}->addfile(@_); $self; } sub _digest { my $self = shift; my $inner_digest = $self->{hasher}->digest; $self->{hasher}->reset->add($self->{k_opad}, $inner_digest); } sub digest { shift->_digest->digest; } sub hexdigest { shift->_digest->hexdigest; } sub b64digest { shift->_digest->b64digest; } # Functional interface require Exporter; *import = \&Exporter::import; use vars qw(@EXPORT_OK); @EXPORT_OK = qw(hmac hmac_hex); sub hmac { my($data, $key, $hash_func, $block_size) = @_; $block_size ||= 64; $key = &$hash_func($key) if length($key) > $block_size; my $k_ipad = $key ^ (chr(0x36) x $block_size); my $k_opad = $key ^ (chr(0x5c) x $block_size); &$hash_func($k_opad, &$hash_func($k_ipad, $data)); } sub hmac_hex { unpack("H*", &hmac); } 1; __END__ =head1 NAME Digest::HMAC - Keyed-Hashing for Message Authentication =head1 SYNOPSIS # Functional style use Digest::HMAC qw(hmac hmac_hex); $digest = hmac($data, $key, \&myhash); print hmac_hex($data, $key, \&myhash); # OO style use Digest::HMAC; $hmac = Digest::HMAC->new($key, "Digest::MyHash"); $hmac->add($data); $hmac->addfile(*FILE); $digest = $hmac->digest; $digest = $hmac->hexdigest; $digest = $hmac->b64digest; =head1 DESCRIPTION HMAC is used for message integrity checks between two parties that share a secret key, and works in combination with some other Digest algorithm, usually MD5 or SHA-1. The HMAC mechanism is described in RFC 2104. HMAC follow the common C interface, but the constructor takes the secret key and the name of some other simple C as argument. The hmac() and hmac_hex() functions and the Digest::HMAC->new() constructor takes an optional $blocksize argument as well. The HMAC algorithm assumes the digester to hash by iterating a basic compression function on blocks of data and the $blocksize should match the byte-length of such blocks. The default $blocksize is 64 which is suitable for the MD5 and SHA-1 digest functions. For stronger algorithms the blocksize probably needs to be increased. =head1 SEE ALSO L, L RFC 2104 =head1 AUTHORS Graham Barr , Gisle Aas =cut PK ]u file.pmnu[package Digest::file; use strict; use Exporter (); use Carp qw(croak); use Digest (); use vars qw($VERSION @ISA @EXPORT_OK); $VERSION = "1.16"; @ISA = qw(Exporter); @EXPORT_OK = qw(digest_file_ctx digest_file digest_file_hex digest_file_base64); sub digest_file_ctx { my $file = shift; croak("No digest algorithm specified") unless @_; local *F; open(F, "<", $file) || croak("Can't open '$file': $!"); binmode(F); my $ctx = Digest->new(@_); $ctx->addfile(*F); close(F); return $ctx; } sub digest_file { digest_file_ctx(@_)->digest; } sub digest_file_hex { digest_file_ctx(@_)->hexdigest; } sub digest_file_base64 { digest_file_ctx(@_)->b64digest; } 1; __END__ =head1 NAME Digest::file - Calculate digests of files =head1 SYNOPSIS # Poor mans "md5sum" command use Digest::file qw(digest_file_hex); for (@ARGV) { print digest_file_hex($_, "MD5"), " $_\n"; } =head1 DESCRIPTION This module provide 3 convenience functions to calculate the digest of files. The following functions are provided: =over =item digest_file( $file, $algorithm, [$arg,...] ) This function will calculate and return the binary digest of the bytes of the given file. The function will croak if it fails to open or read the file. The $algorithm is a string like "MD2", "MD5", "SHA-1", "SHA-512". Additional arguments are passed to the constructor for the implementation of the given algorithm. =item digest_file_hex( $file, $algorithm, [$arg,...] ) Same as digest_file(), but return the digest in hex form. =item digest_file_base64( $file, $algorithm, [$arg,...] ) Same as digest_file(), but return the digest as a base64 encoded string. =back =head1 SEE ALSO L PK ]?\H HMAC_SHA1.pmnu[package Digest::HMAC_SHA1; $VERSION="1.03"; use strict; use Digest::SHA qw(sha1); use Digest::HMAC qw(hmac); # OO interface use vars qw(@ISA); @ISA=qw(Digest::HMAC); sub new { my $class = shift; $class->SUPER::new($_[0], "Digest::SHA", 64); # Digest::SHA defaults to SHA-1 } # Functional interface require Exporter; *import = \&Exporter::import; use vars qw(@EXPORT_OK); @EXPORT_OK=qw(hmac_sha1 hmac_sha1_hex); sub hmac_sha1 { hmac($_[0], $_[1], \&sha1, 64); } sub hmac_sha1_hex { unpack("H*", &hmac_sha1) } 1; __END__ =head1 NAME Digest::HMAC_SHA1 - Keyed-Hashing for Message Authentication =head1 SYNOPSIS # Functional style use Digest::HMAC_SHA1 qw(hmac_sha1 hmac_sha1_hex); $digest = hmac_sha1($data, $key); print hmac_sha1_hex($data, $key); # OO style use Digest::HMAC_SHA1; $hmac = Digest::HMAC_SHA1->new($key); $hmac->add($data); $hmac->addfile(*FILE); $digest = $hmac->digest; $digest = $hmac->hexdigest; $digest = $hmac->b64digest; =head1 DESCRIPTION This module provide HMAC-SHA-1 hashing. =head1 SEE ALSO L, L, L =head1 AUTHOR Gisle Aas =cut PKa]&iiHMAC/reset-i.rinu[U:RDoc::AnyMethod[iI" reset:EFI"Digest::HMAC#reset;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I";Resets the hmac to the initial state and returns self.;T: @fileI""ext/digest/lib/digest/hmac.rb;T:0@omit_headings_from_table_of_contents_below0I"hmac.reset -> hmac ;T0[I"();T@FI" HMAC;TcRDoc::NormalClass00PKa]l+jjHMAC/inspect-i.rinu[U:RDoc::AnyMethod[iI" inspect:EFI"Digest::HMAC#inspect;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"4Creates a printable version of the hmac object.;T: @fileI""ext/digest/lib/digest/hmac.rb;T:0@omit_headings_from_table_of_contents_below0I"hmac.inspect -> string ;T0[I"();T@FI" HMAC;TcRDoc::NormalClass00PKa]82DD HMAC/new-c.rinu[U:RDoc::AnyMethod[iI"new:ETI"Digest::HMAC::new;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"%Creates a Digest::HMAC instance.;T: @fileI""ext/digest/lib/digest/hmac.rb;T:0@omit_headings_from_table_of_contents_below000[I"(key, digester);T@FI" HMAC;TcRDoc::NormalClass00PKa]'WHMAC/update-i.rinu[U:RDoc::AnyMethod[iI" update:EFI"Digest::HMAC#update;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I">Updates the hmac using a given +string+ and returns self.;T: @fileI""ext/digest/lib/digest/hmac.rb;T:0@omit_headings_from_table_of_contents_below0I"8hmac.update(string) -> hmac hmac << string -> hmac ;T0[[I"<<;To;; [; @; 0I" (text);T@FI" HMAC;TcRDoc::NormalClass00PKa]gHMAC/digest_length-i.rinu[U:RDoc::AnyMethod[iI"digest_length:EFI"Digest::HMAC#digest_length;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"AReturns the length in bytes of the hash value of the digest.;T: @fileI""ext/digest/lib/digest/hmac.rb;T:0@omit_headings_from_table_of_contents_below0I"#hmac.digest_length -> Integer ;T0[I"();T@FI" HMAC;TcRDoc::NormalClass00PKa]`oHMAC/cdesc-HMAC.rinu[U:RDoc::NormalClass[iI" HMAC:ETI"Digest::HMAC;TI"Digest::Class;To:RDoc::Markup::Document: @parts[o;;[S:RDoc::Markup::Heading: leveli: textI"digest/hmac.rb;To:RDoc::Markup::BlankLineo:RDoc::Markup::Paragraph;[I"CAn experimental implementation of HMAC keyed-hashing algorithm;T@S; ; i; I" Overview;T@o; ;[ I"?CAUTION: Use of this library is discouraged, because this ;TI"Jimplementation was meant to be experimental but somehow got into the ;TI"H1.9 series without being noticed. Please use OpenSSL::HMAC in the ;TI""openssl" library instead.;T@S; ; i; I" Examples;T@o:RDoc::Markup::Verbatim;[I"require 'digest/hmac' ;TI" ;TI"# one-liner example ;TI"Cputs Digest::HMAC.hexdigest("data", "hash key", Digest::SHA1) ;TI" ;TI"# rather longer one ;TI"4hmac = Digest::HMAC.new("foo", Digest::RMD160) ;TI" ;TI"buf = "" ;TI"#while stream.read(16384, buf) ;TI" hmac.update(buf) ;TI" end ;TI" ;TI"puts hmac.hexdigest;T: @format0: @fileI""ext/digest/lib/digest/hmac.rb;T:0@omit_headings_from_table_of_contents_below0;0;0[[[[[I" class;T[[: public[[I"new;TI""ext/digest/lib/digest/hmac.rb;T[:protected[[: private[[I" instance;T[[;[ [I"<<;T@:[I"block_length;F@:[I"digest_length;F@:[I" inspect;F@:[I" reset;F@:[I" update;F@:[;[[;[[[U:RDoc::Context::Section[i0o;;[;0;0[@.I" Digest;TcRDoc::NormalModulePKa]I[yyHMAC/block_length-i.rinu[U:RDoc::AnyMethod[iI"block_length:EFI"Digest::HMAC#block_length;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"3Returns the block length in bytes of the hmac.;T: @fileI""ext/digest/lib/digest/hmac.rb;T:0@omit_headings_from_table_of_contents_below0I""hmac.block_length -> Integer ;T0[I"();T@FI" HMAC;TcRDoc::NormalClass00PKa]\炌HMAC/%3c%3c-i.rinu[U:RDoc::AnyMethod[iI"<<:ETI"Digest::HMAC#<<;TF: publico:RDoc::Markup::Document: @parts[: @fileI""ext/digest/lib/digest/hmac.rb;T:0@omit_headings_from_table_of_contents_below000[I" (text);T@ FI" HMAC;TcRDoc::NormalClass0[I"Digest::HMAC;TFI" update;FPKq]FppBase/reset-i.rinu[PKq]~Base/update-i.rinu[PKq]yyBase/digest_length-i.rinu[PKq]>4FF_Base/cdesc-Base.rinu[PKq]^ $xxBase/block_length-i.rinu[PKq]I"hh Base/%3c%3c-i.rinu[PKq]l)M SHA1/cdesc-SHA1.rinu[PKq]tkژH Instance/digest%21-i.rinu[PKq]```"Instance/length-i.rinu[PKq]JyJJInstance/cdesc-Instance.rinu[PKq]<ZInstance/reset-i.rinu[PKq]e?qqwInstance/inspect-i.rinu[PKq]l -Instance/hexdigest-i.rinu[PKq]DU>Instance/base64digest%21-i.rinu[PKq] Instance/new-i.rinu[PKq].CCInstance/update-i.rinu[PKq]ptt{"Instance/file-i.rinu[PKq]"e**1$Instance/digest_length-i.rinu[PKq]MtZZ&Instance/size-i.rinu[PKq]uB(Instance/base64digest-i.rinu[PKq]*Q'VV+Instance/to_s-i.rinu[PKq]\T%-Instance/finish-i.rinu[PKq]81U0Instance/digest-i.rinu[PKq]aV+3Instance/hexdigest%21-i.rinu[PKq]+Z'5Instance/block_length-i.rinu[PKq]SۧL7Instance/bubblebabble-i.rinu[PKq]AQ66=9Instance/%3c%3c-i.rinu[PKq]זNN;Instance/%3d%3d-i.rinu[PKq]ԅI>RMD160/cdesc-RMD160.rinu[PKq]zOP@hexencode-c.rinu[PKq] dBcdesc-Digest.rinu[PKq]T4Qbubblebabble-c.rinu[PKq]DZxRMD5/cdesc-MD5.rinu[PKq]~tt,USHA2/reset-i.rinu[PKq]W  VSHA2/new-c.rinu[PKq]SYXSHA2/update-i.rinu[PKq]1{ZSHA2/digest_length-i.rinu[PKq]<7 }6^SHA2/cdesc-SHA2.rinu[PKq]̣tt^gSHA2/block_length-i.rinu[PKq]NjSHA2/%3c%3c-i.rinu[PKq]:::jkClass/cdesc-Class.rinu[PKq]:}}nClass/file-c.rinu[PKq]I3DPPqClass/digest-c.rinu[PKq]Y,v5tClass/bubblebabble-c.rinu[PKq]=G2vClass/base64digest-c.rinu[PKq]B;xClass/hexdigest-c.rinu[PK ]  zbase.pmnu[PK ][QZZ HMAC_MD5.pmnu[PK ]@I I WHMAC.pmnu[PK ]u בfile.pmnu[PK ]?\H ҘHMAC_SHA1.pmnu[PKa]&iiHMAC/reset-i.rinu[PKa]l+jjAHMAC/inspect-i.rinu[PKa]82DD HMAC/new-c.rinu[PKa]'WmHMAC/update-i.rinu[PKa]gYHMAC/digest_length-i.rinu[PKa]`o*HMAC/cdesc-HMAC.rinu[PKa]I[yyHMAC/block_length-i.rinu[PKa]\炌ܭHMAC/%3c%3c-i.rinu[PK;; 0