离散对数求解算法

最新推荐文章于 2023-02-12 20:18:32 发布
原创 最新推荐文章于 2023-02-12 20:18:32 发布 · 1.2w 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#二分查找 #离散对数

本文介绍了离散对数问题的解决算法——baby_step_giant_step，以及其扩展形式用于处理非素数模的情况。通过预处理、二分查找和快速幂等技术，实现了O(sqrt(P)*log(sqrt(P)))时间复杂度的求解过程。同时，讨论了原根和扩展小步大步攻击算法，包括原根的定义、性质、判定定理及求解步骤，最后给出了相关样题和代码模板。


求解一个最小的x满足给定的方程Bx == N (mod P)

使用baby_step_giant_step算法。也就是先小步后大步算法。

1、令x=i*m+j  (m=ceil(sqrt(p)))，

那么原式化为 B^(i*m)*B^j==N(MOD P)

B^j==N*B^(-i*m)(MOD P)---------->B^j==N*B^m^(-i)(MOD P)

2、先预处理B^0,B^1,B^2……B^(m-1),存入HASH表,我使用结构体排序然后二分查找，这一步就是baby_step,每次移动1

3、然后快速幂求出B^-m,枚举i，如果存在N*B^(-i*m)存在于HASH表中，说明存在解x=i*m+j，这一步为giant_step,每次移动m

注意以上解法是最基本的，只能对于gcd(B,P)==1，算法的时间复杂度是O(sqrt(P)*log(sqrt(P)))

样题：poj2417

ps：参考cxlove博客，密码学里面貌似叫做shanks算法 点击打开链接

模板：

///大步小步算法
struct baby///小步算法预存的结构体定义
{
    long long b,j;
    bool operator < (const baby &other)const{
        if(b==other.b)return j<other.j;
        return b<other.b;
    }
}babyv[100005];
///快速幂，x^y%mod
long long q_pow(long long x,long long y,long long mod)
{
    long long ans=1;
    while(y>0)
    {
        if(y&1)ans=(ans*x)%mod;
        x=(x*x)%mod;
        y>>=1;
    }
    return ans;
}
///小步预存的个数为m的结构体里面查找num
long long find(long long num,long long m)
{
    long long l=0,r=m-1,ans=-1;
    while(r>=l)
    {
        long long mid=(r+l)/2;
        if(babyv[mid].b>=num){
            if(babyv[mid].b==num)
                ans=babyv[mid].j;
            r=mid-1;
        }
        else l=mid+1;
    }
    return ans;
}
///B^x=N(modP)求解x，无解返回-1
long long babystep_giantstep(long long B,long long N,long long P)
{
    long long m=ceil(sqrt(P)),ans=1;
    for(long long j=0;j<m;j++)///预存操作
    {
        babyv[j].b=ans;
        babyv[j].j=j;
        ans=(ans*B)%P;///递推
    }
    ans=1;
    sort(babyv,babyv+m);///预存排序
    long long _Bm=q_pow(q_pow(B,P-2,P),m,P);///算出B^(-m)%P的值
    for(long long i=0;i<m;i++)
    {
        long long j=find(N*ans%P,m);///二分查找
        if(j!=-1)return i*m+j;///找到返回答案
        ans=(ans*_Bm)%P;///继续递推
    }
    return -1;///找不到答案
}

poj2417代码：点击打开链接

