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 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");
        }
    }

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 com.tosan.ebank.mobilebanking.api.serialize.Serializer.deserialize() calling method java.util.Random.<init>()


    private static Object deserialize(java.io.DataInputStream p40, byte p41, com.tosan.ebank.mobilebanking.api.serialize.SerialVersionFinder p42, String p43)
    {
        byte v35 = p40.readByte();
        if (v35 > 1) {
            System.out.println(new StringBuffer().append("Warning: trying to deserialize class that has been serialized with a newer version (").append(v35).append(">").append(1).append(").").toString());
        }
        java.util.Vector v13_0;
        if (!p40.readBoolean()) {
            byte v32 = p40.readByte();
            switch (v32) {
                case 0:
                    if (p41 != 1) {
                        if (p41 != 2) {
                            if (p41 != 0) {
                                throw new RuntimeException(new StringBuffer().append("object type identity serialization method \'").append(p41).append("\'is incorrect").toString());
                            } else {
                                if (p43 == null) {
                                    throw new IllegalArgumentException("in object type identity HEADER_TYPE_NOTHING, className must have value");
                                }
                            }
                        } else {
                            if (p42 != null) {
                                p43 = p42.getClass(p40.readShort()).getName();
                            } else {
                                throw new IllegalArgumentException("in object type identity HEADER_TYPE_SERIAL_VERSION_ID, serialVersionIdToClass must have value");
                            }
                        }
                    } else {
                        p43 = p40.readUTF();
                        if (com.tosan.ebank.mobilebanking.api.serialize.Serializer.obfuscationDeserializeMap != null) {
                            String v17_3 = ((String) com.tosan.ebank.mobilebanking.api.serialize.Serializer.obfuscationDeserializeMap.get(p43));
                            if (v17_3 != null) {
                                p43 = v17_3;
                            }
                        }
                    }
                    try {
                        v13_0 = ((com.tosan.ebank.mobilebanking.api.serialize.Externalizable) Class.forName(p43).newInstance());
                        v13_0.read(p40);
                    } catch (ClassNotFoundException v12_2) {
                        System.out.println(new StringBuffer().append("Unable to instantiate serializable \"").append(p43).append("\"").append(v12_2).toString());
                        throw new java.io.IOException(v12_2.toString());
                    }
                    break;
                case 1:
                    if (p41 != 1) {
                        if (p41 != 2) {
                            if (p41 != 0) {
                                throw new RuntimeException(new StringBuffer().append("object type identity serialization method \'").append(p41).append("\'is incorrect").toString());
                            }
                        } else {
                            p40.readShort();
                        }
                    } else {
                        p40.readUTF();
                    }
                    int v24_5 = p40.readInt();
                    com.tosan.ebank.mobilebanking.api.serialize.Externalizable[] v15 = new com.tosan.ebank.mobilebanking.api.serialize.Externalizable[v24_5];
                    Class[] v9 = new Class[Math.min(v24_5, 7)];
                    byte v20 = 0;
                    int v19_7 = 0;
                    while (v19_7 < v15.length) {
                        Class v10;
                        byte v8 = p40.readByte();
                        if (v8 != 0) {
                            v10 = v9[(v8 - 1)];
                        } else {
                            if (p41 != 1) {
                                if (p41 != 2) {
                                    if (p41 != 0) {
                                        throw new RuntimeException(new StringBuffer().append("object type identity serialization method \'").append(p41).append("\'is incorrect").toString());
                                    } else {
                                        if (p43 == null) {
                                            throw new IllegalArgumentException("in object type identity HEADER_TYPE_NOTHING, className must have value");
                                        }
                                    }
                                } else {
                                    if (p42 != null) {
                                        p43 = p42.getClass(p40.readShort()).getName();
                                    } else {
                                        throw new IllegalArgumentException("in object type identity HEADER_TYPE_SERIAL_VERSION_ID, serialVersionIdToClass must have value");
                                    }
                                }
                            } else {
                                p43 = p40.readUTF();
                                if (com.tosan.ebank.mobilebanking.api.serialize.Serializer.obfuscationDeserializeMap != null) {
                                    String v17_1 = ((String) com.tosan.ebank.mobilebanking.api.serialize.Serializer.obfuscationDeserializeMap.get(p43));
                                    if (v17_1 != null) {
                                        p43 = v17_1;
                                    }
                                }
                            }
                            try {
                                v10 = Class.forName(p43);
                            } catch (ClassNotFoundException v12_0) {
                                System.out.println(new StringBuffer().append("Unable to load Serializable class \"").append(p43).append("\"").append(v12_0).toString());
                                throw new java.io.IOException(v12_0.toString());
                            }
                            if (v20 > v9.length) {
                                StringBuffer v0_59 = new Class[(v9.length + 7)];
                                Class[] v26 = v0_59;
                                System.arraycopy(v9, 0, v26, 0, v9.length);
                                v9 = v26;
                            }
                            v9[v20] = v10;
                            v20 = ((byte) (v20 + 1));
                        }
                        try {
                            com.tosan.ebank.mobilebanking.api.serialize.Externalizable v14_1 = ((com.tosan.ebank.mobilebanking.api.serialize.Externalizable) v10.newInstance());
                            v14_1.read(p40);
                            v15[v19_7] = v14_1;
                            v19_7++;
                        } catch (ClassNotFoundException v12_1) {
                            System.out.println(new StringBuffer().append("Unable to instantiate Serializable \"").append(v10.getName()).append("\"").append(v12_1).toString());
                            throw new java.io.IOException(v12_1.toString());
                        }
                    }
                    v13_0 = v15;
                    break;
                case 2:
                    StringBuffer v0_32 = new Object[p40.readInt()];
                    Object[] v27 = v0_32;
                    int v19_6 = 0;
                    while (v19_6 < v27.length) {
                        v27[v19_6] = com.tosan.ebank.mobilebanking.api.serialize.Serializer.deserialize(p40, p41, p42, p43);
                        v19_6++;
                    }
                    v13_0 = v27;
                    break;
                case 3:
                    v13_0 = new Byte(p40.readByte());
                    break;
                case 4:
                    v13_0 = new Short(p40.readShort());
                    break;
                case 5:
                    v13_0 = new Integer(p40.readInt());
                    break;
                case 6:
                    v13_0 = new Long(p40.readLong());
                    break;
                case 7:
                    v13_0 = new Float(p40.readFloat());
                    break;
                case 8:
                    v13_0 = new Double(p40.readDouble());
                    break;
                case 9:
                    v13_0 = p40.readUTF();
                    break;
                case 10:
                    v13_0 = new StringBuffer(p40.readUTF());
                    break;
                case 11:
                    v13_0 = new Character(p40.readChar());
                    break;
                case 12:
                    v13_0 = new Boolean(p40.readBoolean());
                    break;
                case 13:
                    v13_0 = new java.util.Date(p40.readLong());
                    break;
                case 14:
                    java.util.Calendar v6 = java.util.Calendar.getInstance();
                    IllegalArgumentException v36_4 = new java.util.Date;
                    v36_4(p40.readLong());
                    v6.setTime(v36_4);
                    v13_0 = v6;
                    break;
                case 15:
                    v13_0 = new java.util.Random();
                    break;
                case 16:
                    int v30_1 = p40.readInt();
                    java.util.Hashtable v18 = new java.util.Hashtable;
                    v18(v30_1);
                    int v19_5 = 0;
                    while (v19_5 < v30_1) {
                        v18.put(com.tosan.ebank.mobilebanking.api.serialize.Serializer.deserialize(p40, p41, p42, p43), com.tosan.ebank.mobilebanking.api.serialize.Serializer.deserialize(p40, p41, p42, p43));
                        v19_5++;
                    }
                    v13_0 = v18;
                    break;
                case 17:
                case 18:
                    java.util.Vector v34_0;
                    int v30_0 = p40.readInt();
                    if (v32 != 17) {
                        v34_0 = new java.util.Vector;
                        v34_0(v30_0);
                    } else {
                        v34_0 = new java.util.Stack();
                    }
                    int v19_4 = 0;
                    while (v19_4 < v30_0) {
                        v34_0.addElement(com.tosan.ebank.mobilebanking.api.serialize.Serializer.deserialize(p40, p41, p42, p43));
                        v19_4++;
                    }
                    v13_0 = v34_0;
                    break;
                case 19:
                case 20:
                case 21:
                default:
                    throw new java.io.IOException(new StringBuffer().append("Unknown type: ").append(v32).toString());
                    break;
                case 22:
                    byte[] v5 = new byte[p40.readInt()];
                    p40.readFully(v5);
                    v13_0 = v5;
                    break;
                case 23:
                    int v24_2 = p40.readInt();
                    StringBuffer v0_8 = new short[v24_2];
                    short[] v29 = v0_8;
                    int v19_3 = 0;
                    while (v19_3 < v24_2) {
                        v29[v19_3] = p40.readShort();
                        v19_3++;
                    }
                    v13_0 = v29;
                    break;
                case 24:
                    int v24_1 = p40.readInt();
                    StringBuffer v0_4 = new int[v24_1];
                    int[] v21 = v0_4;
                    int v19_2 = 0;
                    while (v19_2 < v24_1) {
                        v21[v19_2] = p40.readInt();
                        v19_2++;
                    }
                    v13_0 = v21;
                    break;
                case 25:
                    int v24_0 = p40.readInt();
                    StringBuffer v0_1 = new long[v24_0];
                    long[] v25 = v0_1;
                    int v19_1 = 0;
                    while (v19_1 < v24_0) {
                        v25[v19_1] = p40.readLong();
                        v19_1++;
                    }
                    v13_0 = v25;
                    break;
                case 26:
                    int v24_10 = p40.readInt();
                    StringBuffer v0_82 = new float[v24_10];
                    float[] v16 = v0_82;
                    int v19_0 = 0;
                    while (v19_0 < v24_10) {
                        v16[v19_0] = p40.readFloat();
                        v19_0++;
                    }
                    v13_0 = v16;
                    break;
                case 27:
                    int v24_9 = p40.readInt();
                    double[] v11 = new double[v24_9];
                    int v19_11 = 0;
                    while (v19_11 < v24_9) {
                        v11[v19_11] = p40.readDouble();
                        v19_11++;
                    }
                    v13_0 = v11;
                    break;
                case 28:
                    int v24_8 = p40.readInt();
                    char[] v7 = new char[v24_8];
                    int v19_10 = 0;
                    while (v19_10 < v24_8) {
                        v7[v19_10] = p40.readChar();
                        v19_10++;
                    }
                    v13_0 = v7;
                    break;
                case 29:
                    int v24_7 = p40.readInt();
                    boolean[] v4 = new boolean[v24_7];
                    int v19_9 = 0;
                    while (v19_9 < v24_7) {
                        v4[v19_9] = p40.readBoolean();
                        v19_9++;
                    }
                    v13_0 = v4;
                    break;
                case 30:
                    int v24_6 = p40.readInt();
                    StringBuffer v0_50 = new String[v24_6];
                    String[] v31 = v0_50;
                    int v19_8 = 0;
                    while (v19_8 < v24_6) {
                        v31[v19_8] = p40.readUTF();
                        v19_8++;
                    }
                    v13_0 = v31;
                    break;
            }
        } else {
            v13_0 = 0;
        }
        return v13_0;
    }

