// 
// Decompiled by Procyon v0.6.0
// 

package org.bouncycastle.jcajce.provider.digest;

import org.bouncycastle.jcajce.provider.config.ConfigurableProvider;
import org.bouncycastle.crypto.CipherKeyGenerator;
import org.bouncycastle.jcajce.provider.symmetric.util.BaseKeyGenerator;
import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import org.bouncycastle.jcajce.provider.symmetric.util.BaseSecretKeyFactory;
import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;
import org.bouncycastle.crypto.macs.KMAC;
import org.bouncycastle.crypto.Mac;
import org.bouncycastle.crypto.macs.HMac;
import org.bouncycastle.jcajce.provider.symmetric.util.BaseMac;
import org.bouncycastle.crypto.digests.TupleHash;
import org.bouncycastle.crypto.digests.SHAKEDigest;
import org.bouncycastle.crypto.digests.ParallelHash;
import org.bouncycastle.crypto.Digest;
import org.bouncycastle.crypto.digests.SHA3Digest;

public class SHA3
{
    private SHA3() {
    }
    
    public static class Digest224 extends DigestSHA3
    {
        public Digest224() {
            super(224);
        }
    }
    
    public static class DigestSHA3 extends BCMessageDigest implements Cloneable
    {
        public DigestSHA3(final int n) {
            super(new SHA3Digest(n));
        }
        
        @Override
        public Object clone() throws CloneNotSupportedException {
            final BCMessageDigest bcMessageDigest = (BCMessageDigest)super.clone();
            bcMessageDigest.digest = new SHA3Digest((SHA3Digest)this.digest);
            return bcMessageDigest;
        }
    }
    
    public static class Digest256 extends DigestSHA3
    {
        public Digest256() {
            super(256);
        }
    }
    
    public static class Digest384 extends DigestSHA3
    {
        public Digest384() {
            super(384);
        }
    }
    
    public static class Digest512 extends DigestSHA3
    {
        public Digest512() {
            super(512);
        }
    }
    
    public static class DigestParallelHash extends BCMessageDigest implements Cloneable
    {
        public DigestParallelHash(final int n, final int n2) {
            super(new ParallelHash(n, null, 128, n2));
        }
        
        @Override
        public Object clone() throws CloneNotSupportedException {
            final BCMessageDigest bcMessageDigest = (BCMessageDigest)super.clone();
            bcMessageDigest.digest = new ParallelHash((ParallelHash)this.digest);
            return bcMessageDigest;
        }
    }
    
    public static class DigestParallelHash128_256 extends DigestParallelHash
    {
        public DigestParallelHash128_256() {
            super(128, 256);
        }
    }
    
    public static class DigestParallelHash256_512 extends DigestParallelHash
    {
        public DigestParallelHash256_512() {
            super(256, 512);
        }
    }
    
    public static class DigestSHAKE extends BCMessageDigest implements Cloneable
    {
        public DigestSHAKE(final int n, final int n2) {
            super(new SHAKEDigest(n));
        }
        
        @Override
        public Object clone() throws CloneNotSupportedException {
            final BCMessageDigest bcMessageDigest = (BCMessageDigest)super.clone();
            bcMessageDigest.digest = new SHAKEDigest((SHAKEDigest)this.digest);
            return bcMessageDigest;
        }
    }
    
    public static class DigestShake128_256 extends DigestSHAKE
    {
        public DigestShake128_256() {
            super(128, 256);
        }
    }
    
    public static class DigestShake256_512 extends DigestSHAKE
    {
        public DigestShake256_512() {
            super(256, 512);
        }
    }
    
    public static class DigestTupleHash extends BCMessageDigest implements Cloneable
    {
        public DigestTupleHash(final int n, final int n2) {
            super(new TupleHash(n, null, n2));
        }
        
        @Override
        public Object clone() throws CloneNotSupportedException {
            final BCMessageDigest bcMessageDigest = (BCMessageDigest)super.clone();
            bcMessageDigest.digest = new TupleHash((TupleHash)this.digest);
            return bcMessageDigest;
        }
    }
    
    public static class DigestTupleHash128_256 extends DigestTupleHash
    {
        public DigestTupleHash128_256() {
            super(128, 256);
        }
    }
    
    public static class DigestTupleHash256_512 extends DigestTupleHash
    {
        public DigestTupleHash256_512() {
            super(256, 512);
        }
    }
    
    public static class HashMac224 extends HashMacSHA3
    {
        public HashMac224() {
            super(224);
        }
    }
    
    public static class HashMacSHA3 extends BaseMac
    {
        public HashMacSHA3(final int n) {
            super(new HMac(new SHA3Digest(n)));
        }
    }
    
    public static class HashMac256 extends HashMacSHA3
    {
        public HashMac256() {
            super(256);
        }
    }
    
    public static class HashMac384 extends HashMacSHA3
    {
        public HashMac384() {
            super(384);
        }
    }
    
