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 uk.co.westhawk.snmp.util.SnmpUtilities.getSaltDES() calling method java.util.Random.<init>()


    public static final byte[] getSaltDES(int p4)
    {
        if (uk.co.westhawk.snmp.util.SnmpUtilities.salt_count == -1) {
            uk.co.westhawk.snmp.util.SnmpUtilities.salt_count = new java.util.Random().nextInt();
        }
        byte[] v1 = new byte[8];
        uk.co.westhawk.snmp.util.SnmpUtilities.setBytesFromInt(v1, p4, 0);
        uk.co.westhawk.snmp.util.SnmpUtilities.setBytesFromInt(v1, uk.co.westhawk.snmp.util.SnmpUtilities.salt_count, 4);
        uk.co.westhawk.snmp.util.SnmpUtilities.salt_count = (uk.co.westhawk.snmp.util.SnmpUtilities.salt_count + 1);
        return v1;
    }

Method org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialField.getRandomRoot() calling method java.util.Random.<init>()


    protected org.spongycastle.pqc.math.linearalgebra.GF2nElement getRandomRoot(org.spongycastle.pqc.math.linearalgebra.GF2Polynomial p12)
    {
        org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial v1_1 = new org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial(p12, this);
        int v2_1 = v1_1.getDegree();
        while (v2_1 > 1) {
            while(true) {
                org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement v6_1 = new org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement(this, new java.util.Random());
                org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial v7_1 = new org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial(2, org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement.ZERO(this));
                v7_1.set(1, v6_1);
                org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial v0_1 = new org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial(v7_1);
                int v5 = 1;
                if (v5 <= (this.mDegree - 1)) {
                    break;
                }
                org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial v3 = v0_1.gcd(v1_1);
                int v4 = v3.getDegree();
                int v2_0 = v1_1.getDegree();
                if ((v4 != 0) && (v4 != v2_0)) {
                    if ((v4 << 1) <= v2_0) {
                        v1_1 = new org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial(v3);
                    } else {
                        v1_1 = v1_1.quotient(v3);
                    }
                    v2_1 = v1_1.getDegree();
                }
            }
            v0_1 = v0_1.multiplyAndReduce(v0_1, v1_1).add(v7_1);
            v5++;
            while (v5 > (this.mDegree - 1)) {
            }
        }
        return v1_1.at(0);
    }

Method org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement.solveQuadraticEquation() calling method java.util.Random.<init>()


    public org.spongycastle.pqc.math.linearalgebra.GF2nElement solveQuadraticEquation()
    {
        org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement v3;
        if (!this.isZero()) {
            if ((this.mDegree & 1) == 1) {
                v3 = this.halfTrace();
                return v3;
            }
            do {
                org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement v1_0 = new org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement(((org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialField) this.mField), new java.util.Random());
                v3 = org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement.ZERO(((org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialField) this.mField));
                org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement v2_1 = ((org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement) v1_0.clone());
                int v0 = 1;
                if (v0 >= this.mDegree) {
                } else {
                    v3.squareThis();
                    v2_1.squareThis();
                    v3.addToThis(v2_1.multiply(this));
                    v2_1.addToThis(v1_0);
                    v0++;
                    while (v0 < this.mDegree) {
                    }
                }
            } while(v2_1.isZero());
            if (!this.equals(v3.square().add(v3))) {
                throw new RuntimeException();
            }
        } else {
            v3 = org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialElement.ZERO(((org.spongycastle.pqc.math.linearalgebra.GF2nPolynomialField) this.mField));
        }
        return v3;
    }

Method org.spongycastle.pqc.math.linearalgebra.GF2nONBField.getRandomRoot() calling method java.util.Random.<init>()


    protected org.spongycastle.pqc.math.linearalgebra.GF2nElement getRandomRoot(org.spongycastle.pqc.math.linearalgebra.GF2Polynomial p12)
    {
        org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial v1_1 = new org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial(p12, this);
        int v2_1 = v1_1.getDegree();
        while (v2_1 > 1) {
            do {
                org.spongycastle.pqc.math.linearalgebra.GF2nONBElement v6_1 = new org.spongycastle.pqc.math.linearalgebra.GF2nONBElement(this, new java.util.Random());
                org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial v7_1 = new org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial(2, org.spongycastle.pqc.math.linearalgebra.GF2nONBElement.ZERO(this));
                v7_1.set(1, v6_1);
                org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial v0_1 = new org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial(v7_1);
                int v5 = 1;
                if (v5 > (this.mDegree - 1)) {
                    org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial v3 = v0_1.gcd(v1_1);
                    int v4 = v3.getDegree();
                    int v2_0 = v1_1.getDegree();
                } else {
                    v0_1 = v0_1.multiplyAndReduce(v0_1, v1_1).add(v7_1);
                    v5++;
                    while (v5 <= (this.mDegree - 1)) {
                    }
                }
            } while((v4 == 0) || (v4 == v2_0));
            if ((v4 << 1) <= v2_0) {
                v1_1 = new org.spongycastle.pqc.math.linearalgebra.GF2nPolynomial(v3);
            } else {
                v1_1 = v1_1.quotient(v3);
            }
            v2_1 = v1_1.getDegree();
        }
        return v1_1.at(0);
    }

Method org.spongycastle.pqc.math.linearalgebra.GF2nONBField.elementOfOrder() calling method java.util.Random.<init>()


    private int elementOfOrder(int p7, int p8)
    {
        java.util.Random v4_1 = new java.util.Random();
        int v2_0 = 0;
        while (v2_0 == 0) {
            v2_0 = (v4_1.nextInt() % (p8 - 1));
            if (v2_0 < 0) {
                v2_0 += (p8 - 1);
            }
        }
        int v1_1 = org.spongycastle.pqc.math.linearalgebra.IntegerFunctions.order(v2_0, p8);
        while (((v1_1 % p7) != 0) || (v1_1 == 0)) {
            while (v2_0 == 0) {
                v2_0 = (v4_1.nextInt() % (p8 - 1));
                if (v2_0 < 0) {
                    v2_0 += (p8 - 1);
                }
            }
            v1_1 = org.spongycastle.pqc.math.linearalgebra.IntegerFunctions.order(v2_0, p8);
        }
        int v3 = v2_0;
        int v0 = 2;
        while (v0 <= (p7 / v1_1)) {
            v3 *= v2_0;
            v0++;
        }
        return v3;
    }

Method org.spongycastle.pqc.math.linearalgebra.GF2Polynomial.<clinit>() calling method java.util.Random.<init>()


    static GF2Polynomial()
    {
        org.spongycastle.pqc.math.linearalgebra.GF2Polynomial.rand = new java.util.Random();
        int[] v0_4 = new boolean[256];
        v0_4 = {0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0};
        org.spongycastle.pqc.math.linearalgebra.GF2Polynomial.parity = v0_4;
        int[] v0_5 = new short[256];
        v0_5 = {0, 1, 4, 5, 16, 17, 20, 21, 64, 65, 68, 69, 80, 81, 84, 85, 256, 257, 260, 261, 272, 273, 276, 277, 320, 321, 324, 325, 336, 337, 340, 341, 1024, 1025, 1028, 1029, 1040, 1041, 1044, 1045, 1088, 1089, 1092, 1093, 1104, 1105, 1108, 1109, 1280, 1281, 1284, 1285, 1296, 1297, 1300, 1301, 1344, 1345, 1348, 1349, 1360, 1361, 1364, 1365, 4096, 4097, 4100, 4101, 4112, 4113, 4116, 4117, 4160, 4161, 4164, 4165, 4176, 4177, 4180, 4181, 4352, 4353, 4356, 4357, 4368, 4369, 4372, 4373, 4416, 4417, 4420, 4421, 4432, 4433, 4436, 4437, 5120, 5121, 5124, 5125, 5136, 5137, 5140, 5141, 5184, 5185, 5188, 5189, 5200, 5201, 5204, 5205, 5376, 5377, 5380, 5381, 5392, 5393, 5396, 5397, 5440, 5441, 5444, 5445, 5456, 5457, 5460, 5461, 16384, 16385, 16388, 16389, 16400, 16401, 16404, 16405, 16448, 16449, 16452, 16453, 16464, 16465, 16468, 16469, 16640, 16641, 16644, 16645, 16656, 16657, 16660, 16661, 16704, 16705, 16708, 16709, 16720, 16721, 16724, 16725, 17408, 17409, 17412, 17413, 17424, 17425, 17428, 17429, 17472, 17473, 17476, 17477, 17488, 17489, 17492, 17493, 17664, 17665, 17668, 17669, 17680, 17681, 17684, 17685, 17728, 17729, 17732, 17733, 17744, 17745, 17748, 17749, 20480, 20481, 20484, 20485, 20496, 20497, 20500, 20501, 20544, 20545, 20548, 20549, 20560, 20561, 20564, 20565, 20736, 20737, 20740, 20741, 20752, 20753, 20756, 20757, 20800, 20801, 20804, 20805, 20816, 20817, 20820, 20821, 21504, 21505, 21508, 21509, 21520, 21521, 21524, 21525, 21568, 21569, 21572, 21573, 21584, 21585, 21588, 21589, 21760, 21761, 21764, 21765, 21776, 21777, 21780, 21781, 21824, 21825, 21828, 21829, 21840, 21841, 21844, 21845};
        org.spongycastle.pqc.math.linearalgebra.GF2Polynomial.squaringTable = v0_5;
        int[] v0_0 = new int[33];
        v0_0 = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, -2147483648, 0};
        org.spongycastle.pqc.math.linearalgebra.GF2Polynomial.bitMask = v0_0;
        int[] v0_1 = new int[33];
        v0_1 = {0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575, 2097151, 4194303, 8388607, 16777215, 33554431, 67108863, 134217727, 268435455, 536870911, 1073741823, 2147483647, -1};
        org.spongycastle.pqc.math.linearalgebra.GF2Polynomial.reverseRightMask = v0_1;
        return;
    }

Method org.spongycastle.math.raw.Mod.random() calling method java.util.Random.<init>()


    public static int[] random(int[] p7)
    {
        int v1 = p7.length;
        java.util.Random v3_1 = new java.util.Random();
        int[] v4 = org.spongycastle.math.raw.Nat.create(v1);
        int v2_4 = p7[(v1 - 1)];
        int v2_5 = (v2_4 | (v2_4 >> 1));
        int v2_0 = (v2_5 | (v2_5 >> 2));
        int v2_1 = (v2_0 | (v2_0 >> 4));
        int v2_2 = (v2_1 | (v2_1 >> 8));
        int v2_3 = (v2_2 | (v2_2 >> 16));
        do {
            int v0 = 0;
            if (v0 == v1) {
                boolean v5_3 = (v1 - 1);
                v4[v5_3] = (v4[v5_3] & v2_3);
            } else {
                v4[v0] = v3_1.nextInt();
                v0++;
                while (v0 != v1) {
                }
            }
        } while(org.spongycastle.math.raw.Nat.gte(v1, v4, p7));
        return v4;
    }

Method org.spongycastle.math.ec.custom.sec.SecT571R1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            do {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(571, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 571) {
                    if (v4.isZero()) {
                    } else {
                        p12 = 0;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 571) {
                    }
                }
            } while(v6.square().add(v6).isZero());
            p12 = v6;
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT571K1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            do {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(571, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 571) {
                    if (v4.isZero()) {
                    } else {
                        p12 = 0;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 571) {
                    }
                }
            } while(v6.square().add(v6).isZero());
            p12 = v6;
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT409R1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(409, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 409) {
                    if (v4.isZero()) {
                        break;
                    }
                    p12 = 0;
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 409) {
                    }
                }
            }
            if (!v6.square().add(v6).isZero()) {
                p12 = v6;
            }
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT409K1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(409, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 409) {
                    if (v4.isZero()) {
                        break;
                    }
                    p12 = 0;
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 409) {
                    }
                }
            }
            if (!v6.square().add(v6).isZero()) {
                p12 = v6;
            }
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT283R1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(283, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 283) {
                    if (!v4.isZero()) {
                        break;
                    }
                    if (!v6.square().add(v6).isZero()) {
                        p12 = v6;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 283) {
                    }
                }
            }
            p12 = 0;
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT283K1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            do {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(283, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 283) {
                    if (v4.isZero()) {
                    } else {
                        p12 = 0;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 283) {
                    }
                }
            } while(v6.square().add(v6).isZero());
            p12 = v6;
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT239K1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(239, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 239) {
                    if (!v4.isZero()) {
                        break;
                    }
                    if (!v6.square().add(v6).isZero()) {
                        p12 = v6;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 239) {
                    }
                }
            }
            p12 = 0;
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT233R1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(233, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 233) {
                    if (v4.isZero()) {
                        break;
                    }
                    p12 = 0;
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 233) {
                    }
                }
            }
            if (!v6.square().add(v6).isZero()) {
                p12 = v6;
            }
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT233K1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(233, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 233) {
                    if (v4.isZero()) {
                        break;
                    }
                    p12 = 0;
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 233) {
                    }
                }
            }
            if (!v6.square().add(v6).isZero()) {
                p12 = v6;
            }
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT193R2Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(193, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 193) {
                    if (v4.isZero()) {
                        break;
                    }
                    p12 = 0;
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 193) {
                    }
                }
            }
            if (!v6.square().add(v6).isZero()) {
                p12 = v6;
            }
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT193R1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(193, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 193) {
                    if (!v4.isZero()) {
                        break;
                    }
                    if (!v6.square().add(v6).isZero()) {
                        p12 = v6;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 193) {
                    }
                }
            }
            p12 = 0;
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT163R2Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(163, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 163) {
                    if (!v4.isZero()) {
                        break;
                    }
                    if (!v6.square().add(v6).isZero()) {
                        p12 = v6;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 163) {
                    }
                }
            }
            p12 = 0;
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT163R1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(163, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 163) {
                    if (!v4.isZero()) {
                        break;
                    }
                    if (!v6.square().add(v6).isZero()) {
                        p12 = v6;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 163) {
                    }
                }
            }
            p12 = 0;
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT163K1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            do {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(163, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 163) {
                    if (v4.isZero()) {
                    } else {
                        p12 = 0;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 163) {
                    }
                }
            } while(v6.square().add(v6).isZero());
            p12 = v6;
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT131R1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(131, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 131) {
                    if (v4.isZero()) {
                        break;
                    }
                    p12 = 0;
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 131) {
                    }
                }
            }
            if (!v6.square().add(v6).isZero()) {
                p12 = v6;
            }
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT113R2Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(113, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 113) {
                    if (!v4.isZero()) {
                        break;
                    }
                    if (!v6.square().add(v6).isZero()) {
                        p12 = v6;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 113) {
                    }
                }
            }
            p12 = 0;
        }
        return p12;
    }

