Info Call to Random API

Description

List of all calls to methods that return pseudo-random values.

Recommendation

Do not seed Random with the current time because that value is more predictable to an attacker than the default seed.

The java.util.Random class must not be used either for security-critical applications or for protecting sensitive data. Use a more secure random number generator, such as the java.security.SecureRandom class.

Technical details

Method com.google.android.gms.internal.measurement.zzka.zzih() calling method java.security.SecureRandom.<init>()


    protected final void zzih()
    {
        this.zzab();
        com.google.android.gms.internal.measurement.zzfi v2_5 = new java.security.SecureRandom();
        long v0 = v2_5.nextLong();
        if (v0 == 0) {
            v0 = v2_5.nextLong();
            if (v0 == 0) {
                this.zzge().zzip().log("Utils falling back to Random for random id");
            }
        }
        this.zzarf.set(v0);
        return;
    }

Method com.google.android.gms.internal.measurement.zzka.zzlc() calling method java.security.SecureRandom.<init>()


    final java.security.SecureRandom zzlc()
    {
        this.zzab();
        if (this.zzare == null) {
            this.zzare = new java.security.SecureRandom();
        }
        return this.zzare;
    }

Method org.spongycastle.cert.crmf.FixedLengthMGF1Padder.getPaddedData() calling method java.security.SecureRandom.<init>()


    public byte[] getPaddedData(byte[] p9)
    {
        byte[] v0 = new byte[this.length];
        byte[] v4 = new byte[this.dig.getDigestSize()];
        byte[] v2 = new byte[(this.length - this.dig.getDigestSize())];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v4);
        org.spongycastle.crypto.generators.MGF1BytesGenerator v3_1 = new org.spongycastle.crypto.generators.MGF1BytesGenerator(this.dig);
        v3_1.init(new org.spongycastle.crypto.params.MGFParameters(v4));
        v3_1.generateBytes(v2, 0, v2.length);
        System.arraycopy(v4, 0, v0, 0, v4.length);
        System.arraycopy(p9, 0, v0, v4.length, p9.length);
        int v1_0 = ((v4.length + p9.length) + 1);
        while (v1_0 != v0.length) {
            v0[v1_0] = ((byte) (this.random.nextInt(255) + 1));
            v1_0++;
        }
        int v1_1 = 0;
        while (v1_1 != v2.length) {
            int v5_18 = (v4.length + v1_1);
            v0[v5_18] = ((byte) (v0[v5_18] ^ v2[v1_1]));
            v1_1++;
        }
        return v0;
    }

Method org.spongycastle.cert.crmf.PKMACBuilder.build() calling method java.security.SecureRandom.<init>()


    public org.spongycastle.operator.MacCalculator build(char[] p6)
    {
        org.spongycastle.operator.MacCalculator v1_3;
        if (this.parameters == null) {
            byte[] v0 = new byte[this.saltLength];
            if (this.random == null) {
                this.random = new java.security.SecureRandom();
            }
            this.random.nextBytes(v0);
            v1_3 = this.genCalculator(new org.spongycastle.asn1.cmp.PBMParameter(v0, this.owf, this.iterationCount, this.mac), p6);
        } else {
            v1_3 = this.genCalculator(this.parameters, p6);
        }
        return v1_3;
    }

Method org.spongycastle.cert.crmf.jcajce.JceCRMFEncryptorBuilder$CRMFOutputEncryptor.<init>() calling method java.security.SecureRandom.<init>()


    JceCRMFEncryptorBuilder$CRMFOutputEncryptor(org.spongycastle.cert.crmf.jcajce.JceCRMFEncryptorBuilder p7, org.spongycastle.asn1.ASN1ObjectIdentifier p8, int p9, java.security.SecureRandom p10)
    {
        this.this$0 = p7;
        javax.crypto.KeyGenerator v1 = org.spongycastle.cert.crmf.jcajce.JceCRMFEncryptorBuilder.access$000(p7).createKeyGenerator(p8);
        if (p10 == null) {
            p10 = new java.security.SecureRandom();
        }
        if (p9 >= 0) {
            v1.init(p9, p10);
        } else {
            v1.init(p10);
        }
        this.cipher = org.spongycastle.cert.crmf.jcajce.JceCRMFEncryptorBuilder.access$000(p7).createCipher(p8);
        this.encKey = v1.generateKey();
        java.security.AlgorithmParameters v2 = org.spongycastle.cert.crmf.jcajce.JceCRMFEncryptorBuilder.access$000(p7).generateParameters(p8, this.encKey, p10);
        try {
            this.cipher.init(1, this.encKey, v2, p10);
        } catch (java.security.GeneralSecurityException v0) {
            throw new org.spongycastle.cert.crmf.CRMFException(new StringBuilder().append("unable to initialize cipher: ").append(v0.getMessage()).toString(), v0);
        }
        if (v2 == null) {
            v2 = this.cipher.getParameters();
        }
        this.algorithmIdentifier = org.spongycastle.cert.crmf.jcajce.JceCRMFEncryptorBuilder.access$000(p7).getAlgorithmIdentifier(p8, v2);
        return;
    }

Method org.spongycastle.cms.CMSEnvelopedGenerator.<init>() calling method java.security.SecureRandom.<init>()


    public CMSEnvelopedGenerator()
    {
        this(new java.security.SecureRandom());
        return;
    }

Method org.spongycastle.cms.CMSSignedGenerator.<init>() calling method java.security.SecureRandom.<init>()


    protected CMSSignedGenerator()
    {
        this(new java.security.SecureRandom());
        return;
    }

Method org.spongycastle.cms.PasswordRecipientInfoGenerator.generate() calling method java.security.SecureRandom.<init>()


    public org.spongycastle.asn1.cms.RecipientInfo generate(org.spongycastle.operator.GenericKey p15)
    {
        byte[] v4 = new byte[this.blockSize];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v4);
        if (this.keyDerivationAlgorithm == null) {
            byte[] v8 = new byte[20];
            this.random.nextBytes(v8);
            this.keyDerivationAlgorithm = new org.spongycastle.asn1.x509.AlgorithmIdentifier(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_PBKDF2, new org.spongycastle.asn1.pkcs.PBKDF2Params(v8, 1024));
        }
        byte[] v0;
        org.spongycastle.asn1.pkcs.PBKDF2Params v7 = org.spongycastle.asn1.pkcs.PBKDF2Params.getInstance(this.keyDerivationAlgorithm.getParameters());
        if (this.schemeID != 0) {
            org.spongycastle.crypto.generators.PKCS5S2ParametersGenerator v3_1 = new org.spongycastle.crypto.generators.PKCS5S2ParametersGenerator();
            v3_1.init(org.spongycastle.crypto.PBEParametersGenerator.PKCS5PasswordToUTF8Bytes(this.password), v7.getSalt(), v7.getIterationCount().intValue());
            v0 = ((org.spongycastle.crypto.params.KeyParameter) v3_1.generateDerivedParameters(this.keySize)).getKey();
        } else {
            org.spongycastle.crypto.generators.PKCS5S2ParametersGenerator v3_3 = new org.spongycastle.crypto.generators.PKCS5S2ParametersGenerator();
            v3_3.init(org.spongycastle.crypto.PBEParametersGenerator.PKCS5PasswordToBytes(this.password), v7.getSalt(), v7.getIterationCount().intValue());
            v0 = ((org.spongycastle.crypto.params.KeyParameter) v3_3.generateDerivedParameters(this.keySize)).getKey();
        }
        org.spongycastle.asn1.DEROctetString v1_1 = new org.spongycastle.asn1.DEROctetString(this.generateEncryptedBytes(new org.spongycastle.asn1.x509.AlgorithmIdentifier(this.kekAlgorithm, new org.spongycastle.asn1.DEROctetString(v4)), v0, p15));
        org.spongycastle.asn1.ASN1EncodableVector v9_1 = new org.spongycastle.asn1.ASN1EncodableVector();
        v9_1.add(this.kekAlgorithm);
        v9_1.add(new org.spongycastle.asn1.DEROctetString(v4));
        return new org.spongycastle.asn1.cms.RecipientInfo(new org.spongycastle.asn1.cms.PasswordRecipientInfo(this.keyDerivationAlgorithm, new org.spongycastle.asn1.x509.AlgorithmIdentifier(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_alg_PWRI_KEK, new org.spongycastle.asn1.DERSequence(v9_1)), v1_1));
    }

Method org.spongycastle.cms.jcajce.JceCMSContentEncryptorBuilder$CMSOutputEncryptor.<init>() calling method java.security.SecureRandom.<init>()


    JceCMSContentEncryptorBuilder$CMSOutputEncryptor(org.spongycastle.cms.jcajce.JceCMSContentEncryptorBuilder p7, org.spongycastle.asn1.ASN1ObjectIdentifier p8, int p9, java.security.SecureRandom p10)
    {
        this.this$0 = p7;
        javax.crypto.KeyGenerator v1 = org.spongycastle.cms.jcajce.JceCMSContentEncryptorBuilder.access$000(p7).createKeyGenerator(p8);
        if (p10 == null) {
            p10 = new java.security.SecureRandom();
        }
        if (p9 >= 0) {
            v1.init(p9, p10);
        } else {
            v1.init(p10);
        }
        this.cipher = org.spongycastle.cms.jcajce.JceCMSContentEncryptorBuilder.access$000(p7).createCipher(p8);
        this.encKey = v1.generateKey();
        java.security.AlgorithmParameters v2 = org.spongycastle.cms.jcajce.JceCMSContentEncryptorBuilder.access$000(p7).generateParameters(p8, this.encKey, p10);
        try {
            this.cipher.init(1, this.encKey, v2, p10);
        } catch (java.security.GeneralSecurityException v0) {
            throw new org.spongycastle.cms.CMSException(new StringBuilder().append("unable to initialize cipher: ").append(v0.getMessage()).toString(), v0);
        }
        if (v2 == null) {
            v2 = this.cipher.getParameters();
        }
        this.algorithmIdentifier = org.spongycastle.cms.jcajce.JceCMSContentEncryptorBuilder.access$000(p7).getAlgorithmIdentifier(p8, v2);
        return;
    }

Method org.spongycastle.cms.jcajce.JceCMSMacCalculatorBuilder$CMSOutputEncryptor.<init>() calling method java.security.SecureRandom.<init>()


    JceCMSMacCalculatorBuilder$CMSOutputEncryptor(org.spongycastle.cms.jcajce.JceCMSMacCalculatorBuilder p6, org.spongycastle.asn1.ASN1ObjectIdentifier p7, int p8, java.security.SecureRandom p9)
    {
        this.this$0 = p6;
        javax.crypto.KeyGenerator v0 = org.spongycastle.cms.jcajce.JceCMSMacCalculatorBuilder.access$000(p6).createKeyGenerator(p7);
        if (p9 == null) {
            p9 = new java.security.SecureRandom();
        }
        this.random = p9;
        if (p8 >= 0) {
            v0.init(p8, p9);
        } else {
            v0.init(p9);
        }
        this.encKey = v0.generateKey();
        this.algorithmIdentifier = org.spongycastle.cms.jcajce.JceCMSMacCalculatorBuilder.access$000(p6).getAlgorithmIdentifier(p7, this.generateParameterSpec(p7, this.encKey));
        this.mac = org.spongycastle.cms.jcajce.JceCMSMacCalculatorBuilder.access$000(p6).createContentMac(this.encKey, this.algorithmIdentifier);
        return;
    }

Method org.spongycastle.cms.jcajce.JceKeyAgreeRecipientInfoGenerator.init() calling method java.security.SecureRandom.<init>()


    private void init(org.spongycastle.asn1.ASN1ObjectIdentifier p7)
    {
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        if ((p7.equals(org.spongycastle.cms.CMSAlgorithm.ECMQV_SHA1KDF)) && (this.ephemeralKP == null)) {
            try {
                java.security.spec.ECParameterSpec v1 = ((java.security.interfaces.ECPublicKey) this.senderPublicKey).getParams();
                java.security.KeyPairGenerator v2 = this.helper.createKeyPairGenerator(p7);
                v2.initialize(v1, this.random);
                this.ephemeralKP = v2.generateKeyPair();
            } catch (java.security.InvalidAlgorithmParameterException v0) {
                throw new org.spongycastle.cms.CMSException(new StringBuilder().append("cannot determine MQV ephemeral key pair parameters from public key: ").append(v0).toString());
            }
        }
        return;
    }

Method org.spongycastle.crypto.agreement.DHAgreement.init() calling method java.security.SecureRandom.<init>()


    public void init(org.spongycastle.crypto.CipherParameters p5)
    {
        org.spongycastle.crypto.params.DHPrivateKeyParameters v0_1;
        if (!(p5 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            this.random = new java.security.SecureRandom();
            v0_1 = ((org.spongycastle.crypto.params.AsymmetricKeyParameter) p5);
        } else {
            this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p5).getRandom();
            v0_1 = ((org.spongycastle.crypto.params.AsymmetricKeyParameter) ((org.spongycastle.crypto.params.ParametersWithRandom) p5).getParameters());
        }
        if ((v0_1 instanceof org.spongycastle.crypto.params.DHPrivateKeyParameters)) {
            this.key = ((org.spongycastle.crypto.params.DHPrivateKeyParameters) v0_1);
            this.dhParams = this.key.getParameters();
            return;
        } else {
            throw new IllegalArgumentException("DHEngine expects DHPrivateKeyParameters");
        }
    }

Method org.spongycastle.crypto.encodings.OAEPEncoding.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            this.random = new java.security.SecureRandom();
        } else {
            this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
        }
        this.engine.init(p3, p4);
        this.forEncryption = p3;
        return;
    }

Method org.spongycastle.crypto.encodings.PKCS1Encoding.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p4, org.spongycastle.crypto.CipherParameters p5)
    {
        org.spongycastle.crypto.params.AsymmetricKeyParameter v0_1;
        if (!(p5 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            this.random = new java.security.SecureRandom();
            v0_1 = ((org.spongycastle.crypto.params.AsymmetricKeyParameter) p5);
        } else {
            this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p5).getRandom();
            v0_1 = ((org.spongycastle.crypto.params.AsymmetricKeyParameter) ((org.spongycastle.crypto.params.ParametersWithRandom) p5).getParameters());
        }
        this.engine.init(p4, p5);
        this.forPrivateKey = v0_1.isPrivate();
        this.forEncryption = p4;
        return;
    }