    public static class HashMac512 extends HashMacSHA3
    {
        public HashMac512() {
            super(512);
        }
    }
    
    public static class KMac128 extends BaseMac
    {
        public KMac128() {
            super(new KMAC(128, new byte[0]));
        }
    }
    
    public static class KMac256 extends BaseMac
    {
        public KMac256() {
            super(new KMAC(256, new byte[0]));
        }
    }
    
    public static class KeyFactory224 extends KeyFactorySHA3
    {
        public KeyFactory224() {
            super(224, NISTObjectIdentifiers.id_hmacWithSHA3_224);
        }
    }
    
    public static class KeyFactorySHA3 extends BaseSecretKeyFactory
    {
        public KeyFactorySHA3(final int i, final ASN1ObjectIdentifier asn1ObjectIdentifier) {
            super("HmacSHA3-" + i, asn1ObjectIdentifier);
        }
    }
    
    public static class KeyFactory256 extends KeyFactorySHA3
    {
        public KeyFactory256() {
            super(256, NISTObjectIdentifiers.id_hmacWithSHA3_256);
        }
    }
    
    public static class KeyFactory384 extends KeyFactorySHA3
    {
        public KeyFactory384() {
            super(384, NISTObjectIdentifiers.id_hmacWithSHA3_384);
        }
    }
    
    public static class KeyFactory512 extends KeyFactorySHA3
    {
        public KeyFactory512() {
            super(512, NISTObjectIdentifiers.id_hmacWithSHA3_512);
        }
    }
    
    public static class KeyFactoryKMAC extends BaseSecretKeyFactory
    {
        public KeyFactoryKMAC(final int i, final ASN1ObjectIdentifier asn1ObjectIdentifier) {
            super("KMAC" + i, asn1ObjectIdentifier);
        }
    }
    
    public static class KeyFactoryKMAC128 extends KeyFactoryKMAC
    {
        public KeyFactoryKMAC128() {
            super(128, NISTObjectIdentifiers.id_KmacWithSHAKE128);
        }
    }
    
    public static class KeyFactoryKMAC256 extends KeyFactoryKMAC
    {
        public KeyFactoryKMAC256() {
            super(256, NISTObjectIdentifiers.id_KmacWithSHAKE256);
        }
    }
    
    public static class KeyGenerator224 extends KeyGeneratorSHA3
    {
        public KeyGenerator224() {
            super(224);
        }
    }
    
    public static class KeyGeneratorSHA3 extends BaseKeyGenerator
    {
        public KeyGeneratorSHA3(final int i) {
            super("HMACSHA3-" + i, i, new CipherKeyGenerator());
        }
    }
    
    public static class KeyGenerator256 extends KeyGeneratorSHA3
    {
        public KeyGenerator256() {
            super(256);
        }
    }
    
    public static class KeyGenerator384 extends KeyGeneratorSHA3
    {
        public KeyGenerator384() {
            super(384);
        }
    }
    
    public static class KeyGenerator512 extends KeyGeneratorSHA3
    {
        public KeyGenerator512() {
            super(512);
        }
    }
    
    public static class Mappings extends DigestAlgorithmProvider
    {
        private static final String PREFIX;
        