#include<cmath>
#include<cstdio>
#include<vector>
#include<string>
#include<cstdlib>
#include<utility>
#include<cstring>
#include<iostream>
#include<algorithm>
#define Inf (1<<29)
#define LL long long
using namespace std;
const int MM=110;
const long long MOD=1000000007;
///大步小步算法
struct baby///小步算法预存的结构体定义
{
    long long b,j;
    bool operator < (const baby &other)const{
        return b<other.b;
    }
}babyv[100005];
///快速幂，x^y%mod
long long q_pow(long long x,long long y,long long mod)
{
    long long ans=1;
    while(y>0)
    {
        if(y&1)ans=(ans*x)%mod;
        x=(x*x)%mod;
        y>>=1;
    }
    return ans;
}
///小步预存的个数为m的结构体里面查找num
long long find(long long num,long long m)
{
    long long l=0,r=m-1;
    while(r>=l)
    {
        long long mid=(r+l)/2;
        if(babyv[mid].b==num)return babyv[mid].j;
        else if(babyv[mid].b>num)r=mid-1;
        else l=mid+1;
    }
    return -1;
}
///B^x=N(modP)求解x，无解返回-1
long long babystep_giantstep(long long B,long long N,long long P)
{
    long long m=ceil(sqrt(P-1)),ans=1;
    for(long long j=0;j<m;j++)///预存操作
    {
        babyv[j].b=ans;
        babyv[j].j=j;
        ans=(ans*B)%P;///递推
    }
    ans=1;
    sort(babyv,babyv+m);///预存排序
    long long _Bm=q_pow(q_pow(B,P-2,P),m,P);///算出B^(-m)%P的值
    for(long long i=0;i<m;i++)
    {
        long long j=find(N*ans%P,m);///二分查找
        if(j!=-1)return i*m+j;///找到返回答案
        ans=(ans*_Bm)%P;///继续递推
    }
    return -1;///找不到答案
}
int main()
{
    long long B,N,P;
    //freopen("D:\\o.txt","r",stdin);
    while(~scanf("%lld%lld%lld",&P,&B,&N))
    {
        long long ans=babystep_giantstep(B,N,P);
        if(ans==-1)puts("no solution");
        else printf("%lld\n",ans);
    }
    return 0;
}
 

 

求解一个最小的x满足给定的方程Ax == B (mod C)
 

其中C任意，即C不一定是素数
 

算法 ： 扩展小步大步攻击
 

扩展小步大步攻击：A ^ x = B (mod C)
 

1 ：  i = 0-> 100 if A^i mod C == B return i;///做这一步是第四步有一个n
 

2 ：  消因子， 将A^x = B mod C 划为 d * A ^ (x – n) = B (modC)
 

3 ： m = ceil (sqrt(C))
 

4 ： 将 A ^ (x - n) 化为  A ^ (I * m + j)(原x 化为了 n + I * m + j)这里与小步大步攻击不同
 

5 ： for j = 0 ->m   hash（j,A ^ j mod  C）
 

6 ： for i = 0 ->m   AA = B/(d * A ^ m ^i)
 

7 ：在hash表中查找AA，若有，取AA对应的j，则答案为I * m + j + n
 

样题：poj3243 hdu2815
 

ps：参考点击打开链接有详细证明的方法
 

模板：
 

 

///扩展大步小步算法
struct baby///小步算法预存的结构体定义
{
    long long b,j;
    bool operator < (const baby &other)const{
        if(b==other.b)return j<other.j;
        return b<other.b;
    }
}babyv[100005];
long long extended_euclid(long long a,long long b,long long &x,long long &y)
{
     long long d;
     if(b == 0) {x = 1;     y = 0;     return a;}
     d = extended_euclid(b, a % b, y, x);
     y -= a / b * x;
     return d;
}
long long Inv(long long a,long long n)
{
     long long d, x, y;
     d = extended_euclid(a, n, x, y);
     if(d == 1)	return (x%n + n) % n;
     else			return -1; // no solution
}
long long gcd(long long x,long long y)
{
    if(y==0)return x;
    return gcd(y,x%y);
}
///快速幂，x^y%mod
long long q_pow(long long x,long long y,long long mod)
{
    long long ans=1;
    while(y>0)
    {
        if(y&1)ans=(ans*x)%mod;
        x=(x*x)%mod;
        y>>=1;
    }
    return ans;
}
///小步预存的个数为m的结构体里面查找num
long long find(long long num,long long m)
{
    long long l=0,r=m-1,ans=-1;
    while(r>=l)
    {
        long long mid=(r+l)/2;
        if(babyv[mid].b>=num){
            if(babyv[mid].b==num)
                ans=babyv[mid].j;
            r=mid-1;
        }
        else l=mid+1;
    }
    return ans;
}
///A^x=B(modC)求解x，gcd(A,C)不一定等于1，无解返回-1
long long ex_babystep_giantstep(long long A,long long B,long long C)
{
    for(long long i=0;i<=100;i++)///先在小于100的数里面测试
        if(q_pow(A,i,C)==B%C)return i;
    ///消因子， 将A^x=B%C化为d*A^(x – n)=B%C
    long long g,n=0,d=1;
    while((g=gcd(A,C))!=1)
    {
        if(B%g)return -1;///无解
        n++;
        B/=g;
        C/=g;
        d=(d*A/g)%C;
    }
    ///无扩展小步大步操作
    long long m=ceil(sqrt(C)),ans=1;
    for(long long j=0;j<m;j++)///预存操作
    {
        babyv[j].b=ans;
        babyv[j].j=j;
        ans=(ans*A)%C;///递推
    }
    ans=1;
    sort(babyv,babyv+m);///预存排序
    long long Bm=q_pow(Inv(A,C),m,C);///算出A^(-m)%C的值
    for(long long i=0;i<m;i++)
    {
        long long j=find(Inv(d,C)*B%C*ans%C,m);///二分查找
        if(j!=-1)return i*m+j+n;///找到返回答案
        ans=(ans*Bm)%C;///继续递推
    }
    return -1;///找不到答案
}
 

 


 
 

