加密中 公钥和私钥如何获得

举个RSA的例子,A想发送明文9726给B,那么他计算97263533(mod 11413)=5761,这就是密文,而B收到5761后,用自己的私钥d＝6597进行解密：57616597（mod 11413)=9726,就得到了明文这里公钥就是3533和11413,私钥是6597和11413分解成的两个质因数101和113其他人虽然知道x3353(mod 11413)=5761,但无法倒推回去求x,只有知道了私钥101和113后才能用算法得出6597可以想象11413若是足够大,那么将其分解质因式会是很困难的，RSA就是建立在对大数分解质因式的困难上的，理论依据是费马定理和欧拉定理

有了私钥，我们就可以使用椭圆曲线乘法这个单向加密函数产生一个公钥（K）。

有了公钥（K），我们就可以使用一个单向加密哈希函数生成比特币地址（A）。

H3

私钥

私钥就是一个随机选出的数字而已。一个比特币地址中的所有资金的控制取决于相应私钥的所有权和控制权。在比特币交易中，私钥用于生成支付比特币所必需的签名以证明资金的所有权。私钥必须始终保持机密，因为一旦被泄露给第三方，相当于该私钥保护之下的比特币也拱手相让了。私钥还必须进行备份，以防意外丢失，因为私钥一旦丢失就难以复原，其所保护的比特币也将永远丢失。

比特币私钥只是一个数字。你可以用硬币、铅笔和纸来随机生成你的私钥：掷硬币256次，用纸和笔记录正反面并转换为0和1，随机得到的256位二进制数字可作为比特币钱包的私钥。该私钥可进一步生成公钥。

H3

公钥

通过椭圆曲线算法可以从私钥计算得到公钥，这是不可逆转的过程：K = k G。其中k是私钥，G是被称为生成点的常数点，而K是所得公钥。其反向运算，被称为“寻找离散对数”——已知公钥K来求出私钥k——是非常困难的，就像去试验所有可能的k值，即暴力搜索。

H3

比特币地址

比特币地址是一个由数字和字母组成的字符串，可以与任何想给你比特币的人分享。由公钥（一个同样由数字和字母组成的字符串）生成的比特币地址以数字“1”开头。下面是一个比特币地址的例子：

1J7mdg5rbQyUHENYdx39WVWK7fsLpEoXZy

在交易中，比特币地址通常以收款方出现。如果把比特币交易比作一张支票，比特币地址就是收款人，也就是我们要写入收款人一栏的内容。一张支票的收款人可能是某个银行账户，也可能是某个公司、机构，甚至是现金支票。支票不需要指定一个特定的账户，而是用一个普通的名字作为收款人，这使它成为一种相当灵活的支付工具。与此类似，比特币地址的使用也使比特币交易变得很灵活。比特币地址可以代表一对公钥和私钥的所有者，也可以代表其它东西，比如“P2SH

(Pay-to-Script-Hash)”付款脚本。

然则>