Method org.spongycastle.crypto.engines.DESedeWrapEngine.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p6, org.spongycastle.crypto.CipherParameters p7)
    {
        java.security.SecureRandom v1_0;
        this.forWrapping = p6;
        this.engine = new org.spongycastle.crypto.modes.CBCBlockCipher(new org.spongycastle.crypto.engines.DESedeEngine());
        if (!(p7 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            v1_0 = new java.security.SecureRandom();
        } else {
            p7 = ((org.spongycastle.crypto.params.ParametersWithRandom) p7).getParameters();
            v1_0 = ((org.spongycastle.crypto.params.ParametersWithRandom) p7).getRandom();
        }
        if (!(p7 instanceof org.spongycastle.crypto.params.KeyParameter)) {
            if ((p7 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                this.paramPlusIV = ((org.spongycastle.crypto.params.ParametersWithIV) p7);
                this.iv = this.paramPlusIV.getIV();
                this.param = ((org.spongycastle.crypto.params.KeyParameter) this.paramPlusIV.getParameters());
                if (!this.forWrapping) {
                    throw new IllegalArgumentException("You should not supply an IV for unwrapping");
                } else {
                    if ((this.iv == null) || (this.iv.length != 8)) {
                        throw new IllegalArgumentException("IV is not 8 octets");
                    }
                }
            }
        } else {
            this.param = ((org.spongycastle.crypto.params.KeyParameter) p7);
            if (this.forWrapping) {
                IllegalArgumentException v2_18 = new byte[8];
                this.iv = v2_18;
                v1_0.nextBytes(this.iv);
                this.paramPlusIV = new org.spongycastle.crypto.params.ParametersWithIV(this.param, this.iv);
            }
        }
        return;
    }

Method org.spongycastle.crypto.engines.ElGamalEngine.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p4, org.spongycastle.crypto.CipherParameters p5)
    {
        if (!(p5 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            this.key = ((org.spongycastle.crypto.params.ElGamalKeyParameters) p5);
            this.random = new java.security.SecureRandom();
        } else {
            this.key = ((org.spongycastle.crypto.params.ElGamalKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p5).getParameters());
            this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p5).getRandom();
        }
        this.forEncryption = p4;
        this.bitSize = this.key.getParameters().getP().bitLength();
        if (!p4) {
            if (!(this.key instanceof org.spongycastle.crypto.params.ElGamalPrivateKeyParameters)) {
                throw new IllegalArgumentException("ElGamalPrivateKeyParameters are required for decryption.");
            }
        } else {
            if (!(this.key instanceof org.spongycastle.crypto.params.ElGamalPublicKeyParameters)) {
                throw new IllegalArgumentException("ElGamalPublicKeyParameters are required for encryption.");
            }
        }
        return;
    }

Method org.spongycastle.crypto.engines.NTRUEngine.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        this.forEncryption = p3;
        if (!p3) {
            this.privKey = ((org.spongycastle.crypto.params.NTRUEncryptionPrivateKeyParameters) p4);
            this.params = this.privKey.getParameters();
        } else {
            if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
                this.random = new java.security.SecureRandom();
                this.pubKey = ((org.spongycastle.crypto.params.NTRUEncryptionPublicKeyParameters) p4);
            } else {
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                this.pubKey = ((org.spongycastle.crypto.params.NTRUEncryptionPublicKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
            }
            this.params = this.pubKey.getParameters();
        }
        return;
    }

Method org.spongycastle.crypto.engines.RC2WrapEngine.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p5, org.spongycastle.crypto.CipherParameters p6)
    {
        this.forWrapping = p5;
        this.engine = new org.spongycastle.crypto.modes.CBCBlockCipher(new org.spongycastle.crypto.engines.RC2Engine());
        if (!(p6 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            this.sr = new java.security.SecureRandom();
        } else {
            this.sr = ((org.spongycastle.crypto.params.ParametersWithRandom) p6).getRandom();
            p6 = ((org.spongycastle.crypto.params.ParametersWithRandom) p6).getParameters();
        }
        if (!(p6 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
            this.param = p6;
            if (this.forWrapping) {
                IllegalArgumentException v1_5 = new byte[8];
                this.iv = v1_5;
                this.sr.nextBytes(this.iv);
                this.paramPlusIV = new org.spongycastle.crypto.params.ParametersWithIV(this.param, this.iv);
            }
        } else {
            this.paramPlusIV = ((org.spongycastle.crypto.params.ParametersWithIV) p6);
            this.iv = this.paramPlusIV.getIV();
            this.param = this.paramPlusIV.getParameters();
            if (!this.forWrapping) {
                throw new IllegalArgumentException("You should not supply an IV for unwrapping");
            } else {
                if ((this.iv == null) || (this.iv.length != 8)) {
                    throw new IllegalArgumentException("IV is not 8 octets");
                }
            }
        }
        return;
    }

Method org.spongycastle.crypto.engines.RFC3211WrapEngine.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        this.forWrapping = p3;
        if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            if (p3) {
                this.rand = new java.security.SecureRandom();
            }
            this.param = ((org.spongycastle.crypto.params.ParametersWithIV) p4);
        } else {
            this.rand = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
            this.param = ((org.spongycastle.crypto.params.ParametersWithIV) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
        }
        return;
    }

Method org.spongycastle.crypto.engines.RSABlindedEngine.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        this.core.init(p3, p4);
        if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            this.key = ((org.spongycastle.crypto.params.RSAKeyParameters) p4);
            this.random = new java.security.SecureRandom();
        } else {
            this.key = ((org.spongycastle.crypto.params.RSAKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
            this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
        }
        return;
    }

Method org.spongycastle.crypto.examples.DESExample.<init>() calling method java.security.SecureRandom.<init>()


    public DESExample(String p16, String p17, String p18, boolean p19)
    {
        this.encrypt = 1;
        this.cipher = 0;
        this.in = 0;
        this.out = 0;
        this.key = 0;
        this.encrypt = p19;
        try {
            this.in = new java.io.BufferedInputStream(new java.io.FileInputStream(p16));
            try {
                this.out = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p17));
            } catch (java.io.IOException v2) {
                System.err.println(new StringBuilder().append("Output file not created [").append(p17).append("]").toString());
                System.exit(1);
            }
            if (!p19) {
                try {
                    java.io.BufferedOutputStream v5_3 = new java.io.BufferedInputStream(new java.io.FileInputStream(p18));
                    int v8 = v5_3.available();
                    byte[] v4_1 = new byte[v8];
                    v5_3.read(v4_1, 0, v8);
                    this.key = org.spongycastle.util.encoders.Hex.decode(v4_1);
                } catch (java.io.IOException v3) {
                    System.err.println(new StringBuilder().append("Decryption key file not found, or not valid [").append(p18).append("]").toString());
                    System.exit(1);
                }
            } else {
                java.security.SecureRandom v10 = 0;
                try {
                    java.security.SecureRandom v11_1 = new java.security.SecureRandom();
                    try {
                        v11_1.setSeed("www.spongycastle.org".getBytes());
                        v10 = v11_1;
                    } catch (Exception v9) {
                        v10 = v11_1;
                        System.err.println("Hmmm, no SHA1PRNG, you need the Sun implementation");
                        System.exit(1);
                    } catch (java.io.IOException v1) {
                        System.err.println(new StringBuilder().append("Could not decryption create key file [").append(p18).append("]").toString());
                        System.exit(1);
                    }
                    org.spongycastle.crypto.KeyGenerationParameters v7_1 = new org.spongycastle.crypto.KeyGenerationParameters(v10, 192);
                    org.spongycastle.crypto.generators.DESedeKeyGenerator v6_1 = new org.spongycastle.crypto.generators.DESedeKeyGenerator();
                    v6_1.init(v7_1);
                    this.key = v6_1.generateKey();
                    java.io.BufferedOutputStream v5_1 = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p18));
                    byte[] v4_0 = org.spongycastle.util.encoders.Hex.encode(this.key);
                    v5_1.write(v4_0, 0, v4_0.length);
                    v5_1.flush();
                    v5_1.close();
                } catch (Exception v9) {
                } catch (java.io.IOException v1) {
                }
            }
            return;
        } catch (java.io.IOException v2) {
            System.err.println(new StringBuilder().append("Input file not found [").append(p16).append("]").toString());
            System.exit(1);
        }
    }

Method org.spongycastle.crypto.generators.NTRUSigningKeyPairGenerator.generateBasis() calling method java.security.SecureRandom.<init>()


    private org.spongycastle.crypto.generators.NTRUSigningKeyPairGenerator$FGBasis generateBasis()
    {
        int v4 = this.params.N;
        int v42 = this.params.q;
        int v30 = this.params.d;
        int v5 = this.params.d1;
        int v6 = this.params.d2;
        int v8 = this.params.d3;
        int v29 = this.params.basisType;
        int v28 = ((v4 * 2) + 1);
        boolean v41 = this.params.primeCheck;
        do {
            org.spongycastle.math.ntru.polynomial.ProductFormPolynomial v16;
            if (this.params.polyType != 0) {
                v16 = org.spongycastle.math.ntru.polynomial.ProductFormPolynomial.generateRandom(v4, v5, v6, (v8 + 1), v8, new java.security.SecureRandom());
            } else {
                v16 = org.spongycastle.math.ntru.polynomial.DenseTernaryPolynomial.generateRandom(v4, (v30 + 1), v30, new java.security.SecureRandom());
            }
            org.spongycastle.math.ntru.polynomial.IntegerPolynomial v10 = v16.toIntegerPolynomial();
            if ((!v41) || (!v10.resultant(v28).res.equals(java.math.BigInteger.ZERO))) {
                org.spongycastle.math.ntru.polynomial.IntegerPolynomial v34 = v10.invertFq(v42);
            }
        } while(v34 == null);
        org.spongycastle.math.ntru.polynomial.Resultant v44 = v10.resultant();
        do {
            org.spongycastle.math.ntru.polynomial.ProductFormPolynomial v35;
            if (this.params.polyType != 0) {
                v35 = org.spongycastle.math.ntru.polynomial.ProductFormPolynomial.generateRandom(v4, v5, v6, (v8 + 1), v8, new java.security.SecureRandom());
            } else {
                v35 = org.spongycastle.math.ntru.polynomial.DenseTernaryPolynomial.generateRandom(v4, (v30 + 1), v30, new java.security.SecureRandom());
            }
            org.spongycastle.math.ntru.polynomial.IntegerPolynomial v11 = v35.toIntegerPolynomial();
            if (((!v41) || (!v11.resultant(v28).res.equals(java.math.BigInteger.ZERO))) && (v11.invertFq(v42) != null)) {
                org.spongycastle.math.ntru.polynomial.Resultant v45 = v11.resultant();
                org.spongycastle.math.ntru.euclid.BigIntEuclidean v43 = org.spongycastle.math.ntru.euclid.BigIntEuclidean.calculate(v44.res, v45.res);
            }
        } while(!v43.gcd.equals(java.math.BigInteger.ONE));
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v24_0;
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v22_1 = ((org.spongycastle.math.ntru.polynomial.BigIntPolynomial) v44.rho.clone());
        v22_1.mult(v43.x.multiply(java.math.BigInteger.valueOf(((long) v42))));
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v23_1 = ((org.spongycastle.math.ntru.polynomial.BigIntPolynomial) v45.rho.clone());
        v23_1.mult(v43.y.multiply(java.math.BigInteger.valueOf(((long) (- v42)))));
        if (this.params.keyGenAlg != 0) {
            int v40 = 0;
            int v39_0 = 1;
            while (v39_0 < v4) {
                v40++;
                v39_0 *= 10;
            }
            org.spongycastle.math.ntru.polynomial.BigDecimalPolynomial v31 = v44.rho.div(new java.math.BigDecimal(v44.res), ((v23_1.getMaxCoeffLength() + 1) + v40));
            org.spongycastle.math.ntru.polynomial.BigDecimalPolynomial v36 = v45.rho.div(new java.math.BigDecimal(v45.res), ((v22_1.getMaxCoeffLength() + 1) + v40));
            org.spongycastle.math.ntru.polynomial.BigDecimalPolynomial v25 = v31.mult(v23_1);
            v25.add(v36.mult(v22_1));
            v25.halve();
            v24_0 = v25.round();
        } else {
            org.spongycastle.crypto.params.NTRUSigningKeyGenerationParameters v0_22 = new int[v4];
            int[] v33 = v0_22;
            org.spongycastle.crypto.params.NTRUSigningKeyGenerationParameters v0_23 = new int[v4];
            int[] v38 = v0_23;
            v33[0] = v10.coeffs[0];
            v38[0] = v11.coeffs[0];
            int v39_1 = 1;
            while (v39_1 < v4) {
                v33[v39_1] = v10.coeffs[(v4 - v39_1)];
                v38[v39_1] = v11.coeffs[(v4 - v39_1)];
                v39_1++;
            }
            org.spongycastle.math.ntru.polynomial.IntegerPolynomial v32_1 = new org.spongycastle.math.ntru.polynomial.IntegerPolynomial(v33);
            org.spongycastle.math.ntru.polynomial.IntegerPolynomial v37_1 = new org.spongycastle.math.ntru.polynomial.IntegerPolynomial(v38);
            org.spongycastle.math.ntru.polynomial.IntegerPolynomial v47 = v16.mult(v32_1);
            v47.add(v35.mult(v37_1));
            org.spongycastle.math.ntru.polynomial.Resultant v46 = v47.resultant();
            org.spongycastle.math.ntru.polynomial.BigIntPolynomial v24_1 = v32_1.mult(v23_1);
            v24_1.add(v37_1.mult(v22_1));
            v24_0 = v24_1.mult(v46.rho);
            v24_0.div(v46.res);
        }
        org.spongycastle.math.ntru.polynomial.IntegerPolynomial v18;
        org.spongycastle.math.ntru.polynomial.ProductFormPolynomial v17;
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v26_1 = ((org.spongycastle.math.ntru.polynomial.BigIntPolynomial) v23_1.clone());
        v26_1.sub(v16.mult(v24_0));
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v27_1 = ((org.spongycastle.math.ntru.polynomial.BigIntPolynomial) v22_1.clone());
        v27_1.sub(v35.mult(v24_0));
        org.spongycastle.math.ntru.polynomial.IntegerPolynomial v12_1 = new org.spongycastle.math.ntru.polynomial.IntegerPolynomial(v26_1);
        org.spongycastle.math.ntru.polynomial.IntegerPolynomial v13_1 = new org.spongycastle.math.ntru.polynomial.IntegerPolynomial(v27_1);
        this.minimizeFG(v10, v11, v12_1, v13_1, v4);
        if (v29 != 0) {
            v17 = v35;
            v18 = v12_1.mult(v34, v42);
        } else {
            v17 = v12_1;
            v18 = v35.mult(v34, v42);
        }
        v18.modPositive(v42);
        return new org.spongycastle.crypto.generators.NTRUSigningKeyPairGenerator$FGBasis(this, v16, v17, v18, v12_1, v13_1, this.params);
    }

Method org.spongycastle.crypto.generators.NTRUSigningKeyPairGenerator.generateBasis() calling method java.security.SecureRandom.<init>()


    private org.spongycastle.crypto.generators.NTRUSigningKeyPairGenerator$FGBasis generateBasis()
    {
        int v4 = this.params.N;
        int v42 = this.params.q;
        int v30 = this.params.d;
        int v5 = this.params.d1;
        int v6 = this.params.d2;
        int v8 = this.params.d3;
        int v29 = this.params.basisType;
        int v28 = ((v4 * 2) + 1);
        boolean v41 = this.params.primeCheck;
        do {
            org.spongycastle.math.ntru.polynomial.ProductFormPolynomial v16;
            if (this.params.polyType != 0) {
                v16 = org.spongycastle.math.ntru.polynomial.ProductFormPolynomial.generateRandom(v4, v5, v6, (v8 + 1), v8, new java.security.SecureRandom());
            } else {
                v16 = org.spongycastle.math.ntru.polynomial.DenseTernaryPolynomial.generateRandom(v4, (v30 + 1), v30, new java.security.SecureRandom());
            }
            org.spongycastle.math.ntru.polynomial.IntegerPolynomial v10 = v16.toIntegerPolynomial();
            if ((!v41) || (!v10.resultant(v28).res.equals(java.math.BigInteger.ZERO))) {
                org.spongycastle.math.ntru.polynomial.IntegerPolynomial v34 = v10.invertFq(v42);
            }
        } while(v34 == null);
        org.spongycastle.math.ntru.polynomial.Resultant v44 = v10.resultant();
        do {
            org.spongycastle.math.ntru.polynomial.ProductFormPolynomial v35;
            if (this.params.polyType != 0) {
                v35 = org.spongycastle.math.ntru.polynomial.ProductFormPolynomial.generateRandom(v4, v5, v6, (v8 + 1), v8, new java.security.SecureRandom());
            } else {
                v35 = org.spongycastle.math.ntru.polynomial.DenseTernaryPolynomial.generateRandom(v4, (v30 + 1), v30, new java.security.SecureRandom());
            }
            org.spongycastle.math.ntru.polynomial.IntegerPolynomial v11 = v35.toIntegerPolynomial();
            if (((!v41) || (!v11.resultant(v28).res.equals(java.math.BigInteger.ZERO))) && (v11.invertFq(v42) != null)) {
                org.spongycastle.math.ntru.polynomial.Resultant v45 = v11.resultant();
                org.spongycastle.math.ntru.euclid.BigIntEuclidean v43 = org.spongycastle.math.ntru.euclid.BigIntEuclidean.calculate(v44.res, v45.res);
            }
        } while(!v43.gcd.equals(java.math.BigInteger.ONE));
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v24_0;
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v22_1 = ((org.spongycastle.math.ntru.polynomial.BigIntPolynomial) v44.rho.clone());
        v22_1.mult(v43.x.multiply(java.math.BigInteger.valueOf(((long) v42))));
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v23_1 = ((org.spongycastle.math.ntru.polynomial.BigIntPolynomial) v45.rho.clone());
        v23_1.mult(v43.y.multiply(java.math.BigInteger.valueOf(((long) (- v42)))));
        if (this.params.keyGenAlg != 0) {
            int v40 = 0;
            int v39_0 = 1;
            while (v39_0 < v4) {
                v40++;
                v39_0 *= 10;
            }
            org.spongycastle.math.ntru.polynomial.BigDecimalPolynomial v31 = v44.rho.div(new java.math.BigDecimal(v44.res), ((v23_1.getMaxCoeffLength() + 1) + v40));
            org.spongycastle.math.ntru.polynomial.BigDecimalPolynomial v36 = v45.rho.div(new java.math.BigDecimal(v45.res), ((v22_1.getMaxCoeffLength() + 1) + v40));
            org.spongycastle.math.ntru.polynomial.BigDecimalPolynomial v25 = v31.mult(v23_1);
            v25.add(v36.mult(v22_1));
            v25.halve();
            v24_0 = v25.round();
        } else {
            org.spongycastle.crypto.params.NTRUSigningKeyGenerationParameters v0_22 = new int[v4];
            int[] v33 = v0_22;
            org.spongycastle.crypto.params.NTRUSigningKeyGenerationParameters v0_23 = new int[v4];
            int[] v38 = v0_23;
            v33[0] = v10.coeffs[0];
            v38[0] = v11.coeffs[0];
            int v39_1 = 1;
            while (v39_1 < v4) {
                v33[v39_1] = v10.coeffs[(v4 - v39_1)];
                v38[v39_1] = v11.coeffs[(v4 - v39_1)];
                v39_1++;
            }
            org.spongycastle.math.ntru.polynomial.IntegerPolynomial v32_1 = new org.spongycastle.math.ntru.polynomial.IntegerPolynomial(v33);
            org.spongycastle.math.ntru.polynomial.IntegerPolynomial v37_1 = new org.spongycastle.math.ntru.polynomial.IntegerPolynomial(v38);
            org.spongycastle.math.ntru.polynomial.IntegerPolynomial v47 = v16.mult(v32_1);
            v47.add(v35.mult(v37_1));
            org.spongycastle.math.ntru.polynomial.Resultant v46 = v47.resultant();
            org.spongycastle.math.ntru.polynomial.BigIntPolynomial v24_1 = v32_1.mult(v23_1);
            v24_1.add(v37_1.mult(v22_1));
            v24_0 = v24_1.mult(v46.rho);
            v24_0.div(v46.res);
        }
        org.spongycastle.math.ntru.polynomial.ProductFormPolynomial v17;
        org.spongycastle.math.ntru.polynomial.IntegerPolynomial v18;
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v26_1 = ((org.spongycastle.math.ntru.polynomial.BigIntPolynomial) v23_1.clone());
        v26_1.sub(v16.mult(v24_0));
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v27_1 = ((org.spongycastle.math.ntru.polynomial.BigIntPolynomial) v22_1.clone());
        v27_1.sub(v35.mult(v24_0));
        org.spongycastle.math.ntru.polynomial.IntegerPolynomial v12_1 = new org.spongycastle.math.ntru.polynomial.IntegerPolynomial(v26_1);
        org.spongycastle.math.ntru.polynomial.IntegerPolynomial v13_1 = new org.spongycastle.math.ntru.polynomial.IntegerPolynomial(v27_1);
        this.minimizeFG(v10, v11, v12_1, v13_1, v4);
        if (v29 != 0) {
            v17 = v35;
            v18 = v12_1.mult(v34, v42);
        } else {
            v17 = v12_1;
            v18 = v35.mult(v34, v42);
        }
        v18.modPositive(v42);
        return new org.spongycastle.crypto.generators.NTRUSigningKeyPairGenerator$FGBasis(this, v16, v17, v18, v12_1, v13_1, this.params);
    }