Method com.google.android.gms.tagmanager.zzai.<init>() calling method java.util.Random.<init>()


    public zzai(android.content.Context p2, String p3)
    {
        this(p2, p3, new java.util.Random());
        return;
    }

Method com.google.android.gms.internal.zzckn.zzbam() calling method java.util.Random.<init>()


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

Method com.google.android.gms.analytics.Tracker.<init>() calling method java.util.Random.<init>()


    Tracker(com.google.android.gms.internal.zzaor p5, String p6, com.google.android.gms.internal.zzaqi p7)
    {
        super(p5);
        super.zzbqw = new java.util.HashMap();
        super.zzdnj = new java.util.HashMap();
        if (p6 != null) {
            super.zzbqw.put("&tid", p6);
        }
        super.zzbqw.put("useSecure", "1");
        super.zzbqw.put("&a", Integer.toString((new java.util.Random().nextInt(2147483647) + 1)));
        super.zzdnk = new com.google.android.gms.internal.zzaqi("tracking", super.zzwh());
        super.zzdnl = new com.google.android.gms.analytics.Tracker$zza(super, p5);
        return;
    }

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 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.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.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.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.DERObjectIdentifier v1_0 = new org.spongycastle.asn1.DERObjectIdentifier(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.DERInteger(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, new org.spongycastle.asn1.pkcs.PKCS12PBEParams(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.DERObjectIdentifier(this.algorithm), org.spongycastle.asn1.ASN1Object.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.jce.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.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.jce.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.jce.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.jce.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.jce.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.jce.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.jce.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.jce.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.jce.provider.asymmetric.ec.KeyPairGenerator$EC.<init>() calling method java.security.SecureRandom.<init>()


    public KeyPairGenerator$EC(String p2)
    {
        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;
        return;
    }

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


    public KeyPairGenerator$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";
        return;
    }

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


    public JDKPKCS12KeyStore(java.security.Provider p5, org.spongycastle.asn1.DERObjectIdentifier p6, org.spongycastle.asn1.DERObjectIdentifier 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.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.JDKKeyPairGenerator$RSA.<init>() calling method java.security.SecureRandom.<init>()


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

Method org.spongycastle.jce.provider.JDKKeyPairGenerator$GOST3410.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.jce.provider.JDKGOST3410PublicKey(((org.spongycastle.crypto.params.GOST3410PublicKeyParameters) v0.getPublic()), this.gost3410Params), new org.spongycastle.jce.provider.JDKGOST3410PrivateKey(((org.spongycastle.crypto.params.GOST3410PrivateKeyParameters) v0.getPrivate()), this.gost3410Params));
    }

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


    public JDKKeyPairGenerator$ElGamal()
    {
        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.jce.provider.JDKKeyPairGenerator$DSA.<init>() calling method java.security.SecureRandom.<init>()


    public JDKKeyPairGenerator$DSA()
    {
        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.jce.provider.JDKKeyPairGenerator$DH.<init>() calling method java.security.SecureRandom.<init>()


    public JDKKeyPairGenerator$DH()
    {
        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.jce.provider.JDKAlgorithmParameterGenerator$RC2.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.jce.provider.JDKAlgorithmParameterGenerator$GOST3410.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.jce.provider.JDKAlgorithmParameterGenerator$ElGamal.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.jce.provider.JDKAlgorithmParameterGenerator$DSA.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.jce.provider.JDKAlgorithmParameterGenerator$DH.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.jce.provider.JDKAlgorithmParameterGenerator$DES.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.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.jce.provider.JCEPBEKey)) {
                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.jce.provider.JCEPBEKey) p11).getOID() == null) {
                    this.pbeAlgorithm = ((org.spongycastle.jce.provider.JCEPBEKey) p11).getAlgorithm();
                } else {
                    this.pbeAlgorithm = ((org.spongycastle.jce.provider.JCEPBEKey) p11).getOID().getId();
                }
                if (((org.spongycastle.jce.provider.JCEPBEKey) 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.jce.provider.PBE$Util.makePBEParameters(((org.spongycastle.jce.provider.JCEPBEKey) p11), p12, this.cipher.getAlgorithmName());
                        this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p12);
                    }
                } else {
                    v3_1 = ((org.spongycastle.jce.provider.JCEPBEKey) p11).getParam();
                    this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((org.spongycastle.jce.provider.JCEPBEKey) p11).getSalt(), ((org.spongycastle.jce.provider.JCEPBEKey) p11).getIterationCount());
                }
                if (((org.spongycastle.jce.provider.JCEPBEKey) 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.JCERSACipher.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)
    {
        if ((p12 != null) && (!(p12 instanceof javax.crypto.spec.OAEPParameterSpec))) {
            throw new IllegalArgumentException("unknown parameter type.");
        } else {
            org.spongycastle.crypto.params.RSAKeyParameters v4;
            if (!(p11 instanceof java.security.interfaces.RSAPublicKey)) {
                if (!(p11 instanceof java.security.interfaces.RSAPrivateKey)) {
                    throw new java.security.InvalidKeyException("unknown key type passed to RSA");
                } else {
                    if (!this.publicKeyOnly) {
                        v4 = org.spongycastle.jce.provider.RSAUtil.generatePrivateKeyParameter(((java.security.interfaces.RSAPrivateKey) p11));
                    } else {
                        throw new java.security.InvalidKeyException("mode 2 requires RSAPublicKey");
                    }
                }
            } else {
                if (!this.privateKeyOnly) {
                    v4 = org.spongycastle.jce.provider.RSAUtil.generatePublicKeyParameter(((java.security.interfaces.RSAPublicKey) p11));
                } else {
                    throw new java.security.InvalidKeyException("mode 1 requires RSAPrivateKey");
                }
            }
            if (p12 != null) {
                this.paramSpec = p12;
                if ((((javax.crypto.spec.OAEPParameterSpec) p12).getMGFAlgorithm().equalsIgnoreCase("MGF1")) || (((javax.crypto.spec.OAEPParameterSpec) p12).getMGFAlgorithm().equals(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_mgf1.getId()))) {
                    if ((((javax.crypto.spec.OAEPParameterSpec) p12).getMGFParameters() instanceof java.security.spec.MGF1ParameterSpec)) {
                        org.spongycastle.crypto.Digest v0 = org.spongycastle.jce.provider.JCEDigestUtil.getDigest(((javax.crypto.spec.OAEPParameterSpec) p12).getDigestAlgorithm());
                        if (v0 != null) {
                            java.security.spec.MGF1ParameterSpec v2_1 = ((java.security.spec.MGF1ParameterSpec) ((javax.crypto.spec.OAEPParameterSpec) p12).getMGFParameters());
                            org.spongycastle.crypto.Digest v1 = org.spongycastle.jce.provider.JCEDigestUtil.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) p12).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) p12).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 (p13 == null) {
                    v3_2 = new org.spongycastle.crypto.params.ParametersWithRandom(v4, new java.security.SecureRandom());
                } else {
                    v3_2 = new org.spongycastle.crypto.params.ParametersWithRandom(v4, p13);
                }
            }
            switch (p10) {
                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(p10).append(" passed to RSA").toString());
            }
            return;
        }
    }

