digest 3.1.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a175b98d1a4a7d66bac0148da4d3516a70e125646e9b867bacd154fb05e4b4ef
+  data.tar.gz: 938ffb653c44c018d9f7c74703f5ee8a885e1f7dbf94270969e2c4c3ac959ba0
+SHA512:
+  metadata.gz: 610b1874d03ed4c45c7a0bc5706506021c8676393e70db96c0bc5e1f46c8f3fb1d1a99a4828ecbd32fea9459b52e4aba52113c0df09926c52b66c4c60015ffd5
+  data.tar.gz: 99d7714c5cf4f4e08331b920bc70efec0413384fb1e930125d238293d104c90421d4dbb12a12eb36026c5a10dc1bc40573930e761948ce7b9e09e7b0a94bdf75

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.md

@@ -0,0 +1,97 @@
+# Digest
+
+![CI](https://github.com/ruby/digest/workflows/CI/badge.svg?branch=master&event=push)
+
+This module provides a framework for message digest libraries.
+
+You may want to look at OpenSSL::Digest as it supports more algorithms.
+
+A cryptographic hash function is a procedure that takes data and returns a fixed bit string: the hash value, also known as _digest_. Hash functions are also called one-way functions, it is easy to compute a digest from a message, but it is infeasible to generate a message from a digest.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'digest'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install digest
+
+## Usage
+
+```ruby
+require 'digest'
+
+# Compute a complete digest
+Digest::SHA256.digest 'message'       #=> "\xABS\n\x13\xE4Y..."
+
+sha256 = Digest::SHA256.new
+sha256.digest 'message'               #=> "\xABS\n\x13\xE4Y..."
+
+# Other encoding formats
+Digest::SHA256.hexdigest 'message'    #=> "ab530a13e459..."
+Digest::SHA256.base64digest 'message' #=> "q1MKE+RZFJgr..."
+
+# Compute digest by chunks
+md5 = Digest::MD5.new
+md5.update 'message1'
+md5 << 'message2'                     # << is an alias for update
+
+md5.hexdigest                         #=> "94af09c09bb9..."
+
+# Compute digest for a file
+sha256 = Digest::SHA256.file 'testfile'
+sha256.hexdigest
+```
+
+Additionally digests can be encoded in "bubble babble" format as a sequence of consonants and vowels which is more recognizable and comparable than a hexadecimal digest.
+
+```ruby
+require 'digest/bubblebabble'
+
+Digest::SHA256.bubblebabble 'message' #=> "xopoh-fedac-fenyh-..."
+```
+
+See the bubble babble specification at http://web.mit.edu/kenta/www/one/bubblebabble/spec/jrtrjwzi/draft-huima-01.txt.
+
+## Digest algorithms
+
+Different digest algorithms (or hash functions) are available:
+
+```
+MD5::
+ See RFC 1321 The MD5 Message-Digest Algorithm
+RIPEMD-160::
+  As Digest::RMD160.
+  See http://homes.esat.kuleuven.be/~bosselae/ripemd160.html.
+SHA1::
+  See FIPS 180 Secure Hash Standard.
+SHA2 family::
+  See FIPS 180 Secure Hash Standard which defines the following algorithms:
+ SHA512
+ SHA384
+ SHA256
+```
+
+The latest versions of the FIPS publications can be found here: http://csrc.nist.gov/publications/PubsFIPS.html.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/digest.
+
+## License
+
+The gem is available as open source under the terms of the [2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause).

data/ext/java/org/jruby/ext/digest/BubbleBabble.java

@@ -0,0 +1,119 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * BSD 2-Clause License
+ *
+ * Copyright (c) 2010, Charles Oliver Nutter <headius@headius.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ***** END LICENSE BLOCK *****/
+
+package org.jruby.ext.digest;
+
+import org.jruby.Ruby;
+import org.jruby.runtime.load.Library;
+import org.jruby.util.ByteList;
+
+import java.io.IOException;
+
+public class BubbleBabble implements Library {
+
+    public void load(final Ruby runtime, boolean wrap) throws IOException {
+        RubyDigest.createDigestBubbleBabble(runtime);
+    }
+
+    /**
+     * Ported from OpenSSH (https://github.com/openssh/openssh-portable/blob/957fbceb0f3166e41b76fdb54075ab3b9cc84cba/sshkey.c#L942-L987)
+     *
+     * OpenSSH License Notice
+     *
+     * Copyright (c) 2000, 2001 Markus Friedl.  All rights reserved.
+     * Copyright (c) 2008 Alexander von Gernler.  All rights reserved.
+     * Copyright (c) 2010,2011 Damien Miller.  All rights reserved.
+     *
+     * Redistribution and use in source and binary forms, with or without
+     * modification, are permitted provided that the following conditions
+     * are met:
+     * 1. Redistributions of source code must retain the above copyright
+     *    notice, this list of conditions and the following disclaimer.
+     * 2. Redistributions in binary form must reproduce the above copyright
+     *    notice, this list of conditions and the following disclaimer in the
+     *    documentation and/or other materials provided with the distribution.
+     *
+     * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+     * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+     * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+     * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+     * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+     * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+     * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+     * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+     */
+    public static ByteList bubblebabble(byte[] message, int begin, int length) {
+        char[] vowels = new char[]{'a', 'e', 'i', 'o', 'u', 'y'};
+        char[] consonants = new char[]{'b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm',
+                'n', 'p', 'r', 's', 't', 'v', 'z', 'x'};
+
+        long seed = 1;
+
+        ByteList retval = new ByteList();
+
+        int rounds = (length / 2) + 1;
+        retval.append('x');
+        for (int i = 0; i < rounds; i++) {
+            int idx0, idx1, idx2, idx3, idx4;
+
+            if ((i + 1 < rounds) || (length % 2 != 0)) {
+                long b = message[begin + 2 * i] & 0xFF;
+                idx0 = (int) ((((b >> 6) & 3) + seed) % 6) & 0xFFFFFFFF;
+                idx1 = (int) (((b) >> 2) & 15) & 0xFFFFFFFF;
+                idx2 = (int) (((b & 3) + (seed / 6)) % 6) & 0xFFFFFFFF;
+                retval.append(vowels[idx0]);
+                retval.append(consonants[idx1]);
+                retval.append(vowels[idx2]);
+                if ((i + 1) < rounds) {
+                    long b2 = message[begin + (2 * i) + 1] & 0xFF;
+                    idx3 = (int) ((b2 >> 4) & 15) & 0xFFFFFFFF;
+                    idx4 = (int) ((b2) & 15) & 0xFFFFFFFF;
+                    retval.append(consonants[idx3]);
+                    retval.append('-');
+                    retval.append(consonants[idx4]);
+                    seed = ((seed * 5) +
+                            ((b * 7) +
+                                    b2)) % 36;
+                }
+            } else {
+                idx0 = (int) (seed % 6) & 0xFFFFFFFF;
+                idx1 = 16;
+                idx2 = (int) (seed / 6) & 0xFFFFFFFF;
+                retval.append(vowels[idx0]);
+                retval.append(consonants[idx1]);
+                retval.append(vowels[idx2]);
+            }
+        }
+        retval.append('x');
+
+        return retval;
+    }
+}

data/ext/java/org/jruby/ext/digest/DigestLibrary.java

@@ -0,0 +1,44 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * BSD 2-Clause License
+ *
+ * Copyright (C) 2006 Ola Bini <ola@ologix.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ***** END LICENSE BLOCK *****/
+
+package org.jruby.ext.digest;
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.runtime.load.Library;
+
+/**
+ * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a>
+ */
+public class DigestLibrary implements Library {
+    public void load(final Ruby runtime, boolean wrap) throws IOException {
+        org.jruby.ext.digest.RubyDigest.createDigest(runtime);
+    }
+}// DigestLibrary

data/ext/java/org/jruby/ext/digest/MD5.java

@@ -0,0 +1,41 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * BSD 2-Clause License
+ *
+ * Copyright (c) 2010, Charles Oliver Nutter <headius@headius.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ***** END LICENSE BLOCK *****/
+
+package org.jruby.ext.digest;
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.runtime.load.Library;
+
+public class MD5 implements Library {
+
+    public void load(final Ruby runtime, boolean wrap) throws IOException {
+        org.jruby.ext.digest.RubyDigest.createDigestMD5(runtime);
+    }
+}

data/ext/java/org/jruby/ext/digest/RMD160.java

@@ -0,0 +1,41 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * BSD 2-Clause License
+ *
+ * Copyright (c) 2010, Charles Oliver Nutter <headius@headius.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ***** END LICENSE BLOCK *****/
+
+package org.jruby.ext.digest;
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.runtime.load.Library;
+
+public class RMD160 implements Library {
+
+    public void load(final Ruby runtime, boolean wrap) throws IOException {
+        org.jruby.ext.digest.RubyDigest.createDigestRMD160(runtime);
+    }
+}

data/ext/java/org/jruby/ext/digest/RubyDigest.java

@@ -0,0 +1,498 @@
+ /*
+ **** BEGIN LICENSE BLOCK *****
+ * BSD 2-Clause License
+ *
+ * Copyright (C) 2006, 2007 Ola Bini <ola@ologix.com>
+ * Copyright (C) 2007 Nick Sieger <nicksieger@gmail.com>
+ * Copyright (C) 2008 Vladimir Sizikov <vsizikov@gmail.com>
+ * Copyright (C) 2009 Joseph LaFata <joe@quibb.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ***** END LICENSE BLOCK *****/
+
+package org.jruby.ext.digest;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.Provider;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.jcodings.specific.USASCIIEncoding;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.Visibility;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ArraySupport;
+import org.jruby.util.ByteList;
+import org.jruby.util.log.Logger;
+import org.jruby.util.log.LoggerFactory;
+
+/**
+ * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a>
+ */
+@JRubyModule(name="Digest")
+public class RubyDigest {
+
+    private static final Map<String, MessageDigest> CLONEABLE_DIGESTS = new HashMap<String, MessageDigest>(8, 1);
+    static {
+        // standard digests from JCA specification; if we can retrieve and clone, save them
+        for (String name : new String[] {"MD2", "MD5", "SHA-1", "SHA-256", "SHA-384", "SHA-512"}) {
+            try {
+                MessageDigest digest = MessageDigest.getInstance(name);
+                digest.clone();
+                CLONEABLE_DIGESTS.put(name, digest);
+            }
+            catch (Exception e) {
+                logger().debug(name + " not clonable", e);
+            }
+        }
+    }
+
+    private static Logger logger() { return LoggerFactory.getLogger(RubyDigest.class); }
+
+    private static final String PROVIDER = "org.bouncycastle.jce.provider.BouncyCastleProvider";
+    private static Provider provider = null;
+
+    public static void createDigest(Ruby runtime) {
+        try {
+            provider = (Provider) Class.forName(PROVIDER).getConstructor().newInstance();
+        }
+        catch (Throwable t) { /* provider is not available */ }
+
+        RubyModule mDigest = runtime.defineModule("Digest");
+        mDigest.defineAnnotatedMethods(RubyDigest.class);
+        RubyModule mDigestInstance = mDigest.defineModuleUnder("Instance");
+        mDigestInstance.defineAnnotatedMethods(DigestInstance.class);
+        RubyClass cDigestClass = mDigest.defineClassUnder("Class", runtime.getObject(), DigestClass::new);
+        cDigestClass.defineAnnotatedMethods(DigestClass.class);
+        cDigestClass.includeModule(mDigestInstance);
+        RubyClass cDigestBase = mDigest.defineClassUnder("Base", cDigestClass, DigestBase::new);
+        cDigestBase.defineAnnotatedMethods(DigestBase.class);
+    }
+
+    private static MessageDigest createMessageDigest(final String name) throws NoSuchAlgorithmException {
+        MessageDigest cloneable = CLONEABLE_DIGESTS.get(name);
+        if (cloneable != null) {
+            try {
+                return (MessageDigest) cloneable.clone();
+            }
+            catch (CloneNotSupportedException e) {
+                // should never happen, since we tested it in static init
+            }
+        }
+
+        // fall back on JCA mechanisms for getting a digest
+        if (provider != null) {
+            try {
+                return MessageDigest.getInstance(name, provider);
+            }
+            catch (NoSuchAlgorithmException e) {
+                // bouncy castle doesn't support algorithm
+            }
+        }
+
+        // fall back to default JCA providers
+        return MessageDigest.getInstance(name);
+    }
+
+    private final static byte[] digits = {
+        '0', '1', '2', '3', '4', '5',
+        '6', '7', '8', '9', 'a', 'b',
+        'c', 'd', 'e', 'f', 'g', 'h',
+        'i', 'j', 'k', 'l', 'm', 'n',
+        'o', 'p', 'q', 'r', 's', 't',
+        'u', 'v', 'w', 'x', 'y', 'z'
+    };
+
+    private static ByteList toHex(byte[] val) {
+        ByteList byteList = new ByteList(val.length * 2);
+        for (int i = 0, j = val.length; i < j; i++) {
+            int b = val[i] & 0xFF;
+            byteList.append(digits[b >> 4]);
+            byteList.append(digits[b & 0xF]);
+        }
+        return byteList;
+    }
+
+    private static RubyString toHexString(Ruby runtime, byte[] val) {
+        return RubyString.newStringNoCopy(runtime, new ByteList(ByteList.plain(toHex(val)), USASCIIEncoding.INSTANCE));
+    }
+
+    @JRubyMethod(name = "hexencode", required = 1, meta = true)
+    public static RubyString hexencode(IRubyObject self, IRubyObject arg) {
+        return toHexString(self.getRuntime(), arg.convertToString().getBytes());
+    }
+
+    @JRubyMethod(name = "bubblebabble", required = 1, meta = true)
+    public static RubyString bubblebabble(IRubyObject recv, IRubyObject arg) {
+        final ByteList bytes = arg.convertToString().getByteList();
+        return RubyString.newString(recv.getRuntime(), BubbleBabble.bubblebabble(bytes.unsafeBytes(), bytes.begin(), bytes.length()));
+    }
+
+    private static class Metadata {
+
+        private final String name;
+        private final int blockLength;
+
+        Metadata(String name, int blockLength) {
+            this.name = name;
+            this.blockLength = blockLength;
+        }
+
+        String getName() {
+            return name;
+        }
+
+        int getBlockLength() {
+            return blockLength;
+        }
+    }
+
+
+    @JRubyClass(name="Digest::MD5", parent="Digest::Base")
+    public static class MD5 {}
+    @JRubyClass(name="Digest::RMD160", parent="Digest::Base")
+    public static class RMD160 {}
+    @JRubyClass(name="Digest::SHA1", parent="Digest::Base")
+    public static class SHA1 {}
+    @JRubyClass(name="Digest::SHA256", parent="Digest::Base")
+    public static class SHA256 {}
+    @JRubyClass(name="Digest::SHA384", parent="Digest::Base")
+    public static class SHA384 {}
+    @JRubyClass(name="Digest::SHA512", parent="Digest::Base")
+    public static class SHA512 {}
+
+    public static void createDigestMD5(Ruby runtime) {
+        runtime.getLoadService().require("digest");
+        RubyModule Digest = runtime.getModule("Digest");
+        RubyClass Base = Digest.getClass("Base");
+        RubyClass MD5 = Digest.defineClassUnder("MD5", Base, Base.getAllocator());
+        MD5.setInternalVariable("metadata", new Metadata("MD5", 64));
+    }
+
+    public static void createDigestRMD160(Ruby runtime) {
+        runtime.getLoadService().require("digest");
+        if(provider == null) {
+            throw runtime.newLoadError("RMD160 not supported without BouncyCastle");
+        }
+        RubyModule Digest = runtime.getModule("Digest");
+        RubyClass Base = Digest.getClass("Base");
+        RubyClass RMD160 = Digest.defineClassUnder("RMD160", Base, Base.getAllocator());
+        RMD160.setInternalVariable("metadata", new Metadata("RIPEMD160", 64));
+    }
+
+    public static void createDigestSHA1(Ruby runtime) {
+        runtime.getLoadService().require("digest");
+        RubyModule Digest = runtime.getModule("Digest");
+        RubyClass Base = Digest.getClass("Base");
+        RubyClass SHA1 = Digest.defineClassUnder("SHA1", Base, Base.getAllocator());
+        SHA1.setInternalVariable("metadata", new Metadata("SHA1", 64));
+    }
+
+    public static void createDigestSHA2(Ruby runtime) {
+        runtime.getLoadService().require("digest");
+        try {
+            createMessageDigest("SHA-256");
+        }
+        catch (NoSuchAlgorithmException e) {
+            RaiseException ex = runtime.newLoadError("SHA2 not supported");
+            ex.initCause(e);
+            throw ex;
+        }
+        final RubyModule Digest = runtime.getModule("Digest");
+        final RubyClass Base = Digest.getClass("Base");
+        RubyClass SHA256 = Digest.defineClassUnder("SHA256", Base, Base.getAllocator());
+        SHA256.setInternalVariable("metadata", new Metadata("SHA-256", 64));
+        RubyClass SHA384 = Digest.defineClassUnder("SHA384", Base, Base.getAllocator());
+        SHA384.setInternalVariable("metadata", new Metadata("SHA-384", 128));
+        RubyClass SHA512 = Digest.defineClassUnder("SHA512", Base, Base.getAllocator());
+        SHA512.setInternalVariable("metadata", new Metadata("SHA-512", 128));
+    }
+
+    public static void createDigestBubbleBabble(Ruby runtime) {
+        runtime.getLoadService().require("digest");
+        RubyModule Digest = runtime.getModule("Digest");
+        RubyClass Base = Digest.getClass("Base");
+        RubyClass MD5 = Digest.defineClassUnder("BubbleBabble", Base, Base.getAllocator());
+        MD5.setInternalVariable("metadata", new Metadata("BubbleBabble", 64));
+    }
+
+    @JRubyModule(name = "Digest::Instance")
+    public static class DigestInstance {
+
+        private static IRubyObject throwUnimplError(IRubyObject self, String name) {
+            throw self.getRuntime().newRuntimeError(String.format("%s does not implement %s()", self.getMetaClass().getRealClass().getName(), name));
+        }
+
+        /* instance methods that should be overridden */
+        @JRubyMethod(name = {"update", "<<"}, required = 1)
+        public static IRubyObject update(ThreadContext context, IRubyObject self, IRubyObject arg) {
+            return throwUnimplError(self, "update");
+        }
+
+        @JRubyMethod()
+        public static IRubyObject finish(ThreadContext context, IRubyObject self) {
+            return throwUnimplError(self, "finish");
+        }
+
+        @JRubyMethod()
+        public static IRubyObject reset(ThreadContext context, IRubyObject self) {
+            return throwUnimplError(self, "reset");
+        }
+
+        @JRubyMethod()
+        public static IRubyObject digest_length(ThreadContext context, IRubyObject self) {
+            return digest(context, self, null).convertToString().bytesize();
+        }
+
+        @JRubyMethod()
+        public static IRubyObject block_length(ThreadContext context, IRubyObject self) {
+            return throwUnimplError(self, "block_length");
+        }
+
+        /* instance methods that may be overridden */
+        @JRubyMethod(name = "==", required = 1)
+        public static IRubyObject op_equal(ThreadContext context, IRubyObject self, IRubyObject oth) {
+            if(oth.isNil()) return context.fals;
+
+            RubyString str1, str2;
+            RubyModule instance = (RubyModule)context.runtime.getModule("Digest").getConstantAt("Instance");
+            if (oth.getMetaClass().getRealClass().hasModuleInHierarchy(instance)) {
+                str1 = digest(context, self, null).convertToString();
+                str2 = digest(context, oth, null).convertToString();
+            } else {
+                str1 = to_s(context, self).convertToString();
+                str2 = oth.convertToString();
+            }
+            boolean ret = str1.bytesize().eql(str2.bytesize()) && (str1.eql(str2));
+            return ret ? context.tru : context.fals;
+        }
+
+        @JRubyMethod()
+        public static IRubyObject inspect(ThreadContext context, IRubyObject self) {
+            return RubyString.newStringNoCopy(self.getRuntime(), ByteList.plain("#<" + self.getMetaClass().getRealClass().getName() + ": " + hexdigest(context, self, null) + ">"));
+        }
+
+        /* instance methods that need not usually be overridden */
+        @JRubyMethod(name = "new")
+        public static IRubyObject newObject(ThreadContext context, IRubyObject self) {
+            return self.rbClone().callMethod(context, "reset");
+        }
+
+        @JRubyMethod(optional = 1)
+        public static IRubyObject digest(ThreadContext context, IRubyObject self, IRubyObject[] args) {
+            final IRubyObject value;
+            if (args != null && args.length > 0) {
+                self.callMethod(context, "reset");
+                self.callMethod(context, "update", args[0]);
+                value = self.callMethod(context, "finish");
+                self.callMethod(context, "reset");
+            } else {
+                IRubyObject clone = self.rbClone();
+                value = clone.callMethod(context, "finish");
+                clone.callMethod(context, "reset");
+            }
+            return value;
+        }
+
+        @JRubyMethod(name = "digest!")
+        public static IRubyObject digest_bang(ThreadContext context, IRubyObject self) {
+            IRubyObject value = self.callMethod(context, "finish");
+            self.callMethod(context, "reset");
+            return value;
+        }
+
+        @JRubyMethod(optional = 1)
+        public static IRubyObject hexdigest(ThreadContext context, IRubyObject self, IRubyObject[] args) {
+            return toHexString(context.runtime, digest(context, self, args).convertToString().getBytes());
+        }
+
+        @JRubyMethod(name = "hexdigest!")
+        public static IRubyObject hexdigest_bang(ThreadContext context, IRubyObject self) {
+            return toHexString(context.runtime, digest_bang(context, self).convertToString().getBytes());
+        }
+
+        @JRubyMethod(name = "bubblebabble", required = 1, optional = 1, meta = true)
+        public static IRubyObject bubblebabble(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock) {
+            byte[] digest = recv.callMethod(context, "digest", args, Block.NULL_BLOCK).convertToString().getBytes();
+            return RubyString.newString(recv.getRuntime(), BubbleBabble.bubblebabble(digest, 0, digest.length));
+        }
+
+        @JRubyMethod()
+        public static IRubyObject to_s(ThreadContext context, IRubyObject self) {
+            return self.callMethod(context, "hexdigest");
+        }
+
+        @JRubyMethod(name = {"length", "size"})
+        public static IRubyObject length(ThreadContext context, IRubyObject self) {
+            return self.callMethod(context, "digest_length");
+        }
+    }
+
+
+    @JRubyClass(name="Digest::Class")
+    public static class DigestClass extends RubyObject {
+        public DigestClass(Ruby runtime, RubyClass type) {
+            super(runtime, type);
+        }
+
+        @JRubyMethod(name = "digest", required = 1, rest = true, meta = true)
+        public static IRubyObject s_digest(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock) {
+            final Ruby runtime = context.runtime;
+            if (args.length < 1) {
+                throw runtime.newArgumentError("no data given");
+            }
+            RubyString str = args[0].convertToString();
+            args = ArraySupport.newCopy(args, 1, args.length - 1); // skip first arg
+            IRubyObject obj = ((RubyClass) recv).newInstance(context, args, Block.NULL_BLOCK);
+            return obj.callMethod(context, "digest", str);
+        }
+
+        @JRubyMethod(name = "hexdigest", required = 1, optional = 1, meta = true)
+        public static IRubyObject s_hexdigest(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock) {
+            Ruby runtime = recv.getRuntime();
+            byte[] digest = recv.callMethod(context, "digest", args, Block.NULL_BLOCK).convertToString().getBytes();
+            return RubyDigest.toHexString(runtime, digest);
+        }
+
+        @JRubyMethod(name = "bubblebabble", required = 1, meta = true)
+        public static RubyString bubblebabble(IRubyObject recv, IRubyObject arg) {
+            byte[] digest = recv.callMethod(recv.getRuntime().getCurrentContext(), "digest", arg).convertToString().getBytes();
+            return RubyString.newString(recv.getRuntime(), BubbleBabble.bubblebabble(digest, 0, digest.length));
+        }
+    }
+
+
+    @JRubyClass(name="Digest::Base")
+    public static class DigestBase extends RubyObject {
+        private MessageDigest algo;
+        private int blockLength = 0;
+
+        public DigestBase(Ruby runtime, RubyClass type) {
+            super(runtime,type);
+
+            if(type == runtime.getModule("Digest").getClass("Base")) {
+                throw runtime.newNotImplementedError("Digest::Base is an abstract class");
+            }
+
+            Metadata metadata = getMetadata(type);
+            if(metadata == null) {
+                throw runtime.newNotImplementedError("the " + type + "() function is unimplemented on this machine");
+            }
+
+            try {
+                setAlgorithm(metadata);
+            } catch(NoSuchAlgorithmException e) {
+                throw runtime.newNotImplementedError("the " + type + "() function is unimplemented on this machine");
+            }
+
+        }
+
+        // if subclass extends particular digest we need to walk to find it...we should rearchitect digest to avoid walking type systems
+        private Metadata getMetadata(RubyModule type) {
+            for (RubyModule current = type; current != null; current = current.getSuperClass()) {
+                Metadata metadata = (Metadata) current.getInternalVariable("metadata");
+
+                if (metadata != null) return metadata;
+            }
+
+            return null;
+        }
+
+        @JRubyMethod(required = 1, visibility = Visibility.PRIVATE)
+        @Override
+        public IRubyObject initialize_copy(IRubyObject obj) {
+            if (this == obj) return this;
+
+            DigestBase from = (DigestBase) obj;
+            from.checkFrozen();
+
+            try {
+                this.algo = (MessageDigest) from.algo.clone();
+            }
+            catch (CloneNotSupportedException e) {
+                String name = from.algo.getAlgorithm();
+                throw getRuntime().newTypeError("Could not initialize copy of digest (" + name + ")");
+            }
+            return this;
+        }
+
+        @JRubyMethod(name = {"update", "<<"}, required = 1)
+        public IRubyObject update(IRubyObject obj) {
+            ByteList bytes = obj.convertToString().getByteList();
+            algo.update(bytes.getUnsafeBytes(), bytes.getBegin(), bytes.getRealSize());
+            return this;
+        }
+
+        @JRubyMethod()
+        public IRubyObject finish() {
+            IRubyObject digest = RubyString.newStringNoCopy(getRuntime(), algo.digest());
+            algo.reset();
+            return digest;
+        }
+
+        @JRubyMethod()
+        public IRubyObject digest_length() {
+            return RubyFixnum.newFixnum(getRuntime(), algo.getDigestLength());
+        }
+
+        @JRubyMethod()
+        public IRubyObject block_length() {
+            if (blockLength == 0) {
+                throw getRuntime().newRuntimeError(
+                        this.getMetaClass() + " doesn't implement block_length()");
+            }
+            return RubyFixnum.newFixnum(getRuntime(), blockLength);
+        }
+
+        @JRubyMethod()
+        public IRubyObject reset() {
+            algo.reset();
+            return this;
+        }
+
+        @JRubyMethod()
+        public IRubyObject bubblebabble(ThreadContext context) {
+            final byte[] digest = algo.digest();
+            return RubyString.newString(context.runtime, BubbleBabble.bubblebabble(digest, 0, digest.length));
+        }
+
+        private void setAlgorithm(Metadata metadata) throws NoSuchAlgorithmException {
+           this.algo = createMessageDigest(metadata.getName());
+           this.blockLength = metadata.getBlockLength();
+        }
+
+    }
+}// RubyDigest

data/ext/java/org/jruby/ext/digest/SHA1.java

@@ -0,0 +1,41 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * BSD 2-Clause License
+ *
+ * Copyright (c) 2010, Charles Oliver Nutter <headius@headius.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ***** END LICENSE BLOCK *****/
+
+package org.jruby.ext.digest;
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.runtime.load.Library;
+
+public class SHA1 implements Library {
+
+    public void load(final Ruby runtime, boolean wrap) throws IOException {
+        org.jruby.ext.digest.RubyDigest.createDigestSHA1(runtime);
+    }
+}

data/ext/java/org/jruby/ext/digest/SHA2.java

@@ -0,0 +1,41 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * BSD 2-Clause License
+ *
+ * Copyright (c) 2010, Charles Oliver Nutter <headius@headius.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ***** END LICENSE BLOCK *****/
+
+package org.jruby.ext.digest;
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.runtime.load.Library;
+
+public class SHA2 implements Library {
+
+    public void load(final Ruby runtime, boolean wrap) throws IOException {
+        org.jruby.ext.digest.RubyDigest.createDigestSHA2(runtime);
+    }
+}

data/ext/java/org/jruby/ext/digest/lib/digest/bubblebabble.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+JRuby::Util.load_ext("org.jruby.ext.digest.BubbleBabble")

data/ext/java/org/jruby/ext/digest/lib/digest/loader.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+JRuby::Util.load_ext('org.jruby.ext.digest.DigestLibrary')

data/ext/java/org/jruby/ext/digest/lib/digest/md5.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+JRuby::Util.load_ext("org.jruby.ext.digest.MD5")

data/ext/java/org/jruby/ext/digest/lib/digest/rmd160.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+JRuby::Util.load_ext("org.jruby.ext.digest.RMD160")

data/ext/java/org/jruby/ext/digest/lib/digest/sha1.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+JRuby::Util.load_ext("org.jruby.ext.digest.SHA1")

data/ext/java/org/jruby/ext/digest/lib/digest/sha2/loader.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+JRuby::Util.load_ext('org.jruby.ext.digest.SHA2')

data/lib/digest/sha2.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: false
+#--
+# sha2.rb - defines Digest::SHA2 class which wraps up the SHA256,
+#           SHA384, and SHA512 classes.
+#++
+# Copyright (c) 2006 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved.  You can redistribute and/or modify it under the same
+# terms as Ruby.
+#
+#   $Id$
+
+require 'digest'
+require 'digest/sha2/loader'
+
+module Digest
+  #
+  # A meta digest provider class for SHA256, SHA384 and SHA512.
+  #
+  # FIPS 180-2 describes SHA2 family of digest algorithms. It defines
+  # three algorithms:
+  # * one which works on chunks of 512 bits and returns a 256-bit
+  #   digest (SHA256),
+  # * one which works on chunks of 1024 bits and returns a 384-bit
+  #   digest (SHA384),
+  # * and one which works on chunks of 1024 bits and returns a 512-bit
+  #   digest (SHA512).
+  #
+  # ==Examples
+  #  require 'digest'
+  #
+  #  # Compute a complete digest
+  #  Digest::SHA2.hexdigest 'abc'          # => "ba7816bf8..."
+  #  Digest::SHA2.new(256).hexdigest 'abc' # => "ba7816bf8..."
+  #  Digest::SHA256.hexdigest 'abc'        # => "ba7816bf8..."
+  #
+  #  Digest::SHA2.new(384).hexdigest 'abc' # => "cb00753f4..."
+  #  Digest::SHA384.hexdigest 'abc'        # => "cb00753f4..."
+  #
+  #  Digest::SHA2.new(512).hexdigest 'abc' # => "ddaf35a19..."
+  #  Digest::SHA512.hexdigest 'abc'        # => "ddaf35a19..."
+  #
+  #  # Compute digest by chunks
+  #  sha2 = Digest::SHA2.new               # =>#<Digest::SHA2:256>
+  #  sha2.update "ab"
+  #  sha2 << "c"                           # alias for #update
+  #  sha2.hexdigest                        # => "ba7816bf8..."
+  #
+  #  # Use the same object to compute another digest
+  #  sha2.reset
+  #  sha2 << "message"
+  #  sha2.hexdigest                        # => "ab530a13e..."
+  #
+  class SHA2 < Digest::Class
+    # call-seq:
+    #   Digest::SHA2.new(bitlen = 256) -> digest_obj
+    #
+    # Create a new SHA2 hash object with a given bit length.
+    #
+    # Valid bit lengths are 256, 384 and 512.
+    def initialize(bitlen = 256)
+      case bitlen
+      when 256
+        @sha2 = Digest::SHA256.new
+      when 384
+        @sha2 = Digest::SHA384.new
+      when 512
+        @sha2 = Digest::SHA512.new
+      else
+        raise ArgumentError, "unsupported bit length: %s" % bitlen.inspect
+      end
+      @bitlen = bitlen
+    end
+
+    # call-seq:
+    #   digest_obj.reset -> digest_obj
+    #
+    # Reset the digest to the initial state and return self.
+    def reset
+      @sha2.reset
+      self
+    end
+
+    # call-seq:
+    #   digest_obj.update(string) -> digest_obj
+    #   digest_obj << string -> digest_obj
+    #
+    # Update the digest using a given _string_ and return self.
+    def update(str)
+      @sha2.update(str)
+      self
+    end
+    alias << update
+
+    def finish # :nodoc:
+      @sha2.digest!
+    end
+    private :finish
+
+
+    # call-seq:
+    #   digest_obj.block_length -> Integer
+    #
+    # Return the block length of the digest in bytes.
+    #
+    #   Digest::SHA256.new.block_length * 8
+    #   # => 512
+    #   Digest::SHA384.new.block_length * 8
+    #   # => 1024
+    #   Digest::SHA512.new.block_length * 8
+    #   # => 1024
+    def block_length
+      @sha2.block_length
+    end
+
+    # call-seq:
+    #   digest_obj.digest_length -> Integer
+    #
+    # Return the length of the hash value (the digest) in bytes.
+    #
+    #   Digest::SHA256.new.digest_length * 8
+    #   # => 256
+    #   Digest::SHA384.new.digest_length * 8
+    #   # => 384
+    #   Digest::SHA512.new.digest_length * 8
+    #   # => 512
+    #
+    # For example, digests produced by Digest::SHA256 will always be 32 bytes
+    # (256 bits) in size.
+    def digest_length
+      @sha2.digest_length
+    end
+
+    def initialize_copy(other) # :nodoc:
+      @sha2 = other.instance_eval { @sha2.clone }
+    end
+
+    def inspect # :nodoc:
+      "#<%s:%d %s>" % [self.class.name, @bitlen, hexdigest]
+    end
+  end
+end

data/lib/digest/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Digest
+  VERSION = "3.1.0"
+end

data/lib/digest.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: false
+
+if defined?(Digest) &&
+    /\A(?:2\.|3\.0\.[0-2]\z)/.match?(RUBY_VERSION) &&
+    caller_locations.any? { |l|
+      %r{/(rubygems/gem_runner|bundler/cli)\.rb}.match?(l.path)
+    }
+  # Before Ruby 3.0.3/3.1.0, the gem and bundle commands used to load
+  # the digest library before loading additionally installed gems, so
+  # you will get constant redefinition warnings and unexpected
+  # implementation overwriting if we proceed here.  Avoid that.
+  return
+end
+
+require 'digest/version'
+require 'digest/loader'
+
+module Digest
+  # A mutex for Digest().
+  REQUIRE_MUTEX = Thread::Mutex.new
+
+  def self.const_missing(name) # :nodoc:
+    case name
+    when :SHA256, :SHA384, :SHA512
+      lib = 'digest/sha2'
+    else
+      lib = File.join('digest', name.to_s.downcase)
+    end
+
+    begin
+      require lib
+    rescue LoadError
+      raise LoadError, "library not found for class Digest::#{name} -- #{lib}", caller(1)
+    end
+    unless Digest.const_defined?(name)
+      raise NameError, "uninitialized constant Digest::#{name}", caller(1)
+    end
+    Digest.const_get(name)
+  end
+
+  class ::Digest::Class
+    # Creates a digest object and reads a given file, _name_.
+    # Optional arguments are passed to the constructor of the digest
+    # class.
+    #
+    #   p Digest::SHA256.file("X11R6.8.2-src.tar.bz2").hexdigest
+    #   # => "f02e3c85572dc9ad7cb77c2a638e3be24cc1b5bea9fdbb0b0299c9668475c534"
+    def self.file(name, *args)
+      new(*args).file(name)
+    end
+
+    # Returns the base64 encoded hash value of a given _string_.  The
+    # return value is properly padded with '=' and contains no line
+    # feeds.
+    def self.base64digest(str, *args)
+      [digest(str, *args)].pack('m0')
+    end
+  end
+
+  module Instance
+    # Updates the digest with the contents of a given file _name_ and
+    # returns self.
+    def file(name)
+      File.open(name, "rb") {|f|
+        buf = ""
+        while f.read(16384, buf)
+          update buf
+        end
+      }
+      self
+    end
+
+    # If none is given, returns the resulting hash value of the digest
+    # in a base64 encoded form, keeping the digest's state.
+    #
+    # If a +string+ is given, returns the hash value for the given
+    # +string+ in a base64 encoded form, resetting the digest to the
+    # initial state before and after the process.
+    #
+    # In either case, the return value is properly padded with '=' and
+    # contains no line feeds.
+    def base64digest(str = nil)
+      [str ? digest(str) : digest].pack('m0')
+    end
+
+    # Returns the resulting hash value and resets the digest to the
+    # initial state.
+    def base64digest!
+      [digest!].pack('m0')
+    end
+  end
+end
+
+# call-seq:
+#   Digest(name) -> digest_subclass
+#
+# Returns a Digest subclass by +name+ in a thread-safe manner even
+# when on-demand loading is involved.
+#
+#   require 'digest'
+#
+#   Digest("MD5")
+#   # => Digest::MD5
+#
+#   Digest(:SHA256)
+#   # => Digest::SHA256
+#
+#   Digest(:Foo)
+#   # => LoadError: library not found for class Digest::Foo -- digest/foo
+def Digest(name)
+  const = name.to_sym
+  Digest::REQUIRE_MUTEX.synchronize {
+    # Ignore autoload's because it is void when we have #const_missing
+    Digest.const_missing(const)
+  }
+rescue LoadError
+  # Constants do not necessarily rely on digest/*.
+  if Digest.const_defined?(const)
+    Digest.const_get(const)
+  else
+    raise
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: digest
+version: !ruby/object:Gem::Version
+  version: 3.1.0
+platform: java
+authors:
+- Akinori MUSHA
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-12-24 00:00:00.000000000 Z
+dependencies: []
+description: Provides a framework for message digest libraries.
+email:
+- knu@idaemons.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- ext/java/org/jruby/ext/digest/BubbleBabble.java
+- ext/java/org/jruby/ext/digest/DigestLibrary.java
+- ext/java/org/jruby/ext/digest/MD5.java
+- ext/java/org/jruby/ext/digest/RMD160.java
+- ext/java/org/jruby/ext/digest/RubyDigest.java
+- ext/java/org/jruby/ext/digest/SHA1.java
+- ext/java/org/jruby/ext/digest/SHA2.java
+- ext/java/org/jruby/ext/digest/lib/digest/bubblebabble.rb
+- ext/java/org/jruby/ext/digest/lib/digest/loader.rb
+- ext/java/org/jruby/ext/digest/lib/digest/md5.rb
+- ext/java/org/jruby/ext/digest/lib/digest/rmd160.rb
+- ext/java/org/jruby/ext/digest/lib/digest/sha1.rb
+- ext/java/org/jruby/ext/digest/lib/digest/sha2/loader.rb
+- lib/digest.jar
+- lib/digest.rb
+- lib/digest/sha2.rb
+- lib/digest/version.rb
+homepage: https://github.com/ruby/digest
+licenses:
+- Ruby
+- BSD-2-Clause
+metadata:
+  msys2_mingw_dependencies: openssl
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- ext/java/org/jruby/ext/digest/lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.14
+signing_key:
+specification_version: 4
+summary: Provides a framework for message digest libraries.
+test_files: []