        @Override
        public void configure(final ConfigurableProvider configurableProvider) {
            configurableProvider.addAlgorithm("MessageDigest.SHA3-224", Mappings.PREFIX + "$Digest224");
            configurableProvider.addAlgorithm("MessageDigest.SHA3-256", Mappings.PREFIX + "$Digest256");
            configurableProvider.addAlgorithm("MessageDigest.SHA3-384", Mappings.PREFIX + "$Digest384");
            configurableProvider.addAlgorithm("MessageDigest.SHA3-512", Mappings.PREFIX + "$Digest512");
            configurableProvider.addAlgorithm("MessageDigest", NISTObjectIdentifiers.id_sha3_224, Mappings.PREFIX + "$Digest224");
            configurableProvider.addAlgorithm("MessageDigest", NISTObjectIdentifiers.id_sha3_256, Mappings.PREFIX + "$Digest256");
            configurableProvider.addAlgorithm("MessageDigest", NISTObjectIdentifiers.id_sha3_384, Mappings.PREFIX + "$Digest384");
            configurableProvider.addAlgorithm("MessageDigest", NISTObjectIdentifiers.id_sha3_512, Mappings.PREFIX + "$Digest512");
            configurableProvider.addAlgorithm("MessageDigest.SHAKE256-512", Mappings.PREFIX + "$DigestShake256_512");
            configurableProvider.addAlgorithm("MessageDigest.SHAKE128-256", Mappings.PREFIX + "$DigestShake128_256");
            configurableProvider.addAlgorithm("MessageDigest", NISTObjectIdentifiers.id_shake256, Mappings.PREFIX + "$DigestShake256_512");
            configurableProvider.addAlgorithm("MessageDigest", NISTObjectIdentifiers.id_shake128, Mappings.PREFIX + "$DigestShake128_256");
            configurableProvider.addAlgorithm("Alg.Alias.MessageDigest.SHAKE256", "SHAKE256-512");
            configurableProvider.addAlgorithm("Alg.Alias.MessageDigest.SHAKE128", "SHAKE128-256");
            this.addHMACAlgorithm(configurableProvider, "SHA3-224", Mappings.PREFIX + "$HashMac224", Mappings.PREFIX + "$KeyGenerator224");
            this.addHMACAlias(configurableProvider, "SHA3-224", NISTObjectIdentifiers.id_hmacWithSHA3_224);
            configurableProvider.addAlgorithm("SecretKeyFactory.HMACSHA3-224", Mappings.PREFIX + "$KeyFactory224");
            configurableProvider.addAlgorithm("Alg.Alias.SecretKeyFactory." + NISTObjectIdentifiers.id_hmacWithSHA3_224, "HMACSHA3-224");
            this.addHMACAlgorithm(configurableProvider, "SHA3-256", Mappings.PREFIX + "$HashMac256", Mappings.PREFIX + "$KeyGenerator256");
            this.addHMACAlias(configurableProvider, "SHA3-256", NISTObjectIdentifiers.id_hmacWithSHA3_256);
            configurableProvider.addAlgorithm("SecretKeyFactory.HMACSHA3-256", Mappings.PREFIX + "$KeyFactory256");
            configurableProvider.addAlgorithm("Alg.Alias.SecretKeyFactory." + NISTObjectIdentifiers.id_hmacWithSHA3_256, "HMACSHA3-256");
            this.addHMACAlgorithm(configurableProvider, "SHA3-384", Mappings.PREFIX + "$HashMac384", Mappings.PREFIX + "$KeyGenerator384");
            this.addHMACAlias(configurableProvider, "SHA3-384", NISTObjectIdentifiers.id_hmacWithSHA3_384);
            configurableProvider.addAlgorithm("SecretKeyFactory.HMACSHA3-384", Mappings.PREFIX + "$KeyFactory384");
            configurableProvider.addAlgorithm("Alg.Alias.SecretKeyFactory." + NISTObjectIdentifiers.id_hmacWithSHA3_384, "HMACSHA3-384");
            this.addHMACAlgorithm(configurableProvider, "SHA3-512", Mappings.PREFIX + "$HashMac512", Mappings.PREFIX + "$KeyGenerator512");
            this.addHMACAlias(configurableProvider, "SHA3-512", NISTObjectIdentifiers.id_hmacWithSHA3_512);
            configurableProvider.addAlgorithm("SecretKeyFactory.HMACSHA3-512", Mappings.PREFIX + "$KeyFactory512");
            configurableProvider.addAlgorithm("Alg.Alias.SecretKeyFactory." + NISTObjectIdentifiers.id_hmacWithSHA3_512, "HMACSHA3-512");
            this.addKMACAlgorithm(configurableProvider, "128", Mappings.PREFIX + "$KMac128", Mappings.PREFIX + "$KeyGenerator256");
            configurableProvider.addAlgorithm("SecretKeyFactory.KMAC128", Mappings.PREFIX + "$KeyFactoryKMAC128");
            configurableProvider.addAlgorithm("Alg.Alias.SecretKeyFactory." + NISTObjectIdentifiers.id_Kmac128, "KMAC128");
            this.addKMACAlgorithm(configurableProvider, "256", Mappings.PREFIX + "$KMac256", Mappings.PREFIX + "$KeyGenerator512");
            configurableProvider.addAlgorithm("SecretKeyFactory.KMAC256", Mappings.PREFIX + "$KeyFactoryKMAC256");
            configurableProvider.addAlgorithm("Alg.Alias.SecretKeyFactory." + NISTObjectIdentifiers.id_Kmac256, "KMAC256");
            configurableProvider.addAlgorithm("MessageDigest.TUPLEHASH256-512", Mappings.PREFIX + "$DigestTupleHash256_512");
            configurableProvider.addAlgorithm("MessageDigest.TUPLEHASH128-256", Mappings.PREFIX + "$DigestTupleHash128_256");
            configurableProvider.addAlgorithm("Alg.Alias.MessageDigest.TUPLEHASH256", "TUPLEHASH256-512");
            configurableProvider.addAlgorithm("Alg.Alias.MessageDigest.TUPLEHASH128", "TUPLEHASH128-256");
            configurableProvider.addAlgorithm("MessageDigest.PARALLELHASH256-512", Mappings.PREFIX + "$DigestParallelHash256_512");
            configurableProvider.addAlgorithm("MessageDigest.PARALLELHASH128-256", Mappings.PREFIX + "$DigestParallelHash128_256");
            configurableProvider.addAlgorithm("Alg.Alias.MessageDigest.PARALLELHASH256", "PARALLELHASH256-512");
            configurableProvider.addAlgorithm("Alg.Alias.MessageDigest.PARALLELHASH128", "PARALLELHASH128-256");
        }
        
        static {
            PREFIX = SHA3.class.getName();
        }
    }
}