Method org.spongycastle.jce.provider.JCEKeyGenerator.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.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 v5;
            org.spongycastle.crypto.params.AsymmetricKeyParameter v4;
            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.jce.provider.asymmetric.ec.ECUtil.generatePublicKeyParameter(((org.spongycastle.jce.interfaces.IESKey) p12).getPublic());
                v4 = org.spongycastle.jce.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.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.jce.provider.JCEPBEKey)) {
                    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_6 = v8_4;
                                                } else {
                                                    v7_6 = new org.spongycastle.crypto.params.ParametersWithRandom(v8_4, p18);
                                                }
                                                try {
                                                    switch (p15) {
                                                        case 1:
                                                        case 3:
                                                            this.cipher.init(1, v7_6);
                                                            return;
                                                        case 2:
                                                        case 4:
                                                            this.cipher.init(0, v7_6);
                                                            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))) {
                                    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 {
                                    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.jce.provider.JCEPBEKey) p16).getOID() == null) {
                        this.pbeAlgorithm = ((org.spongycastle.jce.provider.JCEPBEKey) p16).getAlgorithm();
                    } else {
                        this.pbeAlgorithm = ((org.spongycastle.jce.provider.JCEPBEKey) p16).getOID().getId();
                    }
                    if (((org.spongycastle.jce.provider.JCEPBEKey) 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.jce.provider.PBE$Util.makePBEParameters(((org.spongycastle.jce.provider.JCEPBEKey) p16), p17, this.cipher.getUnderlyingCipher().getAlgorithmName());
                        }
                    } else {
                        v7_1 = ((org.spongycastle.jce.provider.JCEPBEKey) p16).getParam();
                        this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((org.spongycastle.jce.provider.JCEPBEKey) p16).getSalt(), ((org.spongycastle.jce.provider.JCEPBEKey) 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.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.jce.provider.JCEPBEKey)) {
            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.jce.provider.JCEPBEKey) 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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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 net.monius.exchange.interop.cryptography.ECC.generateECKeyPair() calling method java.security.SecureRandom.<init>()


    private org.spongycastle.crypto.AsymmetricCipherKeyPair generateECKeyPair(org.spongycastle.crypto.params.ECDomainParameters p4)
    {
        org.spongycastle.crypto.generators.ECKeyPairGenerator v0_1 = new org.spongycastle.crypto.generators.ECKeyPairGenerator();
        v0_1.init(new org.spongycastle.crypto.params.ECKeyGenerationParameters(p4, new java.security.SecureRandom()));
        return v0_1.generateKeyPair();
    }