JavaKeyStore的类型JKS和JCEKS是Java密钥库(KeyStore)的两种比较常见类型(我所知道的共有5种，JKS,JCEKS,PKCS12,BKS，UBER)。JKS的Provider是SUN，在每个版本的JDK中都有，JCEKS的Provider是SUNJCE，14后我们都能够直接使用它。JCEKS在安全级别上要比JKS强，使用的Provider是JCEKS(推荐)，尤其在保护KeyStore中的私钥上（使用TripleDes）。PKCS#12是公钥加密标准，它规定了可包含所有私钥、公钥和证书。其以二进制格式存储，也称为PFX文件，在windows中可以直接导入到密钥区，注意，PKCS#12的密钥库保护密码同时也用于保护Key。BKS来自BouncyCastleProvider，它使用的也是TripleDES来保护密钥库中的Key，它能够防止证书库被不小心修改（Keystore的keyentry改掉1个bit都会产生错误），BKS能够跟JKS互 *** 作，读者可以用Keytool去TryTry。UBER比较特别，当密码是通过命令行提供的时候，它只能跟keytool交互。整个keystore是通过PBE/SHA1/Twofish加密，因此keystore能够防止被误改、察看以及校验。以前，SunJDK(提供者为SUN)允许你在不提供密码的情况下直接加载一个Keystore，类似cacerts，UBER不允许这种情况。证书导入Der/Cer证书导入：要从某个文件中导入某个证书，使用keytool工具的-import命令：1keytool-import-filemycertder-keystoremykeystorejks如果在-keystore选项中指定了一个并不存在的密钥仓库，则该密钥仓库将被创建。如果不指定-keystore选项，则缺省密钥仓库将是宿主目录中名为keystore的文件。如果该文件并不存在，则它将被创建。创建密钥仓库时会要求输入访问口令，以后需要使用此口令来访问。可使用-list命令来查看密钥仓库里的内容：1keytool-list-rfc-keystoremykeystorejksP12格式证书导入：keytool无法直接导入PKCS12文件。第一种方法是使用IE将pfx证书导入，再导出为cert格式文件。使用上面介绍的方法将其导入到密钥仓库中。这样的话仓库里面只包含了证书信息，没有私钥内容。第二种方法是将pfx文件导入到IE浏览器中，再导出为pfx文件。新生成的pfx不能被导入到keystore中，报错：keytool错误：javalangException:所输入的不是一个X509认证。新生成的pfx文件可以被当作keystore使用。但会报个错误asunknownattr136141311171,查了下资料,说IE导出的就会这样,使用Netscape就不会有这个错误第三种方法是将pfx文件当作一个keystore使用。但是通过微软的证书管理控制台生成的pfx文件不能直接使用。keytool不认此格式，报keytool错误：javaioIOException:failedtodecryptsafecontentsentry。需要通过OpenSSL转换一下：1opensslpkcs12-inmycertspfx-outmycertspem2opensslpkcs12-export-inmycertspem-outmykeystorep12通过keytool的-list命令可检查下密钥仓库中的内容：1keytool-rfc-list-keystoremykeystorep12-storetypepkcs12这里需要指明仓库类型为pkcs12，因为缺省的类型为jks。这样此密钥仓库就即包含证书信息也包含私钥信息。P7B格式证书导入：keytool无法直接导入p7b文件。需要将证书链RootServerp7b（包含根证书）导出为根rootcacer和子rootcaservercer。将这两个证书导入到可信任的密钥仓库中。1keytool-import-aliasrootca-trustcacerts-filerootcacer-keystoretestkeytrustjks遇到是否信任该证书提示时，输入y1keytool-import-aliasrootcaserver-trustcacerts-filerootcaservercer-keystoretestkeytrustjks总结P12格式的证书是不能使用keytool工具导入到keystore中的TheSun'sPKCS12Keystore对从IE和其他的windows程序生成的pfx格式的证书支持不太好P7B证书链不能直接导入到keystore，需要将里面的证书导出成cer格式，再分别导入到keystore。

原理

有限域GF(p)上的椭圆曲线y² = x³ + ax + b，若P(Xp, Yp), Q(Xq, Yq)，且P≠-Q，则R(Xr,Yr) = P+Q          由如下规则确定：

 Xr = (λ² - Xp - Xq) mod p

Yr = (λ(Xp - Xr) - Yp) mod p

其中λ = (Yq - Yp)/(Xq - Xp) mod p（若P≠Q）, λ = (3Xp² + a)/2Yp mod p（若P=Q）

 因此，有限域GF(23)上的椭圆曲线y² ≡ x³ + x + 1 (mod 23)，假设以(0,1)为G点，计算2G、3G、4GxG等等，方法如下：

 计算2G：

λ = (3x0² + 1)/2x1 mod 23 = (1/2) mod 23

= 12

Xr = (12² - 0 - 0) mod 23 = 6

Yr = (12(0 - 6) - 1) mod 23 = 19

即2G为点(6,19)

Python 实现

# 获取私钥

```

def random_key():

    # Gotta be secure after that javaSecureRandom fiasco

    #randomrandrange(1, curven)

    entropy = osurandom(32) \

        + str(randomrandrange(2256)) \

        + str(int(timetime() 1000000))

    return sha256(entropy)

```

def privkey_to_pubkey(privkey):

    f = get_privkey_format(privkey)

    privkey = decode_privkey(privkey, f)

    if privkey == 0 or privkey >= N:

        raise Exception("Invalid privkey")

    if f in ['bin', 'bin_compressed', 'hex', 'hex_compressed', 'decimal']:

        return encode_pubkey(fast_multiply(G, privkey), f)

     else:

        return encode_pubkey(fast_multiply(G, privkey), freplace('wif', 'hex'))

#获取私钥的数据格式

def get_privkey_format(priv):

    if isinstance(priv, (int, long)): return 'decimal'

    elif len(priv) == 32: return 'bin'

    elif len(priv) == 33: return 'bin_compressed'

    elif len(priv) == 64: return 'hex'

    elif len(priv) == 66: return 'hex_compressed'

    else:

        bin_p = b58check_to_bin(priv)

        if len(bin_p) == 32: return 'wif'

        elif len(bin_p) == 33: return 'wif_compressed'

        else: raise Exception("WIF does not represent privkey")

def decode(string, base):

    base = int(base)

    code_string = get_code_string(base)

    result = 0

    if base == 16:

        string = stringlower()

    while len(string) > 0:

        result = base

        result += code_stringfind(string[0])

        string = string[1:]

    return result

