Question

现在我已经生成了一个强素数的素数P，我怎么能生成一个原始根g？

我相信我会为g生成另一个bigInt，然后检查它是否是原始根。

这一代很容易，我可以像在Prime p一代那样做。

检查以确保它是原始根我有点难过。我需要确保等于g ^（（p-1）/ 2）的g ^ q与1 mod p不一致。是否有BigInteger函数来处理这个问题？

维基百科有这样的欧拉的理论。但我不确定哪个是我的，哪个是我的。我可以使用^ phi（n）来讨论这个论坛吗？

public void getKey() {
debug("Getting key (seed) from user");

BigInteger primeP;
BigInteger primeQ;
int bitLength = 512;
Random rnd = new Random();
boolean boolPrimeP = false;
boolean boolPrimeQ = false;
int iteration= 0;

while (boolPrimeQ == false || boolPrimeP == false){
    iteration++;
    primeQ = BigInteger.probablePrime(bitLength, rnd);
    boolPrimeQ = primeQ.isProbablePrime(3);
    if (boolPrimeQ==true){
        primeP = primeQ.multiply(BigInteger.valueOf(2));
        primeP = primeP.add(BigInteger.valueOf(1));
        boolPrimeP = primeP.isProbablePrime(3);
        if (boolPrimeP==true){
            break;
        }
    }
}

Answer 1

查找原始根mod p 很困难，尤其是在 p 非常大的情况下。我不确定在任何java库中是否存在预先构建的GetPrimitive()函数，但是遵循以下方法是我遇到的最好的（这是{{3中概述的一般算法） }}）。

您需要为快速取幂mod p 构建自己的函数。这通常是一个非常简单的递归任务。下面是伪代码，可以帮助您入门：

Function FastExpModP(x as int, n as int, p as int) {
    if (n == 0) {
        return(1);
    } else if (n == 1) {
        return(x);
    } else if (n mod 2==0) {
        return(FastExpModP(x^2 mod p, n/2, p));
    } else {
        return(x * FastExpModP(x^2 mod p, (n-1)/2, p)) mod p);
    }
}

接下来，你必须找到除{em> p - 1之后的所有素数（不是必然的素数因子分解），因为phi(p) = p - 1。假设 p - 1的素因子如下： p ₁，p ₂，...，p _k （已经发布了几种易于理解的算法来执行此任务，因此除非有要求，否则我会将其删除。）

现在所需要的只是检查表格的所有指数的每个元素的模幂运算mod p （我通常以数字2开头）

（ p - 1）/ p _i ，对于所有1＆lt; = i ＆lt; = ķ

直到找到所有指数的结果不等于1。以下是此任务的伪代码：

Function GetPrimitive(p as int, pfacs[] as int) {
    m = p - 1
    for (int i = 2; i <= m; ++i) {
        for (int q = 1; q <= pfacs.length; ++q) {
            test = FastExpModP(i, m/pfacs[q], p)
            if (test==1) {
                break;
            }
        }
        if (test > 1) {
            return(i);
        }
    }
}

例如，取素数 p = 28764457.现在， m = p - 1和的素数因子m 是：

2,3,7,131和1307

和 m 除以上述每个素数给出：

14382228,9588152,4109208,219576和22008

现在，我们将从2迭代，检查模幂运算mod p 以查看每个指数的结果是否等于1.我们停止一旦找到一个数字，使得模幂运算mod每个指数的 p 不等于1.

For 2 we have:
    2^14382228 = 1 mod p ==>> stop... try 3

For 3 we have:
    3^14382228 = 1 mod p ==>> stop... try 4

For 4 we have (same as 2 since 4 = 2^2):
    4^14382228 = 1 mod p ==>> stop... try 5

For 5 we have:
    5^14382228 = 28764456 mod p, 5^9588152 = 13076987 mod p, 5^4109208 = 1 mod p ==>> stop... try 6

For 6 we have:
    6^14382228 = 1 mod p ==>> stop... try 7

For 7 we have:
    7^14382228 = 1 mod p ==>> stop... try 8

For 8 we have (same as 2 since 8 = 2^3):
    8^14382228 = 1 mod p ==>> stop... try 9

For 9 we have (same as 3 since 9 = 3^2):
    9^14382228 = 1 mod p ==>> stop... try 10

For 10 we have:
    10^14382228 = 28764456 mod p, 10^9588152 = 15687469 mod p, 10^4109208 = 23392715 mod p
    10^219576 = 17852870 mod p, 10^22008 = 5014623 mod p ==>> winner!!!

因此，调用函数GetPrimitive(28764457, {2, 3, 7, 131, 1307})将返回10作为最小的原始根mod p 。

有关此主题的更多数学背景，请查看此wikipedia。

Answer 2

您想生成强素数，还是实现检查素性的算法？素数 P 强，如果它接近下一个素数 q ，而不是最小素数 p 小于 P 。在数学上，它意味着：

P＆gt; （p + q）/ 2;这里p是最接近的较小的，q是最接近的磨碎素，而不是P.

BigInteger有一个方法nextProbablePrime。当生成素数 p 时，生成下一个 P 然后下一个 q ，然后检查，如果 P＆gt; （P + Q）/ 2

在这里，你试图生成素数 P ，使得P = 2 * q - 1，这不是强素数，请参阅：https://en.wikipedia.org/wiki/Strong_prime

是否有BigInteger函数来处理这个问题？

“这个”是什么意思？ BigInt检查初始性并生成素数，也可以计算模数或其他算术运算。

但我不确定哪个是我的，哪个是我的

您的 n 就是数字 P ，您正在测试素数。 a 是用于检查的原始根，如果 P 是素数。

我怎样才能生成原始根g？

随机：）

另见Rabin-Miller算法。 https://rosettacode.org/wiki/Miller%E2%80%93Rabin_primality_test

java cyrptography BigInteger - 生成素数q找到素数P = 2q + 1，完成 - 现在如何生成和确认原始根g？

2 个答案: