Java AsymmetricCipherKeyPair.getPublic方法代码示例

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
public KeyPair generateKeyPair()
{
    if (!initialised)
    {
        param = new RainbowKeyGenerationParameters(random, new RainbowParameters(new RainbowParameterSpec().getVi()));

        engine.init(param);
        initialised = true;
    }

    AsymmetricCipherKeyPair pair = engine.generateKeyPair();
    RainbowPublicKeyParameters pub = (RainbowPublicKeyParameters)pair.getPublic();
    RainbowPrivateKeyParameters priv = (RainbowPrivateKeyParameters)pair.getPrivate();

    return new KeyPair(new BCRainbowPublicKey(pub),
        new BCRainbowPrivateKey(priv));
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
public KeyPair generateKeyPair()
{
    if (!initialised)
    {
        DSAParametersGenerator pGen = new DSAParametersGenerator();

        pGen.init(strength, certainty, random);
        param = new DSAKeyGenerationParameters(random, pGen.generateParameters());
        engine.init(param);
        initialised = true;
    }

    AsymmetricCipherKeyPair pair = engine.generateKeyPair();
    DSAPublicKeyParameters pub = (DSAPublicKeyParameters)pair.getPublic();
    DSAPrivateKeyParameters priv = (DSAPrivateKeyParameters)pair.getPrivate();

    return new KeyPair(new BCDSAPublicKey(pub),
        new BCDSAPrivateKey(priv));
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
public static X509CertificateHolder makeCertificate(AsymmetricCipherKeyPair subKP, String _subDN, AsymmetricCipherKeyPair issKP, String _issDN, boolean _ca)
    throws IOException, OperatorCreationException
{
    RSAKeyParameters lwPubKey = (RSAKeyParameters)subKP.getPublic();

    X509v3CertificateBuilder v3CertGen = new X509v3CertificateBuilder(
        new X500Name(_issDN),
        allocateSerialNumber(),
        new Date(System.currentTimeMillis()),
        new Date(System.currentTimeMillis() + (1000L * 60 * 60 * 24 * 100)),
        new X500Name(_subDN),
        new SubjectPublicKeyInfo(new AlgorithmIdentifier(PKCSObjectIdentifiers.rsaEncryption, DERNull.INSTANCE), new RSAPublicKey(lwPubKey.getModulus(), lwPubKey.getExponent()))
    );

    AlgorithmIdentifier sigAlgId = new DefaultSignatureAlgorithmIdentifierFinder().find("SHA1WithRSAEncryption");
    AlgorithmIdentifier digAlgId = new DefaultDigestAlgorithmIdentifierFinder().find(sigAlgId);

    ContentSigner sigGen = new BcRSAContentSignerBuilder(sigAlgId, digAlgId).build((AsymmetricKeyParameter)issKP.getPrivate());

    v3CertGen.addExtension(
        X509Extension.basicConstraints,
        false,
        new BasicConstraints(_ca));

    return v3CertGen.build(sigGen);
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
public KeyPair generateKeyPair()
{
    if (!initialised)
    {
        init(new GOST3410ParameterSpec(CryptoProObjectIdentifiers.gostR3410_94_CryptoPro_A.getId()), new SecureRandom());
    }

    AsymmetricCipherKeyPair pair = engine.generateKeyPair();
    GOST3410PublicKeyParameters pub = (GOST3410PublicKeyParameters)pair.getPublic();
    GOST3410PrivateKeyParameters priv = (GOST3410PrivateKeyParameters)pair.getPrivate();

    return new KeyPair(new BCGOST3410PublicKey(pub, gost3410Params), new BCGOST3410PrivateKey(priv, gost3410Params));
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
public KeyPair generateKeyPair()
{
    AsymmetricCipherKeyPair pair = engine.generateKeyPair();
    RSAKeyParameters pub = (RSAKeyParameters)pair.getPublic();
    RSAPrivateCrtKeyParameters priv = (RSAPrivateCrtKeyParameters)pair.getPrivate();

    return new KeyPair(new BCRSAPublicKey(pub),
        new BCRSAPrivateCrtKey(priv));
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
public ECPoint initEnc(SM2 sm2, ECPoint userKey) {
    AsymmetricCipherKeyPair key = sm2.ecc_key_pair_generator.generateKeyPair();
    ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();
    ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();
    BigInteger k = ecpriv.getD();
    ECPoint c1 = ecpub.getQ();
    this.p2 = userKey.multiply(k);
    reset();
    return c1;
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
/**
 * Create a new PrivateKey using the platform provided secure random source.
 *
 * @param compressed set to false if you relly want legacy format
 * @return new PrivateKey
 */
public static PrivateKey createNew(boolean compressed) {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(domain, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    return new PrivateKey(privParams.getD(), compressed, pubParams.getQ().getEncoded(compressed));
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
@BeforeClass
public static void setUpClass() throws CoseException {

    X9ECParameters p = NISTNamedCurves.getByName("P-256");
    
    ECDomainParameters parameters = new ECDomainParameters(p.getCurve(), p.getG(), p.getN(), p.getH());
    ECKeyPairGenerator pGen = new ECKeyPairGenerator();
    ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(parameters, null);
    pGen.init(genParam);
    
    AsymmetricCipherKeyPair p1 = pGen.generateKeyPair();
    
    keyPublic = (ECPublicKeyParameters) p1.getPublic();
    keyPrivate = (ECPrivateKeyParameters) p1.getPrivate();
    
byte[] rgbX = keyPublic.getQ().normalize().getXCoord().getEncoded();
byte[] rgbY = keyPublic.getQ().normalize().getYCoord().getEncoded();
boolean signY = true;
byte[] rgbD = keyPrivate.getD().toByteArray();

CBORObject key = CBORObject.NewMap();
    key.Add(KeyKeys.KeyType.AsCBOR(), KeyKeys.KeyType_EC2);
    key.Add(KeyKeys.EC2_Curve.AsCBOR(), KeyKeys.EC2_P256);
    key.Add(KeyKeys.EC2_X.AsCBOR(), rgbX);
    key.Add(KeyKeys.EC2_Y.AsCBOR(), rgbY);
    cnKeyPublic = new OneKey(key);
    
    key = CBORObject.NewMap();
    key.Add(KeyKeys.KeyType.AsCBOR(), KeyKeys.KeyType_EC2);
    key.Add(KeyKeys.EC2_Curve.AsCBOR(), KeyKeys.EC2_P256);
    key.Add(KeyKeys.EC2_X.AsCBOR(), rgbX);
    key.Add(KeyKeys.EC2_Y.AsCBOR(), rgbY);
    cnKeyPublicCompressed = new OneKey(key);

    key = CBORObject.NewMap();
    key.Add(KeyKeys.KeyType.AsCBOR(), KeyKeys.KeyType_EC2);
    key.Add(KeyKeys.EC2_Curve.AsCBOR(), KeyKeys.EC2_P256);
    key.Add(KeyKeys.EC2_D.AsCBOR(), rgbD);
    cnKeyPrivate = new OneKey(key);
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
protected void setEcDhParams() {
    msg.prepareComputations();
    generateNamedCurveList(msg);
    generatePointFormatList(msg);
    prepareCurveType(msg);
    prepareNamedCurve(msg);

    ECDomainParameters ecParams = generateEcParameters(msg);
    AsymmetricCipherKeyPair keyPair = TlsECCUtils.generateECKeyPair(chooser.getContext().getBadSecureRandom(),
            ecParams);

    pubEcParams = (ECPublicKeyParameters) keyPair.getPublic();
    privEcParams = (ECPrivateKeyParameters) keyPair.getPrivate();
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
public static DHPrivateKeyParameters generateEphemeralServerKeyExchange(SecureRandom random, DHParameters dhParams,
    OutputStream output) throws IOException
{
    AsymmetricCipherKeyPair kp = generateDHKeyPair(random, dhParams);

    DHPublicKeyParameters dhPublic = (DHPublicKeyParameters)kp.getPublic();
    new ServerDHParams(dhPublic).encode(output);

    return (DHPrivateKeyParameters)kp.getPrivate();
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
public static ECPrivateKeyParameters generateEphemeralClientKeyExchange(SecureRandom random, short[] ecPointFormats,
    ECDomainParameters ecParams, OutputStream output) throws IOException
{
    AsymmetricCipherKeyPair kp = generateECKeyPair(random, ecParams);

    ECPublicKeyParameters ecPublicKey = (ECPublicKeyParameters) kp.getPublic();
    writeECPoint(ecPointFormats, ecPublicKey.getQ(), output);

    return (ECPrivateKeyParameters) kp.getPrivate();
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
private void testGPWithRandom(
    DHKeyPairGenerator kpGen)
{
    //
    // generate first pair
    //
    AsymmetricCipherKeyPair     pair = kpGen.generateKeyPair();

    DHPublicKeyParameters       pu1 = (DHPublicKeyParameters)pair.getPublic();
    DHPrivateKeyParameters      pv1 = (DHPrivateKeyParameters)pair.getPrivate();
    //
    // generate second pair
    //
    pair = kpGen.generateKeyPair();

    DHPublicKeyParameters       pu2 = (DHPublicKeyParameters)pair.getPublic();
    DHPrivateKeyParameters      pv2 = (DHPrivateKeyParameters)pair.getPrivate();

    //
    // two way
    //
    DHAgreement    e1 = new DHAgreement();
    DHAgreement    e2 = new DHAgreement();

    e1.init(new ParametersWithRandom(pv1, new SecureRandom()));
    e2.init(new ParametersWithRandom(pv2, new SecureRandom()));

    BigInteger   m1 = e1.calculateMessage();
    BigInteger   m2 = e2.calculateMessage();

    BigInteger   k1 = e1.calculateAgreement(pu2, m2);
    BigInteger   k2 = e2.calculateAgreement(pu1, m1);
    
    if (!k1.equals(k2))
    {
        fail("basic with random 2-way test failed");
    }
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
private void testSimpleWithRandom(
    DHBasicKeyPairGenerator kpGen)
{
    //
    // generate first pair
    //
    AsymmetricCipherKeyPair     pair = kpGen.generateKeyPair();

    DHPublicKeyParameters       pu1 = (DHPublicKeyParameters)pair.getPublic();
    DHPrivateKeyParameters      pv1 = (DHPrivateKeyParameters)pair.getPrivate();
    //
    // generate second pair
    //
    pair = kpGen.generateKeyPair();

    DHPublicKeyParameters       pu2 = (DHPublicKeyParameters)pair.getPublic();
    DHPrivateKeyParameters      pv2 = (DHPrivateKeyParameters)pair.getPrivate();

    //
    // two way
    //
    DHBasicAgreement    e1 = new DHBasicAgreement();
    DHBasicAgreement    e2 = new DHBasicAgreement();

    e1.init(new ParametersWithRandom(pv1, new SecureRandom()));
    e2.init(new ParametersWithRandom(pv2, new SecureRandom()));

    BigInteger   k1 = e1.calculateAgreement(pu2);
    BigInteger   k2 = e2.calculateAgreement(pu1);

    if (!k1.equals(k2))
    {
        fail("basic with random 2-way test failed");
    }
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
public static DHPrivateKeyParameters generateEphemeralClientKeyExchange(SecureRandom random, DHParameters dhParams,
    OutputStream output) throws IOException
{
    AsymmetricCipherKeyPair kp = generateDHKeyPair(random, dhParams);

    DHPublicKeyParameters dhPublic = (DHPublicKeyParameters) kp.getPublic();
    writeDHParameter(dhPublic.getY(), output);

    return (DHPrivateKeyParameters) kp.getPrivate();
}
 

import org.bouncycastle.crypto.AsymmetricCipherKeyPair; //导入方法依赖的package包/类
/**
 * generate a signature for the given message using the key we were
 * initialised with.  Generally, the order of the curve should be at 
 * least as long as the hash of the message of interest, and with 
 * ECNR it *must* be at least as long.  
 *
 * @param digest  the digest to be signed.
 * @exception DataLengthException if the digest is longer than the key allows
 */
public BigInteger[] generateSignature(
    byte[] digest)
{
    if (! this.forSigning) 
    {
        throw new IllegalStateException("not initialised for signing");
    }
    
    BigInteger n = ((ECPrivateKeyParameters)this.key).getParameters().getN();
    int nBitLength = n.bitLength();
    
    BigInteger e = new BigInteger(1, digest);
    int eBitLength = e.bitLength();
    
    ECPrivateKeyParameters  privKey = (ECPrivateKeyParameters)key;
           
    if (eBitLength > nBitLength) 
    {
        throw new DataLengthException("input too large for ECNR key.");
    }

    BigInteger r = null;
    BigInteger s = null;

    AsymmetricCipherKeyPair tempPair;
    do // generate r
    {
        // generate another, but very temporary, key pair using 
        // the same EC parameters
        ECKeyPairGenerator keyGen = new ECKeyPairGenerator();
        
        keyGen.init(new ECKeyGenerationParameters(privKey.getParameters(), this.random));
        
        tempPair = keyGen.generateKeyPair();

        //    BigInteger Vx = tempPair.getPublic().getW().getAffineX();
        ECPublicKeyParameters V = (ECPublicKeyParameters)tempPair.getPublic();        // get temp's public key
        BigInteger Vx = V.getQ().getX().toBigInteger();        // get the point's x coordinate
        
        r = Vx.add(e).mod(n);
    }
    while (r.equals(ECConstants.ZERO));

    // generate s
    BigInteger x = privKey.getD();                // private key value
    BigInteger u = ((ECPrivateKeyParameters)tempPair.getPrivate()).getD();    // temp's private key value
    s = u.subtract(r.multiply(x)).mod(n);

    BigInteger[]  res = new BigInteger[2];
    res[0] = r;
    res[1] = s;

    return res;
}