Method org.spongycastle.crypto.generators.RSABlindingFactorGenerator.init() calling method java.security.SecureRandom.<init>()


    public void init(org.spongycastle.crypto.CipherParameters p4)
    {
        if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            this.key = ((org.spongycastle.crypto.params.RSAKeyParameters) p4);
            this.random = new java.security.SecureRandom();
        } else {
            this.key = ((org.spongycastle.crypto.params.RSAKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
            this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
        }
        if (!(this.key instanceof org.spongycastle.crypto.params.RSAPrivateCrtKeyParameters)) {
            return;
        } else {
            throw new IllegalArgumentException("generator requires RSA public key");
        }
    }

Method org.spongycastle.crypto.paddings.ISO10126d2Padding.init() calling method java.security.SecureRandom.<init>()


    public void init(java.security.SecureRandom p2)
    {
        if (p2 == null) {
            this.random = new java.security.SecureRandom();
        } else {
            this.random = p2;
        }
        return;
    }

Method org.spongycastle.crypto.params.NTRUEncryptionKeyGenerationParameters.<init>() calling method java.security.SecureRandom.<init>()


    public NTRUEncryptionKeyGenerationParameters(int p3, int p4, int p5, int p6, int p7, int p8, int p9, int p10, int p11, int p12, boolean p13, byte[] p14, boolean p15, boolean p16, org.spongycastle.crypto.Digest p17)
    {
        super(new java.security.SecureRandom(), p9);
        super.N = p3;
        super.q = p4;
        super.df1 = p5;
        super.df2 = p6;
        super.df3 = p7;
        super.db = p9;
        super.dm0 = p8;
        super.c = p10;
        super.minCallsR = p11;
        super.minCallsMask = p12;
        super.hashSeed = p13;
        super.oid = p14;
        super.sparse = p15;
        super.fastFp = p16;
        super.polyType = 1;
        super.hashAlg = p17;
        super.init();
        return;
    }

Method org.spongycastle.crypto.params.NTRUEncryptionKeyGenerationParameters.<init>() calling method java.security.SecureRandom.<init>()


    public NTRUEncryptionKeyGenerationParameters(int p2, int p3, int p4, int p5, int p6, int p7, int p8, int p9, boolean p10, byte[] p11, boolean p12, boolean p13, org.spongycastle.crypto.Digest p14)
    {
        super(new java.security.SecureRandom(), p6);
        super.N = p2;
        super.q = p3;
        super.df = p4;
        super.db = p6;
        super.dm0 = p5;
        super.c = p7;
        super.minCallsR = p8;
        super.minCallsMask = p9;
        super.hashSeed = p10;
        super.oid = p11;
        super.sparse = p12;
        super.fastFp = p13;
        super.polyType = 0;
        super.hashAlg = p14;
        super.init();
        return;
    }

Method org.spongycastle.crypto.params.NTRUEncryptionKeyGenerationParameters.<init>() calling method java.security.SecureRandom.<init>()


    public NTRUEncryptionKeyGenerationParameters(java.io.InputStream p5)
    {
        super(new java.security.SecureRandom(), -1);
        java.io.DataInputStream v1_1 = new java.io.DataInputStream(p5);
        super.N = v1_1.readInt();
        super.q = v1_1.readInt();
        super.df = v1_1.readInt();
        super.df1 = v1_1.readInt();
        super.df2 = v1_1.readInt();
        super.df3 = v1_1.readInt();
        super.db = v1_1.readInt();
        super.dm0 = v1_1.readInt();
        super.c = v1_1.readInt();
        super.minCallsR = v1_1.readInt();
        super.minCallsMask = v1_1.readInt();
        super.hashSeed = v1_1.readBoolean();
        org.spongycastle.crypto.digests.SHA256Digest v2_14 = new byte[3];
        super.oid = v2_14;
        v1_1.read(super.oid);
        super.sparse = v1_1.readBoolean();
        super.fastFp = v1_1.readBoolean();
        super.polyType = v1_1.read();
        String v0 = v1_1.readUTF();
        if (!"SHA-512".equals(v0)) {
            if ("SHA-256".equals(v0)) {
                super.hashAlg = new org.spongycastle.crypto.digests.SHA256Digest();
            }
        } else {
            super.hashAlg = new org.spongycastle.crypto.digests.SHA512Digest();
        }
        super.init();
        return;
    }

Method org.spongycastle.crypto.params.NTRUSigningKeyGenerationParameters.<init>() calling method java.security.SecureRandom.<init>()


    public NTRUSigningKeyGenerationParameters(int p3, int p4, int p5, int p6, int p7, double p8, double p10, double p12, boolean p14, boolean p15, int p16, org.spongycastle.crypto.Digest p17)
    {
        super(new java.security.SecureRandom(), p3);
        super.signFailTolerance = 100;
        super.bitsF = 6;
        super.N = p3;
        super.q = p4;
        super.d = p5;
        super.B = p6;
        super.basisType = p7;
        super.beta = p8;
        super.normBound = p10;
        super.keyNormBound = p12;
        super.primeCheck = p14;
        super.sparse = p15;
        super.keyGenAlg = p16;
        super.hashAlg = p17;
        super.polyType = 0;
        super.init();
        return;
    }

Method org.spongycastle.crypto.params.NTRUSigningKeyGenerationParameters.<init>() calling method java.security.SecureRandom.<init>()


    public NTRUSigningKeyGenerationParameters(int p3, int p4, int p5, int p6, int p7, int p8, int p9, double p10, double p12, double p14, boolean p16, boolean p17, int p18, org.spongycastle.crypto.Digest p19)
    {
        super(new java.security.SecureRandom(), p3);
        super.signFailTolerance = 100;
        super.bitsF = 6;
        super.N = p3;
        super.q = p4;
        super.d1 = p5;
        super.d2 = p6;
        super.d3 = p7;
        super.B = p8;
        super.basisType = p9;
        super.beta = p10;
        super.normBound = p12;
        super.keyNormBound = p14;
        super.primeCheck = p16;
        super.sparse = p17;
        super.keyGenAlg = p18;
        super.hashAlg = p19;
        super.polyType = 1;
        super.init();
        return;
    }

Method org.spongycastle.crypto.params.NTRUSigningKeyGenerationParameters.<init>() calling method java.security.SecureRandom.<init>()


    public NTRUSigningKeyGenerationParameters(java.io.InputStream p5)
    {
        super(new java.security.SecureRandom(), 0);
        super.signFailTolerance = 100;
        super.bitsF = 6;
        java.io.DataInputStream v1_1 = new java.io.DataInputStream(p5);
        super.N = v1_1.readInt();
        super.q = v1_1.readInt();
        super.d = v1_1.readInt();
        super.d1 = v1_1.readInt();
        super.d2 = v1_1.readInt();
        super.d3 = v1_1.readInt();
        super.B = v1_1.readInt();
        super.basisType = v1_1.readInt();
        super.beta = v1_1.readDouble();
        super.normBound = v1_1.readDouble();
        super.keyNormBound = v1_1.readDouble();
        super.signFailTolerance = v1_1.readInt();
        super.primeCheck = v1_1.readBoolean();
        super.sparse = v1_1.readBoolean();
        super.bitsF = v1_1.readInt();
        super.keyGenAlg = v1_1.read();
        String v0 = v1_1.readUTF();
        if (!"SHA-512".equals(v0)) {
            if ("SHA-256".equals(v0)) {
                super.hashAlg = new org.spongycastle.crypto.digests.SHA256Digest();
            }
        } else {
            super.hashAlg = new org.spongycastle.crypto.digests.SHA512Digest();
        }
        super.polyType = v1_1.read();
        super.init();
        return;
    }

Method org.spongycastle.crypto.params.ParametersWithRandom.<init>() calling method java.security.SecureRandom.<init>()


    public ParametersWithRandom(org.spongycastle.crypto.CipherParameters p2)
    {
        this(p2, new java.security.SecureRandom());
        return;
    }

Method org.spongycastle.crypto.signers.DSASigner.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        if (!p3) {
            this.key = ((org.spongycastle.crypto.params.DSAPublicKeyParameters) p4);
        } else {
            if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
                this.random = new java.security.SecureRandom();
                this.key = ((org.spongycastle.crypto.params.DSAPrivateKeyParameters) p4);
            } else {
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                this.key = ((org.spongycastle.crypto.params.DSAPrivateKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
            }
        }
        return;
    }

Method org.spongycastle.crypto.signers.ECDSASigner.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        if (!p3) {
            this.key = ((org.spongycastle.crypto.params.ECPublicKeyParameters) p4);
        } else {
            if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
                this.random = new java.security.SecureRandom();
                this.key = ((org.spongycastle.crypto.params.ECPrivateKeyParameters) p4);
            } else {
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                this.key = ((org.spongycastle.crypto.params.ECPrivateKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
            }
        }
        return;
    }

Method org.spongycastle.crypto.signers.ECGOST3410Signer.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        if (!p3) {
            this.key = ((org.spongycastle.crypto.params.ECPublicKeyParameters) p4);
        } else {
            if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
                this.random = new java.security.SecureRandom();
                this.key = ((org.spongycastle.crypto.params.ECPrivateKeyParameters) p4);
            } else {
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                this.key = ((org.spongycastle.crypto.params.ECPrivateKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
            }
        }
        return;
    }

Method org.spongycastle.crypto.signers.ECNRSigner.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        this.forSigning = p3;
        if (!p3) {
            this.key = ((org.spongycastle.crypto.params.ECPublicKeyParameters) p4);
        } else {
            if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
                this.random = new java.security.SecureRandom();
                this.key = ((org.spongycastle.crypto.params.ECPrivateKeyParameters) p4);
            } else {
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                this.key = ((org.spongycastle.crypto.params.ECPrivateKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
            }
        }
        return;
    }

Method org.spongycastle.crypto.signers.GOST3410Signer.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        if (!p3) {
            this.key = ((org.spongycastle.crypto.params.GOST3410PublicKeyParameters) p4);
        } else {
            if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
                this.random = new java.security.SecureRandom();
                this.key = ((org.spongycastle.crypto.params.GOST3410PrivateKeyParameters) p4);
            } else {
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                this.key = ((org.spongycastle.crypto.params.GOST3410PrivateKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
            }
        }
        return;
    }

Method org.spongycastle.crypto.signers.ISO9796d2PSSSigner.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p6, org.spongycastle.crypto.CipherParameters p7)
    {
        org.spongycastle.crypto.params.RSAKeyParameters v0_1;
        int v1 = this.saltLength;
        if (!(p7 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            if (!(p7 instanceof org.spongycastle.crypto.params.ParametersWithSalt)) {
                v0_1 = ((org.spongycastle.crypto.params.RSAKeyParameters) p7);
                if (p6) {
                    this.random = new java.security.SecureRandom();
                }
            } else {
                v0_1 = ((org.spongycastle.crypto.params.RSAKeyParameters) ((org.spongycastle.crypto.params.ParametersWithSalt) p7).getParameters());
                this.standardSalt = ((org.spongycastle.crypto.params.ParametersWithSalt) p7).getSalt();
                v1 = this.standardSalt.length;
                if (this.standardSalt.length != this.saltLength) {
                    throw new IllegalArgumentException("Fixed salt is of wrong length");
                }
            }
        } else {
            v0_1 = ((org.spongycastle.crypto.params.RSAKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p7).getParameters());
            if (p6) {
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p7).getRandom();
            }
        }
        this.cipher.init(p6, v0_1);
        this.keyBits = v0_1.getModulus().bitLength();
        java.security.SecureRandom v3_15 = new byte[((this.keyBits + 7) / 8)];
        this.block = v3_15;
        if (this.trailer != 188) {
            java.security.SecureRandom v3_23 = new byte[((((this.block.length - this.digest.getDigestSize()) - v1) - 1) - 2)];
            this.mBuf = v3_23;
        } else {
            java.security.SecureRandom v3_30 = new byte[((((this.block.length - this.digest.getDigestSize()) - v1) - 1) - 1)];
            this.mBuf = v3_30;
        }
        this.reset();
        return;
    }

Method org.spongycastle.crypto.signers.PSSSigner.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p7, org.spongycastle.crypto.CipherParameters p8)
    {
        org.spongycastle.crypto.params.RSABlindingParameters v2_0;
        if (!(p8 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            v2_0 = p8;
            if (p7) {
                this.random = new java.security.SecureRandom();
            }
        } else {
            v2_0 = ((org.spongycastle.crypto.params.ParametersWithRandom) p8).getParameters();
            this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p8).getRandom();
        }
        org.spongycastle.crypto.params.RSAKeyParameters v0_1;
        this.cipher.init(p7, v2_0);
        if (!(v2_0 instanceof org.spongycastle.crypto.params.RSABlindingParameters)) {
            v0_1 = ((org.spongycastle.crypto.params.RSAKeyParameters) v2_0);
        } else {
            v0_1 = ((org.spongycastle.crypto.params.RSABlindingParameters) v2_0).getPublicKey();
        }
        this.emBits = (v0_1.getModulus().bitLength() - 1);
        if (this.emBits >= (((this.hLen * 8) + (this.sLen * 8)) + 9)) {
            byte[] v3_12 = new byte[((this.emBits + 7) / 8)];
            this.block = v3_12;
            this.reset();
            return;
        } else {
            throw new IllegalArgumentException("key too small for specified hash and salt lengths");
        }
    }

Method org.spongycastle.crypto.tls.TlsProtocolHandler.createSecureRandom() calling method java.security.SecureRandom.<init>()


    private static java.security.SecureRandom createSecureRandom()
    {
        org.spongycastle.crypto.prng.ThreadedSeedGenerator v1_1 = new org.spongycastle.crypto.prng.ThreadedSeedGenerator();
        java.security.SecureRandom v0_1 = new java.security.SecureRandom();
        v0_1.setSeed(v1_1.generateSeed(20, 1));
        return v0_1;
    }

Method org.spongycastle.jcajce.provider.asymmetric.dh.AlgorithmParameterGeneratorSpi.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        org.spongycastle.crypto.generators.DHParametersGenerator v2_1 = new org.spongycastle.crypto.generators.DHParametersGenerator();
        if (this.random == null) {
            v2_1.init(this.strength, 20, new java.security.SecureRandom());
        } else {
            v2_1.init(this.strength, 20, this.random);
        }
        org.spongycastle.crypto.params.DHParameters v1 = v2_1.generateParameters();
        try {
            java.security.AlgorithmParameters v3 = java.security.AlgorithmParameters.getInstance("DH", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v3.init(new javax.crypto.spec.DHParameterSpec(v1.getP(), v1.getG(), this.l));
            return v3;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.asymmetric.dh.KeyPairGeneratorSpi.<init>() calling method java.security.SecureRandom.<init>()


    public KeyPairGeneratorSpi()
    {
        super("DH");
        super.engine = new org.spongycastle.crypto.generators.DHBasicKeyPairGenerator();
        super.strength = 1024;
        super.certainty = 20;
        super.random = new java.security.SecureRandom();
        super.initialised = 0;
        return;
    }

Method org.spongycastle.jcajce.provider.asymmetric.dsa.AlgorithmParameterGeneratorSpi.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        org.spongycastle.crypto.generators.DSAParametersGenerator v2_1 = new org.spongycastle.crypto.generators.DSAParametersGenerator();
        if (this.random == null) {
            v2_1.init(this.strength, 20, new java.security.SecureRandom());
        } else {
            v2_1.init(this.strength, 20, this.random);
        }
        org.spongycastle.crypto.params.DSAParameters v1 = v2_1.generateParameters();
        try {
            java.security.AlgorithmParameters v3 = java.security.AlgorithmParameters.getInstance("DSA", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v3.init(new java.security.spec.DSAParameterSpec(v1.getP(), v1.getQ(), v1.getG()));
            return v3;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.asymmetric.dsa.KeyPairGeneratorSpi.<init>() calling method java.security.SecureRandom.<init>()


    public KeyPairGeneratorSpi()
    {
        super("DSA");
        super.engine = new org.spongycastle.crypto.generators.DSAKeyPairGenerator();
        super.strength = 1024;
        super.certainty = 20;
        super.random = new java.security.SecureRandom();
        super.initialised = 0;
        return;
    }

Method org.spongycastle.jcajce.provider.asymmetric.ec.KeyPairGeneratorSpi$EC.<init>() calling method java.security.SecureRandom.<init>()


    public KeyPairGeneratorSpi$EC()
    {
        super("EC");
        super.engine = new org.spongycastle.crypto.generators.ECKeyPairGenerator();
        super.ecParams = 0;
        super.strength = 239;
        super.certainty = 50;
        super.random = new java.security.SecureRandom();
        super.initialised = 0;
        super.algorithm = "EC";
        super.configuration = org.spongycastle.jce.provider.BouncyCastleProvider.CONFIGURATION;
        return;
    }

Method org.spongycastle.jcajce.provider.asymmetric.ec.KeyPairGeneratorSpi$EC.<init>() calling method java.security.SecureRandom.<init>()


    public KeyPairGeneratorSpi$EC(String p2, org.spongycastle.jcajce.provider.config.ProviderConfiguration p3)
    {
        super(p2);
        super.engine = new org.spongycastle.crypto.generators.ECKeyPairGenerator();
        super.ecParams = 0;
        super.strength = 239;
        super.certainty = 50;
        super.random = new java.security.SecureRandom();
        super.initialised = 0;
        super.algorithm = p2;
        super.configuration = p3;
        return;
    }

Method org.spongycastle.jcajce.provider.asymmetric.elgamal.AlgorithmParameterGeneratorSpi.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        org.spongycastle.crypto.generators.ElGamalParametersGenerator v2_1 = new org.spongycastle.crypto.generators.ElGamalParametersGenerator();
        if (this.random == null) {
            v2_1.init(this.strength, 20, new java.security.SecureRandom());
        } else {
            v2_1.init(this.strength, 20, this.random);
        }
        org.spongycastle.crypto.params.ElGamalParameters v1 = v2_1.generateParameters();
        try {
            java.security.AlgorithmParameters v3 = java.security.AlgorithmParameters.getInstance("ElGamal", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v3.init(new javax.crypto.spec.DHParameterSpec(v1.getP(), v1.getG(), this.l));
            return v3;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.asymmetric.elgamal.KeyPairGeneratorSpi.<init>() calling method java.security.SecureRandom.<init>()


    public KeyPairGeneratorSpi()
    {
        super("ElGamal");
        super.engine = new org.spongycastle.crypto.generators.ElGamalKeyPairGenerator();
        super.strength = 1024;
        super.certainty = 20;
        super.random = new java.security.SecureRandom();
        super.initialised = 0;
        return;
    }

Method org.spongycastle.jcajce.provider.asymmetric.gost.AlgorithmParameterGeneratorSpi.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        org.spongycastle.crypto.generators.GOST3410ParametersGenerator v2_1 = new org.spongycastle.crypto.generators.GOST3410ParametersGenerator();
        if (this.random == null) {
            v2_1.init(this.strength, 2, new java.security.SecureRandom());
        } else {
            v2_1.init(this.strength, 2, this.random);
        }
        org.spongycastle.crypto.params.GOST3410Parameters v1 = v2_1.generateParameters();
        try {
            java.security.AlgorithmParameters v3 = java.security.AlgorithmParameters.getInstance("GOST3410", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v3.init(new org.spongycastle.jce.spec.GOST3410ParameterSpec(new org.spongycastle.jce.spec.GOST3410PublicKeyParameterSetSpec(v1.getP(), v1.getQ(), v1.getA())));
            return v3;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.asymmetric.gost.KeyPairGeneratorSpi.generateKeyPair() calling method java.security.SecureRandom.<init>()


    public java.security.KeyPair generateKeyPair()
    {
        if (!this.initialised) {
            this.init(new org.spongycastle.jce.spec.GOST3410ParameterSpec(org.spongycastle.asn1.cryptopro.CryptoProObjectIdentifiers.gostR3410_94_CryptoPro_A.getId()), new java.security.SecureRandom());
        }
        org.spongycastle.crypto.AsymmetricCipherKeyPair v0 = this.engine.generateKeyPair();
        return new java.security.KeyPair(new org.spongycastle.jcajce.provider.asymmetric.gost.BCGOST3410PublicKey(((org.spongycastle.crypto.params.GOST3410PublicKeyParameters) v0.getPublic()), this.gost3410Params), new org.spongycastle.jcajce.provider.asymmetric.gost.BCGOST3410PrivateKey(((org.spongycastle.crypto.params.GOST3410PrivateKeyParameters) v0.getPrivate()), this.gost3410Params));
    }

Method org.spongycastle.jcajce.provider.asymmetric.rsa.CipherSpi.engineInit() calling method java.security.SecureRandom.<init>()


    protected void engineInit(int p11, java.security.Key p12, java.security.spec.AlgorithmParameterSpec p13, java.security.SecureRandom p14)
    {
        if ((p13 != null) && (!(p13 instanceof javax.crypto.spec.OAEPParameterSpec))) {
            throw new IllegalArgumentException("unknown parameter type.");
        } else {
            org.spongycastle.crypto.params.RSAKeyParameters v4;
            if (!(p12 instanceof java.security.interfaces.RSAPublicKey)) {
                if (!(p12 instanceof java.security.interfaces.RSAPrivateKey)) {
                    throw new java.security.InvalidKeyException("unknown key type passed to RSA");
                } else {
                    if ((!this.publicKeyOnly) || (p11 != 1)) {
                        v4 = org.spongycastle.jcajce.provider.asymmetric.rsa.RSAUtil.generatePrivateKeyParameter(((java.security.interfaces.RSAPrivateKey) p12));
                    } else {
                        throw new java.security.InvalidKeyException("mode 2 requires RSAPublicKey");
                    }
                }
            } else {
                if ((!this.privateKeyOnly) || (p11 != 1)) {
                    v4 = org.spongycastle.jcajce.provider.asymmetric.rsa.RSAUtil.generatePublicKeyParameter(((java.security.interfaces.RSAPublicKey) p12));
                } else {
                    throw new java.security.InvalidKeyException("mode 1 requires RSAPrivateKey");
                }
            }
            if (p13 != null) {
                this.paramSpec = p13;
                if ((((javax.crypto.spec.OAEPParameterSpec) p13).getMGFAlgorithm().equalsIgnoreCase("MGF1")) || (((javax.crypto.spec.OAEPParameterSpec) p13).getMGFAlgorithm().equals(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_mgf1.getId()))) {
                    if ((((javax.crypto.spec.OAEPParameterSpec) p13).getMGFParameters() instanceof java.security.spec.MGF1ParameterSpec)) {
                        org.spongycastle.crypto.Digest v0 = org.spongycastle.jcajce.provider.util.DigestFactory.getDigest(((javax.crypto.spec.OAEPParameterSpec) p13).getDigestAlgorithm());
                        if (v0 != null) {
                            java.security.spec.MGF1ParameterSpec v2_1 = ((java.security.spec.MGF1ParameterSpec) ((javax.crypto.spec.OAEPParameterSpec) p13).getMGFParameters());
                            org.spongycastle.crypto.Digest v1 = org.spongycastle.jcajce.provider.util.DigestFactory.getDigest(v2_1.getDigestAlgorithm());
                            if (v1 != null) {
                                this.cipher = new org.spongycastle.crypto.encodings.OAEPEncoding(new org.spongycastle.crypto.engines.RSABlindedEngine(), v0, v1, ((javax.crypto.spec.PSource$PSpecified) ((javax.crypto.spec.OAEPParameterSpec) p13).getPSource()).getValue());
                            } else {
                                throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("no match on MGF digest algorithm: ").append(v2_1.getDigestAlgorithm()).toString());
                            }
                        } else {
                            throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("no match on digest algorithm: ").append(((javax.crypto.spec.OAEPParameterSpec) p13).getDigestAlgorithm()).toString());
                        }
                    } else {
                        throw new java.security.InvalidAlgorithmParameterException("unkown MGF parameters");
                    }
                } else {
                    throw new java.security.InvalidAlgorithmParameterException("unknown mask generation function specified");
                }
            }
            org.spongycastle.crypto.params.ParametersWithRandom v3_2;
            if ((this.cipher instanceof org.spongycastle.crypto.engines.RSABlindedEngine)) {
                v3_2 = v4;
            } else {
                if (p14 == null) {
                    v3_2 = new org.spongycastle.crypto.params.ParametersWithRandom(v4, new java.security.SecureRandom());
                } else {
                    v3_2 = new org.spongycastle.crypto.params.ParametersWithRandom(v4, p14);
                }
            }
            switch (p11) {
                case 1:
                case 3:
                    this.cipher.init(1, v3_2);
                    break;
                case 2:
                case 4:
                    this.cipher.init(0, v3_2);
                    break;
                default:
                    throw new java.security.InvalidParameterException(new StringBuilder().append("unknown opmode ").append(p11).append(" passed to RSA").toString());
            }
            return;
        }
    }

Method org.spongycastle.jcajce.provider.asymmetric.rsa.KeyPairGeneratorSpi.<init>() calling method java.security.SecureRandom.<init>()


    public KeyPairGeneratorSpi()
    {
        super("RSA");
        super.engine = new org.spongycastle.crypto.generators.RSAKeyPairGenerator();
        super.param = new org.spongycastle.crypto.params.RSAKeyGenerationParameters(org.spongycastle.jcajce.provider.asymmetric.rsa.KeyPairGeneratorSpi.defaultPublicExponent, new java.security.SecureRandom(), 2048, 12);
        super.engine.init(super.param);
        return;
    }

Method org.spongycastle.jcajce.provider.symmetric.util.BaseKeyGenerator.engineGenerateKey() calling method java.security.SecureRandom.<init>()


    protected javax.crypto.SecretKey engineGenerateKey()
    {
        if (this.uninitialised) {
            this.engine.init(new org.spongycastle.crypto.KeyGenerationParameters(new java.security.SecureRandom(), this.defaultKeySize));
            this.uninitialised = 0;
        }
        return new javax.crypto.spec.SecretKeySpec(this.engine.generateKey(), this.algName);
    }

Method org.spongycastle.jcajce.provider.symmetric.AES$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[16];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("AES", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher.engineInit() calling method java.security.SecureRandom.<init>()


    protected void engineInit(int p15, java.security.Key p16, java.security.spec.AlgorithmParameterSpec p17, java.security.SecureRandom p18)
    {
        this.pbeSpec = 0;
        this.pbeAlgorithm = 0;
        this.engineParams = 0;
        if ((p16 instanceof javax.crypto.SecretKey)) {
            if ((p17 != null) || (!this.baseEngine.getAlgorithmName().startsWith("RC5-64"))) {
                org.spongycastle.crypto.params.ParametersWithIV v7_1;
                if (!(p16 instanceof org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey)) {
                    if (p17 != null) {
                        if (!(p17 instanceof javax.crypto.spec.IvParameterSpec)) {
                            org.spongycastle.crypto.params.ParametersWithIV v8_1;
                            if (!(p17 instanceof org.spongycastle.jce.spec.GOST28147ParameterSpec)) {
                                if (!(p17 instanceof javax.crypto.spec.RC2ParameterSpec)) {
                                    if (!(p17 instanceof javax.crypto.spec.RC5ParameterSpec)) {
                                        throw new java.security.InvalidAlgorithmParameterException("unknown parameter type.");
                                    } else {
                                        v7_1 = new org.spongycastle.crypto.params.RC5Parameters(p16.getEncoded(), ((javax.crypto.spec.RC5ParameterSpec) p17).getRounds());
                                        if (!this.baseEngine.getAlgorithmName().startsWith("RC5")) {
                                            throw new java.security.InvalidAlgorithmParameterException("RC5 parameters passed to a cipher that is not RC5.");
                                        } else {
                                            if (!this.baseEngine.getAlgorithmName().equals("RC5-32")) {
                                                if ((this.baseEngine.getAlgorithmName().equals("RC5-64")) && (((javax.crypto.spec.RC5ParameterSpec) p17).getWordSize() != 64)) {
                                                    throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("RC5 already set up for a word size of 64 not ").append(((javax.crypto.spec.RC5ParameterSpec) p17).getWordSize()).append(".").toString());
                                                }
                                            } else {
                                                if (((javax.crypto.spec.RC5ParameterSpec) p17).getWordSize() != 32) {
                                                    throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("RC5 already set up for a word size of 32 not ").append(((javax.crypto.spec.RC5ParameterSpec) p17).getWordSize()).append(".").toString());
                                                }
                                            }
                                            if ((((javax.crypto.spec.RC5ParameterSpec) p17).getIV() == null) || (this.ivLength == 0)) {
                                                if ((this.ivLength == 0) || ((v7_1 instanceof org.spongycastle.crypto.params.ParametersWithIV))) {
                                                    org.spongycastle.crypto.params.ParametersWithIV v8_4 = v7_1;
                                                } else {
                                                    java.security.SecureRandom v4_0 = p18;
                                                    if (p18 == null) {
                                                        v4_0 = new java.security.SecureRandom();
                                                    }
                                                    if ((p15 != 1) && (p15 != 3)) {
                                                        if (this.cipher.getUnderlyingCipher().getAlgorithmName().indexOf("PGPCFB") >= 0) {
                                                        } else {
                                                            throw new java.security.InvalidAlgorithmParameterException("no IV set when one expected");
                                                        }
                                                    } else {
                                                        byte[] v3 = new byte[this.ivLength];
                                                        v4_0.nextBytes(v3);
                                                        v8_4 = new org.spongycastle.crypto.params.ParametersWithIV(v7_1, v3);
                                                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v8_4);
                                                    }
                                                }
                                                if ((p18 == null) || (!this.padded)) {
                                                    org.spongycastle.crypto.params.ParametersWithIV v7_7 = v8_4;
                                                } else {
                                                    v7_7 = new org.spongycastle.crypto.params.ParametersWithRandom(v8_4, p18);
                                                }
                                                try {
                                                    switch (p15) {
                                                        case 1:
                                                        case 3:
                                                            this.cipher.init(1, v7_7);
                                                            return;
                                                        case 2:
                                                        case 4:
                                                            this.cipher.init(0, v7_7);
                                                            return;
                                                        default:
                                                            throw new java.security.InvalidParameterException(new StringBuilder().append("unknown opmode ").append(p15).append(" passed").toString());
                                                    }
                                                } catch (Exception v1) {
                                                }
                                                throw new java.security.InvalidKeyException(v1.getMessage());
                                            } else {
                                                v8_1 = new org.spongycastle.crypto.params.ParametersWithIV(v7_1, ((javax.crypto.spec.RC5ParameterSpec) p17).getIV());
                                                this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v8_1);
                                            }
                                        }
                                    }
                                } else {
                                    v7_1 = new org.spongycastle.crypto.params.RC2Parameters(p16.getEncoded(), ((javax.crypto.spec.RC2ParameterSpec) p17).getEffectiveKeyBits());
                                    if ((((javax.crypto.spec.RC2ParameterSpec) p17).getIV() == null) || (this.ivLength == 0)) {
                                    } else {
                                        v8_1 = new org.spongycastle.crypto.params.ParametersWithIV(v7_1, ((javax.crypto.spec.RC2ParameterSpec) p17).getIV());
                                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v8_1);
                                    }
                                }
                            } else {
                                v7_1 = new org.spongycastle.crypto.params.ParametersWithSBox(new org.spongycastle.crypto.params.KeyParameter(p16.getEncoded()), ((org.spongycastle.jce.spec.GOST28147ParameterSpec) p17).getSbox());
                                if ((((org.spongycastle.jce.spec.GOST28147ParameterSpec) p17).getIV() == null) || (this.ivLength == 0)) {
                                } else {
                                    v8_1 = new org.spongycastle.crypto.params.ParametersWithIV(v7_1, ((org.spongycastle.jce.spec.GOST28147ParameterSpec) p17).getIV());
                                    this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v8_1);
                                }
                            }
                            v7_1 = v8_1;
                        } else {
                            if (this.ivLength == 0) {
                                if ((this.modeName == null) || (!this.modeName.equals("ECB"))) {
                                    v7_1 = new org.spongycastle.crypto.params.KeyParameter(p16.getEncoded());
                                } else {
                                    throw new java.security.InvalidAlgorithmParameterException("ECB mode does not use an IV");
                                }
                            } else {
                                if ((((javax.crypto.spec.IvParameterSpec) p17).getIV().length == this.ivLength) || (this.isAEADModeName(this.modeName))) {
                                    if (!(p16 instanceof org.spongycastle.jce.spec.RepeatedSecretKeySpec)) {
                                        v7_1 = new org.spongycastle.crypto.params.ParametersWithIV(new org.spongycastle.crypto.params.KeyParameter(p16.getEncoded()), ((javax.crypto.spec.IvParameterSpec) p17).getIV());
                                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v7_1);
                                    } else {
                                        v7_1 = new org.spongycastle.crypto.params.ParametersWithIV(0, ((javax.crypto.spec.IvParameterSpec) p17).getIV());
                                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v7_1);
                                    }
                                } else {
                                    throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("IV must be ").append(this.ivLength).append(" bytes long.").toString());
                                }
                            }
                        }
                    } else {
                        v7_1 = new org.spongycastle.crypto.params.KeyParameter(p16.getEncoded());
                    }
                } else {
                    if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getOID() == null) {
                        this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getAlgorithm();
                    } else {
                        this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getOID().getId();
                    }
                    if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getParam() == null) {
                        if (!(p17 instanceof javax.crypto.spec.PBEParameterSpec)) {
                            throw new java.security.InvalidAlgorithmParameterException("PBE requires PBE parameters to be set.");
                        } else {
                            this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p17);
                            v7_1 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16), p17, this.cipher.getUnderlyingCipher().getAlgorithmName());
                        }
                    } else {
                        v7_1 = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getParam();
                        this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getSalt(), ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getIterationCount());
                    }
                    if ((v7_1 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v7_1);
                    }
                }
            } else {
                throw new java.security.InvalidAlgorithmParameterException("RC5 requires an RC5ParametersSpec to be passed in.");
            }
        } else {
            throw new java.security.InvalidKeyException(new StringBuilder().append("Key for algorithm ").append(p16.getAlgorithm()).append(" not suitable for symmetric enryption.").toString());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.util.BaseStreamCipher.engineInit() calling method java.security.SecureRandom.<init>()


    protected void engineInit(int p10, java.security.Key p11, java.security.spec.AlgorithmParameterSpec p12, java.security.SecureRandom p13)
    {
        this.pbeSpec = 0;
        this.pbeAlgorithm = 0;
        this.engineParams = 0;
        if ((p11 instanceof javax.crypto.SecretKey)) {
            org.spongycastle.crypto.params.ParametersWithIV v3_1;
            if (!(p11 instanceof org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey)) {
                if (p12 != null) {
                    if (!(p12 instanceof javax.crypto.spec.IvParameterSpec)) {
                        throw new IllegalArgumentException("unknown parameter type.");
                    } else {
                        v3_1 = new org.spongycastle.crypto.params.ParametersWithIV(new org.spongycastle.crypto.params.KeyParameter(p11.getEncoded()), ((javax.crypto.spec.IvParameterSpec) p12).getIV());
                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v3_1);
                    }
                } else {
                    v3_1 = new org.spongycastle.crypto.params.KeyParameter(p11.getEncoded());
                }
            } else {
                if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getOID() == null) {
                    this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getAlgorithm();
                } else {
                    this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getOID().getId();
                }
                if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getParam() == null) {
                    if (!(p12 instanceof javax.crypto.spec.PBEParameterSpec)) {
                        throw new java.security.InvalidAlgorithmParameterException("PBE requires PBE parameters to be set.");
                    } else {
                        v3_1 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11), p12, this.cipher.getAlgorithmName());
                        this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p12);
                    }
                } else {
                    v3_1 = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getParam();
                    this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getSalt(), ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getIterationCount());
                }
                if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getIvSize() != 0) {
                    this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v3_1);
                }
            }
            if ((this.ivLength != 0) && (!(v3_1 instanceof org.spongycastle.crypto.params.ParametersWithIV))) {
                java.security.SecureRandom v1_0 = p13;
                if (p13 == null) {
                    v1_0 = new java.security.SecureRandom();
                }
                if ((p10 != 1) && (p10 != 3)) {
                    throw new java.security.InvalidAlgorithmParameterException("no IV set when one expected");
                } else {
                    byte[] v0 = new byte[this.ivLength];
                    v1_0.nextBytes(v0);
                    org.spongycastle.crypto.params.ParametersWithIV v4_1 = new org.spongycastle.crypto.params.ParametersWithIV(v3_1, v0);
                    this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v4_1);
                    v3_1 = v4_1;
                }
            }
            switch (p10) {
                case 1:
                case 3:
                    this.cipher.init(1, v3_1);
                    break;
                case 2:
                case 4:
                    this.cipher.init(0, v3_1);
                    break;
                default:
                    System.out.println("eeek!");
            }
            return;
        } else {
            throw new java.security.InvalidKeyException(new StringBuilder().append("Key for algorithm ").append(p11.getAlgorithm()).append(" not suitable for symmetric enryption.").toString());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.CAST5$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[8];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("CAST5", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.Camellia$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[16];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("Camellia", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.DES$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[8];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("DES", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.DES$KeyGenerator.engineGenerateKey() calling method java.security.SecureRandom.<init>()


    protected javax.crypto.SecretKey engineGenerateKey()
    {
        if (this.uninitialised) {
            this.engine.init(new org.spongycastle.crypto.KeyGenerationParameters(new java.security.SecureRandom(), this.defaultKeySize));
            this.uninitialised = 0;
        }
        return new javax.crypto.spec.SecretKeySpec(this.engine.generateKey(), this.algName);
    }

Method org.spongycastle.jcajce.provider.symmetric.DESede$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[8];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("DES", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.DESede$KeyGenerator.engineGenerateKey() calling method java.security.SecureRandom.<init>()


    protected javax.crypto.SecretKey engineGenerateKey()
    {
        if (this.uninitialised) {
            this.engine.init(new org.spongycastle.crypto.KeyGenerationParameters(new java.security.SecureRandom(), this.defaultKeySize));
            this.uninitialised = 0;
        }
        javax.crypto.spec.SecretKeySpec v1_3;
        if (this.keySizeSet) {
            v1_3 = new javax.crypto.spec.SecretKeySpec(this.engine.generateKey(), this.algName);
        } else {
            byte[] v0 = this.engine.generateKey();
            System.arraycopy(v0, 0, v0, 16, 8);
            v1_3 = new javax.crypto.spec.SecretKeySpec(v0, this.algName);
        }
        return v1_3;
    }

Method org.spongycastle.jcajce.provider.symmetric.GOST28147$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[16];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("GOST28147", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.IDEA$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[8];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("IDEA", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.Noekeon$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[16];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("Noekeon", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.RC2$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        java.security.AlgorithmParameters v2;
        if (this.spec != null) {
            try {
                v2 = java.security.AlgorithmParameters.getInstance("RC2", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
                v2.init(this.spec);
            } catch (Exception v0_1) {
                throw new RuntimeException(v0_1.getMessage());
            }
        } else {
            byte[] v1 = new byte[8];
            if (this.random == null) {
                this.random = new java.security.SecureRandom();
            }
            this.random.nextBytes(v1);
            try {
                v2 = java.security.AlgorithmParameters.getInstance("RC2", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
                v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            } catch (Exception v0_0) {
                throw new RuntimeException(v0_0.getMessage());
            }
        }
        return v2;
    }

Method org.spongycastle.jcajce.provider.symmetric.RC5$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[8];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("RC5", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.RC6$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[16];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("RC6", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.SEED$AlgParamGen.engineGenerateParameters() calling method java.security.SecureRandom.<init>()


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[16];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = java.security.AlgorithmParameters.getInstance("SEED", org.spongycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jce.provider.BrokenJCEBlockCipher.engineInit() calling method java.security.SecureRandom.<init>()


    protected void engineInit(int p14, java.security.Key p15, java.security.spec.AlgorithmParameterSpec p16, java.security.SecureRandom p17)
    {
        org.spongycastle.crypto.params.ParametersWithIV v9_0;
        if (!(p15 instanceof org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey)) {
            if (p16 != null) {
                if (!(p16 instanceof javax.crypto.spec.IvParameterSpec)) {
                    org.spongycastle.crypto.params.ParametersWithIV v10_3;
                    if (!(p16 instanceof javax.crypto.spec.RC2ParameterSpec)) {
                        if (!(p16 instanceof javax.crypto.spec.RC5ParameterSpec)) {
                            throw new java.security.InvalidAlgorithmParameterException("unknown parameter type.");
                        } else {
                            v9_0 = new org.spongycastle.crypto.params.RC5Parameters(p15.getEncoded(), ((javax.crypto.spec.RC5ParameterSpec) p16).getRounds());
                            if (((javax.crypto.spec.RC5ParameterSpec) p16).getWordSize() == 32) {
                                if ((((javax.crypto.spec.RC5ParameterSpec) p16).getIV() == null) || (this.ivLength == 0)) {
                                    if ((this.ivLength != 0) && (!(v9_0 instanceof org.spongycastle.crypto.params.ParametersWithIV))) {
                                        if (p17 == null) {
                                            p17 = new java.security.SecureRandom();
                                        }
                                        if ((p14 != 1) && (p14 != 3)) {
                                            throw new java.security.InvalidAlgorithmParameterException("no IV set when one expected");
                                        } else {
                                            byte[] v8 = new byte[this.ivLength];
                                            p17.nextBytes(v8);
                                            org.spongycastle.crypto.params.ParametersWithIV v10_1 = new org.spongycastle.crypto.params.ParametersWithIV(v9_0, v8);
                                            this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v10_1);
                                            v9_0 = v10_1;
                                        }
                                    }
                                    switch (p14) {
                                        case 1:
                                        case 3:
                                            this.cipher.init(1, v9_0);
                                            break;
                                        case 2:
                                        case 4:
                                            this.cipher.init(0, v9_0);
                                            break;
                                        default:
                                            System.out.println("eeek!");
                                    }
                                    return;
                                } else {
                                    v10_3 = new org.spongycastle.crypto.params.ParametersWithIV(v9_0, ((javax.crypto.spec.RC5ParameterSpec) p16).getIV());
                                    this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v10_3);
                                }
                            } else {
                                throw new IllegalArgumentException("can only accept RC5 word size 32 (at the moment...)");
                            }
                        }
                    } else {
                        v9_0 = new org.spongycastle.crypto.params.RC2Parameters(p15.getEncoded(), ((javax.crypto.spec.RC2ParameterSpec) p16).getEffectiveKeyBits());
                        if ((((javax.crypto.spec.RC2ParameterSpec) p16).getIV() == null) || (this.ivLength == 0)) {
                        } else {
                            v10_3 = new org.spongycastle.crypto.params.ParametersWithIV(v9_0, ((javax.crypto.spec.RC2ParameterSpec) p16).getIV());
                            this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v10_3);
                        }
                    }
                    v9_0 = v10_3;
                } else {
                    if (this.ivLength == 0) {
                        v9_0 = new org.spongycastle.crypto.params.KeyParameter(p15.getEncoded());
                    } else {
                        v9_0 = new org.spongycastle.crypto.params.ParametersWithIV(new org.spongycastle.crypto.params.KeyParameter(p15.getEncoded()), ((javax.crypto.spec.IvParameterSpec) p16).getIV());
                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v9_0);
                    }
                }
            } else {
                v9_0 = new org.spongycastle.crypto.params.KeyParameter(p15.getEncoded());
            }
        } else {
            v9_0 = org.spongycastle.jce.provider.BrokenPBE$Util.makePBEParameters(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p15), p16, this.pbeType, this.pbeHash, this.cipher.getUnderlyingCipher().getAlgorithmName(), this.pbeKeySize, this.pbeIvSize);
            if (this.pbeIvSize != 0) {
                this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v9_0);
            }
        }
    }

Method org.spongycastle.jce.provider.JCEBlockCipher.engineInit() calling method java.security.SecureRandom.<init>()


    protected void engineInit(int p15, java.security.Key p16, java.security.spec.AlgorithmParameterSpec p17, java.security.SecureRandom p18)
    {
        this.pbeSpec = 0;
        this.pbeAlgorithm = 0;
        this.engineParams = 0;
        if ((p16 instanceof javax.crypto.SecretKey)) {
            if ((p17 != null) || (!this.baseEngine.getAlgorithmName().startsWith("RC5-64"))) {
                org.spongycastle.crypto.params.ParametersWithIV v7_1;
                if (!(p16 instanceof org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey)) {
                    if (p17 != null) {
                        if (!(p17 instanceof javax.crypto.spec.IvParameterSpec)) {
                            org.spongycastle.crypto.params.ParametersWithIV v8_1;
                            if (!(p17 instanceof org.spongycastle.jce.spec.GOST28147ParameterSpec)) {
                                if (!(p17 instanceof javax.crypto.spec.RC2ParameterSpec)) {
                                    if (!(p17 instanceof javax.crypto.spec.RC5ParameterSpec)) {
                                        throw new java.security.InvalidAlgorithmParameterException("unknown parameter type.");
                                    } else {
                                        v7_1 = new org.spongycastle.crypto.params.RC5Parameters(p16.getEncoded(), ((javax.crypto.spec.RC5ParameterSpec) p17).getRounds());
                                        if (!this.baseEngine.getAlgorithmName().startsWith("RC5")) {
                                            throw new java.security.InvalidAlgorithmParameterException("RC5 parameters passed to a cipher that is not RC5.");
                                        } else {
                                            if (!this.baseEngine.getAlgorithmName().equals("RC5-32")) {
                                                if ((this.baseEngine.getAlgorithmName().equals("RC5-64")) && (((javax.crypto.spec.RC5ParameterSpec) p17).getWordSize() != 64)) {
                                                    throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("RC5 already set up for a word size of 64 not ").append(((javax.crypto.spec.RC5ParameterSpec) p17).getWordSize()).append(".").toString());
                                                }
                                            } else {
                                                if (((javax.crypto.spec.RC5ParameterSpec) p17).getWordSize() != 32) {
                                                    throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("RC5 already set up for a word size of 32 not ").append(((javax.crypto.spec.RC5ParameterSpec) p17).getWordSize()).append(".").toString());
                                                }
                                            }
                                            if ((((javax.crypto.spec.RC5ParameterSpec) p17).getIV() == null) || (this.ivLength == 0)) {
                                                if ((this.ivLength == 0) || ((v7_1 instanceof org.spongycastle.crypto.params.ParametersWithIV))) {
                                                    org.spongycastle.crypto.params.ParametersWithIV v8_4 = v7_1;
                                                } else {
                                                    java.security.SecureRandom v4_0 = p18;
                                                    if (p18 == null) {
                                                        v4_0 = new java.security.SecureRandom();
                                                    }
                                                    if ((p15 != 1) && (p15 != 3)) {
                                                        if (this.cipher.getUnderlyingCipher().getAlgorithmName().indexOf("PGPCFB") >= 0) {
                                                        } else {
                                                            throw new java.security.InvalidAlgorithmParameterException("no IV set when one expected");
                                                        }
                                                    } else {
                                                        byte[] v3 = new byte[this.ivLength];
                                                        v4_0.nextBytes(v3);
                                                        v8_4 = new org.spongycastle.crypto.params.ParametersWithIV(v7_1, v3);
                                                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v8_4);
                                                    }
                                                }
                                                if ((p18 == null) || (!this.padded)) {
                                                    org.spongycastle.crypto.params.ParametersWithIV v7_7 = v8_4;
                                                } else {
                                                    v7_7 = new org.spongycastle.crypto.params.ParametersWithRandom(v8_4, p18);
                                                }
                                                try {
                                                    switch (p15) {
                                                        case 1:
                                                        case 3:
                                                            this.cipher.init(1, v7_7);
                                                            return;
                                                        case 2:
                                                        case 4:
                                                            this.cipher.init(0, v7_7);
                                                            return;
                                                        default:
                                                            throw new java.security.InvalidParameterException(new StringBuilder().append("unknown opmode ").append(p15).append(" passed").toString());
                                                    }
                                                } catch (Exception v1) {
                                                }
                                                throw new java.security.InvalidKeyException(v1.getMessage());
                                            } else {
                                                v8_1 = new org.spongycastle.crypto.params.ParametersWithIV(v7_1, ((javax.crypto.spec.RC5ParameterSpec) p17).getIV());
                                                this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v8_1);
                                            }
                                        }
                                    }
                                } else {
                                    v7_1 = new org.spongycastle.crypto.params.RC2Parameters(p16.getEncoded(), ((javax.crypto.spec.RC2ParameterSpec) p17).getEffectiveKeyBits());
                                    if ((((javax.crypto.spec.RC2ParameterSpec) p17).getIV() == null) || (this.ivLength == 0)) {
                                    } else {
                                        v8_1 = new org.spongycastle.crypto.params.ParametersWithIV(v7_1, ((javax.crypto.spec.RC2ParameterSpec) p17).getIV());
                                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v8_1);
                                    }
                                }
                            } else {
                                v7_1 = new org.spongycastle.crypto.params.ParametersWithSBox(new org.spongycastle.crypto.params.KeyParameter(p16.getEncoded()), ((org.spongycastle.jce.spec.GOST28147ParameterSpec) p17).getSbox());
                                if ((((org.spongycastle.jce.spec.GOST28147ParameterSpec) p17).getIV() == null) || (this.ivLength == 0)) {
                                } else {
                                    v8_1 = new org.spongycastle.crypto.params.ParametersWithIV(v7_1, ((org.spongycastle.jce.spec.GOST28147ParameterSpec) p17).getIV());
                                    this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v8_1);
                                }
                            }
                            v7_1 = v8_1;
                        } else {
                            if (this.ivLength == 0) {
                                if ((this.modeName == null) || (!this.modeName.equals("ECB"))) {
                                    v7_1 = new org.spongycastle.crypto.params.KeyParameter(p16.getEncoded());
                                } else {
                                    throw new java.security.InvalidAlgorithmParameterException("ECB mode does not use an IV");
                                }
                            } else {
                                if ((((javax.crypto.spec.IvParameterSpec) p17).getIV().length == this.ivLength) || (this.isAEADModeName(this.modeName))) {
                                    if (!(p16 instanceof org.spongycastle.jce.spec.RepeatedSecretKeySpec)) {
                                        v7_1 = new org.spongycastle.crypto.params.ParametersWithIV(new org.spongycastle.crypto.params.KeyParameter(p16.getEncoded()), ((javax.crypto.spec.IvParameterSpec) p17).getIV());
                                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v7_1);
                                    } else {
                                        v7_1 = new org.spongycastle.crypto.params.ParametersWithIV(0, ((javax.crypto.spec.IvParameterSpec) p17).getIV());
                                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v7_1);
                                    }
                                } else {
                                    throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("IV must be ").append(this.ivLength).append(" bytes long.").toString());
                                }
                            }
                        }
                    } else {
                        v7_1 = new org.spongycastle.crypto.params.KeyParameter(p16.getEncoded());
                    }
                } else {
                    if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getOID() == null) {
                        this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getAlgorithm();
                    } else {
                        this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getOID().getId();
                    }
                    if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getParam() == null) {
                        if (!(p17 instanceof javax.crypto.spec.PBEParameterSpec)) {
                            throw new java.security.InvalidAlgorithmParameterException("PBE requires PBE parameters to be set.");
                        } else {
                            this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p17);
                            v7_1 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16), p17, this.cipher.getUnderlyingCipher().getAlgorithmName());
                        }
                    } else {
                        v7_1 = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getParam();
                        this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getSalt(), ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getIterationCount());
                    }
                    if ((v7_1 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v7_1);
                    }
                }
            } else {
                throw new java.security.InvalidAlgorithmParameterException("RC5 requires an RC5ParametersSpec to be passed in.");
            }
        } else {
            throw new java.security.InvalidKeyException(new StringBuilder().append("Key for algorithm ").append(p16.getAlgorithm()).append(" not suitable for symmetric enryption.").toString());
        }
    }