Method net.monius.exchange.interop.cryptography.CryptographerEx.generateECKeyPair() calling method java.security.SecureRandom.<init>()


    private org.spongycastle.crypto.AsymmetricCipherKeyPair generateECKeyPair(org.spongycastle.crypto.params.ECDomainParameters p4)
    {
        org.spongycastle.crypto.generators.ECKeyPairGenerator v0_1 = new org.spongycastle.crypto.generators.ECKeyPairGenerator();
        v0_1.init(new org.spongycastle.crypto.params.ECKeyGenerationParameters(p4, new java.security.SecureRandom()));
        return v0_1.generateKeyPair();
    }

Method com.google.android.gms.internal.zzckn.zzban() calling method java.security.SecureRandom.<init>()


    final java.security.SecureRandom zzban()
    {
        this.zzut();
        if (this.zzjgt == null) {
            this.zzjgt = new java.security.SecureRandom();
        }
        return this.zzjgt;
    }

Method com.google.android.gms.internal.zzckn.zzaym() calling method java.security.SecureRandom.<init>()


    protected final void zzaym()
    {
        this.zzut();
        com.google.android.gms.internal.zzcgl v2_5 = new java.security.SecureRandom();
        long v0 = v2_5.nextLong();
        if (v0 == 0) {
            v0 = v2_5.nextLong();
            if (v0 == 0) {
                this.zzawm().zzayt().log("Utils falling back to Random for random id");
            }
        }
        this.zzjgu.set(v0);
        return;
    }