def decode_privkey(priv,formt=None):

    if not formt: formt = get_privkey_format(priv)

    if formt == 'decimal': return priv

    elif formt == 'bin': return decode(priv, 256)

    elif formt == 'bin_compressed': return decode(priv[:32], 256)

    elif formt == 'hex': return decode(priv, 16)

    elif formt == 'hex_compressed': return decode(priv[:64], 16)

    else:

        bin_p = b58check_to_bin(priv)

        if len(bin_p) == 32: return decode(bin_p, 256)

        elif len(bin_p) == 33: return decode(bin_p[:32], 256)

        else: raise Exception("WIF does not represent privkey")

def jordan_add(a, b):

    if jordan_isinf(a):

        return b

    if jordan_isinf(b):

        return a

    if (a[0][0] b[0][1] - b[0][0] a[0][1]) % P == 0:

        if (a[1][0] b[1][1] - b[1][0] a[1][1]) % P == 0:

            return jordan_double(a)

        else:

            return ((0, 1), (0, 1))

    xdiff = subcoords(b[0], a[0])

    ydiff = subcoords(b[1], a[1])

    m = mulcoords(ydiff, invcoords(xdiff))

    x = subcoords(subcoords(mulcoords(m, m), a[0]), b[0])

    y = subcoords(mulcoords(m, subcoords(a[0], x)), a[1])

    return (x, y)

def jordan_double(a):

    if jordan_isinf(a):

        return ((0, 1), (0, 1))

    num = addcoords(mul_by_const(mulcoords(a[0], a[0]), 3), (A, 1))

    den = mul_by_const(a[1], 2)

    m = mulcoords(num, invcoords(den))

    x = subcoords(mulcoords(m, m), mul_by_const(a[0], 2))

    y = subcoords(mulcoords(m, subcoords(a[0], x)), a[1])

    return (x, y)

# G, privkey

#13,6,3,1

def jordan_multiply(a, n):

    if jordan_isinf(a) or n == 0:

        return ((0, 0), (0, 0))

    if n == 1:

        return a

    if n < 0 or n >= N:

        return jordan_multiply(a, n % N)

    if (n % 2) == 0:

        return  jordan_double(jordan_multiply(a, n/2))

    if (n % 2) == 1:

        return jordan_add(jordan_double(jordan_multiply(a, n/2)), a)

def to_jordan(p):

    return ((p[0], 1), (p[1], 1))

def from_jordan(p):

    return (p[0][0] inv(p[0][1], P) % P, p[1][0] inv(p[1][1], P) % P)

#G, privkey

def fast_multiply(a, n):

    return from_jordan(jordan_multiply(to_jordan(a), n))

def fast_add(a, b):

    return from_jordan(jordan_add(to_jordan(a), to_jordan(b)))

# Elliptic curve Jordan form functions

# P = (m, n, p, q) where m/n = x, p/q = y

def isinf(p):

    return p[0] == 0 and p[1] == 0

def jordan_isinf(p):

    return p[0][0] == 0 and p[1][0] == 0

def mulcoords(c1, c2):

    return (c1[0] c2[0] % P, c1[1] c2[1] % P)

def mul_by_const(c, v):

    return (c[0] v % P, c[1])

def addcoords(c1, c2):

    return ((c1[0] c2[1] + c2[0] c1[1]) % P, c1[1] c2[1] % P)

def subcoords(c1, c2):

    return ((c1[0] c2[1] - c2[0] c1[1]) % P, c1[1] c2[1] % P)

def invcoords(c):

    return (c[1], c[0])

# Extended Euclidean Algorithm

#p[0][1],p[1][1],p

#a%n = a- a/n n

#x1=y2; y1=x2-(a/b)y2;

def inv(a, n):

    lm, hm = 1, 0

    low, high = a % n, n

    while low > 1:

        r = high/low

        nm, new = hm-lmr, high-lowr

        lm, low, hm, high = nm, new, lm, low

    return lm % n

使用公钥和私钥接入独立站点需要执行以下几步：

1 生成公钥和私钥：首先，你需要使用相应的工具生成公钥和私钥。这通常可以使用RSA的特定实现工具完成，比如OpenSSL或一些可用的秘密算法库（PKI）。

2 将公钥上传到服务器上：接下来，你需要将生成的公钥上传到你要接入的服务器上。

3 从服务器中获取私钥：当公钥已经上传之后，现在你可以从服务器获取对应的私钥，这可以通过ssh-keygen等Linux里的一些秘密算法工具来实现。

4 使用私钥登陆服务器：最后，你可以使用私钥来登陆服务器，或者使用私钥来签名一些文档或信息，确保它的完整性和有效性。

以上就是关于加密中 公钥和私钥如何获得全部的内容，包括:加密中 公钥和私钥如何获得、知道私钥怎么提币、公钥与私钥用于加解密和签名等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！