Method org.spongycastle.jce.provider.JCEIESCipher.engineInit() calling method java.security.SecureRandom.<init>()


    protected void engineInit(int p11, java.security.Key p12, java.security.spec.AlgorithmParameterSpec p13, java.security.SecureRandom p14)
    {
        if ((p12 instanceof org.spongycastle.jce.interfaces.IESKey)) {
            if ((p13 != null) || ((p11 != 1) && (p11 != 3))) {
                if (!(p13 instanceof org.spongycastle.jce.spec.IESParameterSpec)) {
                    throw new java.security.InvalidAlgorithmParameterException("must be passed IES parameters");
                }
            } else {
                byte[] v0 = new byte[16];
                byte[] v1 = new byte[16];
                if (p14 == null) {
                    p14 = new java.security.SecureRandom();
                }
                p14.nextBytes(v0);
                p14.nextBytes(v1);
                p13 = new org.spongycastle.jce.spec.IESParameterSpec(v0, v1, 128);
            }
            org.spongycastle.crypto.params.AsymmetricKeyParameter v4;
            org.spongycastle.crypto.params.AsymmetricKeyParameter v5;
            if (!(((org.spongycastle.jce.interfaces.IESKey) p12).getPublic() instanceof org.spongycastle.jce.interfaces.ECPublicKey)) {
                v5 = org.spongycastle.jce.provider.DHUtil.generatePublicKeyParameter(((org.spongycastle.jce.interfaces.IESKey) p12).getPublic());
                v4 = org.spongycastle.jce.provider.DHUtil.generatePrivateKeyParameter(((org.spongycastle.jce.interfaces.IESKey) p12).getPrivate());
            } else {
                v5 = org.spongycastle.jcajce.provider.asymmetric.ec.ECUtil.generatePublicKeyParameter(((org.spongycastle.jce.interfaces.IESKey) p12).getPublic());
                v4 = org.spongycastle.jcajce.provider.asymmetric.ec.ECUtil.generatePrivateKeyParameter(((org.spongycastle.jce.interfaces.IESKey) p12).getPrivate());
            }
            this.engineParams = ((org.spongycastle.jce.spec.IESParameterSpec) p13);
            org.spongycastle.crypto.params.IESParameters v3_1 = new org.spongycastle.crypto.params.IESParameters(this.engineParams.getDerivationV(), this.engineParams.getEncodingV(), this.engineParams.getMacKeySize());
            this.state = p11;
            this.buffer.reset();
            switch (p11) {
                case 1:
                case 3:
                    this.cipher.init(1, v4, v5, v3_1);
                    break;
                case 2:
                case 4:
                    this.cipher.init(0, v4, v5, v3_1);
                    break;
                default:
                    System.out.println("eeek!");
            }
            return;
        } else {
            throw new java.security.InvalidKeyException("must be passed IES key");
        }
    }