Method org.spongycastle.math.ec.custom.sec.SecT113R1Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(113, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 113) {
                    if (v4.isZero()) {
                        break;
                    }
                    p12 = 0;
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 113) {
                    }
                }
            }
            if (!v6.square().add(v6).isZero()) {
                p12 = v6;
            }
        }
        return p12;
    }

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


    public org.spongycastle.math.ec.ECFieldElement sqrt()
    {
        if ((!this.isZero()) && (!this.isOne())) {
            if (this.q.testBit(0)) {
                if (!this.q.testBit(1)) {
                    if (!this.q.testBit(2)) {
                        java.math.BigInteger v11 = this.q.shiftRight(1);
                        if (this.x.modPow(v11, this.q).equals(org.spongycastle.math.ec.ECConstants.ONE)) {
                            java.math.BigInteger v7 = this.x;
                            java.math.BigInteger v9 = this.modDouble(this.modDouble(v7));
                            java.math.BigInteger v10 = v11.add(org.spongycastle.math.ec.ECConstants.ONE);
                            java.math.BigInteger v12 = this.q.subtract(org.spongycastle.math.ec.ECConstants.ONE);
                            java.util.Random v13_1 = new java.util.Random();
                            do {
                                java.math.BigInteger v4_1 = new java.math.BigInteger(this.q.bitLength(), v13_1);
                                if ((v4_1.compareTo(this.q) < 0) && (this.modReduce(v4_1.multiply(v4_1).subtract(v9)).modPow(v11, this.q).equals(v12))) {
                                    java.math.BigInteger[] v14 = this.lucasSequence(v4_1, v7, v10);
                                    java.math.BigInteger v5 = v14[0];
                                    java.math.BigInteger v6 = v14[1];
                                    if (!this.modMult(v6, v6).equals(v9)) {
                                    } else {
                                        this = new org.spongycastle.math.ec.ECFieldElement$Fp(this.q, this.r, this.modHalfAbs(v6));
                                    }
                                }
                            } while((v5.equals(org.spongycastle.math.ec.ECConstants.ONE)) || (v5.equals(v12)));
                            this = 0;
                        } else {
                            this = 0;
                        }
                    } else {
                        java.math.BigInteger v15 = this.x.modPow(this.q.shiftRight(3), this.q);
                        java.math.BigInteger v16 = this.modMult(v15, this.x);
                        if (!this.modMult(v16, v15).equals(org.spongycastle.math.ec.ECConstants.ONE)) {
                            boolean v20_19 = new org.spongycastle.math.ec.ECFieldElement$Fp;
                            v20_19(this.q, this.r, this.modMult(v16, org.spongycastle.math.ec.ECConstants.TWO.modPow(this.q.shiftRight(2), this.q)));
                            this = this.checkSqrt(v20_19);
                        } else {
                            boolean v20_20 = new org.spongycastle.math.ec.ECFieldElement$Fp;
                            v20_20(this.q, this.r, v16);
                            this = this.checkSqrt(v20_20);
                        }
                    }
                } else {
                    this = this.checkSqrt(new org.spongycastle.math.ec.ECFieldElement$Fp(this.q, this.r, this.x.modPow(this.q.shiftRight(2).add(org.spongycastle.math.ec.ECConstants.ONE), this.q)));
                }
            } else {
                throw new RuntimeException("not done yet");
            }
        }
        return this;
    }

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


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p11)
    {
        if (!p11.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_1 = new java.util.Random();
            while(true) {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(this.m, v2_1));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p11;
                int v1 = 1;
                if (v1 >= this.m) {
                    if (v4.isZero()) {
                        break;
                    }
                    p11 = 0;
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p11);
                    v1++;
                    while (v1 < this.m) {
                    }
                }
            }
            if (!v6.square().add(v6).isZero()) {
                p11 = v6;
            }
        }
        return p11;
    }

Method org.spongycastle.asn1.ua.DSTU4145PointEncoder.solveQuadraticEquation() calling method java.util.Random.<init>()


    private static org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECCurve p11, org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v8 = p11.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v3_1 = new java.util.Random();
            int v2 = p12.getFieldSize();
            do {
                org.spongycastle.math.ec.ECFieldElement v4 = p11.fromBigInteger(new java.math.BigInteger(v2, v3_1));
                org.spongycastle.math.ec.ECFieldElement v7 = v8;
                org.spongycastle.math.ec.ECFieldElement v5 = p12;
                int v1 = 1;
                if (v1 > (v2 - 1)) {
                    if (v5.isZero()) {
                    } else {
                        p12 = 0;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v6 = v5.square();
                    v7 = v7.square().add(v6.multiply(v4));
                    v5 = v6.add(p12);
                    v1++;
                    while (v1 <= (v2 - 1)) {
                    }
                }
            } while(v7.square().add(v7).isZero());
            p12 = v7;
        }
        return p12;
    }

Method org.apache.http.entity.mime.MultipartEntityBuilder.generateBoundary() calling method java.util.Random.<init>()


    private String generateBoundary()
    {
        StringBuilder v0_1 = new StringBuilder();
        java.util.Random v3_1 = new java.util.Random();
        int v1 = (v3_1.nextInt(11) + 30);
        int v2 = 0;
        while (v2 < v1) {
            v0_1.append(org.apache.http.entity.mime.MultipartEntityBuilder.MULTIPART_CHARS[v3_1.nextInt(org.apache.http.entity.mime.MultipartEntityBuilder.MULTIPART_CHARS.length)]);
            v2++;
        }
        return v0_1.toString();
    }

Method org.apache.http.entity.mime.MultipartEntity.generateBoundary() calling method java.util.Random.<init>()


    protected String generateBoundary()
    {
        StringBuilder v0_1 = new StringBuilder();
        java.util.Random v3_1 = new java.util.Random();
        int v1 = (v3_1.nextInt(11) + 30);
        int v2 = 0;
        while (v2 < v1) {
            v0_1.append(org.apache.http.entity.mime.MultipartEntity.MULTIPART_CHARS[v3_1.nextInt(org.apache.http.entity.mime.MultipartEntity.MULTIPART_CHARS.length)]);
            v2++;
        }
        return v0_1.toString();
    }

Method org.apache.commons.net.ftp.FTPClient.<init>() calling method java.util.Random.<init>()


    public FTPClient()
    {
        this.__controlKeepAliveReplyTimeout = 1000;
        this.__autodetectEncoding = 0;
        this.__initDefaults();
        this.__dataTimeout = -1;
        this.__remoteVerificationEnabled = 1;
        this.__parserFactory = new org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory();
        this.__configuration = 0;
        this.__listHiddenFiles = 0;
        this.__useEPSVwithIPv4 = 0;
        this.__random = new java.util.Random();
        return;
    }

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


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

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


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

Method org.spongycastle.jcajce.provider.keystore.bc.BcKeyStoreSpi$StoreEntry.<init>() calling method java.security.SecureRandom.setSeed()


    BcKeyStoreSpi$StoreEntry(org.spongycastle.jcajce.provider.keystore.bc.BcKeyStoreSpi 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.jcajce.provider.keystore.bc.BcKeyStoreSpi.access$000(p11, p13, v9_3);
        v9_3.close();
        this.obj = v6_1.toByteArray();
        return;
    }

Method org.spongycastle.crypto.prng.X931SecureRandom.setSeed() calling method java.security.SecureRandom.setSeed()


    public void setSeed(byte[] p2)
    {
        try {
            if (this.randomSource != null) {
                this.randomSource.setSeed(p2);
            }
        } catch (java.security.SecureRandom v0_2) {
            throw v0_2;
        }
        return;
    }

Method org.spongycastle.crypto.prng.X931SecureRandom.setSeed() calling method java.security.SecureRandom.setSeed()


    public void setSeed(long p2)
    {
        try {
            if (this.randomSource != null) {
                this.randomSource.setSeed(p2);
            }
        } catch (java.security.SecureRandom v0_2) {
            throw v0_2;
        }
        return;
    }

Method org.spongycastle.crypto.prng.SP800SecureRandom.setSeed() calling method java.security.SecureRandom.setSeed()


    public void setSeed(byte[] p2)
    {
        try {
            if (this.randomSource != null) {
                this.randomSource.setSeed(p2);
            }
        } catch (java.security.SecureRandom v0_2) {
            throw v0_2;
        }
        return;
    }