poj3243点击打开链接
 

 

#include<cmath>
#include<cstdio>
#include<vector>
#include<string>
#include<cstdlib>
#include<utility>
#include<cstring>
#include<iostream>
#include<algorithm>
#define Inf (1<<29)
#define LL long long
using namespace std;
const int MM=110;
const long long MOD=1000000007;
///扩展大步小步算法
struct baby///小步算法预存的结构体定义
{
    long long b,j;
    bool operator < (const baby &other)const{
        if(b==other.b)return j<other.j;
        return b<other.b;
    }
}babyv[100005];
long long extended_euclid(long long a,long long b,long long &x,long long &y)
{
     long long d;
     if(b == 0) {x = 1;     y = 0;     return a;}
     d = extended_euclid(b, a % b, y, x);
     y -= a / b * x;
     return d;
}
long long Inv(long long a,long long n)
{
     long long d, x, y;
     d = extended_euclid(a, n, x, y);
     if(d == 1)	return (x%n + n) % n;
     else			return -1; // no solution
}
long long gcd(long long x,long long y)
{
    if(y==0)return x;
    return gcd(y,x%y);
}
///快速幂，x^y%mod
long long q_pow(long long x,long long y,long long mod)
{
    long long ans=1;
    while(y>0)
    {
        if(y&1)ans=(ans*x)%mod;
        x=(x*x)%mod;
        y>>=1;
    }
    return ans;
}
///小步预存的个数为m的结构体里面查找num
long long find(long long num,long long m)
{
    long long l=0,r=m-1,ans=-1;
    while(r>=l)
    {
        long long mid=(r+l)/2;
        if(babyv[mid].b>=num){
            if(babyv[mid].b==num)
                ans=babyv[mid].j;
            r=mid-1;
        }
        else l=mid+1;
    }
    return ans;
}
///A^x=B(modC)求解x，gcd(A,C)不一定等于1，无解返回-1
long long ex_babystep_giantstep(long long A,long long B,long long C)
{
    for(long long i=0;i<=100;i++)///先在小于100的数里面测试
        if(q_pow(A,i,C)==B%C)return i;
    ///消因子， 将A^x=B%C化为d*A^(x – n)=B%C
    long long g,n=0,d=1;
    while((g=gcd(A,C))!=1)
    {
        if(B%g)return -1;///无解
        n++;
        B/=g;
        C/=g;
        d=(d*A/g)%C;
    }
    ///无扩展小步大步操作
    long long m=ceil(sqrt(C)),ans=1;
    for(long long j=0;j<m;j++)///预存操作
    {
        babyv[j].b=ans;
        babyv[j].j=j;
        ans=(ans*A)%C;///递推
    }
    ans=1;
    sort(babyv,babyv+m);///预存排序
    long long Bm=q_pow(Inv(A,C),m,C);///算出A^(-m)%C的值
    for(long long i=0;i<m;i++)
    {
        long long j=find(Inv(d,C)*B%C*ans%C,m);///二分查找
        if(j!=-1)return i*m+j+n;///找到返回答案
        ans=(ans*Bm)%C;///继续递推
    }
    return -1;///找不到答案
}
int main()
{
    long long X,Z,K;
    //freopen("D:\\o.txt","r",stdin);
    while(~scanf("%lld%lld%lld",&X,&Z,&K))
    {
        if(X==0&&Z==0&&K==0)break;
        long long ans=ex_babystep_giantstep(X,K,Z);
        if(ans==-1)puts("No Solution");
        else printf("%lld\n",ans);
    }
    return 0;
}






 hdu2815
点击打开链接 

注意：K>=Z
 
 


 
 

 

#include<cmath>
#include<cstdio>
#include<vector>
#include<string>
#include<cstdlib>
#include<utility>
#include<cstring>
#include<iostream>
#include<algorithm>
#define Inf (1<<29)
#define LL long long
using namespace std;
const int MM=110;
const long long MOD=1000000007;
///扩展大步小步算法
struct baby///小步算法预存的结构体定义
{
    long long b,j;
    bool operator < (const baby &other)const{
        if(b==other.b)return j<other.j;
        return b<other.b;
    }
}babyv[100005];
long long extended_euclid(long long a,long long b,long long &x,long long &y)
{
     long long d;
     if(b == 0) {x = 1;     y = 0;     return a;}
     d = extended_euclid(b, a % b, y, x);
     y -= a / b * x;
     return d;
}
long long Inv(long long a,long long n)
{
     long long d, x, y;
     d = extended_euclid(a, n, x, y);
     if(d == 1)	return (x%n + n) % n;
     else			return -1; // no solution
}
long long gcd(long long x,long long y)
{
    if(y==0)return x;
    return gcd(y,x%y);
}
///快速幂，x^y%mod
long long q_pow(long long x,long long y,long long mod)
{
    long long ans=1;
    while(y>0)
    {
        if(y&1)ans=(ans*x)%mod;
        x=(x*x)%mod;
        y>>=1;
    }
    return ans;
}
///小步预存的个数为m的结构体里面查找num
long long find(long long num,long long m)
{
    long long l=0,r=m-1,ans=-1;
    while(r>=l)
    {
        long long mid=(r+l)/2;
        if(babyv[mid].b>=num){
            if(babyv[mid].b==num)
                ans=babyv[mid].j;
            r=mid-1;
        }
        else l=mid+1;
    }
    return ans;
}
///A^x=B(modC)求解x，gcd(A,C)不一定等于1，无解返回-1
long long ex_babystep_giantstep(long long A,long long B,long long C)
{
    for(long long i=0;i<=100;i++)///先在小于100的数里面测试
        if(q_pow(A,i,C)==B%C)return i;
    ///消因子， 将A^x=B%C化为d*A^(x – n)=B%C
    long long g,n=0,d=1;
    while((g=gcd(A,C))!=1)
    {
        if(B%g)return -1;///无解
        n++;
        B/=g;
        C/=g;
        d=(d*A/g)%C;
    }
    ///无扩展小步大步操作
    long long m=ceil(sqrt(C)),ans=1;
    for(long long j=0;j<m;j++)///预存操作
    {
        babyv[j].b=ans;
        babyv[j].j=j;
        ans=(ans*A)%C;///递推
    }
    ans=1;
    sort(babyv,babyv+m);///预存排序
    long long Bm=q_pow(Inv(A,C),m,C);///算出A^(-m)%C的值
    for(long long i=0;i<m;i++)
    {
        long long j=find(Inv(d,C)*B%C*ans%C,m);///二分查找
        if(j!=-1)return i*m+j+n;///找到返回答案
        ans=(ans*Bm)%C;///继续递推
    }
    return -1;///找不到答案
}
int main()
{
    long long X,Z,K;
    while(~scanf("%I64d%I64d%I64d",&X,&Z,&K))
    {
        //if(X==0&&Z==0&&K==0)break;
        if(K>=Z){puts("Orz,I can’t find D!");continue;}
        long long ans=ex_babystep_giantstep(X,K,Z);
        if(ans==-1)puts("Orz,I can’t find D!");
        else printf("%I64d\n",ans);
    }
    return 0;
}



 

给定k，m，newx，其中m是素数，求出满足x^k mod m = newx 所有 x 的值
 

预备：
 
 

a、模mod的群G的元的阶的定义：a^m%mod==e的最小整数m叫做元a的阶
 b、原根（本原元素）的定义:a^phi(m)%m==e,phi(m)是a的阶，则称a是模m的一个原根
 

原根的性质：{1,2,...,m-1} = {g,g^2,...,g^(m-1)}其中g是原根
 

原根的判定定理（欧拉定理）：p（大于2）是一个素数，a是本原元素当且仅当a的（p－1）╱q次方（模p）不等于1，q是p-1的所有因子
 
 

求解问题的算法步骤如下 
 
 

1) 先暴力求m的原根g
  2) 大步小步求g^t = newx mod m
  3) 则g^(t+v*m1) = newx mod m, m1 = p - 1
  4) 设x = g^u mod p, x^k = (g^u)^k = g^(uk) = g^(t+v*m1)
 

化成uk+vm=t，可以用扩展欧几里得求得
 
 

样题：hdu3930  点击打开链接
 
 

参考自点击打开链接
 

代码如下：
 

 

#include<cmath>
#include<cstdio>
#include<vector>
#include<string>
#include<cstdlib>
#include<utility>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
long long cnt=0;
long long p[2000001];
bool isprime[2000001];
///求a*b%c,因为a，b很大，所以要先将b写成二进制数
long long mul_mod(long long a, long long b, long long mod )
{
    long long ans = 0, d = a % mod;
    while( b )
    {
        if( b & 1 )
        {
            ans += d;
            if( ans > mod )ans -= mod;
        }
        d += d;
        if( d > mod )d -= mod;
        b >>= 1;
    }
    return ans;
}
void init()
{
    isprime[0]=isprime[1]=true;
    for(int i=2; i<=1000000; i++)
    {
        if(isprime[i])continue;
        p[cnt++]=i;
        for(int j=i+i; j<=1000000; j+=i)
            isprime[j]=true;
    }
}
long long num=0;
long long f[200];
void factor(long long n)
{
    num=0;
    for(long long i=0; i<cnt&&p[i]*p[i]<=n; i++)
    {
        if(n%p[i]==0)
        {
            f[num++]=p[i];
            while(n%p[i]==0)n/=p[i];
        }
    }
    if(n>1)f[num++]=n;
}
///扩展大步小步算法
struct baby///小步算法预存的结构体定义
{
    long long b,j;
    bool operator < (const baby &other)const
    {
        if(b==other.b)return j<other.j;
        return b<other.b;
    }
} babyv[4000005];
long long extended_euclid(long long a,long long b,long long &x,long long &y)
{
    long long d;
    if(b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    d = extended_euclid(b, a % b, y, x);
    y -= a / b * x;
    return d;
}
long long Inv(long long a,long long n)
{
    long long d, x, y;
    d = extended_euclid(a, n, x, y);
    if(d == 1)	return (x%n + n) % n;
    else			return -1; // no solution
}
long long gcd(long long x,long long y)
{
    if(y==0)return x;
    return gcd(y,x%y);
}
///快速幂，x^y%mod
long long q_pow(long long x,long long y,long long mod)
{
    long long ans=1;
    while(y>0)
    {
        //if(y&1)ans=(ans*x)%mod;
        if(y&1)ans=mul_mod(ans,x,mod);
        //x=(x*x)%mod;
        x=mul_mod(x,x,mod);
        y>>=1;
    }
    return ans;
}
///小步预存的个数为m的结构体里面查找num
long long find(long long num,long long m)
{
    long long l=0,r=m-1,ans=-1;
    while(r>=l)
    {
        long long mid=(r+l)/2;
        if(babyv[mid].b>=num)
        {
            if(babyv[mid].b==num)
                ans=babyv[mid].j;
            r=mid-1;
        }
        else l=mid+1;
    }
    return ans;
}
///A^x=B(modC)求解x，gcd(A,C)不一定等于1，无解返回-1
long long ex_babystep_giantstep(long long A,long long B,long long C)
{
    for(long long i=0; i<=100; i++) ///先在小于100的数里面测试
        if(q_pow(A,i,C)==B%C)return i;
    ///消因子， 将A^x=B%C化为d*A^(x – n)=B%C
    long long g,n=0,d=1;
    while((g=gcd(A,C))!=1)
    {
        if(B%g)return -1;///无解
        n++;
        B/=g;
        C/=g;
        //d=(d*A/g)%C;
        d=mul_mod(d,A/g,C);
    }
    ///无扩展小步大步操作
    long long m=ceil(sqrt(C+0.0)),ans=1;
    for(long long j=0; j<m; j++) ///预存操作
    {
        babyv[j].b=ans;
        babyv[j].j=j;
        //ans=(ans*A)%C;///递推
        ans=mul_mod(ans,A,C);
    }
    ans=1;
    sort(babyv,babyv+m);///预存排序
    long long Bm=q_pow(Inv(A,C),m,C);///算出A^(-m)%C的值
    for(long long i=0; i<m; i++)
    {
        long long temp=mul_mod(Inv(d,C),B,C);//Inv(d,C)*B%C*ans%C
        temp=mul_mod(temp,ans,C);
        long long j=find(temp,m);///二分查找
        if(j!=-1)return i*m+j+n;///找到返回答案
        //ans=(ans*Bm)%C;///继续递推
        ans=mul_mod(ans,Bm,C);
    }
    return -1;///找不到答案
}
bool judge(long long g,long long mod)
{
    long long i;
    for(i=0; i<num; i++)
        if(q_pow(g,(mod-1)/f[i],mod)==1)break;
    if(i>=num)return true;
    return false;
}
long long find_g(long long mod)
{
    factor(mod-1);
    for(long long g=2;; g++)
        if(judge(g,mod))return g;
}
vector<long long>res;
int main()
{
    init();
    long long Case=1;
    long long newx,k,m;
    while(scanf("%I64d%I64d%I64d",&k,&m,&newx)!=EOF)
    {
        printf("case%I64d:\n",Case++);
        long long u,v;
        long long g=find_g(m);
        long long t=ex_babystep_giantstep(g,newx,m);
        long long GCD=extended_euclid(k,m-1,u,v);
        if(t%GCD||newx>=m)puts("-1");
        else
        {
            res.clear();
            long long up=t/GCD;
            long long down=(m-1)/GCD;
            u=(u*up%down+down)%down;
            for(long long i=0; i<GCD; i++)
            {
                long long temp=u+down*i;
                res.push_back(q_pow(g,temp,m));
            }
            sort(res.begin(),res.end());
            for(long long i=0; i<res.size(); i++)
                printf("%I64d\n",res[i]);
        }
    }
    return 0;
}


 

 

 


                

        

    

  



    



                



	

		

			

				
					
密码学笔记：离散对数求解相关算法实现

				
			

			

				

					Slightwind's Blog
				

				

					03-25
					
					1万+
					
				

			

		

		

			
				
离散对数求解相关算法计算方法介绍以及使用Python3实现...

			
		

	



                

            
              



	

		

			

				
					
求解离散对数——BSGS算法の板子

				
			

			

				

					ADP+Pi==ATP
				

				

					02-20
					
					3028
					
				

			

		

		

			
				
ATP发现坐在机房里最直接的代价就是用于零食的生活费和体重都直线上涨= =

			
		

	



              


  
              

                


	

		

			

				
					
离散对数-BSGS算法

				
			

			

				

					oWuHen12的博客
				

				

					10-01
					
					972
					
				

			

		

		

			
				
口胡
参考：扩展大步小步法解决离散对数问题
离散对数主要是求解这样一类问题：
ax≡b(modm)a^x \equiv b \pmod max≡b(modm) 大概就是(modm)\pmod m(modm)意义下的对数
这里只考虑 (m,a)(m,a)(m,a)为1的情况。一般来说，给出的m是一个质数。
设x=A⌈p⌉+Bx = A \lceil \sqrt{p} \rceil + Bx=A⌈p​...

			
		

	





	

		

			

				
					
离散对数求解、BSGS算法

				
			

			

				

					nameofcsdn的博客
				

				

					04-23
					
					3229
					
				

			

		

		

			
				
目录

一，广义离散对数问题

二，广义离散对数问题的规约

三，shanks算法

四，OJ实战

一，广义离散对数问题

包括狭义的离散对数问题，和椭圆曲线上的点的数乘的逆运算，都算广义离散对数问题，他们的求解方案都差不多。

为了能够用统一的语言来描述，我们首先考虑，如何把广义离散对数问题，规约成狭义离散对数问题。

二，广义离散对数问题的规约

1，逆元

有限域中，元素的逆元可以用费马小定理+快速幂，a^(p-2)是a的逆元

椭圆曲线上，点A（x,y）的逆元是-A，即（x,-y）

2，基点的阶

			
		

	



		

			
		



	

		

			

				
					
离散对数求解学习笔记

				
			

			

				

					weixin_30701521的博客
				

				

					09-19
					
					717
					
				

			

		

		

			
				
一个经典的算法——BSGS算法
 BSGS全名为Baby-Step-Giant-Step，即大小步法，有人戏称之为北上广深算法。可以快速求解离散对数问题，形如，C是素数。
 BSGS算法使用了一个重要的引理：

重要的引理
 如果，那么。

 证明这个引理需要用到欧拉定理

欧拉定理
 如果，那么。
 证明（十分精彩的证明）：
...

			
		

	





	

		

			

				
					
实验二 编程实现离散对数求解 （Python实现）

				
			

			

				

					chuxuezheerer的博客
				

				

					06-07
					
					2940
					
				

			

		

		

			
				
一.实验内容
本周的任务是写一个程序来计算模素数p的离散对数。

二.解题思路
根据实验文档中提供的思路，令B=q=220B=\sqrt{q}=2^{20}B=q​=220,x=x0B+x1x=x_0B+x_1x=x0​B+x1​,其中x0,x1∈[0,B)x_0,x_1\in[0,B)x0​,x1​∈[0,B)
经过变换有：
h=gx0B+x1=(gB)x0⋅gx1(modp) h=g^{x_0B+x_1}=(g^B)^{x_0}·g^{x_1}( mod p)h=gx0​B+x1​=(gB)x0​⋅gx

			
		

	





	

		

			

				
					
Pollard rho 算法求解离散对数问题

				
			

			

				

					国科大网安二班的博客
				

				

					02-28
					
					4605
					
				

			

		

		

			
				
Pollard ρ\rhoρ 算法求解离散对数问题
离散对数(DLP)问题：设有群(G,⋅)(G,\cdot)(G,⋅)，α∈G\alpha \in Gα∈G是一个nnn阶元素。给定β∈<α>\beta \in \left< \alpha \right>β∈⟨α⟩，找到指数c，0≤c≤n−1c，0\le c\le n-1c，0≤c≤n−1，满足
αc=β
\alpha ^{c} =\beta
αc=β
前面分享过因子分解的Pollard ρ\rhoρ 算法（为了更好地理解Pollar

			
		

	





	

		

			

				
					
密码学离散对数算法

				
			

			

				

					m0_67837149的博客
				

				

					02-12
					
					667
					
				

			

		

		

			
				
密码学离散对数算法

			
		

	





	

		

			

				
					
离散对数求解e算法

					
最新发布

				
			

			

				

					09-13
				

			

		

		

			
				
不过，常见的离散对数求解算法有Pollard rho算法、小步大步算法（BSGS）、Pohlig - Hellman算法等。  Pollard rho算法是启发式的算法，不是确定性的数学证明算法，它可能得到较好的解，也可能会失败，这取决于攻击者...

			
		

	





	

		

			

				
					
求离散对数问题——指数演算法

				
			

			

				

					国科大网安二班的博客
				

				

					03-14
					
					2109
					
				

			

		

		

			
				
求离散对数问题——指数演算法
离散对数(DLP)问题：设有群(G,⋅)(G,\cdot)(G,⋅)，α∈G\alpha \in Gα∈G是一个nnn阶元素。给定β∈<α>\beta \in \left< \alpha \right>β∈⟨α⟩，找到指数a，0≤a≤n−1a，0\le a\le n-1a，0≤a≤n−1，满足
αa=β
\alpha ^{a} =\beta
αa=β
这时aaa也表达成：a=log⁡αβa=\log_{\alpha}\betaa=logα​β.
前面介绍

			
		

	





	

		

			

				
					
离散对数求解实验

				
			

			

				

					qq_28786023的博客
				

				

					10-11
					
					1293
					
				

			

		

		

			
				
数据如下：
p=
13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084171

g=
11717829880366207009516117596335367088558084999998952205599979459063929499736583746670.

			
		

	





	

		

			

				
					
离散对数的求解(bsgs)

				
			

			

				

					weixin_30718391的博客
				

				

					04-16
					
					259
					
				

			

		

		

			
				
bsgs算法
主要用来解决${A^x} = B(\bmod C)$(c是质数)，都是整数，已知A、B、C求x。
例：poj 2417Discrete Logging
具体步骤如下：
先把$x = i*m - j$，其中$m = ceil(\sqrt C )$，（ceil是向上取整）。
这样原式就变为${A^{(i*m - j)}} = B(\bmod C)$，
再变为${A^j...

			
		

	





	

		

			

				
					
大步小步算法（求解离散对数）

				
			

			

				

					qq_50812688的博客
				

				

					07-16
					
					1387
					
				

			

		

		

			
				
baby step giant step简称为大步小步算法，是一个用来求解离散对数的方法，设a的b次对m取模得b，a与m互质时我们令x=At-B,a的At次等于b*a的B次，之后先对右边的数进行存储，，哈希map速度快一点，之后再从左边找，有则返回值，这是一种类似于meet In the middle 的算法，不难验证我们取t为sqrt（fi（m））则可以搜索到所有数值，为了避免算欧拉函数我们令t=sqrt（m），



扩展大步小步算法，当a与m不互质时，我们把式子写成a*a的x-1次+mn=b，同除d若

			
		

	





	

		

			

				
					
离散对数(例题+详解+代码模板)

				
			

			

				

					dreamzuora的博客
				

				

					10-06
					
					3108
					
				

			

		

		

			
				
题意：
给定x,n,m,求x^y=n(mod m)的解(其中m是素数)




求解一个最小的x满足给定的方程Bx == N (mod P)

使用baby_step_giant_step算法。也就是先小步后大步算法。

1、令x=i*m+j  (m=ceil(sqrt(p)))，

那么原式化为 B^(i*m)*B^j==N(MOD P)

B^j==N*B^(-i*

			
		

	





	

		

			

				
					
离散对数及其拓展 大步小步算法 BSGS

				
			

			

				

					稻云麦花的博客
				

				

					09-11
					
					798
					
				

			

		

		

			
				
离散对数及其拓展
离散对数是在群Zp∗Z_{p}^{*}Zp∗​而言的,其中ppp是素数。即在在群Zp∗Z_{p}^{*}Zp∗​内，aaa是生成元，求关于xxx的方程ax=ba^x=bax=b的解，并将解记作x=logabx=log_{a}{b}x=loga​b，离散对数指的就是这个logablog_{a}{b}loga​b.由于群Zp∗Z_{p}^{*}Zp∗​的阶是p−1p-1p−1,且是循...

			
		

	





	

		

			

				
					
BSGS算法求解离散对数

				
			

			

				

					Harris-H的博客
				

				

					11-16
					
					661
					
				

			

		

		

			
				
小步大步算法：BSGS(Baby Step Giant Step)BSGS(Baby\ Step\ Giant\ Step)BSGS(Baby Step Giant Step)
拔山盖世算法，百度搜索谷歌搜索算法
用来求解离散对数(即模意义下的对数)的算法。
给出：ax≡b(modm)a^x\equiv b\pmod{m}ax≡b(modm)中a,b,ma,b,ma,b,m值，(a,ma,ma,m互质)，求解xxx。
由欧拉定理可知：aaa在模mm

			
		

	





	

		

			

				
					
x^A=B(mod C)的解 (离散对数与原根)

				
			

			

				

					Valieli的博客
				

				

					12-17
					
					421
					
				

			

		

		

			
				
x^A=B(mod C)的解 (离散对数与原根)
#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <math.h>
#include <bitset>
#include <map>

u...

			
		

	





	

		

			

				
					
离散对数－详解

				
			

			

				

					weixin_33883178的博客
				

				

					08-17
					
					742
					
				

			

		

		

			
				
首先要了解什么是cyclic group
In group theory, a cyclic group is a group that can be generated by a single element, in the sense that the group has an element g (called a "generator" of the group) such that, ...

			
		

	





	

		

			

				
					
生日攻击实现离散对数问题的求解(C++)

				
			

			

				

					weixin_42189863的博客
				

				

					01-15
					
					1661
					
				

			

		

		

			
				
！！！生日攻击是个概率性问题，以下代码可能只能实现部分离散对数求解问题，通过修改随机数种子可能会解决不同的问题…
// BirthdayAttack.cpp : 定义控制台应用程序的入口点。
//生日攻击

#include "stdafx.h"
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;
#include &lt;cmath&gt;
us...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值