Method org.spongycastle.jce.provider.JCEStreamCipher.engineInit() calling method java.security.SecureRandom.<init>()


    protected void engineInit(int p10, java.security.Key p11, java.security.spec.AlgorithmParameterSpec p12, java.security.SecureRandom p13)
    {
        this.pbeSpec = 0;
        this.pbeAlgorithm = 0;
        this.engineParams = 0;
        if ((p11 instanceof javax.crypto.SecretKey)) {
            org.spongycastle.crypto.params.ParametersWithIV v3_1;
            if (!(p11 instanceof org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey)) {
                if (p12 != null) {
                    if (!(p12 instanceof javax.crypto.spec.IvParameterSpec)) {
                        throw new IllegalArgumentException("unknown parameter type.");
                    } else {
                        v3_1 = new org.spongycastle.crypto.params.ParametersWithIV(new org.spongycastle.crypto.params.KeyParameter(p11.getEncoded()), ((javax.crypto.spec.IvParameterSpec) p12).getIV());
                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v3_1);
                    }
                } else {
                    v3_1 = new org.spongycastle.crypto.params.KeyParameter(p11.getEncoded());
                }
            } else {
                if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getOID() == null) {
                    this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getAlgorithm();
                } else {
                    this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getOID().getId();
                }
                if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getParam() == null) {
                    if (!(p12 instanceof javax.crypto.spec.PBEParameterSpec)) {
                        throw new java.security.InvalidAlgorithmParameterException("PBE requires PBE parameters to be set.");
                    } else {
                        v3_1 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11), p12, this.cipher.getAlgorithmName());
                        this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p12);
                    }
                } else {
                    v3_1 = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getParam();
                    this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getSalt(), ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getIterationCount());
                }
                if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p11).getIvSize() != 0) {
                    this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v3_1);
                }
            }
            if ((this.ivLength != 0) && (!(v3_1 instanceof org.spongycastle.crypto.params.ParametersWithIV))) {
                java.security.SecureRandom v1_0 = p13;
                if (p13 == null) {
                    v1_0 = new java.security.SecureRandom();
                }
                if ((p10 != 1) && (p10 != 3)) {
                    throw new java.security.InvalidAlgorithmParameterException("no IV set when one expected");
                } else {
                    byte[] v0 = new byte[this.ivLength];
                    v1_0.nextBytes(v0);
                    org.spongycastle.crypto.params.ParametersWithIV v4_1 = new org.spongycastle.crypto.params.ParametersWithIV(v3_1, v0);
                    this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v4_1);
                    v3_1 = v4_1;
                }
            }
            switch (p10) {
                case 1:
                case 3:
                    this.cipher.init(1, v3_1);
                    break;
                case 2:
                case 4:
                    this.cipher.init(0, v3_1);
                    break;
                default:
                    System.out.println("eeek!");
            }
            return;
        } else {
            throw new java.security.InvalidKeyException(new StringBuilder().append("Key for algorithm ").append(p11.getAlgorithm()).append(" not suitable for symmetric enryption.").toString());
        }
    }

Method org.spongycastle.jce.provider.JDKKeyStore.<init>() calling method java.security.SecureRandom.<init>()


    public JDKKeyStore()
    {
        this.table = new java.util.Hashtable();
        this.random = new java.security.SecureRandom();
        return;
    }

Method org.spongycastle.jce.provider.JDKPKCS12KeyStore.<init>() calling method java.security.SecureRandom.<init>()


    public JDKPKCS12KeyStore(java.security.Provider p5, org.spongycastle.asn1.ASN1ObjectIdentifier p6, org.spongycastle.asn1.ASN1ObjectIdentifier p7)
    {
        this.keys = new org.spongycastle.jce.provider.JDKPKCS12KeyStore$IgnoresCaseHashtable(0);
        this.localIds = new java.util.Hashtable();
        this.certs = new org.spongycastle.jce.provider.JDKPKCS12KeyStore$IgnoresCaseHashtable(0);
        this.chainCerts = new java.util.Hashtable();
        this.keyCerts = new java.util.Hashtable();
        this.random = new java.security.SecureRandom();
        this.keyAlgorithm = p6;
        this.certAlgorithm = p7;
        try {
            if (p5 == null) {
                this.certFact = java.security.cert.CertificateFactory.getInstance("X.509");
            } else {
                this.certFact = java.security.cert.CertificateFactory.getInstance("X.509", p5);
            }
        } catch (Exception v0) {
            throw new IllegalArgumentException(new StringBuilder().append("can\'t create cert factory - ").append(v0.toString()).toString());
        }
        return;
    }

Method org.spongycastle.math.ntru.polynomial.BigIntPolynomial.generateRandomSmall() calling method java.security.SecureRandom.<init>()


    static org.spongycastle.math.ntru.polynomial.BigIntPolynomial generateRandomSmall(int p6, int p7, int p8)
    {
        java.util.ArrayList v0_1 = new java.util.ArrayList();
        int v1_1 = 0;
        while (v1_1 < p7) {
            v0_1.add(org.spongycastle.math.ntru.polynomial.Constants.BIGINT_ONE);
            v1_1++;
        }
        int v1_2 = 0;
        while (v1_2 < p8) {
            v0_1.add(java.math.BigInteger.valueOf(-1));
            v1_2++;
        }
        while (v0_1.size() < p6) {
            v0_1.add(org.spongycastle.math.ntru.polynomial.Constants.BIGINT_ZERO);
        }
        java.util.Collections.shuffle(v0_1, new java.security.SecureRandom());
        org.spongycastle.math.ntru.polynomial.BigIntPolynomial v2_1 = new org.spongycastle.math.ntru.polynomial.BigIntPolynomial(p6);
        int v1_0 = 0;
        while (v1_0 < v0_1.size()) {
            v2_1.coeffs[v1_0] = ((java.math.BigInteger) v0_1.get(v1_0));
            v1_0++;
        }
        return v2_1;
    }

Method org.spongycastle.openssl.PKCS8Generator.generate() calling method java.security.SecureRandom.<init>()


    public org.spongycastle.util.io.pem.PemObject generate()
    {
        org.spongycastle.util.io.pem.PemGenerationException v13_16;
        byte[] v7 = this.key.getEncoded();
        if (this.algorithm != null) {
            org.spongycastle.asn1.ASN1ObjectIdentifier v1_0 = new org.spongycastle.asn1.ASN1ObjectIdentifier(this.algorithm);
            if (!org.spongycastle.openssl.PEMUtilities.isPKCS5Scheme2(v1_0)) {
                if (!org.spongycastle.openssl.PEMUtilities.isPKCS12(v1_0)) {
                    throw new org.spongycastle.util.io.pem.PemGenerationException(new StringBuilder().append("unknown algorithm: ").append(this.algorithm).toString());
                } else {
                    byte[] v10_0 = new byte[20];
                    if (this.random == null) {
                        this.random = new java.security.SecureRandom();
                    }
                    this.random.nextBytes(v10_0);
                    try {
                        this.cipher.init(1, this.secKeyFact.generateSecret(new javax.crypto.spec.PBEKeySpec(this.password)), new javax.crypto.spec.PBEParameterSpec(v10_0, this.iterationCount));
                        org.spongycastle.asn1.ASN1EncodableVector v12_3 = new org.spongycastle.asn1.ASN1EncodableVector();
                        v12_3.add(new org.spongycastle.asn1.DEROctetString(v10_0));
                        v12_3.add(new org.spongycastle.asn1.ASN1Integer(this.iterationCount));
                        v13_16 = new org.spongycastle.util.io.pem.PemObject("ENCRYPTED PRIVATE KEY", new org.spongycastle.asn1.pkcs.EncryptedPrivateKeyInfo(new org.spongycastle.asn1.x509.AlgorithmIdentifier(v1_0, org.spongycastle.asn1.pkcs.PKCS12PBEParams.getInstance(new org.spongycastle.asn1.DERSequence(v12_3))), this.cipher.doFinal(v7)).getEncoded());
                    } catch (java.security.GeneralSecurityException v3_3) {
                        throw new org.spongycastle.util.io.pem.PemGenerationException(v3_3.getMessage(), v3_3);
                    } catch (java.security.GeneralSecurityException v3_2) {
                        throw new org.spongycastle.util.io.pem.PemGenerationException(v3_2.getMessage(), v3_2);
                    }
                }
            } else {
                byte[] v10_1 = new byte[20];
                if (this.random == null) {
                    this.random = new java.security.SecureRandom();
                }
                this.random.nextBytes(v10_1);
                javax.crypto.SecretKey v6 = org.spongycastle.openssl.PEMUtilities.generateSecretKeyForPKCS5Scheme2(this.algorithm, this.password, v10_1, this.iterationCount);
                java.security.AlgorithmParameters v8 = this.paramGen.generateParameters();
                try {
                    this.cipher.init(1, v6, v8);
                    org.spongycastle.asn1.pkcs.EncryptionScheme v11_1 = new org.spongycastle.asn1.pkcs.EncryptionScheme(new org.spongycastle.asn1.ASN1ObjectIdentifier(this.algorithm), org.spongycastle.asn1.ASN1Primitive.fromByteArray(v8.getEncoded()));
                    org.spongycastle.asn1.pkcs.KeyDerivationFunc v4_1 = new org.spongycastle.asn1.pkcs.KeyDerivationFunc(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_PBKDF2, new org.spongycastle.asn1.pkcs.PBKDF2Params(v10_1, this.iterationCount));
                    org.spongycastle.asn1.ASN1EncodableVector v12_1 = new org.spongycastle.asn1.ASN1EncodableVector();
                    v12_1.add(v4_1);
                    v12_1.add(v11_1);
                    org.spongycastle.asn1.DERSequence v16 = new org.spongycastle.asn1.DERSequence;
                    v16(v12_1);
                    v13_16 = new org.spongycastle.util.io.pem.PemObject("ENCRYPTED PRIVATE KEY", new org.spongycastle.asn1.pkcs.EncryptedPrivateKeyInfo(new org.spongycastle.asn1.x509.AlgorithmIdentifier(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_PBES2, new org.spongycastle.asn1.pkcs.PBES2Parameters(v16)), this.cipher.doFinal(v7)).getEncoded());
                } catch (java.security.GeneralSecurityException v3_1) {
                    throw new org.spongycastle.util.io.pem.PemGenerationException(v3_1.getMessage(), v3_1);
                } catch (java.security.GeneralSecurityException v3_0) {
                    throw new org.spongycastle.util.io.pem.PemGenerationException(v3_0.getMessage(), v3_0);
                }
            }
        } else {
            v13_16 = new org.spongycastle.util.io.pem.PemObject("PRIVATE KEY", v7);
        }
        return v13_16;
    }

Method org.spongycastle.pkcs.bc.BcPKCS12MacCalculatorBuilder.build() calling method java.security.SecureRandom.<init>()


    public org.spongycastle.operator.MacCalculator build(char[] p6)
    {
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        byte[] v0 = new byte[this.saltLength];
        this.random.nextBytes(v0);
        return org.spongycastle.pkcs.bc.PKCS12PBEUtils.createMacCalculator(this.algorithmIdentifier.getAlgorithm(), this.digest, new org.spongycastle.asn1.pkcs.PKCS12PBEParams(v0, this.iterationCount), p6);
    }

Method org.spongycastle.pkcs.bc.BcPKCS12PBEOutputEncryptorBuilder.build() calling method java.security.SecureRandom.<init>()


    public org.spongycastle.operator.OutputEncryptor build(char[] p8)
    {
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        byte[] v3 = new byte[20];
        this.random.nextBytes(v3);
        org.spongycastle.asn1.pkcs.PKCS12PBEParams v2_1 = new org.spongycastle.asn1.pkcs.PKCS12PBEParams(v3, 1024);
        this.engine.init(1, org.spongycastle.pkcs.bc.PKCS12PBEUtils.createCipherParameters(this.algorithm, this.digest, this.engine.getBlockSize(), v2_1, p8));
        return new org.spongycastle.pkcs.bc.BcPKCS12PBEOutputEncryptorBuilder$1(this, v2_1, p8);
    }

Method org.spongycastle.util.test.FixedSecureRandom.<init>() calling method java.security.SecureRandom.<init>()


    public FixedSecureRandom(boolean p6, byte[][] p7)
    {
        java.io.ByteArrayOutputStream v0_1 = new java.io.ByteArrayOutputStream();
        int v2 = 0;
        while (v2 != p7.length) {
            try {
                v0_1.write(p7[v2]);
                v2++;
            } catch (java.io.IOException v1) {
                throw new IllegalArgumentException("can\'t save value array.");
            }
        }
        this._data = v0_1.toByteArray();
        if (p6) {
            this._intPad = (this._data.length % 4);
        }
        return;
    }

Method org.spongycastle.crypto.examples.DESExample.<init>() calling method java.security.SecureRandom.setSeed()


    public DESExample(String p16, String p17, String p18, boolean p19)
    {
        this.encrypt = 1;
        this.cipher = 0;
        this.in = 0;
        this.out = 0;
        this.key = 0;
        this.encrypt = p19;
        try {
            this.in = new java.io.BufferedInputStream(new java.io.FileInputStream(p16));
            try {
                this.out = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p17));
            } catch (java.io.IOException v2) {
                System.err.println(new StringBuilder().append("Output file not created [").append(p17).append("]").toString());
                System.exit(1);
            }
            if (!p19) {
                try {
                    java.io.BufferedOutputStream v5_3 = new java.io.BufferedInputStream(new java.io.FileInputStream(p18));
                    int v8 = v5_3.available();
                    byte[] v4_1 = new byte[v8];
                    v5_3.read(v4_1, 0, v8);
                    this.key = org.spongycastle.util.encoders.Hex.decode(v4_1);
                } catch (java.io.IOException v3) {
                    System.err.println(new StringBuilder().append("Decryption key file not found, or not valid [").append(p18).append("]").toString());
                    System.exit(1);
                }
            } else {
                java.security.SecureRandom v10 = 0;
                try {
                    java.security.SecureRandom v11_1 = new java.security.SecureRandom();
                    try {
                        v11_1.setSeed("www.spongycastle.org".getBytes());
                        v10 = v11_1;
                    } catch (Exception v9) {
                        v10 = v11_1;
                        System.err.println("Hmmm, no SHA1PRNG, you need the Sun implementation");
                        System.exit(1);
                    } catch (java.io.IOException v1) {
                        System.err.println(new StringBuilder().append("Could not decryption create key file [").append(p18).append("]").toString());
                        System.exit(1);
                    }
                    org.spongycastle.crypto.KeyGenerationParameters v7_1 = new org.spongycastle.crypto.KeyGenerationParameters(v10, 192);
                    org.spongycastle.crypto.generators.DESedeKeyGenerator v6_1 = new org.spongycastle.crypto.generators.DESedeKeyGenerator();
                    v6_1.init(v7_1);
                    this.key = v6_1.generateKey();
                    java.io.BufferedOutputStream v5_1 = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p18));
                    byte[] v4_0 = org.spongycastle.util.encoders.Hex.encode(this.key);
                    v5_1.write(v4_0, 0, v4_0.length);
                    v5_1.flush();
                    v5_1.close();
                } catch (Exception v9) {
                } catch (java.io.IOException v1) {
                }
            }
            return;
        } catch (java.io.IOException v2) {
            System.err.println(new StringBuilder().append("Input file not found [").append(p16).append("]").toString());
            System.exit(1);
        }
    }

Method org.spongycastle.crypto.tls.TlsProtocolHandler.createSecureRandom() calling method java.security.SecureRandom.setSeed()


    private static java.security.SecureRandom createSecureRandom()
    {
        org.spongycastle.crypto.prng.ThreadedSeedGenerator v1_1 = new org.spongycastle.crypto.prng.ThreadedSeedGenerator();
        java.security.SecureRandom v0_1 = new java.security.SecureRandom();
        v0_1.setSeed(v1_1.generateSeed(20, 1));
        return v0_1;
    }

Method org.spongycastle.jce.provider.JDKKeyStore$StoreEntry.<init>() calling method java.security.SecureRandom.setSeed()


    JDKKeyStore$StoreEntry(org.spongycastle.jce.provider.JDKKeyStore p11, String p12, java.security.Key p13, char[] p14, java.security.cert.Certificate[] p15)
    {
        this.this$0 = p11;
        this.date = new java.util.Date();
        this.type = 4;
        this.alias = p12;
        this.certChain = p15;
        byte[] v4 = new byte[20];
        p11.random.setSeed(System.currentTimeMillis());
        p11.random.nextBytes(v4);
        int v5 = ((p11.random.nextInt() & 1023) + 1024);
        java.io.ByteArrayOutputStream v6_1 = new java.io.ByteArrayOutputStream();
        java.io.DataOutputStream v9_1 = new java.io.DataOutputStream(v6_1);
        v9_1.writeInt(v4.length);
        v9_1.write(v4);
        v9_1.writeInt(v5);
        java.io.DataOutputStream v9_3 = new java.io.DataOutputStream(new javax.crypto.CipherOutputStream(v9_1, p11.makePBECipher("PBEWithSHAAnd3-KeyTripleDES-CBC", 1, p14, v4, v5)));
        org.spongycastle.jce.provider.JDKKeyStore.access$000(p11, p13, v9_3);
        v9_3.close();
        this.obj = v6_1.toByteArray();
        return;
    }

Method com.amulyakhare.textdrawable.util.ColorGenerator.<init>() calling method java.util.Random.<init>()


    private ColorGenerator(java.util.List p5)
    {
        this.mColors = p5;
        this.mRandom = new java.util.Random(System.currentTimeMillis());
        return;
    }

Method com.crashlytics.android.answers.RandomBackoff.<init>() calling method java.util.Random.<init>()


    public RandomBackoff(io.fabric.sdk.android.services.concurrency.internal.Backoff p3, double p4)
    {
        this(p3, p4, new java.util.Random());
        return;
    }

Method okhttp3.OkHttpClient.newWebSocket() calling method java.util.Random.<init>()


    public okhttp3.WebSocket newWebSocket(okhttp3.Request p7, okhttp3.WebSocketListener p8)
    {
        okhttp3.internal.ws.RealWebSocket v0_1 = new okhttp3.internal.ws.RealWebSocket(p7, p8, new java.util.Random(), ((long) this.pingInterval));
        v0_1.connect(this);
        return v0_1;
    }

Method com.google.android.gms.internal.measurement.zzka.zzlb() calling method java.util.Random.<init>()


    public final long zzlb()
    {
        try {
            Throwable v0_2;
            if (this.zzarf.get() != 0) {
                try {
                    this.zzarf.compareAndSet(-1, 1);
                    v0_2 = this.zzarf.getAndIncrement();
                } catch (Throwable v0_3) {
                    throw v0_3;
                }
            } else {
                Throwable v0_7 = new java.util.Random((System.nanoTime() ^ this.zzbt().currentTimeMillis())).nextLong();
                int v3_1 = (this.zzarg + 1);
                this.zzarg = v3_1;
                v0_2 = (v0_7 + ((long) v3_1));
            }
        } catch (Throwable v0_8) {
            throw v0_8;
        }
        return v0_2;
    }

Method com.mapit.TribalApp.ForgotPasswordActivity.sendPostSmsOnMobile() calling method java.util.Random.<init>()


    public String sendPostSmsOnMobile()
    {
        try {
            String v21_0 = new com.Manager.AllPackageManager;
            v21_0(this);
            this.forgotpassMobileNo = v21_0.getForgotpassMobileNo();
            String v2 = ((com.android.db.ForgotpassMobileNo) this.forgotpassMobileNo.get(0)).getMobile_No();
            java.net.URL v19 = new java.net.URL;
            v19(utils.Constant.BASEURLEmailSmsSend);
            java.net.HttpURLConnection v5_1 = ((java.net.HttpURLConnection) v19.openConnection());
            java.util.HashMap v14_1 = new java.util.HashMap();
            v5_1.setConnectTimeout(15000);
            v5_1.setReadTimeout(15000);
            v5_1.setRequestMethod("POST");
            v5_1.setDoInput(1);
            v5_1.setDoOutput(1);
            String v0_15 = new Object[1];
            java.io.InputStream v22_3 = v0_15;
            v22_3[0] = Integer.valueOf(new java.util.Random().nextInt(10000));
            this.generatedPassword = String.format("%06d", v22_3);
            v14_1.put("checkey", "ar098-8983sdf-9384sdf-8382ad");
            v14_1.put("mode", "sms");
            v14_1.put("message", new StringBuilder().append("OTP for Forgot Password -").append(this.generatedPassword).toString());
            v14_1.put("mobileNo", v2);
            java.io.OutputStream v15 = v5_1.getOutputStream();
            String v21_26 = new java.io.OutputStreamWriter;
            v21_26(v15, "UTF-8");
            java.io.BufferedWriter v20_0 = new java.io.BufferedWriter(v21_26);
            v20_0.write(com.mapit.TribalApp.ForgotPasswordActivity.getPostDataString(v14_1));
            v20_0.flush();
            v20_0.close();
            v15.close();
            String v10 = String.valueOf(v5_1.getResponseCode());
            java.io.BufferedReader v4_1 = new java.io.BufferedReader(new java.io.InputStreamReader(v5_1.getInputStream()));
            StringBuilder v18_1 = new StringBuilder();
        } catch (Exception v7) {
            v7.printStackTrace();
            return v10;
        }
        while(true) {
            String v16 = v4_1.readLine();
            if (v16 == null) {
                break;
            }
            v18_1.append(v16);
        }
        com.android.db.DaoSession v6 = com.Manager.BaseManager.getDBSessoin(this);
        v6.getForgotpassSmsStatusDao().deleteAll();
        com.android.db.ForgotpassSmsStatusDao v9 = v6.getForgotpassSmsStatusDao();
        org.json.JSONArray v12_1 = new org.json.JSONArray(v18_1.toString());
        if (v12_1.length() > 0) {
            int v11 = 0;
            while (v11 < v12_1.length()) {
                v9.insertOrReplace(new com.android.db.ForgotpassSmsStatus(v12_1.getJSONObject(v11).getString("Status")));
                v11++;
            }
        }
        v5_1.disconnect();
        return v10;
    }

Method com.mapit.TribalApp.LoginActivity$TaskLogin.onPostExecute() calling method java.util.Random.<init>()


    protected void onPostExecute(String p27)
    {
        this = super.onPostExecute(p27);
        try {
            if (!this.responseString.equals("200")) {
                if (!this.responseString.equalsIgnoreCase("300")) {
                    if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                        this.this$0.mProgressDialog.dismiss();
                    }
                    android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131298370)).toString(), 0).show();
                } else {
                    if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                        this.this$0.mProgressDialog.dismiss();
                    }
                    android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131298376)).toString(), 0).show();
                }
            } else {
                this.this$0.userLogin = new com.Manager.AllPackageManager(this.this$0).getUserLogin();
                this.this$0.PasswordChange = ((com.android.db.UserLogin) this.this$0.userLogin.get(0)).getPasswordChange();
                this.this$0.UserIdChange = ((com.android.db.UserLogin) this.this$0.userLogin.get(0)).getUserIdChange();
                this.this$0.LskOprcode = ((com.android.db.UserLogin) this.this$0.userLogin.get(0)).getLSK_OprCode();
                this.this$0.Activation = ((com.android.db.UserLogin) this.this$0.userLogin.get(0)).getActivation();
                this.this$0.CreatedByUserid = ((com.android.db.UserLogin) this.this$0.userLogin.get(0)).getCreatedByUserID();
                this.this$0.Rolecode = ((com.android.db.UserLogin) this.this$0.userLogin.get(0)).getRoleId();
                this.this$0.encrypteddbPassword = ((com.android.db.UserLogin) this.this$0.userLogin.get(0)).getPassword();
                android.util.Log.i("PasswordChange", new StringBuilder().append("").append(this.this$0.PasswordChange).toString());
                if (!this.this$0.Rolecode.equalsIgnoreCase("2")) {
                    if (!this.this$0.Rolecode.equalsIgnoreCase("9")) {
                        if (!this.this$0.Rolecode.equalsIgnoreCase("7")) {
                            if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                this.this$0.mProgressDialog.dismiss();
                            }
                            android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131298376)).toString(), 0).show();
                        } else {
                            String v16_2 = this.this$0.encrypteddbPassword;
                            try {
                                String v4_2 = com.mapit.TribalApp.LoginActivity.md5(this.this$0.password);
                                android.app.ProgressDialog v0_365 = new Object[1];
                                String v23_119 = v0_365;
                                v23_119[0] = Integer.valueOf(new java.util.Random().nextInt(10000));
                                String v13_2 = String.format("%04d", v23_119);
                                android.util.Log.d("MyApp", new StringBuilder().append("Generated Password : ").append(v13_2).toString());
                                String v10_2 = com.mapit.TribalApp.LoginActivity.md5(new StringBuilder().append(v13_2).append(v4_2).toString());
                                String v18_2 = com.mapit.TribalApp.LoginActivity.md5(new StringBuilder().append(v13_2).append(v16_2.toString().toLowerCase()).toString());
                                android.util.Log.i("clintside", v10_2);
                                android.util.Log.i("serverside", v18_2);
                            } catch (Exception v12_3) {
                                v12_3.printStackTrace();
                            }
                            if (!v10_2.equalsIgnoreCase(v18_2)) {
                                if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                    this.this$0.mProgressDialog.dismiss();
                                }
                                android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131298376)).toString(), 0).show();
                                android.util.Log.i("ummatch", "unmatch");
                            } else {
                                com.android.db.DaoSession v11_4 = com.Manager.BaseManager.getDBSessoin(this.this$0);
                                v11_4.getLoginSucessDao().deleteAll();
                                v11_4.getLoginSucessDao().insertOrReplace(new com.android.db.LoginSucess("1"));
                                android.util.Log.i("match", "match");
                                this.this$0.InternetStatus = utils.Util.isInternetExist(this.this$0.mContext);
                                if (!this.this$0.InternetStatus.equalsIgnoreCase("true")) {
                                    if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                        this.this$0.mProgressDialog.dismiss();
                                    }
                                    android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131297448)).toString(), 0).show();
                                } else {
                                    android.app.ProgressDialog v0_425 = new String[0];
                                    new com.mapit.TribalApp.LoginActivity$LoginInsertLog(this.this$0).execute(v0_425);
                                }
                            }
                        }
                    } else {
                        String v16_3 = this.this$0.encrypteddbPassword;
                        try {
                            String v4_3 = com.mapit.TribalApp.LoginActivity.md5(this.this$0.password);
                            android.app.ProgressDialog v0_435 = new Object[1];
                            String v23_153 = v0_435;
                            v23_153[0] = Integer.valueOf(new java.util.Random().nextInt(10000));
                            String v13_3 = String.format("%04d", v23_153);
                            android.util.Log.d("MyApp", new StringBuilder().append("Generated Password : ").append(v13_3).toString());
                            String v10_3 = com.mapit.TribalApp.LoginActivity.md5(new StringBuilder().append(v13_3).append(v4_3).toString());
                            String v18_3 = com.mapit.TribalApp.LoginActivity.md5(new StringBuilder().append(v13_3).append(v16_3.toString().toLowerCase()).toString());
                            android.util.Log.i("clintside", v10_3);
                            android.util.Log.i("serverside", v18_3);
                        } catch (Exception v12_4) {
                            v12_4.printStackTrace();
                        }
                        if (!v10_3.equalsIgnoreCase(v18_3)) {
                            if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                this.this$0.mProgressDialog.dismiss();
                            }
                            android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131298376)).toString(), 0).show();
                            android.util.Log.i("ummatch", "unmatch");
                        } else {
                            com.android.db.DaoSession v11_5 = com.Manager.BaseManager.getDBSessoin(this.this$0);
                            v11_5.getLoginSucessDao().deleteAll();
                            v11_5.getLoginSucessDao().insertOrReplace(new com.android.db.LoginSucess("1"));
                            android.util.Log.i("match", "match");
                            this.this$0.InternetStatus = utils.Util.isInternetExist(this.this$0.mContext);
                            if (!this.this$0.InternetStatus.equalsIgnoreCase("true")) {
                                if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                    this.this$0.mProgressDialog.dismiss();
                                }
                                android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131297448)).toString(), 0).show();
                            } else {
                                android.app.ProgressDialog v0_504 = new String[0];
                                new com.mapit.TribalApp.LoginActivity$LoginInsertLog(this.this$0).execute(v0_504);
                            }
                        }
                    }
                } else {
                    android.util.Log.i("PasswordChange", new StringBuilder().append("").append(this.this$0.PasswordChange).toString());
                    if (this.this$0.CreatedByUserid.equalsIgnoreCase("null")) {
                        this.this$0.CreatedByUserid = "0";
                    }
                    if (this.this$0.LskOprcode.equalsIgnoreCase("null")) {
                        this.this$0.LskOprcode = "0";
                    }
                    if (this.this$0.CreatedByUserid.equalsIgnoreCase("na")) {
                        this.this$0.CreatedByUserid = "0";
                    }
                    if (this.this$0.LskOprcode.equalsIgnoreCase("na")) {
                        this.this$0.LskOprcode = "0";
                    }
                    int v2 = Integer.parseInt(this.this$0.CreatedByUserid);
                    int v3 = Integer.parseInt(this.this$0.LskOprcode);
                    if (!this.this$0.Activation.equalsIgnoreCase("false")) {
                        if (((v2 <= 0) || (Integer.parseInt(this.this$0.PasswordChange) != 0)) && (Integer.parseInt(this.this$0.UserIdChange) != 0)) {
                            if ((Integer.parseInt(this.this$0.PasswordChange) <= 0) && (Integer.parseInt(this.this$0.UserIdChange) <= 0)) {
                                if (v3 <= 0) {
                                    android.util.Log.i("elsematch", new StringBuilder().append("").append(this.this$0.PasswordChange).toString());
                                    android.util.Log.i("else", "elsematch");
                                    String v16_0 = this.this$0.encrypteddbPassword;
                                    try {
                                        String v4_0 = com.mapit.TribalApp.LoginActivity.md5(this.this$0.password);
                                        android.app.ProgressDialog v0_10 = new Object[1];
                                        String v23_3 = v0_10;
                                        v23_3[0] = Integer.valueOf(new java.util.Random().nextInt(10000));
                                        String v13_0 = String.format("%04d", v23_3);
                                        android.util.Log.d("MyApp", new StringBuilder().append("Generated Password : ").append(v13_0).toString());
                                        String v10_0 = com.mapit.TribalApp.LoginActivity.md5(new StringBuilder().append(v13_0).append(v4_0).toString());
                                        String v18_0 = com.mapit.TribalApp.LoginActivity.md5(new StringBuilder().append(v13_0).append(v16_0.toString().toLowerCase()).toString());
                                        android.util.Log.i("clintside", v10_0);
                                        android.util.Log.i("serverside", v18_0);
                                    } catch (Exception v12_0) {
                                        v12_0.printStackTrace();
                                    }
                                    if (!v10_0.equalsIgnoreCase(v18_0)) {
                                        if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                            this.this$0.mProgressDialog.dismiss();
                                        }
                                        android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131298376)).toString(), 0).show();
                                        android.util.Log.i("ummatch", "unmatch");
                                    } else {
                                        com.android.db.DaoSession v11_0 = com.Manager.BaseManager.getDBSessoin(this.this$0);
                                        v11_0.getLoginSucessDao().deleteAll();
                                        v11_0.getLoginSucessDao().insertOrReplace(new com.android.db.LoginSucess("1"));
                                        android.util.Log.i("match", "match");
                                        this.this$0.InternetStatus = utils.Util.isInternetExist(this.this$0.mContext);
                                        if (!this.this$0.InternetStatus.equalsIgnoreCase("true")) {
                                            if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                                this.this$0.mProgressDialog.dismiss();
                                            }
                                            android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131297448)).toString(), 0).show();
                                        } else {
                                            android.app.ProgressDialog v0_72 = new String[0];
                                            new com.mapit.TribalApp.LoginActivity$LoginInsertLog(this.this$0).execute(v0_72);
                                        }
                                    }
                                } else {
                                    android.util.Log.i("LskOprcodeval", new StringBuilder().append("").append(this.this$0.PasswordChange).toString());
                                    if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                        this.this$0.mProgressDialog.dismiss();
                                    }
                                    com.android.db.DaoSession v11_1 = com.Manager.BaseManager.getDBSessoin(this.this$0);
                                    v11_1.getAppLanguageDao().deleteAll();
                                    v11_1.getAppLanguageDao().insertOrReplace(new com.android.db.AppLanguage(com.mapit.TribalApp.LoginActivity.universallanguagelogin));
                                    this.this$0.intent = new android.content.Intent(this.this$0, com.mapit.TribalApp.FirstTimeUserPasswordActivity);
                                    this.this$0.intent.putExtra("oldusername", this.this$0.user_name);
                                    this.this$0.startActivity(this.this$0.intent);
                                    this.this$0.finish();
                                    this.this$0.overridePendingTransition(2131034135, 2131034137);
                                }
                            } else {
                                android.util.Log.i("elsematch", new StringBuilder().append("").append(this.this$0.PasswordChange).toString());
                                android.util.Log.i("else", "elsematch");
                                String v16_1 = this.this$0.encrypteddbPassword;
                                try {
                                    String v4_1 = com.mapit.TribalApp.LoginActivity.md5(this.this$0.password);
                                    android.app.ProgressDialog v0_135 = new Object[1];
                                    String v23_55 = v0_135;
                                    v23_55[0] = Integer.valueOf(new java.util.Random().nextInt(10000));
                                    String v13_1 = String.format("%04d", v23_55);
                                    android.util.Log.d("MyApp", new StringBuilder().append("Generated Password : ").append(v13_1).toString());
                                    String v10_1 = com.mapit.TribalApp.LoginActivity.md5(new StringBuilder().append(v13_1).append(v4_1).toString());
                                    String v18_1 = com.mapit.TribalApp.LoginActivity.md5(new StringBuilder().append(v13_1).append(v16_1.toString().toLowerCase()).toString());
                                    android.util.Log.i("clintside", v10_1);
                                    android.util.Log.i("serverside", v18_1);
                                } catch (Exception v12_1) {
                                    v12_1.printStackTrace();
                                }
                                if (!v10_1.equalsIgnoreCase(v18_1)) {
                                    if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                        this.this$0.mProgressDialog.dismiss();
                                    }
                                    android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131298376)).toString(), 0).show();
                                    android.util.Log.i("ummatch", "unmatch");
                                } else {
                                    android.util.Log.i("match", "match");
                                    com.android.db.DaoSession v11_2 = com.Manager.BaseManager.getDBSessoin(this.this$0);
                                    v11_2.getLoginSucessDao().deleteAll();
                                    v11_2.getLoginSucessDao().insertOrReplace(new com.android.db.LoginSucess("1"));
                                    this.this$0.InternetStatus = utils.Util.isInternetExist(this.this$0.mContext);
                                    if (!this.this$0.InternetStatus.equalsIgnoreCase("true")) {
                                        if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                            this.this$0.mProgressDialog.dismiss();
                                        }
                                        android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), new StringBuilder().append("").append(this.this$0.getResources().getString(2131297448)).toString(), 0).show();
                                    } else {
                                        android.app.ProgressDialog v0_201 = new String[0];
                                        new com.mapit.TribalApp.LoginActivity$LoginInsertLog(this.this$0).execute(v0_201);
                                    }
                                }
                            }
                        } else {
                            android.util.Log.i("CreatedByUseridval", new StringBuilder().append("").append(this.this$0.PasswordChange).toString());
                            int v5 = Integer.parseInt(this.this$0.PasswordChange);
                            int v7 = Integer.parseInt(this.this$0.UserIdChange);
                            if ((v5 == 0) || (v7 == 0)) {
                                if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                                    this.this$0.mProgressDialog.dismiss();
                                }
                                com.android.db.DaoSession v11_3 = com.Manager.BaseManager.getDBSessoin(this.this$0);
                                v11_3.getAppLanguageDao().deleteAll();
                                v11_3.getAppLanguageDao().insertOrReplace(new com.android.db.AppLanguage(com.mapit.TribalApp.LoginActivity.universallanguagelogin));
                                this.this$0.intent = new android.content.Intent(this.this$0, com.mapit.TribalApp.FirstTimeUserPasswordActivity);
                                this.this$0.intent.putExtra("oldusername", this.this$0.user_name);
                                this.this$0.startActivity(this.this$0.intent);
                                this.this$0.finish();
                                this.this$0.overridePendingTransition(2131034135, 2131034137);
                            }
                        }
                    } else {
                        android.util.Log.i("Activation", new StringBuilder().append("").append(this.this$0.PasswordChange).toString());
                        if ((this.this$0.mProgressDialog != null) && (this.this$0.mProgressDialog.isShowing())) {
                            this.this$0.mProgressDialog.dismiss();
                        }
                        android.support.design.widget.Snackbar.make(com.mapit.TribalApp.LoginActivity.access$000(this.this$0), "User not Activated", 0).show();
                    }
                }
            }
        } catch (Exception v12_2) {
            v12_2.printStackTrace();
        }
        return;
    }