Method org.spongycastle.crypto.prng.SP800SecureRandom.setSeed() calling method java.security.SecureRandom.setSeed()


    public void setSeed(long p2)
    {
        try {
            if (this.randomSource != null) {
                this.randomSource.setSeed(p2);
            }
        } catch (java.security.SecureRandom v0_2) {
            throw v0_2;
        }
        return;
    }

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


    public DESExample(String p16, String p17, String p18, boolean p19)
    {
        this.encrypt = 1;
        this.cipher = 0;
        this.in = 0;
        this.out = 0;
        this.key = 0;
        this.encrypt = p19;
        try {
            this.in = new java.io.BufferedInputStream(new java.io.FileInputStream(p16));
            try {
                this.out = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p17));
            } catch (java.io.IOException v2) {
                System.err.println(new StringBuilder().append("Output file not created [").append(p17).append("]").toString());
                System.exit(1);
            }
            if (!p19) {
                try {
                    java.io.BufferedOutputStream v5_3 = new java.io.BufferedInputStream(new java.io.FileInputStream(p18));
                    int v8 = v5_3.available();
                    byte[] v4_1 = new byte[v8];
                    v5_3.read(v4_1, 0, v8);
                    this.key = org.spongycastle.util.encoders.Hex.decode(v4_1);
                } catch (java.io.IOException v3) {
                    System.err.println(new StringBuilder().append("Decryption key file not found, or not valid [").append(p18).append("]").toString());
                    System.exit(1);
                }
            } else {
                java.security.SecureRandom v10 = 0;
                try {
                    java.security.SecureRandom v11_1 = new java.security.SecureRandom();
                    try {
                        v11_1.setSeed("www.bouncycastle.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 uk.co.westhawk.snmp.util.SnmpUtilities.getSaltAES() calling method java.security.SecureRandom.<init>()


    public static byte[] getSaltAES()
    {
        if (uk.co.westhawk.snmp.util.SnmpUtilities.asalt != 0) {
            uk.co.westhawk.snmp.util.SnmpUtilities.asalt = (uk.co.westhawk.snmp.util.SnmpUtilities.asalt + 1);
        } else {
            uk.co.westhawk.snmp.util.SnmpUtilities.asalt = new java.security.SecureRandom().nextLong();
        }
        byte[] v1 = new byte[8];
        uk.co.westhawk.snmp.util.SnmpUtilities.setBytesFromLong(v1, uk.co.westhawk.snmp.util.SnmpUtilities.asalt, 0);
        return v1;
    }

Method org.spongycastle.pqc.jcajce.provider.rainbow.RainbowKeyPairGeneratorSpi.<init>() calling method java.security.SecureRandom.<init>()


    public RainbowKeyPairGeneratorSpi()
    {
        super("Rainbow");
        super.engine = new org.spongycastle.pqc.crypto.rainbow.RainbowKeyPairGenerator();
        super.strength = 1024;
        super.random = new java.security.SecureRandom();
        super.initialised = 0;
        return;
    }

Method org.spongycastle.pqc.jcajce.provider.util.AsymmetricBlockCipher.initEncrypt() calling method java.security.SecureRandom.<init>()


    public final void initEncrypt(java.security.Key p2, java.security.spec.AlgorithmParameterSpec p3)
    {
        this.initEncrypt(p2, p3, new java.security.SecureRandom());
        return;
    }

Method org.spongycastle.pqc.jcajce.provider.util.AsymmetricBlockCipher.initEncrypt() calling method java.security.SecureRandom.<init>()


    public final void initEncrypt(java.security.Key p4)
    {
        try {
            this.initEncrypt(p4, 0, new java.security.SecureRandom());
            return;
        } catch (java.security.InvalidAlgorithmParameterException v0) {
            throw new java.security.InvalidParameterException("This cipher needs algorithm parameters for initialization (cannot be null).");
        }
    }

Method org.spongycastle.pqc.jcajce.provider.mceliece.McElieceKeyPairGeneratorSpi$McElieceCCA2.initialize() calling method java.security.SecureRandom.<init>()


    public void initialize(java.security.spec.AlgorithmParameterSpec p7)
    {
        this.kpg = new org.spongycastle.pqc.crypto.mceliece.McElieceCCA2KeyPairGenerator();
        super.initialize(p7);
        this.kpg.init(new org.spongycastle.pqc.crypto.mceliece.McElieceCCA2KeyGenerationParameters(new java.security.SecureRandom(), new org.spongycastle.pqc.crypto.mceliece.McElieceCCA2Parameters(((org.spongycastle.pqc.jcajce.spec.ECCKeyGenParameterSpec) p7).getM(), ((org.spongycastle.pqc.jcajce.spec.ECCKeyGenParameterSpec) p7).getT())));
        return;
    }

Method org.spongycastle.pqc.jcajce.provider.mceliece.McElieceKeyPairGeneratorSpi$McEliece.initialize() calling method java.security.SecureRandom.<init>()


    public void initialize(java.security.spec.AlgorithmParameterSpec p7)
    {
        this.kpg = new org.spongycastle.pqc.crypto.mceliece.McElieceKeyPairGenerator();
        super.initialize(p7);
        this.kpg.init(new org.spongycastle.pqc.crypto.mceliece.McElieceKeyGenerationParameters(new java.security.SecureRandom(), new org.spongycastle.pqc.crypto.mceliece.McElieceParameters(((org.spongycastle.pqc.jcajce.spec.ECCKeyGenParameterSpec) p7).getM(), ((org.spongycastle.pqc.jcajce.spec.ECCKeyGenParameterSpec) p7).getT())));
        return;
    }

Method org.spongycastle.pqc.jcajce.provider.util.AsymmetricHybridCipher.initEncrypt() calling method java.security.SecureRandom.<init>()


    public final void initEncrypt(java.security.Key p2, java.security.spec.AlgorithmParameterSpec p3)
    {
        this.initEncrypt(p2, p3, new java.security.SecureRandom());
        return;
    }

Method org.spongycastle.pqc.jcajce.provider.util.AsymmetricHybridCipher.initEncrypt() calling method java.security.SecureRandom.<init>()


    public final void initEncrypt(java.security.Key p4)
    {
        try {
            this.initEncrypt(p4, 0, new java.security.SecureRandom());
            return;
        } catch (java.security.InvalidAlgorithmParameterException v0) {
            throw new java.security.InvalidParameterException("This cipher needs algorithm parameters for initialization (cannot be null).");
        }
    }

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


    public org.spongycastle.operator.OutputEncryptor build(char[] p13)
    {
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        byte[] v6 = new byte[20];
        this.random.nextBytes(v6);
        try {
            javax.crypto.Cipher v1;
            org.spongycastle.asn1.x509.AlgorithmIdentifier v3_1;
            if (!this.algorithm.on(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.pkcs_12PbeIds)) {
                if (!this.algorithm.equals(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_PBES2)) {
                    throw new org.spongycastle.operator.OperatorCreationException("unrecognised algorithm");
                } else {
                    javax.crypto.SecretKey v4 = this.helper.createSecretKeyFactory(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_PBKDF2.getId()).generateSecret(new javax.crypto.spec.PBEKeySpec(p13, v6, this.iterationCount, this.keySizeProvider.getKeySize(new org.spongycastle.asn1.x509.AlgorithmIdentifier(this.keyEncAlgorithm))));
                    v1 = this.helper.createCipher(this.keyEncAlgorithm.getId());
                    v1.init(1, v4, this.random);
                    v3_1 = new org.spongycastle.asn1.x509.AlgorithmIdentifier(this.algorithm, new org.spongycastle.asn1.pkcs.PBES2Parameters(new org.spongycastle.asn1.pkcs.KeyDerivationFunc(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_PBKDF2, new org.spongycastle.asn1.pkcs.PBKDF2Params(v6, this.iterationCount)), new org.spongycastle.asn1.pkcs.EncryptionScheme(this.keyEncAlgorithm, org.spongycastle.asn1.ASN1Primitive.fromByteArray(v1.getParameters().getEncoded()))));
                }
            } else {
                v1 = this.helper.createCipher(this.algorithm.getId());
                v1.init(1, new org.spongycastle.jcajce.PKCS12KeyWithParameters(p13, v6, this.iterationCount));
                v3_1 = new org.spongycastle.asn1.x509.AlgorithmIdentifier(this.algorithm, new org.spongycastle.asn1.pkcs.PKCS12PBEParams(v6, this.iterationCount));
            }
        } catch (Exception v2) {
            throw new org.spongycastle.operator.OperatorCreationException(new StringBuilder().append("unable to create OutputEncryptor: ").append(v2.getMessage()).toString(), v2);
        }
        return new org.spongycastle.pkcs.jcajce.JcePKCSPBEOutputEncryptorBuilder$1(this, v3_1, v1, p13);
    }

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


    public org.spongycastle.operator.MacCalculator build(char[] p9)
    {
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        try {
            javax.crypto.Mac v3 = this.helper.createMac(this.algorithm.getId());
            this.saltLength = v3.getMacLength();
            byte[] v4 = new byte[this.saltLength];
            this.random.nextBytes(v4);
            javax.crypto.spec.PBEParameterSpec v0_1 = new javax.crypto.spec.PBEParameterSpec(v4, this.iterationCount);
            org.spongycastle.jcajce.PKCS12Key v2_1 = new org.spongycastle.jcajce.PKCS12Key(p9);
            v3.init(v2_1, v0_1);
            return new org.spongycastle.pkcs.jcajce.JcePKCS12MacCalculatorBuilder$1(this, v4, v3, v2_1);
        } catch (Exception v1) {
            throw new org.spongycastle.operator.OperatorCreationException(new StringBuilder().append("unable to create MAC calculator: ").append(v1.getMessage()).toString(), v1);
        }
    }

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


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

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


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

Method org.spongycastle.openssl.jcajce.JcePEMEncryptorBuilder.build() calling method java.security.SecureRandom.<init>()


    public org.spongycastle.openssl.PEMEncryptor build(char[] p5)
    {
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        int v1;
        if (!this.algorithm.startsWith("AES-")) {
            v1 = 8;
        } else {
            v1 = 16;
        }
        byte[] v0 = new byte[v1];
        this.random.nextBytes(v0);
        return new org.spongycastle.openssl.jcajce.JcePEMEncryptorBuilder$1(this, v0, p5);
    }

Method org.spongycastle.openssl.jcajce.JceOpenSSLPKCS8EncryptorBuilder.build() calling method java.security.SecureRandom.<init>()


    public org.spongycastle.operator.OutputEncryptor build()
    {
        org.spongycastle.operator.OperatorCreationException v5_1 = new byte[20];
        this.salt = v5_1;
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(this.salt);
        try {
            this.cipher = this.helper.createCipher(this.algOID.getId());
        } catch (java.security.GeneralSecurityException v1_2) {
            throw new org.spongycastle.operator.OperatorCreationException(new StringBuilder().append(this.algOID).append(" not available: ").append(v1_2.getMessage()).toString(), v1_2);
        }
        if (org.spongycastle.openssl.jcajce.PEMUtilities.isPKCS5Scheme2(this.algOID)) {
            this.paramGen = this.helper.createAlgorithmParameterGenerator(this.algOID.getId());
        }
        org.spongycastle.asn1.x509.AlgorithmIdentifier v0_1;
        if (!org.spongycastle.openssl.jcajce.PEMUtilities.isPKCS5Scheme2(this.algOID)) {
            if (!org.spongycastle.openssl.jcajce.PEMUtilities.isPKCS12(this.algOID)) {
                throw new org.spongycastle.operator.OperatorCreationException(new StringBuilder().append("unknown algorithm: ").append(this.algOID).toString(), 0);
            } else {
                org.spongycastle.asn1.ASN1EncodableVector v4_3 = new org.spongycastle.asn1.ASN1EncodableVector();
                v4_3.add(new org.spongycastle.asn1.DEROctetString(this.salt));
                v4_3.add(new org.spongycastle.asn1.ASN1Integer(((long) this.iterationCount)));
                v0_1 = new org.spongycastle.asn1.x509.AlgorithmIdentifier(this.algOID, org.spongycastle.asn1.pkcs.PKCS12PBEParams.getInstance(new org.spongycastle.asn1.DERSequence(v4_3)));
                try {
                    this.cipher.init(1, new org.spongycastle.jcajce.PKCS12KeyWithParameters(this.password, this.salt, this.iterationCount));
                } catch (java.security.GeneralSecurityException v1_3) {
                    throw new org.spongycastle.operator.OperatorCreationException(v1_3.getMessage(), v1_3);
                }
            }
        } else {
            this.params = this.paramGen.generateParameters();
            try {
                org.spongycastle.asn1.pkcs.KeyDerivationFunc v3_1 = new org.spongycastle.asn1.pkcs.KeyDerivationFunc(this.algOID, org.spongycastle.asn1.ASN1Primitive.fromByteArray(this.params.getEncoded()));
                org.spongycastle.asn1.pkcs.KeyDerivationFunc v2_1 = new org.spongycastle.asn1.pkcs.KeyDerivationFunc(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_PBKDF2, new org.spongycastle.asn1.pkcs.PBKDF2Params(this.salt, this.iterationCount));
                org.spongycastle.asn1.ASN1EncodableVector v4_1 = new org.spongycastle.asn1.ASN1EncodableVector();
                v4_1.add(v2_1);
                v4_1.add(v3_1);
                v0_1 = new org.spongycastle.asn1.x509.AlgorithmIdentifier(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_PBES2, org.spongycastle.asn1.pkcs.PBES2Parameters.getInstance(new org.spongycastle.asn1.DERSequence(v4_1)));
                try {
                    this.key = org.spongycastle.openssl.jcajce.PEMUtilities.generateSecretKeyForPKCS5Scheme2(this.helper, this.algOID.getId(), this.password, this.salt, this.iterationCount);
                    this.cipher.init(1, this.key, this.params);
                } catch (java.security.GeneralSecurityException v1_1) {
                    throw new org.spongycastle.operator.OperatorCreationException(v1_1.getMessage(), v1_1);
                }
            } catch (java.security.GeneralSecurityException v1_0) {
                throw new org.spongycastle.operator.OperatorCreationException(v1_0.getMessage(), v1_0);
            }
        }
        return new org.spongycastle.openssl.jcajce.JceOpenSSLPKCS8EncryptorBuilder$1(this, v0_1);
    }

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


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

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


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[32];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = this.createParametersInstance("Shacal2");
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.SM4$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 = this.createParametersInstance("SM4");
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

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


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

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


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

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


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

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


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        java.security.AlgorithmParameters v2;
        if (this.spec != null) {
            try {
                v2 = this.createParametersInstance("RC2");
                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 = this.createParametersInstance("RC2");
                v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            } catch (Exception v0_0) {
                throw new RuntimeException(v0_0.getMessage());
            }
        }
        return v2;
    }

Method org.spongycastle.jcajce.provider.symmetric.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 = this.createParametersInstance("Noekeon");
            v2.init(new javax.crypto.spec.IvParameterSpec(v1));
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

Method org.spongycastle.jcajce.provider.symmetric.util.BaseStreamCipher.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)) {
            org.spongycastle.crypto.params.ParametersWithIV v12_0;
            if (!(p16 instanceof org.spongycastle.jcajce.PKCS12Key)) {
                if (!(p16 instanceof org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey)) {
                    if (p17 != null) {
                        if (!(p17 instanceof javax.crypto.spec.IvParameterSpec)) {
                            throw new java.security.InvalidAlgorithmParameterException("unknown parameter type.");
                        } else {
                            v12_0 = 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) v12_0);
                        }
                    } else {
                        if (this.digest <= 0) {
                            v12_0 = new org.spongycastle.crypto.params.KeyParameter(p16.getEncoded());
                        } else {
                            throw new java.security.InvalidKeyException("Algorithm requires a PBE key");
                        }
                    }
                } else {
                    if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getOID() == null) {
                        this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getAlgorithm();
                    } else {
                        this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getOID().getId();
                    }
                    if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getParam() == null) {
                        if (!(p17 instanceof javax.crypto.spec.PBEParameterSpec)) {
                            throw new java.security.InvalidAlgorithmParameterException("PBE requires PBE parameters to be set.");
                        } else {
                            v12_0 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16), p17, this.cipher.getAlgorithmName());
                            this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p17);
                        }
                    } else {
                        v12_0 = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getParam();
                        this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getSalt(), ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getIterationCount());
                    }
                    if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p16).getIvSize() != 0) {
                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v12_0);
                    }
                }
            } else {
                this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p17);
                if (((((org.spongycastle.jcajce.PKCS12Key) p16) instanceof org.spongycastle.jcajce.PKCS12KeyWithParameters)) && (this.pbeSpec == null)) {
                    this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((org.spongycastle.jcajce.PKCS12KeyWithParameters) ((org.spongycastle.jcajce.PKCS12Key) p16)).getSalt(), ((org.spongycastle.jcajce.PKCS12KeyWithParameters) ((org.spongycastle.jcajce.PKCS12Key) p16)).getIterationCount());
                }
                v12_0 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((org.spongycastle.jcajce.PKCS12Key) p16).getEncoded(), 2, this.digest, this.keySizeInBits, (this.ivLength * 8), this.pbeSpec, this.cipher.getAlgorithmName());
            }
            if ((this.ivLength != 0) && (!(v12_0 instanceof org.spongycastle.crypto.params.ParametersWithIV))) {
                java.security.SecureRandom v10_0 = p18;
                if (p18 == null) {
                    v10_0 = new java.security.SecureRandom();
                }
                if ((p15 != 1) && (p15 != 3)) {
                    throw new java.security.InvalidAlgorithmParameterException("no IV set when one expected");
                } else {
                    byte[] v9 = new byte[this.ivLength];
                    v10_0.nextBytes(v9);
                    org.spongycastle.crypto.params.ParametersWithIV v13_1 = new org.spongycastle.crypto.params.ParametersWithIV(v12_0, v9);
                    this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v13_1);
                    v12_0 = v13_1;
                }
            }
            try {
                switch (p15) {
                    case 1:
                    case 3:
                        this.cipher.init(1, v12_0);
                        return;
                    case 2:
                    case 4:
                        this.cipher.init(0, v12_0);
                        return;
                    default:
                        throw new java.security.InvalidParameterException(new StringBuilder().append("unknown opmode ").append(p15).append(" passed").toString());
                }
            } catch (Exception v8) {
            }
            throw new java.security.InvalidKeyException(v8.getMessage());
        } else {
            throw new java.security.InvalidKeyException(new StringBuilder().append("Key for algorithm ").append(p16.getAlgorithm()).append(" not suitable for symmetric enryption.").toString());
        }
    }

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


    protected void engineInit(int p23, java.security.Key p24, java.security.spec.AlgorithmParameterSpec p25, java.security.SecureRandom p26)
    {
        this.pbeSpec = 0;
        this.pbeAlgorithm = 0;
        this.engineParams = 0;
        this.aeadParams = 0;
        if ((p24 instanceof javax.crypto.SecretKey)) {
            if ((p25 != null) || (!this.baseEngine.getAlgorithmName().startsWith("RC5-64"))) {
                if ((this.scheme != 2) && (!(p24 instanceof org.spongycastle.jcajce.PKCS12Key))) {
                    if (!(p24 instanceof org.spongycastle.jcajce.PBKDF1Key)) {
                        if (!(p24 instanceof org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey)) {
                            if (!(p24 instanceof javax.crypto.interfaces.PBEKey)) {
                                if ((p24 instanceof org.spongycastle.jcajce.spec.RepeatedSecretKeySpec)) {
                                    org.spongycastle.crypto.params.ParametersWithIV v17_0 = 0;
                                } else {
                                    if ((this.scheme != 0) && ((this.scheme != 4) && ((this.scheme != 1) && (this.scheme != 5)))) {
                                        v17_0 = new org.spongycastle.crypto.params.KeyParameter;
                                        v17_0(p24.getEncoded());
                                    } else {
                                        throw new java.security.InvalidKeyException("Algorithm requires a PBE key");
                                    }
                                }
                            } else {
                                this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p25);
                                if (((((javax.crypto.interfaces.PBEKey) p24) instanceof org.spongycastle.jcajce.PKCS12KeyWithParameters)) && (this.pbeSpec == null)) {
                                    this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((javax.crypto.interfaces.PBEKey) p24).getSalt(), ((javax.crypto.interfaces.PBEKey) p24).getIterationCount());
                                }
                                v17_0 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((javax.crypto.interfaces.PBEKey) p24).getEncoded(), this.scheme, this.digest, this.keySizeInBits, (this.ivLength * 8), this.pbeSpec, this.cipher.getAlgorithmName());
                                if ((v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                    this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                                }
                            }
                        } else {
                            if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24).getOID() == null) {
                                this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24).getAlgorithm();
                            } else {
                                this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24).getOID().getId();
                            }
                            if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24).getParam() == null) {
                                if (!(p25 instanceof javax.crypto.spec.PBEParameterSpec)) {
                                    throw new java.security.InvalidAlgorithmParameterException("PBE requires PBE parameters to be set.");
                                } else {
                                    this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p25);
                                    v17_0 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24), p25, this.cipher.getUnderlyingCipher().getAlgorithmName());
                                }
                            } else {
                                v17_0 = this.adjustParameters(p25, ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24).getParam());
                            }
                            if ((v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                            }
                        }
                    } else {
                        if ((p25 instanceof javax.crypto.spec.PBEParameterSpec)) {
                            this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p25);
                        }
                        if (((((org.spongycastle.jcajce.PBKDF1Key) p24) instanceof org.spongycastle.jcajce.PBKDF1KeyWithParameters)) && (this.pbeSpec == null)) {
                            this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((org.spongycastle.jcajce.PBKDF1KeyWithParameters) ((org.spongycastle.jcajce.PBKDF1Key) p24)).getSalt(), ((org.spongycastle.jcajce.PBKDF1KeyWithParameters) ((org.spongycastle.jcajce.PBKDF1Key) p24)).getIterationCount());
                        }
                        v17_0 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((org.spongycastle.jcajce.PBKDF1Key) p24).getEncoded(), 0, this.digest, this.keySizeInBits, (this.ivLength * 8), this.pbeSpec, this.cipher.getAlgorithmName());
                        if ((v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                            this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                        }
                    }
                } else {
                    try {
                        if ((p25 instanceof javax.crypto.spec.PBEParameterSpec)) {
                            this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p25);
                        }
                    } catch (Exception v10) {
                        throw new java.security.InvalidKeyException("PKCS12 requires a SecretKey/PBEKey");
                    }
                    if (((((javax.crypto.SecretKey) p24) instanceof javax.crypto.interfaces.PBEKey)) && (this.pbeSpec == null)) {
                        this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((javax.crypto.interfaces.PBEKey) ((javax.crypto.SecretKey) p24)).getSalt(), ((javax.crypto.interfaces.PBEKey) ((javax.crypto.SecretKey) p24)).getIterationCount());
                    }
                    if ((this.pbeSpec != null) || ((((javax.crypto.SecretKey) p24) instanceof javax.crypto.interfaces.PBEKey))) {
                        v17_0 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((javax.crypto.SecretKey) p24).getEncoded(), 2, this.digest, this.keySizeInBits, (this.ivLength * 8), this.pbeSpec, this.cipher.getAlgorithmName());
                        if ((v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                            this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                        }
                    } else {
                        throw new java.security.InvalidKeyException("Algorithm requires a PBE key");
                    }
                }
                if (!(p25 instanceof javax.crypto.spec.IvParameterSpec)) {
                    if (!(p25 instanceof org.spongycastle.jcajce.spec.GOST28147ParameterSpec)) {
                        if (!(p25 instanceof javax.crypto.spec.RC2ParameterSpec)) {
                            if (!(p25 instanceof javax.crypto.spec.RC5ParameterSpec)) {
                                if ((org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher.gcmSpecClass == null) || (!org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher.gcmSpecClass.isInstance(p25))) {
                                    if ((p25 != null) && (!(p25 instanceof javax.crypto.spec.PBEParameterSpec))) {
                                        throw new java.security.InvalidAlgorithmParameterException("unknown parameter type.");
                                    }
                                } else {
                                    if ((this.isAEADModeName(this.modeName)) || ((this.cipher instanceof org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher$AEADGenericBlockCipher))) {
                                        try {
                                            org.spongycastle.crypto.params.KeyParameter v15_0;
                                            String v5_5 = new Class[0];
                                            reflect.Method v21 = org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher.gcmSpecClass.getDeclaredMethod("getTLen", v5_5);
                                            String v5_7 = new Class[0];
                                            byte[] v12_0 = org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher.gcmSpecClass.getDeclaredMethod("getIV", v5_7);
                                        } catch (Exception v10) {
                                            throw new java.security.InvalidAlgorithmParameterException("Cannot process GCMParameterSpec.");
                                        }
                                        if (!(v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                            v15_0 = ((org.spongycastle.crypto.params.KeyParameter) v17_0);
                                        } else {
                                            v15_0 = ((org.spongycastle.crypto.params.KeyParameter) ((org.spongycastle.crypto.params.ParametersWithIV) v17_0).getParameters());
                                        }
                                        v17_0 = new org.spongycastle.crypto.params.AEADParameters;
                                        org.spongycastle.crypto.params.ParametersWithIV v3_79 = new Object[0];
                                        org.spongycastle.crypto.params.ParametersWithIV v3_83 = new Object[0];
                                        v17_0(v15_0, ((Integer) v21.invoke(p25, v3_79)).intValue(), ((byte[]) ((byte[]) v12_0.invoke(p25, v3_83))));
                                        this.aeadParams = v17_0;
                                    } else {
                                        throw new java.security.InvalidAlgorithmParameterException("GCMParameterSpec can only be used with AEAD modes.");
                                    }
                                }
                            } else {
                                v17_0 = new org.spongycastle.crypto.params.RC5Parameters;
                                v17_0(p24.getEncoded(), ((javax.crypto.spec.RC5ParameterSpec) p25).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) p25).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) p25).getWordSize()).append(".").toString());
                                        }
                                    } else {
                                        if (((javax.crypto.spec.RC5ParameterSpec) p25).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) p25).getWordSize()).append(".").toString());
                                        }
                                    }
                                    if ((((javax.crypto.spec.RC5ParameterSpec) p25).getIV() != null) && (this.ivLength != 0)) {
                                        if (!(v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                            org.spongycastle.crypto.params.ParametersWithIV v18_0 = new org.spongycastle.crypto.params.ParametersWithIV;
                                            v18_0(v17_0, ((javax.crypto.spec.RC5ParameterSpec) p25).getIV());
                                            v17_0 = v18_0;
                                        } else {
                                            org.spongycastle.crypto.params.ParametersWithIV v18_1 = new org.spongycastle.crypto.params.ParametersWithIV;
                                            v18_1(((org.spongycastle.crypto.params.ParametersWithIV) v17_0).getParameters(), ((javax.crypto.spec.RC5ParameterSpec) p25).getIV());
                                            v17_0 = v18_1;
                                        }
                                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                                    }
                                }
                            }
                        } else {
                            v17_0 = new org.spongycastle.crypto.params.RC2Parameters;
                            v17_0(p24.getEncoded(), ((javax.crypto.spec.RC2ParameterSpec) p25).getEffectiveKeyBits());
                            if ((((javax.crypto.spec.RC2ParameterSpec) p25).getIV() != null) && (this.ivLength != 0)) {
                                if (!(v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                    org.spongycastle.crypto.params.ParametersWithIV v18_2 = new org.spongycastle.crypto.params.ParametersWithIV;
                                    v18_2(v17_0, ((javax.crypto.spec.RC2ParameterSpec) p25).getIV());
                                    v17_0 = v18_2;
                                } else {
                                    org.spongycastle.crypto.params.ParametersWithIV v18_3 = new org.spongycastle.crypto.params.ParametersWithIV;
                                    v18_3(((org.spongycastle.crypto.params.ParametersWithIV) v17_0).getParameters(), ((javax.crypto.spec.RC2ParameterSpec) p25).getIV());
                                    v17_0 = v18_3;
                                }
                                this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                            }
                        }
                    } else {
                        v17_0 = new org.spongycastle.crypto.params.ParametersWithSBox;
                        v17_0(new org.spongycastle.crypto.params.KeyParameter(p24.getEncoded()), ((org.spongycastle.jcajce.spec.GOST28147ParameterSpec) p25).getSbox());
                        if ((((org.spongycastle.jcajce.spec.GOST28147ParameterSpec) p25).getIV() != null) && (this.ivLength != 0)) {
                            if (!(v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                org.spongycastle.crypto.params.ParametersWithIV v18_4 = new org.spongycastle.crypto.params.ParametersWithIV;
                                v18_4(v17_0, ((org.spongycastle.jcajce.spec.GOST28147ParameterSpec) p25).getIV());
                                v17_0 = v18_4;
                            } else {
                                org.spongycastle.crypto.params.ParametersWithIV v18_5 = new org.spongycastle.crypto.params.ParametersWithIV;
                                v18_5(((org.spongycastle.crypto.params.ParametersWithIV) v17_0).getParameters(), ((org.spongycastle.jcajce.spec.GOST28147ParameterSpec) p25).getIV());
                                v17_0 = v18_5;
                            }
                            this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                        }
                    }
                } else {
                    if (this.ivLength == 0) {
                        if ((this.modeName != null) && (this.modeName.equals("ECB"))) {
                            throw new java.security.InvalidAlgorithmParameterException("ECB mode does not use an IV");
                        }
                    } else {
                        if ((((javax.crypto.spec.IvParameterSpec) p25).getIV().length == this.ivLength) || (((this.cipher instanceof org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher$AEADGenericBlockCipher)) || (!this.fixedIv))) {
                            if (!(v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                org.spongycastle.crypto.params.ParametersWithIV v18_6 = new org.spongycastle.crypto.params.ParametersWithIV;
                                v18_6(v17_0, ((javax.crypto.spec.IvParameterSpec) p25).getIV());
                                v17_0 = v18_6;
                            } else {
                                org.spongycastle.crypto.params.ParametersWithIV v18_7 = new org.spongycastle.crypto.params.ParametersWithIV;
                                v18_7(((org.spongycastle.crypto.params.ParametersWithIV) v17_0).getParameters(), ((javax.crypto.spec.IvParameterSpec) p25).getIV());
                                v17_0 = v18_7;
                            }
                            this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                        } else {
                            throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("IV must be ").append(this.ivLength).append(" bytes long.").toString());
                        }
                    }
                }
                if ((this.ivLength == 0) || (((v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) || ((v17_0 instanceof org.spongycastle.crypto.params.AEADParameters)))) {
                    org.spongycastle.crypto.params.ParametersWithIV v18_8 = v17_0;
                } else {
                    java.security.SecureRandom v13_0 = p26;
                    if (p26 == null) {
                        v13_0 = new java.security.SecureRandom();
                    }
                    if ((p23 != 1) && (p23 != 3)) {
                        if (this.cipher.getUnderlyingCipher().getAlgorithmName().indexOf("PGPCFB") >= 0) {
                        } else {
                            throw new java.security.InvalidAlgorithmParameterException("no IV set when one expected");
                        }
                    } else {
                        byte[] v12_1 = new byte[this.ivLength];
                        v13_0.nextBytes(v12_1);
                        v18_8 = new org.spongycastle.crypto.params.ParametersWithIV;
                        v18_8(v17_0, v12_1);
                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v18_8);
                    }
                }
                if ((p26 == null) || (!this.padded)) {
                    org.spongycastle.crypto.params.ParametersWithIV v17_6 = v18_8;
                } else {
                    v17_6 = new org.spongycastle.crypto.params.ParametersWithRandom;
                    v17_6(v18_8, p26);
                }
                try {
                    switch (p23) {
                        case 1:
                        case 3:
                            this.cipher.init(1, v17_6);
                            return;
                        case 2:
                        case 4:
                            this.cipher.init(0, v17_6);
                            return;
                        default:
                            throw new java.security.InvalidParameterException(new StringBuilder().append("unknown opmode ").append(p23).append(" passed").toString());
                    }
                } catch (Exception v10) {
                }
                throw new org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher$1(this, v10.getMessage(), v10);
            } 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(p24.getAlgorithm()).append(" not suitable for symmetric enryption.").toString());
        }
    }

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


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[12];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = this.createParametersInstance("GCM");
            v2.init(new org.spongycastle.asn1.cms.GCMParameters(v1, 12).getEncoded());
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

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


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        byte[] v1 = new byte[12];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v1);
        try {
            java.security.AlgorithmParameters v2 = this.createParametersInstance("CCM");
            v2.init(new org.spongycastle.asn1.cms.CCMParameters(v1, 12).getEncoded());
            return v2;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

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


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

Method org.spongycastle.jcajce.provider.keystore.pkcs12.PKCS12KeyStoreSpi.<init>() calling method java.security.SecureRandom.<init>()


    public PKCS12KeyStoreSpi(java.security.Provider p5, org.spongycastle.asn1.ASN1ObjectIdentifier p6, org.spongycastle.asn1.ASN1ObjectIdentifier p7)
    {
        this.helper = new org.spongycastle.jcajce.util.BCJcaJceHelper();
        this.keys = new org.spongycastle.jcajce.provider.keystore.pkcs12.PKCS12KeyStoreSpi$IgnoresCaseHashtable(0);
        this.localIds = new java.util.Hashtable();
        this.certs = new org.spongycastle.jcajce.provider.keystore.pkcs12.PKCS12KeyStoreSpi$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.jcajce.provider.keystore.bc.BcKeyStoreSpi.<init>() calling method java.security.SecureRandom.<init>()


    public BcKeyStoreSpi(int p2)
    {
        this.table = new java.util.Hashtable();
        this.random = new java.security.SecureRandom();
        this.helper = new org.spongycastle.jcajce.util.BCJcaJceHelper();
        this.version = p2;
        return;
    }

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


    protected void engineInit(int p5, java.security.SecureRandom p6)
    {
        if (p6 == null) {
            try {
                p6 = new java.security.SecureRandom();
            } catch (IllegalArgumentException v0) {
                throw new java.security.InvalidParameterException(v0.getMessage());
            }
        }
        this.engine.init(new org.spongycastle.crypto.KeyGenerationParameters(p6, p5));
        this.uninitialised = 0;
        return;
    }

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


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

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


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

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


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

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


    protected void engineInit(int p11, java.security.Key p12, java.security.spec.AlgorithmParameterSpec p13, java.security.SecureRandom p14)
    {
        if ((p12 instanceof org.spongycastle.jce.interfaces.IESKey)) {
            if ((p13 != null) || ((p11 != 1) && (p11 != 3))) {
                if (!(p13 instanceof org.spongycastle.jce.spec.IESParameterSpec)) {
                    throw new java.security.InvalidAlgorithmParameterException("must be passed IES parameters");
                }
            } else {
                byte[] v0 = new byte[16];
                byte[] v1 = new byte[16];
                if (p14 == null) {
                    p14 = new java.security.SecureRandom();
                }
                p14.nextBytes(v0);
                p14.nextBytes(v1);
                p13 = new org.spongycastle.jce.spec.IESParameterSpec(v0, v1, 128);
            }
            org.spongycastle.crypto.params.AsymmetricKeyParameter v4;
            org.spongycastle.crypto.params.AsymmetricKeyParameter v5;
            if (!(((org.spongycastle.jce.interfaces.IESKey) p12).getPublic() instanceof javax.crypto.interfaces.DHPublicKey)) {
                v5 = org.spongycastle.jcajce.provider.asymmetric.util.ECUtil.generatePublicKeyParameter(((org.spongycastle.jce.interfaces.IESKey) p12).getPublic());
                v4 = org.spongycastle.jcajce.provider.asymmetric.util.ECUtil.generatePrivateKeyParameter(((org.spongycastle.jce.interfaces.IESKey) p12).getPrivate());
            } else {
                v5 = org.spongycastle.jcajce.provider.asymmetric.util.DHUtil.generatePublicKeyParameter(((org.spongycastle.jce.interfaces.IESKey) p12).getPublic());
                v4 = org.spongycastle.jcajce.provider.asymmetric.util.DHUtil.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.jcajce.provider.asymmetric.gost.KeyPairGeneratorSpi.generateKeyPair() calling method java.security.SecureRandom.<init>()


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

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


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

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


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

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


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

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


    public java.security.KeyPair generateKeyPair()
    {
        if (!this.initialised) {
            this.initialize(this.strength, new java.security.SecureRandom());
        }
        java.security.KeyPair v0_8;
        org.spongycastle.crypto.AsymmetricCipherKeyPair v6 = this.engine.generateKeyPair();
        org.spongycastle.crypto.params.ECPublicKeyParameters v7_1 = ((org.spongycastle.crypto.params.ECPublicKeyParameters) v6.getPublic());
        org.spongycastle.crypto.params.ECPrivateKeyParameters v2_1 = ((org.spongycastle.crypto.params.ECPrivateKeyParameters) v6.getPrivate());
        if (!(this.ecParams instanceof org.spongycastle.jce.spec.ECParameterSpec)) {
            if (this.ecParams != null) {
                java.security.spec.ECParameterSpec v4_1 = ((java.security.spec.ECParameterSpec) this.ecParams);
                org.spongycastle.jcajce.provider.asymmetric.ec.BCECPublicKey v3_1 = new org.spongycastle.jcajce.provider.asymmetric.ec.BCECPublicKey(this.algorithm, v7_1, v4_1, this.configuration);
                v0_8 = new java.security.KeyPair(v3_1, new org.spongycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey(this.algorithm, v2_1, v3_1, v4_1, this.configuration));
            } else {
                v0_8 = new java.security.KeyPair(new org.spongycastle.jcajce.provider.asymmetric.ec.BCECPublicKey(this.algorithm, v7_1, this.configuration), new org.spongycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey(this.algorithm, v2_1, this.configuration));
            }
        } else {
            java.security.spec.ECParameterSpec v4_3 = ((org.spongycastle.jce.spec.ECParameterSpec) this.ecParams);
            org.spongycastle.jcajce.provider.asymmetric.ec.BCECPublicKey v3_3 = new org.spongycastle.jcajce.provider.asymmetric.ec.BCECPublicKey(this.algorithm, v7_1, v4_3, this.configuration);
            v0_8 = new java.security.KeyPair(v3_3, new org.spongycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey(this.algorithm, v2_1, v3_3, v4_3, this.configuration));
        }
        return v0_8;
    }

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


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

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


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

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


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

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


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        org.spongycastle.crypto.generators.DSAParametersGenerator v2_1;
        if (this.strength > 1024) {
            v2_1 = new org.spongycastle.crypto.generators.DSAParametersGenerator(new org.spongycastle.crypto.digests.SHA256Digest());
        } else {
            v2_1 = new org.spongycastle.crypto.generators.DSAParametersGenerator();
        }
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        if (this.strength != 1024) {
            if (this.strength <= 1024) {
                v2_1.init(this.strength, 20, this.random);
            } else {
                this.params = new org.spongycastle.crypto.params.DSAParameterGenerationParameters(this.strength, 256, 80, this.random);
                v2_1.init(this.params);
            }
        } else {
            this.params = new org.spongycastle.crypto.params.DSAParameterGenerationParameters(1024, 160, 80, this.random);
            v2_1.init(this.params);
        }
        org.spongycastle.crypto.params.DSAParameters v1 = v2_1.generateParameters();
        try {
            java.security.AlgorithmParameters v3 = this.createParametersInstance("DSA");
            v3.init(new java.security.spec.DSAParameterSpec(v1.getP(), v1.getQ(), v1.getG()));
            return v3;
        } catch (Exception v0) {
            throw new RuntimeException(v0.getMessage());
        }
    }

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


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

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


    protected java.security.AlgorithmParameters engineGenerateParameters()
    {
        org.spongycastle.crypto.generators.DHParametersGenerator v2_1 = new org.spongycastle.crypto.generators.DHParametersGenerator();
        if (this.random == null) {
            v2_1.init(this.strength, 20, new java.security.SecureRandom());
        } else {
            v2_1.init(this.strength, 20, this.random);
        }
        org.spongycastle.crypto.params.DHParameters v1 = v2_1.generateParameters();
        try {
            java.security.AlgorithmParameters v3 = this.createParametersInstance("DH");
            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.cms.jcajce.JceKeyAgreeRecipientInfoGenerator.init() calling method java.security.SecureRandom.<init>()


    private void init(org.spongycastle.asn1.ASN1ObjectIdentifier p8)
    {
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        if ((org.spongycastle.cms.jcajce.CMSUtils.isMQV(p8)) && (this.ephemeralKP == null)) {
            try {
                org.spongycastle.asn1.x509.SubjectPublicKeyInfo v3 = org.spongycastle.asn1.x509.SubjectPublicKeyInfo.getInstance(this.senderPublicKey.getEncoded());
                java.security.AlgorithmParameters v1 = this.helper.createAlgorithmParameters(p8);
                v1.init(v3.getAlgorithm().getParameters().toASN1Primitive().getEncoded());
                java.security.KeyPairGenerator v2 = this.helper.createKeyPairGenerator(p8);
                v2.initialize(v1.getParameterSpec(java.security.spec.AlgorithmParameterSpec), this.random);
                this.ephemeralKP = v2.generateKeyPair();
            } catch (Exception v0) {
                throw new org.spongycastle.cms.CMSException(new StringBuilder().append("cannot determine MQV ephemeral key pair parameters from public key: ").append(v0).toString(), v0);
            }
        }
        return;
    }

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


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

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


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

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


    BcCMSContentEncryptorBuilder$CMSOutputEncryptor(org.spongycastle.cms.bc.BcCMSContentEncryptorBuilder p5, org.spongycastle.asn1.ASN1ObjectIdentifier p6, int p7, java.security.SecureRandom p8)
    {
        this.this$0 = p5;
        if (p8 == null) {
            p8 = new java.security.SecureRandom();
        }
        this.encKey = new org.spongycastle.crypto.params.KeyParameter(org.spongycastle.cms.bc.BcCMSContentEncryptorBuilder.access$000(p5).createKeyGenerator(p6, p8).generateKey());
        this.algorithmIdentifier = org.spongycastle.cms.bc.BcCMSContentEncryptorBuilder.access$000(p5).generateAlgorithmIdentifier(p6, this.encKey, p8);
        org.spongycastle.cms.bc.BcCMSContentEncryptorBuilder.access$000(p5);
        this.cipher = org.spongycastle.cms.bc.EnvelopedDataHelper.createContentCipher(1, this.encKey, this.algorithmIdentifier);
        return;
    }

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


    public org.spongycastle.asn1.cms.RecipientInfo generate(org.spongycastle.operator.GenericKey p13)
    {
        byte[] v3 = new byte[this.blockSize];
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        this.random.nextBytes(v3);
        if (this.keyDerivationAlgorithm == null) {
            byte[] v6 = new byte[20];
            this.random.nextBytes(v6);
            this.keyDerivationAlgorithm = new org.spongycastle.asn1.x509.AlgorithmIdentifier(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_PBKDF2, new org.spongycastle.asn1.pkcs.PBKDF2Params(v6, 1024));
        }
        org.spongycastle.asn1.DEROctetString v1_1 = new org.spongycastle.asn1.DEROctetString(this.generateEncryptedBytes(new org.spongycastle.asn1.x509.AlgorithmIdentifier(this.kekAlgorithm, new org.spongycastle.asn1.DEROctetString(v3)), this.calculateDerivedKey(this.schemeID, this.keyDerivationAlgorithm, this.keySize), p13));
        org.spongycastle.asn1.ASN1EncodableVector v7_1 = new org.spongycastle.asn1.ASN1EncodableVector();
        v7_1.add(this.kekAlgorithm);
        v7_1.add(new org.spongycastle.asn1.DEROctetString(v3));
        return new org.spongycastle.asn1.cms.RecipientInfo(new org.spongycastle.asn1.cms.PasswordRecipientInfo(this.keyDerivationAlgorithm, new org.spongycastle.asn1.x509.AlgorithmIdentifier(org.spongycastle.asn1.pkcs.PKCSObjectIdentifiers.id_alg_PWRI_KEK, new org.spongycastle.asn1.DERSequence(v7_1)), v1_1));
    }

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


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

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


    public TestRandomEntropySourceProvider(boolean p2)
    {
        this._sr = new java.security.SecureRandom();
        this._predictionResistant = p2;
        return;
    }

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.pqc.math.ntru.polynomial.BigIntPolynomial.generateRandomSmall() calling method java.security.SecureRandom.<init>()


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

Method org.spongycastle.pqc.math.linearalgebra.IntegerFunctions.randomize() calling method java.security.SecureRandom.<init>()


    public static java.math.BigInteger randomize(java.math.BigInteger p6, java.security.SecureRandom p7)
    {
        int v0 = p6.bitLength();
        java.math.BigInteger v2_1 = java.math.BigInteger.valueOf(0);
        if (p7 == null) {
            if (org.spongycastle.pqc.math.linearalgebra.IntegerFunctions.sr == null) {
                p7 = new java.security.SecureRandom();
            } else {
                p7 = org.spongycastle.pqc.math.linearalgebra.IntegerFunctions.sr;
            }
        }
        int v1 = 0;
        while (v1 < 20) {
            v2_1 = new java.math.BigInteger(v0, p7);
            if (v2_1.compareTo(p6) >= 0) {
                v1++;
            } else {
                java.math.BigInteger v3_1 = v2_1;
            }
            return v3_1;
        }
        v3_1 = v2_1.mod(p6);
        return v3_1;
    }

Method org.spongycastle.pqc.math.linearalgebra.IntegerFunctions.randomize() calling method java.security.SecureRandom.<init>()


    public static java.math.BigInteger randomize(java.math.BigInteger p1)
    {
        if (org.spongycastle.pqc.math.linearalgebra.IntegerFunctions.sr == null) {
            org.spongycastle.pqc.math.linearalgebra.IntegerFunctions.sr = new java.security.SecureRandom();
        }
        return org.spongycastle.pqc.math.linearalgebra.IntegerFunctions.randomize(p1, org.spongycastle.pqc.math.linearalgebra.IntegerFunctions.sr);
    }

Method org.spongycastle.pqc.math.linearalgebra.GF2mField.getRandomNonZeroElement() calling method java.security.SecureRandom.<init>()


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

Method org.spongycastle.pqc.math.linearalgebra.GF2Matrix.<init>() calling method java.security.SecureRandom.<init>()


    public GF2Matrix(int p2, char p3)
    {
        this(p2, p3, new java.security.SecureRandom());
        return;
    }

Method org.spongycastle.pqc.crypto.rainbow.RainbowSigner.init() calling method java.security.SecureRandom.<init>()


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

Method org.spongycastle.pqc.crypto.rainbow.RainbowKeyPairGenerator.initialize() calling method java.security.SecureRandom.<init>()


    public void initialize(org.spongycastle.crypto.KeyGenerationParameters p2)
    {
        this.rainbowParams = ((org.spongycastle.pqc.crypto.rainbow.RainbowKeyGenerationParameters) p2);
        this.sr = new java.security.SecureRandom();
        this.vi = this.rainbowParams.getParameters().getVi();
        this.numOfLayers = this.rainbowParams.getParameters().getNumOfLayers();
        this.initialized = 1;
        return;
    }

Method org.spongycastle.pqc.crypto.rainbow.RainbowKeyPairGenerator.initializeDefault() calling method java.security.SecureRandom.<init>()


    private void initializeDefault()
    {
        this.initialize(new org.spongycastle.pqc.crypto.rainbow.RainbowKeyGenerationParameters(new java.security.SecureRandom(), new org.spongycastle.pqc.crypto.rainbow.RainbowParameters()));
        return;
    }

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

Method org.spongycastle.pqc.crypto.mceliece.McEliecePointchevalCipher.initCipherEncrypt() calling method java.security.SecureRandom.<init>()


    public void initCipherEncrypt(org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters p2)
    {
        int v0_5;
        if (this.sr == null) {
            v0_5 = new java.security.SecureRandom();
        } else {
            v0_5 = this.sr;
        }
        this.sr = v0_5;
        this.messDigest = p2.getParameters().getDigest();
        this.n = p2.getN();
        this.k = p2.getK();
        this.t = p2.getT();
        return;
    }

Method org.spongycastle.pqc.crypto.mceliece.McEliecePointchevalCipher.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        if (!p3) {
            this.key = ((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PrivateKeyParameters) p4);
            this.initCipherDecrypt(((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PrivateKeyParameters) this.key));
        } else {
            if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
                this.sr = new java.security.SecureRandom();
                this.key = ((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) p4);
                this.initCipherEncrypt(((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) this.key));
            } else {
                this.sr = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                this.key = ((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
                this.initCipherEncrypt(((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) this.key));
            }
        }
        return;
    }

Method org.spongycastle.pqc.crypto.mceliece.McEliecePKCSCipher.initCipherEncrypt() calling method java.security.SecureRandom.<init>()


    public void initCipherEncrypt(org.spongycastle.pqc.crypto.mceliece.McEliecePublicKeyParameters p2)
    {
        int v0_8;
        if (this.sr == null) {
            v0_8 = new java.security.SecureRandom();
        } else {
            v0_8 = this.sr;
        }
        this.sr = v0_8;
        this.n = p2.getN();
        this.k = p2.getK();
        this.t = p2.getT();
        this.cipherTextSize = (this.n >> 3);
        this.maxPlainTextSize = (this.k >> 3);
        return;
    }

Method org.spongycastle.pqc.crypto.mceliece.McEliecePKCSCipher.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        if (!p3) {
            this.key = ((org.spongycastle.pqc.crypto.mceliece.McEliecePrivateKeyParameters) p4);
            this.initCipherDecrypt(((org.spongycastle.pqc.crypto.mceliece.McEliecePrivateKeyParameters) this.key));
        } else {
            if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
                this.sr = new java.security.SecureRandom();
                this.key = ((org.spongycastle.pqc.crypto.mceliece.McEliecePublicKeyParameters) p4);
                this.initCipherEncrypt(((org.spongycastle.pqc.crypto.mceliece.McEliecePublicKeyParameters) this.key));
            } else {
                this.sr = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                this.key = ((org.spongycastle.pqc.crypto.mceliece.McEliecePublicKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
                this.initCipherEncrypt(((org.spongycastle.pqc.crypto.mceliece.McEliecePublicKeyParameters) this.key));
            }
        }
        return;
    }

Method org.spongycastle.pqc.crypto.mceliece.McElieceKobaraImaiCipher.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        if (!p3) {
            this.key = ((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PrivateKeyParameters) p4);
            this.initCipherDecrypt(((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PrivateKeyParameters) this.key));
        } else {
            if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
                this.sr = new java.security.SecureRandom();
                this.key = ((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) p4);
                this.initCipherEncrypt(((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) this.key));
            } else {
                this.sr = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                this.key = ((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
                this.initCipherEncrypt(((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) this.key));
            }
        }
        return;
    }

Method org.spongycastle.pqc.crypto.mceliece.McElieceKeyPairGenerator.initializeDefault() calling method java.security.SecureRandom.<init>()


    private void initializeDefault()
    {
        this.initialize(new org.spongycastle.pqc.crypto.mceliece.McElieceKeyGenerationParameters(new java.security.SecureRandom(), new org.spongycastle.pqc.crypto.mceliece.McElieceParameters()));
        return;
    }

Method org.spongycastle.pqc.crypto.mceliece.McElieceKeyPairGenerator.initialize() calling method java.security.SecureRandom.<init>()


    private void initialize(org.spongycastle.crypto.KeyGenerationParameters p2)
    {
        this.mcElieceParams = ((org.spongycastle.pqc.crypto.mceliece.McElieceKeyGenerationParameters) p2);
        this.random = new java.security.SecureRandom();
        this.m = this.mcElieceParams.getParameters().getM();
        this.n = this.mcElieceParams.getParameters().getN();
        this.t = this.mcElieceParams.getParameters().getT();
        this.fieldPoly = this.mcElieceParams.getParameters().getFieldPoly();
        this.initialized = 1;
        return;
    }

Method org.spongycastle.pqc.crypto.mceliece.McElieceFujisakiCipher.init() calling method java.security.SecureRandom.<init>()


    public void init(boolean p3, org.spongycastle.crypto.CipherParameters p4)
    {
        if (!p3) {
            this.key = ((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PrivateKeyParameters) p4);
            this.initCipherDecrypt(((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PrivateKeyParameters) this.key));
        } else {
            if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
                this.sr = new java.security.SecureRandom();
                this.key = ((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) p4);
                this.initCipherEncrypt(((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) this.key));
            } else {
                this.sr = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                this.key = ((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
                this.initCipherEncrypt(((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters) this.key));
            }
        }
        return;
    }

Method org.spongycastle.pqc.crypto.mceliece.McElieceFujisakiCipher.initCipherEncrypt() calling method java.security.SecureRandom.<init>()


    private void initCipherEncrypt(org.spongycastle.pqc.crypto.mceliece.McElieceCCA2PublicKeyParameters p2)
    {
        int v0_5;
        if (this.sr == null) {
            v0_5 = new java.security.SecureRandom();
        } else {
            v0_5 = this.sr;
        }
        this.sr = v0_5;
        this.messDigest = p2.getParameters().getDigest();
        this.n = p2.getN();
        this.k = p2.getK();
        this.t = p2.getT();
        return;
    }

Method org.spongycastle.pqc.crypto.mceliece.McElieceCCA2KeyPairGenerator.init() calling method java.security.SecureRandom.<init>()


    public void init(org.spongycastle.crypto.KeyGenerationParameters p2)
    {
        this.mcElieceCCA2Params = ((org.spongycastle.pqc.crypto.mceliece.McElieceCCA2KeyGenerationParameters) p2);
        this.random = new java.security.SecureRandom();
        this.m = this.mcElieceCCA2Params.getParameters().getM();
        this.n = this.mcElieceCCA2Params.getParameters().getN();
        this.t = this.mcElieceCCA2Params.getParameters().getT();
        this.fieldPoly = this.mcElieceCCA2Params.getParameters().getFieldPoly();
        this.initialized = 1;
        return;
    }

Method org.spongycastle.pqc.crypto.mceliece.McElieceCCA2KeyPairGenerator.initializeDefault() calling method java.security.SecureRandom.<init>()


    private void initializeDefault()
    {
        this.init(new org.spongycastle.pqc.crypto.mceliece.McElieceCCA2KeyGenerationParameters(new java.security.SecureRandom(), new org.spongycastle.pqc.crypto.mceliece.McElieceCCA2Parameters()));
        return;
    }

Method org.spongycastle.pqc.crypto.gmss.GMSSSigner.init() calling method java.security.SecureRandom.<init>()


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

Method org.spongycastle.pqc.crypto.gmss.GMSSKeyPairGenerator.initialize() calling method java.security.SecureRandom.<init>()


    public void initialize(org.spongycastle.crypto.KeyGenerationParameters p8)
    {
        this.gmssParams = ((org.spongycastle.pqc.crypto.gmss.GMSSKeyGenerationParameters) p8);
        this.gmssPS = new org.spongycastle.pqc.crypto.gmss.GMSSParameters(this.gmssParams.getParameters().getNumOfLayers(), this.gmssParams.getParameters().getHeightOfTrees(), this.gmssParams.getParameters().getWinternitzParameter(), this.gmssParams.getParameters().getK());
        this.numLayer = this.gmssPS.getNumOfLayers();
        this.heightOfTrees = this.gmssPS.getHeightOfTrees();
        this.otsIndex = this.gmssPS.getWinternitzParameter();
        this.K = this.gmssPS.getK();
        this.currentSeeds = ((byte[][]) reflect.Array.newInstance(Byte.TYPE, new int[] {this.numLayer, this.mdLength})));
        this.nextNextSeeds = ((byte[][]) reflect.Array.newInstance(Byte.TYPE, new int[] {(this.numLayer - 1), this.mdLength})));
        java.security.SecureRandom v1_1 = new java.security.SecureRandom();
        int v0 = 0;
        while (v0 < this.numLayer) {
            v1_1.nextBytes(this.currentSeeds[v0]);
            this.gmssRandom.nextSeed(this.currentSeeds[v0]);
            v0++;
        }
        this.initialized = 1;
        return;
    }

Method org.spongycastle.pqc.crypto.gmss.GMSSKeyPairGenerator.initializeDefault() calling method java.security.SecureRandom.<init>()


    private void initializeDefault()
    {
        int[] v0 = new int[4];
        v0 = {10, 10, 10, 10};
        int[] v2 = new int[4];
        v2 = {3, 3, 3, 3};
        int[] v1 = new int[4];
        v1 = {2, 2, 2, 2};
        this.initialize(new org.spongycastle.pqc.crypto.gmss.GMSSKeyGenerationParameters(new java.security.SecureRandom(), new org.spongycastle.pqc.crypto.gmss.GMSSParameters(v0.length, v0, v2, v1)));
        return;
    }

Method org.spongycastle.math.ec.tools.DiscoverEndomorphisms.printGLVTypeBParameters() calling method java.security.SecureRandom.<init>()


    private static void printGLVTypeBParameters(org.spongycastle.asn1.x9.X9ECParameters p39)
    {
        java.math.BigInteger v20 = p39.getN();
        java.math.BigInteger[] v31 = 0;
        java.math.BigInteger v18 = org.spongycastle.math.ec.tools.DiscoverEndomorphisms.solveQuadraticEquation(v20, org.spongycastle.math.ec.ECConstants.ONE, org.spongycastle.math.ec.ECConstants.ONE);
        java.math.BigInteger[] v25 = org.spongycastle.math.ec.tools.DiscoverEndomorphisms.extEuclidGLV(v20, v18);
        java.math.BigInteger v0_11 = new java.math.BigInteger[2];
        java.math.BigInteger[] v30 = v0_11;
        v30[0] = v25[2];
        v30[1] = v25[3].negate();
        java.math.BigInteger v0_27 = new java.math.BigInteger[2];
        java.math.BigInteger v35_51 = v0_27;
        v35_51[0] = v25[0];
        v35_51[1] = v25[1].negate();
        java.math.BigInteger v0_38 = new java.math.BigInteger[2];
        java.math.BigInteger v36_56 = v0_38;
        v36_56[0] = v25[4];
        v36_56[1] = v25[5].negate();
        v31 = org.spongycastle.math.ec.tools.DiscoverEndomorphisms.chooseShortest(v35_51, v36_56);
        if ((!org.spongycastle.math.ec.tools.DiscoverEndomorphisms.isVectorBoundedBySqrt(v31, v20)) && (org.spongycastle.math.ec.tools.DiscoverEndomorphisms.areRelativelyPrime(v30[0], v30[1]))) {
            java.math.BigInteger v22_1 = v30[0];
            java.math.BigInteger v28 = v30[1];
            java.math.BigInteger v26 = v22_1.add(v28.multiply(v18)).divide(v20);
            java.math.BigInteger v0_45 = new java.math.BigInteger[2];
            java.math.BigInteger v35_77 = v0_45;
            v35_77[0] = v26.abs();
            v35_77[1] = v28.abs();
            java.math.BigInteger[] v32 = org.spongycastle.math.ec.tools.DiscoverEndomorphisms.extEuclidBezout(v35_77);
            java.math.BigInteger v29 = v32[0];
            java.math.BigInteger v33 = v32[1];
            if (v26.signum() < 0) {
                v29 = v29.negate();
            }
            if (v28.signum() > 0) {
                v33 = v33.negate();
            }
            if (v26.multiply(v29).subtract(v28.multiply(v33)).equals(org.spongycastle.math.ec.ECConstants.ONE)) {
                java.math.BigInteger v34 = v33.multiply(v20).subtract(v29.multiply(v18));
                java.math.BigInteger v8 = v29.negate();
                java.math.BigInteger v9 = v34.negate();
                java.math.BigInteger v27 = org.spongycastle.math.ec.tools.DiscoverEndomorphisms.isqrt(v20.subtract(org.spongycastle.math.ec.ECConstants.ONE)).add(org.spongycastle.math.ec.ECConstants.ONE);
                java.math.BigInteger[] v24 = org.spongycastle.math.ec.tools.DiscoverEndomorphisms.intersect(org.spongycastle.math.ec.tools.DiscoverEndomorphisms.calculateRange(v8, v27, v28), org.spongycastle.math.ec.tools.DiscoverEndomorphisms.calculateRange(v9, v27, v22_1));
                if (v24 != null) {
                    java.math.BigInteger v6 = v24[0];
                    while (v6.compareTo(v24[1]) <= 0) {
                        java.math.BigInteger[] v12 = new java.math.BigInteger[2];
                        v12[0] = v34.add(v6.multiply(v22_1));
                        v12[1] = v29.add(v6.multiply(v28));
                        if (org.spongycastle.math.ec.tools.DiscoverEndomorphisms.isShorter(v12, v31)) {
                            v31 = v12;
                        }
                        v6 = v6.add(org.spongycastle.math.ec.ECConstants.ONE);
                    }
                }
            } else {
                throw new IllegalStateException();
            }
        }
        org.spongycastle.math.ec.ECPoint v3 = p39.getG().normalize();
        org.spongycastle.math.ec.ECPoint v19 = v3.multiply(v18).normalize();
        if (v3.getYCoord().equals(v19.getYCoord())) {
            java.math.BigInteger v21 = p39.getCurve().getField().getCharacteristic();
            java.math.BigInteger v15 = v21.divide(org.spongycastle.math.ec.ECConstants.THREE);
            while (org.spongycastle.util.BigIntegers.createRandomInRange(org.spongycastle.math.ec.ECConstants.TWO, v21.subtract(org.spongycastle.math.ec.ECConstants.TWO), new java.security.SecureRandom()).modPow(v15, v21).equals(org.spongycastle.math.ec.ECConstants.ONE)) {
            }
            org.spongycastle.math.ec.ECFieldElement v10 = p39.getCurve().fromBigInteger(org.spongycastle.math.ec.ECConstants.TWO.modPow(v15, v21));
            if (!v3.getXCoord().multiply(v10).equals(v19.getXCoord())) {
                v10 = v10.square();
                if (!v3.getXCoord().multiply(v10).equals(v19.getXCoord())) {
                    throw new IllegalStateException("Derivation of GLV Type B parameters failed unexpectedly");
                }
            }
            java.math.BigInteger v14 = v30[0].multiply(v31[1]).subtract(v30[1].multiply(v31[0]));
            int v11 = ((v20.bitLength() + 16) - (v20.bitLength() & 7));
            java.math.BigInteger v16 = org.spongycastle.math.ec.tools.DiscoverEndomorphisms.roundQuotient(v31[1].shiftLeft(v11), v14);
            java.math.BigInteger v17 = org.spongycastle.math.ec.tools.DiscoverEndomorphisms.roundQuotient(v30[1].shiftLeft(v11), v14).negate();
            org.spongycastle.math.ec.tools.DiscoverEndomorphisms.printProperty("Beta", v10.toBigInteger().toString(16));
            org.spongycastle.math.ec.tools.DiscoverEndomorphisms.printProperty("Lambda", v18.toString(16));
            org.spongycastle.math.ec.tools.DiscoverEndomorphisms.printProperty("v1", new StringBuilder().append("{ ").append(v30[0].toString(16)).append(", ").append(v30[1].toString(16)).append(" }").toString());
            org.spongycastle.math.ec.tools.DiscoverEndomorphisms.printProperty("v2", new StringBuilder().append("{ ").append(v31[0].toString(16)).append(", ").append(v31[1].toString(16)).append(" }").toString());
            org.spongycastle.math.ec.tools.DiscoverEndomorphisms.printProperty("(OPT) g1", v16.toString(16));
            org.spongycastle.math.ec.tools.DiscoverEndomorphisms.printProperty("(OPT) g2", v17.toString(16));
            org.spongycastle.math.ec.tools.DiscoverEndomorphisms.printProperty("(OPT) bits", Integer.toString(v11));
            return;
        } else {
            throw new IllegalStateException("Derivation of GLV Type B parameters failed unexpectedly");
        }
    }

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;
        if (!(v2_0 instanceof org.spongycastle.crypto.params.RSABlindingParameters)) {
            v0_1 = ((org.spongycastle.crypto.params.RSAKeyParameters) v2_0);
            this.cipher.init(p7, v2_0);
        } else {
            v0_1 = ((org.spongycastle.crypto.params.RSABlindingParameters) v2_0).getPublicKey();
            this.cipher.init(p7, p8);
        }
        this.emBits = (v0_1.getModulus().bitLength() - 1);
        if (this.emBits >= (((this.hLen * 8) + (this.sLen * 8)) + 9)) {
            byte[] v3_13 = new byte[((this.emBits + 7) / 8)];
            this.block = v3_13;
            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.initSecureRandom() calling method java.security.SecureRandom.<init>()


    protected java.security.SecureRandom initSecureRandom(boolean p1, java.security.SecureRandom p2)
    {
        if (p1) {
            if (p2 == null) {
                p2 = new java.security.SecureRandom();
            }
        } else {
            p2 = 0;
        }
        return p2;
    }

Method org.spongycastle.crypto.signers.DSTU4145Signer.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();
            } else {
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
                p4 = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters();
            }
            this.key = ((org.spongycastle.crypto.params.ECPrivateKeyParameters) p4);
        }
        return;
    }

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


    protected java.security.SecureRandom initSecureRandom(boolean p1, java.security.SecureRandom p2)
    {
        if (p1) {
            if (p2 == null) {
                p2 = new java.security.SecureRandom();
            }
        } else {
            p2 = 0;
        }
        return p2;
    }

Method org.spongycastle.crypto.prng.X931SecureRandomBuilder.<init>() calling method java.security.SecureRandom.<init>()


    public X931SecureRandomBuilder()
    {
        this(new java.security.SecureRandom(), 0);
        return;
    }

Method org.spongycastle.crypto.prng.X931SecureRandom.<init>() calling method java.security.SecureRandom.<init>()


    X931SecureRandom(java.security.SecureRandom p1, org.spongycastle.crypto.prng.X931RNG p2, boolean p3)
    {
        this.randomSource = p1;
        this.drbg = p2;
        this.predictionResistant = p3;
        return;
    }

Method org.spongycastle.crypto.prng.SP800SecureRandomBuilder.<init>() calling method java.security.SecureRandom.<init>()


    public SP800SecureRandomBuilder()
    {
        this(new java.security.SecureRandom(), 0);
        return;
    }

Method org.spongycastle.crypto.prng.SP800SecureRandom.<init>() calling method java.security.SecureRandom.<init>()


    SP800SecureRandom(java.security.SecureRandom p1, org.spongycastle.crypto.prng.EntropySource p2, org.spongycastle.crypto.prng.DRBGProvider p3, boolean p4)
    {
        this.randomSource = p1;
        this.entropySource = p2;
        this.drbgProvider = p3;
        this.predictionResistant = p4;
        return;
    }

Method org.spongycastle.crypto.prng.FixedSecureRandom.<init>() calling method java.security.SecureRandom.<init>()


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

Method org.spongycastle.crypto.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.generators.ECKeyPairGenerator.init() calling method java.security.SecureRandom.<init>()


    public void init(org.spongycastle.crypto.KeyGenerationParameters p3)
    {
        this.random = ((org.spongycastle.crypto.params.ECKeyGenerationParameters) p3).getRandom();
        this.params = ((org.spongycastle.crypto.params.ECKeyGenerationParameters) p3).getDomainParameters();
        if (this.random == null) {
            this.random = new java.security.SecureRandom();
        }
        return;
    }

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


    public static void main(String[] p30)
    {
        org.spongycastle.crypto.agreement.jpake.JPAKEPrimeOrderGroup v6 = org.spongycastle.crypto.agreement.jpake.JPAKEPrimeOrderGroups.NIST_3072;
        java.math.BigInteger v28 = v6.getP();
        java.math.BigInteger v29 = v6.getQ();
        java.math.BigInteger v27 = v6.getG();
        System.out.println("********* Initialization **********");
        System.out.println("Public parameters for the cyclic group:");
        System.out.println(new StringBuilder().append("p (").append(v28.bitLength()).append(" bits): ").append(v28.toString(16)).toString());
        System.out.println(new StringBuilder().append("q (").append(v29.bitLength()).append(" bits): ").append(v29.toString(16)).toString());
        System.out.println(new StringBuilder().append("g (").append(v28.bitLength()).append(" bits): ").append(v27.toString(16)).toString());
        System.out.println(new StringBuilder().append("p mod q = ").append(v28.mod(v29).toString(16)).toString());
        System.out.println(new StringBuilder().append("g^{q} mod p = ").append(v27.modPow(v29, v28).toString(16)).toString());
        System.out.println("");
        System.out.println(new StringBuilder().append("(Secret passwords used by Alice and Bob: \"").append("password").append("\" and \"").append("password").append("\")\n").toString());
        org.spongycastle.crypto.digests.SHA256Digest v7_1 = new org.spongycastle.crypto.digests.SHA256Digest();
        java.security.SecureRandom v8_1 = new java.security.SecureRandom();
        org.spongycastle.crypto.agreement.jpake.JPAKEParticipant v3_1 = new org.spongycastle.crypto.agreement.jpake.JPAKEParticipant("alice", "password".toCharArray(), v6, v7_1, v8_1);
        org.spongycastle.crypto.agreement.jpake.JPAKEParticipant v9_1 = new org.spongycastle.crypto.agreement.jpake.JPAKEParticipant("bob", "password".toCharArray(), v6, v7_1, v8_1);
        org.spongycastle.crypto.agreement.jpake.JPAKERound1Payload v18 = v3_1.createRound1PayloadToSend();
        org.spongycastle.crypto.agreement.jpake.JPAKERound1Payload v24 = v9_1.createRound1PayloadToSend();
        System.out.println("************ Round 1 **************");
        System.out.println("Alice sends to Bob: ");
        System.out.println(new StringBuilder().append("g^{x1}=").append(v18.getGx1().toString(16)).toString());
        System.out.println(new StringBuilder().append("g^{x2}=").append(v18.getGx2().toString(16)).toString());
        System.out.println(new StringBuilder().append("KP{x1}={").append(v18.getKnowledgeProofForX1()[0].toString(16)).append("};{").append(v18.getKnowledgeProofForX1()[1].toString(16)).append("}").toString());
        System.out.println(new StringBuilder().append("KP{x2}={").append(v18.getKnowledgeProofForX2()[0].toString(16)).append("};{").append(v18.getKnowledgeProofForX2()[1].toString(16)).append("}").toString());
        System.out.println("");
        System.out.println("Bob sends to Alice: ");
        System.out.println(new StringBuilder().append("g^{x3}=").append(v24.getGx1().toString(16)).toString());
        System.out.println(new StringBuilder().append("g^{x4}=").append(v24.getGx2().toString(16)).toString());
        System.out.println(new StringBuilder().append("KP{x3}={").append(v24.getKnowledgeProofForX1()[0].toString(16)).append("};{").append(v24.getKnowledgeProofForX1()[1].toString(16)).append("}").toString());
        System.out.println(new StringBuilder().append("KP{x4}={").append(v24.getKnowledgeProofForX2()[0].toString(16)).append("};{").append(v24.getKnowledgeProofForX2()[1].toString(16)).append("}").toString());
        System.out.println("");
        v3_1.validateRound1PayloadReceived(v24);
        System.out.println("Alice checks g^{x4}!=1: OK");
        System.out.println("Alice checks KP{x3}: OK");
        System.out.println("Alice checks KP{x4}: OK");
        System.out.println("");
        v9_1.validateRound1PayloadReceived(v18);
        System.out.println("Bob checks g^{x2}!=1: OK");
        System.out.println("Bob checks KP{x1},: OK");
        System.out.println("Bob checks KP{x2},: OK");
        System.out.println("");
        org.spongycastle.crypto.agreement.jpake.JPAKERound2Payload v19 = v3_1.createRound2PayloadToSend();
        org.spongycastle.crypto.agreement.jpake.JPAKERound2Payload v25 = v9_1.createRound2PayloadToSend();
        System.out.println("************ Round 2 **************");
        System.out.println("Alice sends to Bob: ");
        System.out.println(new StringBuilder().append("A=").append(v19.getA().toString(16)).toString());
        System.out.println(new StringBuilder().append("KP{x2*s}={").append(v19.getKnowledgeProofForX2s()[0].toString(16)).append("},{").append(v19.getKnowledgeProofForX2s()[1].toString(16)).append("}").toString());
        System.out.println("");
        System.out.println("Bob sends to Alice");
        System.out.println(new StringBuilder().append("B=").append(v25.getA().toString(16)).toString());
        System.out.println(new StringBuilder().append("KP{x4*s}={").append(v25.getKnowledgeProofForX2s()[0].toString(16)).append("},{").append(v25.getKnowledgeProofForX2s()[1].toString(16)).append("}").toString());
        System.out.println("");
        v3_1.validateRound2PayloadReceived(v25);
        System.out.println("Alice checks KP{x4*s}: OK\n");
        v9_1.validateRound2PayloadReceived(v19);
        System.out.println("Bob checks KP{x2*s}: OK\n");
        java.math.BigInteger v16 = v3_1.calculateKeyingMaterial();
        java.math.BigInteger v22 = v9_1.calculateKeyingMaterial();
        System.out.println("********* After round 2 ***********");
        System.out.println(new StringBuilder().append("Alice computes key material \t K=").append(v16.toString(16)).toString());
        System.out.println(new StringBuilder().append("Bob computes key material \t K=").append(v22.toString(16)).toString());
        System.out.println();
        org.spongycastle.crypto.examples.JPAKEExample.deriveSessionKey(v16);
        org.spongycastle.crypto.examples.JPAKEExample.deriveSessionKey(v22);
        org.spongycastle.crypto.agreement.jpake.JPAKERound3Payload v20 = v3_1.createRound3PayloadToSend(v16);
        org.spongycastle.crypto.agreement.jpake.JPAKERound3Payload v26 = v9_1.createRound3PayloadToSend(v22);
        System.out.println("************ Round 3 **************");
        System.out.println("Alice sends to Bob: ");
        System.out.println(new StringBuilder().append("MacTag=").append(v20.getMacTag().toString(16)).toString());
        System.out.println("");
        System.out.println("Bob sends to Alice: ");
        System.out.println(new StringBuilder().append("MacTag=").append(v26.getMacTag().toString(16)).toString());
        System.out.println("");
        v3_1.validateRound3PayloadReceived(v26, v16);
        System.out.println("Alice checks MacTag: OK\n");
        v9_1.validateRound3PayloadReceived(v20, v22);
        System.out.println("Bob checks MacTag: OK\n");
        System.out.println();
        System.out.println("MacTags validated, therefore the keying material matches.");
        return;
    }

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


    public DESExample(String p16, String p17, String p18, boolean p19)
    {
        this.encrypt = 1;
        this.cipher = 0;
        this.in = 0;
        this.out = 0;
        this.key = 0;
        this.encrypt = p19;
        try {
            this.in = new java.io.BufferedInputStream(new java.io.FileInputStream(p16));
            try {
                this.out = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p17));
            } catch (java.io.IOException v2) {
                System.err.println(new StringBuilder().append("Output file not created [").append(p17).append("]").toString());
                System.exit(1);
            }
            if (!p19) {
                try {
                    java.io.BufferedOutputStream v5_3 = new java.io.BufferedInputStream(new java.io.FileInputStream(p18));
                    int v8 = v5_3.available();
                    byte[] v4_1 = new byte[v8];
                    v5_3.read(v4_1, 0, v8);
                    this.key = org.spongycastle.util.encoders.Hex.decode(v4_1);
                } catch (java.io.IOException v3) {
                    System.err.println(new StringBuilder().append("Decryption key file not found, or not valid [").append(p18).append("]").toString());
                    System.exit(1);
                }
            } else {
                java.security.SecureRandom v10 = 0;
                try {
                    java.security.SecureRandom v11_1 = new java.security.SecureRandom();
                    try {
                        v11_1.setSeed("www.bouncycastle.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.engines.CramerShoupCoreEngine.initSecureRandom() calling method java.security.SecureRandom.<init>()


    protected java.security.SecureRandom initSecureRandom(boolean p1, java.security.SecureRandom p2)
    {
        if (p1) {
            if (p2 == null) {
                p2 = new java.security.SecureRandom();
            }
        } else {
            p2 = 0;
        }
        return p2;
    }

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)) {
            v0_1 = ((org.spongycastle.crypto.params.AsymmetricKeyParameter) p5);
            if ((!((org.spongycastle.crypto.params.AsymmetricKeyParameter) p5).isPrivate()) && (p4)) {
                this.random = new java.security.SecureRandom();
            }
        } 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.ec.ECNewRandomnessTransform.init() calling method java.security.SecureRandom.<init>()


    public void init(org.spongycastle.crypto.CipherParameters p4)
    {
        if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            if ((p4 instanceof org.spongycastle.crypto.params.ECPublicKeyParameters)) {
                this.key = ((org.spongycastle.crypto.params.ECPublicKeyParameters) p4);
                this.random = new java.security.SecureRandom();
            } else {
                throw new IllegalArgumentException("ECPublicKeyParameters are required for new randomness transform.");
            }
        } else {
            if ((((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters() instanceof org.spongycastle.crypto.params.ECPublicKeyParameters)) {
                this.key = ((org.spongycastle.crypto.params.ECPublicKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
            } else {
                throw new IllegalArgumentException("ECPublicKeyParameters are required for new randomness transform.");
            }
        }
        return;
    }

Method org.spongycastle.crypto.ec.ECNewPublicKeyTransform.init() calling method java.security.SecureRandom.<init>()


    public void init(org.spongycastle.crypto.CipherParameters p4)
    {
        if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            if ((p4 instanceof org.spongycastle.crypto.params.ECPublicKeyParameters)) {
                this.key = ((org.spongycastle.crypto.params.ECPublicKeyParameters) p4);
                this.random = new java.security.SecureRandom();
            } else {
                throw new IllegalArgumentException("ECPublicKeyParameters are required for new public key transform.");
            }
        } else {
            if ((((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters() instanceof org.spongycastle.crypto.params.ECPublicKeyParameters)) {
                this.key = ((org.spongycastle.crypto.params.ECPublicKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
            } else {
                throw new IllegalArgumentException("ECPublicKeyParameters are required for new public key transform.");
            }
        }
        return;
    }

Method org.spongycastle.crypto.ec.ECElGamalEncryptor.init() calling method java.security.SecureRandom.<init>()


    public void init(org.spongycastle.crypto.CipherParameters p4)
    {
        if (!(p4 instanceof org.spongycastle.crypto.params.ParametersWithRandom)) {
            if ((p4 instanceof org.spongycastle.crypto.params.ECPublicKeyParameters)) {
                this.key = ((org.spongycastle.crypto.params.ECPublicKeyParameters) p4);
                this.random = new java.security.SecureRandom();
            } else {
                throw new IllegalArgumentException("ECPublicKeyParameters are required for encryption.");
            }
        } else {
            if ((((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters() instanceof org.spongycastle.crypto.params.ECPublicKeyParameters)) {
                this.key = ((org.spongycastle.crypto.params.ECPublicKeyParameters) ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getParameters());
                this.random = ((org.spongycastle.crypto.params.ParametersWithRandom) p4).getRandom();
            } else {
                throw new IllegalArgumentException("ECPublicKeyParameters are required for encryption.");
            }
        }
        return;
    }

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


    public JPAKEParticipant(String p7, char[] p8, org.spongycastle.crypto.agreement.jpake.JPAKEPrimeOrderGroup p9)
    {
        this(p7, p8, p9, new org.spongycastle.crypto.digests.SHA256Digest(), new java.security.SecureRandom());
        return;
    }

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


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

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


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

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


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

Method com.zebra.sdk.certificate.internal.CertUtilities.savePrivateKey() calling method java.security.SecureRandom.<init>()


    protected void savePrivateKey(java.security.PrivateKey p7, java.io.Writer p8, String p9)
    {
        try {
            org.spongycastle.operator.OperatorCreationException v0_1 = new org.spongycastle.util.io.pem.PemWriter(p8);
            org.spongycastle.util.io.pem.PemObject v1_3 = new org.spongycastle.openssl.jcajce.JceOpenSSLPKCS8EncryptorBuilder(com.zebra.sdk.certificate.internal.CertUtilities.PRIVATE_KEY_CMS_ALGO);
            v1_3.setProvider("SC");
            v1_3.setRandom(new java.security.SecureRandom(new org.spongycastle.crypto.prng.ThreadedSeedGenerator().generateSeed(20, 1)));
            v1_3.setPasssword(p9.toCharArray());
            v0_1.writeObject(new org.spongycastle.openssl.jcajce.JcaPKCS8Generator(p7, v1_3.build()).generate());
            v0_1.close();
        } catch (org.spongycastle.operator.OperatorCreationException v0) {
        } catch (org.spongycastle.operator.OperatorCreationException v0) {
        } catch (org.spongycastle.operator.OperatorCreationException v0) {
        }
        return;
    }

Method org.spongycastle.math.ec.custom.sec.SecT131R2Curve.solveQuadraticEquation() calling method java.util.Random.<init>()


    private org.spongycastle.math.ec.ECFieldElement solveQuadraticEquation(org.spongycastle.math.ec.ECFieldElement p12)
    {
        if (!p12.isZero()) {
            org.spongycastle.math.ec.ECFieldElement v7 = this.fromBigInteger(org.spongycastle.math.ec.ECConstants.ZERO);
            org.spongycastle.math.ec.ECFieldElement v0 = 0;
            java.util.Random v2_0 = new java.util.Random();
            do {
                org.spongycastle.math.ec.ECFieldElement v3 = this.fromBigInteger(new java.math.BigInteger(131, v2_0));
                org.spongycastle.math.ec.ECFieldElement v6 = v7;
                org.spongycastle.math.ec.ECFieldElement v4 = p12;
                int v1 = 1;
                if (v1 >= 131) {
                    if (v4.isZero()) {
                    } else {
                        p12 = 0;
                    }
                } else {
                    org.spongycastle.math.ec.ECFieldElement v5 = v4.square();
                    v6 = v6.square().add(v5.multiply(v3));
                    v4 = v5.add(p12);
                    v1++;
                    while (v1 < 131) {
                    }
                }
            } while(v6.square().add(v6).isZero());
            p12 = v6;
        }
        return p12;
    }