java cyrptography BigInteger-生成素数q以查找素数P=2q+；1，完成-现在如何生成和确认基元根g？

既然我已经生成了素数p，它是一个强素数，我怎么能生成一个本原根g呢

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

这一代很容易，我可以像在素数p代中一样做到这一点

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

维基百科有这样的欧拉理论。但我不确定哪个是我的a，哪个是我的n。我可以用φ（n）来表示这个公式，对吗

---

您想生成一个强素数，还是实现一个检查素数的算法？ 质数P是强的，如果它更接近下一个质数q，而不是比P小的最大质数P。从数学上来说，它意味着：

p>（p+q）/2；这里p是比p小的最接近的，q是比p小的最接近的梯度素数

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

这里你试图生成素数p，使得p=2*q-1，这不是一个强素数，参见：

是否有BigInteger函数来处理此问题

你说的“这个”是什么意思？BigInt检查素数并生成素数，还可以计算模或其他算术运算

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

在这种情况下，你的n是p，你在测试素性。 如果P是素数，则a是用于检查的基元根

如何生成原始根g

随机：）

另见Rabin-Miller算法。

---

很难找到原始根mod p，特别是当p非常大时。我不确定在任何java库中是否存在预构建的

GetPrimitive（）

函数，但是遵循下面的方法是我遇到的最好的方法（这是上面介绍的通用算法）

您需要构建自己的函数以实现快速求幂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);
    }
}

接下来，您必须找到所有除p-1的素数（不一定是素数分解），因为

phi（p）=p-1

。假设p-1的主要因素如下：p1，p2，…，pk（已经有几个已发布的易于理解的算法用于执行此任务，因此除非有要求，否则我将省略此项）

现在需要做的就是检查每个元素（我通常从数字2开始）在形式的所有指数上的模幂mod p

---

（p-1）/pi，尽管如此，我认为这并不能真正回答OP的问题。OP清楚地指出，他已经生成了一个强素数，并且想要找到这样一个数的本原根。你在这里，但我对素数生成感到困惑，因为它似乎是安全的，而不是强的，是吗？确实如此。很好的捕捉。因为你的素数P有特殊的形式P=2q+1，所以检查素数性很容易。因为P-1=2q，所以选择一个g！=1如果g^2！=1和g^q！=1那么g是一个原始根。@JamesKPolk，很好的洞察力。在花了一点时间验证你评论中的数学之后，我下面的答案似乎来自黑暗时代。你为什么不加上你的评论作为回答呢，因为它比你的回答高得多？我不希望我的答案仍然是主要的。我会很高兴地把它投上去，把我的移走，以免增加噪音。

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

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

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!!!