Method com.sun.org.apache.bcel.internal.verifier.structurals.Pass3bVerifier.circulationPump() calling method java.util.Random.<init>()


    private void circulationPump(com.sun.org.apache.bcel.internal.verifier.structurals.ControlFlowGraph p34, com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext p35, com.sun.org.apache.bcel.internal.verifier.structurals.Frame p36, com.sun.org.apache.bcel.internal.verifier.structurals.InstConstraintVisitor p37, com.sun.org.apache.bcel.internal.verifier.structurals.ExecutionVisitor p38)
    {
        new java.util.Random();
        com.sun.org.apache.bcel.internal.verifier.structurals.Pass3bVerifier$InstructionContextQueue v10_1 = new com.sun.org.apache.bcel.internal.verifier.structurals.Pass3bVerifier$InstructionContextQueue(0);
        p35.execute(p36, new java.util.ArrayList(), p37, p38);
        v10_1.add(p35, new java.util.ArrayList());
        while (!v10_1.isEmpty()) {
            com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext v26 = v10_1.getIC(0);
            java.util.ArrayList v5 = v10_1.getEC(0);
            v10_1.remove(0);
            java.util.ArrayList v16_1 = ((java.util.ArrayList) ((java.util.ArrayList) v5.clone()));
            java.util.ArrayList v15_1 = ((java.util.ArrayList) ((java.util.ArrayList) v5.clone()));
            v15_1.add(v26);
            if (!(v26.getInstruction().getInstruction() instanceof com.sun.org.apache.bcel.internal.generic.RET)) {
                com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext[] v23 = v26.getSuccessors();
                int v20_0 = 0;
                while (v20_0 < v23.length) {
                    com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext v27_0 = v23[v20_0];
                    if (v27_0.execute(v26.getOutFrame(v16_1), v15_1, p37, p38)) {
                        v10_1.add(v27_0, ((java.util.ArrayList) v15_1.clone()));
                    }
                    v20_0++;
                }
            } else {
                com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext v25 = p34.contextOf(((com.sun.org.apache.bcel.internal.generic.ReturnaddressType) v26.getOutFrame(v16_1).getLocals().get(((com.sun.org.apache.bcel.internal.generic.RET) ((com.sun.org.apache.bcel.internal.generic.RET) v26.getInstruction().getInstruction())).getIndex())).getTarget());
                com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext v13_0 = 0;
                int v21 = 0;
                int v22 = (v16_1.size() - 1);
                while (v22 >= 0) {
                    if (v21 >= 0) {
                        if ((((com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext) v16_1.get(v22)).getInstruction().getInstruction() instanceof com.sun.org.apache.bcel.internal.generic.JsrInstruction)) {
                            if (v21 != 0) {
                                v21--;
                            } else {
                                v13_0 = ((com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext) v16_1.get(v22));
                                break;
                            }
                        }
                        if ((((com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext) v16_1.get(v22)).getInstruction().getInstruction() instanceof com.sun.org.apache.bcel.internal.generic.RET)) {
                            v21++;
                        }
                        v22--;
                    } else {
                        throw new com.sun.org.apache.bcel.internal.verifier.exc.AssertionViolatedException("More RET than JSR in execution chain?!");
                    }
                }
                if (v13_0 != null) {
                    com.sun.org.apache.bcel.internal.generic.JsrInstruction v12_1 = ((com.sun.org.apache.bcel.internal.generic.JsrInstruction) ((com.sun.org.apache.bcel.internal.generic.JsrInstruction) v13_0.getInstruction().getInstruction()));
                    if (v25 == p34.contextOf(v12_1.physicalSuccessor())) {
                        if (v25.execute(v26.getOutFrame(v16_1), v15_1, p37, p38)) {
                            v10_1.add(v25, ((java.util.ArrayList) v15_1.clone()));
                        }
                    } else {
                        throw new com.sun.org.apache.bcel.internal.verifier.exc.AssertionViolatedException(new StringBuilder().append("RET \'").append(v26.getInstruction()).append("\' info inconsistent: jump back to \'").append(v25).append("\' or \'").append(p34.contextOf(v12_1.physicalSuccessor())).append("\'?").toString());
                    }
                } else {
                    throw new com.sun.org.apache.bcel.internal.verifier.exc.AssertionViolatedException(new StringBuilder().append("RET without a JSR before in ExecutionChain?! EC: \'").append(v16_1).append("\'.").toString());
                }
            }
            com.sun.org.apache.bcel.internal.verifier.structurals.ExceptionHandler[] v6 = v26.getExceptionHandlers();
            int v20_1 = 0;
            while (v20_1 < v6.length) {
                String v28_62;
                com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext v27_1 = p34.contextOf(v6[v20_1].getHandlerStart());
                com.sun.org.apache.bcel.internal.verifier.structurals.LocalVariables v30_0 = v26.getOutFrame(v16_1).getLocals();
                com.sun.org.apache.bcel.internal.verifier.structurals.OperandStack v31 = new com.sun.org.apache.bcel.internal.verifier.structurals.OperandStack;
                int v32 = v26.getOutFrame(v16_1).getStack().maxStack();
                if (v6[v20_1].getExceptionType() != null) {
                    v28_62 = v6[v20_1].getExceptionType();
                } else {
                    v28_62 = com.sun.org.apache.bcel.internal.generic.Type.THROWABLE;
                }
                v31(v32, v28_62);
                if (v27_1.execute(new com.sun.org.apache.bcel.internal.verifier.structurals.Frame(v30_0, v31), new java.util.ArrayList(), p37, p38)) {
                    v10_1.add(v27_1, new java.util.ArrayList());
                }
                v20_1++;
            }
        }
        com.sun.org.apache.bcel.internal.generic.InstructionHandle v11 = p35.getInstruction();
        do {
            if (((v11.getInstruction() instanceof com.sun.org.apache.bcel.internal.generic.ReturnInstruction)) && (!p34.isDead(v11))) {
                com.sun.org.apache.bcel.internal.verifier.structurals.InstructionContext v9 = p34.contextOf(v11);
                com.sun.org.apache.bcel.internal.verifier.structurals.Frame v7 = v9.getOutFrame(new java.util.ArrayList());
                com.sun.org.apache.bcel.internal.verifier.structurals.LocalVariables v14 = v7.getLocals();
                int v8_0 = 0;
                while (v8_0 < v14.maxLocals()) {
                    if ((v14.get(v8_0) instanceof com.sun.org.apache.bcel.internal.verifier.structurals.UninitializedObjectType)) {
                        this.addMessage(new StringBuilder().append("Warning: ReturnInstruction \'").append(v9).append("\' may leave method with an uninitialized object in the local variables array \'").append(v14).append("\'.").toString());
                    }
                    v8_0++;
                }
                com.sun.org.apache.bcel.internal.verifier.structurals.OperandStack v17 = v7.getStack();
                int v8_1 = 0;
                while (v8_1 < v17.size()) {
                    if ((v17.peek(v8_1) instanceof com.sun.org.apache.bcel.internal.verifier.structurals.UninitializedObjectType)) {
                        this.addMessage(new StringBuilder().append("Warning: ReturnInstruction \'").append(v9).append("\' may leave method with an uninitialized object on the operand stack \'").append(v17).append("\'.").toString());
                    }
                    v8_1++;
                }
            }
            v11 = v11.getNext();
        } while(v11 != null);
    }

Method com.sun.xml.internal.stream.writers.XMLStreamWriterImpl.init() calling method java.util.Random.<init>()


    private void init()
    {
        this.fReuse = 0;
        this.fNamespaceDecls = new java.util.ArrayList();
        this.fPrefixGen = new java.util.Random();
        this.fAttributeCache = new java.util.ArrayList();
        this.fInternalNamespaceContext = new com.sun.org.apache.xerces.internal.util.NamespaceSupport();
        this.fNamespaceContext = new com.sun.xml.internal.stream.writers.XMLStreamWriterImpl$NamespaceContextImpl(this);
        this.fNamespaceContext.internalContext = this.fInternalNamespaceContext;
        if (this.fPropertyManager != null) {
            this.fIsRepairingNamespace = ((Boolean) this.fPropertyManager.getProperty("javax.xml.stream.isRepairingNamespaces")).booleanValue();
            this.setEscapeCharacters(((Boolean) this.fPropertyManager.getProperty("escapeCharacters")).booleanValue());
        }
        return;
    }

Method de.greenrobot.dao.test.DbTest.<init>() calling method java.util.Random.<init>()


    public DbTest(boolean p2)
    {
        this.inMemory = p2;
        this.random = new java.util.Random();
        return;
    }

Method org.apache.commons.lang3.RandomStringUtils.<clinit>() calling method java.util.Random.<init>()


    static RandomStringUtils()
    {
        org.apache.commons.lang3.RandomStringUtils.RANDOM = new java.util.Random();
        return;
    }

Method org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl.nextBytes() calling method java.util.Random.<init>()


    private static declared_synchronized void nextBytes(byte[] p12)
    {
        try {
            if (org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl._random == null) {
                try {
                    byte[] v8_5;
                    java.io.ByteArrayOutputStream v0_1 = new java.io.ByteArrayOutputStream();
                    java.io.DataOutputStream v2_1 = new java.io.DataOutputStream(v0_1);
                } catch (java.io.IOException v3) {
                    org.apache.xmlbeans.impl.common.XBeanDebug.logException(v3);
                    org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl._random = new java.util.Random(System.currentTimeMillis());
                }
                if (org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl.class$org$apache$xmlbeans$impl$schema$SchemaTypeSystemImpl != null) {
                    v8_5 = org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl.class$org$apache$xmlbeans$impl$schema$SchemaTypeSystemImpl;
                } else {
                    v8_5 = org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl.class$("org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl");
                    org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl.class$org$apache$xmlbeans$impl$schema$SchemaTypeSystemImpl = v8_5;
                }
                v2_1.writeInt(System.identityHashCode(v8_5));
                String[] v7 = new String[9];
                v7[0] = "user.name";
                v7[1] = "user.dir";
                v7[2] = "user.timezone";
                v7[3] = "user.country";
                v7[4] = "java.class.path";
                v7[5] = "java.home";
                v7[6] = "java.vendor";
                v7[7] = "java.version";
                v7[8] = "os.version";
                int v4_1 = 0;
                while (v4_1 < v7.length) {
                    String v6 = org.apache.xmlbeans.SystemProperties.getProperty(v7[v4_1]);
                    if (v6 != null) {
                        v2_1.writeUTF(v6);
                        v2_1.writeInt(System.identityHashCode(v6));
                    }
                    v4_1++;
                }
                v2_1.writeLong(Runtime.getRuntime().freeMemory());
                v2_1.close();
                byte[] v1 = v0_1.toByteArray();
                int v4_2 = 0;
                while (v4_2 < v1.length) {
                    int v5_0 = (v4_2 % org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl._mask.length);
                    byte[] v8_22 = org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl._mask;
                    v8_22[v5_0] = ((byte) (v8_22[v5_0] * 21));
                    byte[] v8_23 = org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl._mask;
                    v8_23[v5_0] = ((byte) (v8_23[v5_0] + v4_2));
                    v4_2++;
                }
            }
        } catch (byte[] v8_4) {
            throw v8_4;
        }
        org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl._random.nextBytes(p12);
        int v4_0 = 0;
        while (v4_0 < p12.length) {
            p12[v4_0] = ((byte) (p12[v4_0] ^ org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl._mask[(v4_0 & org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl._mask.length)]));
            v4_0++;
        }
        return;
    }

Method org.apache.xmlbeans.impl.xsd2inst.SampleXmlUtil.<init>() calling method java.util.Random.<init>()


    private SampleXmlUtil(boolean p5)
    {
        this._picker = new java.util.Random(1);
        this._typeStack = new java.util.ArrayList();
        this._soapEnc = p5;
        return;
    }

Method org.spongycastle.math.ec.ECCurve$F2m.solveQuadradicEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadradicEquation(org.spongycastle.math.ec.ECFieldElement p15)
    {
        org.spongycastle.math.ec.ECFieldElement v0_1 = new org.spongycastle.math.ec.ECFieldElement$F2m(this.m, this.k1, this.k2, this.k3, org.spongycastle.math.ec.ECConstants.ZERO);
        if (!p15.toBigInteger().equals(org.spongycastle.math.ec.ECConstants.ZERO)) {
            org.spongycastle.math.ec.ECFieldElement v7 = v0_1;
            java.util.Random v9_1 = new java.util.Random();
            do {
                org.spongycastle.math.ec.ECFieldElement$F2m v1_2 = new org.spongycastle.math.ec.ECFieldElement$F2m(this.m, this.k1, this.k2, this.k3, new java.math.BigInteger(this.m, v9_1));
                org.spongycastle.math.ec.ECFieldElement v12 = v0_1;
                org.spongycastle.math.ec.ECFieldElement v10 = p15;
                int v8 = 1;
                if (v8 > (this.m - 1)) {
                    if (v10.toBigInteger().equals(org.spongycastle.math.ec.ECConstants.ZERO)) {
                    } else {
                        v0_1 = 0;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v11 = v10.square();
                    v12 = v12.square().add(v11.multiply(v1_2));
                    v10 = v11.add(p15);
                    v8++;
                    while (v8 <= (this.m - 1)) {
                    }
                }
            } while(v12.square().add(v12).toBigInteger().equals(org.spongycastle.math.ec.ECConstants.ZERO));
            v0_1 = v12;
        }
        return v0_1;
    }

Method org.spongycastle.math.ec.ECFieldElement$Fp.sqrt() calling method java.util.Random.<init>()


    public org.spongycastle.math.ec.ECFieldElement sqrt()
    {
        if (this.q.testBit(0)) {
            int v12_1;
            if (!this.q.testBit(1)) {
                java.math.BigInteger v8 = this.q.subtract(org.spongycastle.math.ec.ECConstants.ONE);
                java.math.BigInteger v7 = v8.shiftRight(1);
                if (this.x.modPow(v7, this.q).equals(org.spongycastle.math.ec.ECConstants.ONE)) {
                    java.math.BigInteger v6 = v8.shiftRight(2).shiftLeft(1).add(org.spongycastle.math.ec.ECConstants.ONE);
                    java.math.BigInteger v2 = this.x;
                    java.math.BigInteger v5 = v2.shiftLeft(2).mod(this.q);
                    java.util.Random v9_1 = new java.util.Random();
                    do {
                        java.math.BigInteger v1_1 = new java.math.BigInteger(this.q.bitLength(), v9_1);
                        if ((v1_1.compareTo(this.q) < 0) && (v1_1.multiply(v1_1).subtract(v5).modPow(v7, this.q).equals(v8))) {
                            java.math.BigInteger[] v10 = org.spongycastle.math.ec.ECFieldElement$Fp.lucasSequence(this.q, v1_1, v2, v6);
                            java.math.BigInteger v3 = v10[0];
                            java.math.BigInteger v4_0 = v10[1];
                            if (!v4_0.multiply(v4_0).mod(this.q).equals(v5)) {
                            } else {
                                if (v4_0.testBit(0)) {
                                    v4_0 = v4_0.add(this.q);
                                }
                                v12_1 = new org.spongycastle.math.ec.ECFieldElement$Fp(this.q, v4_0.shiftRight(1));
                            }
                        }
                    } while((v3.equals(org.spongycastle.math.ec.ECConstants.ONE)) || (v3.equals(v8)));
                    v12_1 = 0;
                } else {
                    v12_1 = 0;
                }
            } else {
                v12_1 = new org.spongycastle.math.ec.ECFieldElement$Fp(this.q, this.x.modPow(this.q.shiftRight(2).add(org.spongycastle.math.ec.ECConstants.ONE), this.q));
                if (!v12_1.square().equals(this)) {
                    v12_1 = 0;
                }
            }
            return v12_1;
        } else {
            throw new RuntimeException("not done yet");
        }
    }