import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates an entirely new keypair. Point compression is used so the resulting public key will be 33 bytes
 * (32 for the co-ordinate and 1 byte to represent the y bit).
 */
public ECKey() {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(ecParams, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    priv = privParams.getD();
    // Unfortunately Bouncy Castle does not let us explicitly change a point to be compressed, even though it
    // could easily do so. We must re-build it here so the ECPoints withCompression flag can be set to true.
    ECPoint uncompressed = pubParams.getQ();
    ECPoint compressed = compressPoint(uncompressed);
    pub = compressed.getEncoded();

    creationTimeSeconds = Utils.now().getTime() / 1000;
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * If the device has not previously generated and persisted its device ID (aka
 * public/private keypair for PSI), generates and stores said ID.
 *
 * If the ID is already stored, this harmlessly does nothing.
 */
private void generateAndStoreDeviceID() {
  String privateDeviceID = store.get(DEVICE_PRIVATE_ID_KEY);
  String publicDeviceID = store.get(DEVICE_PUBLIC_ID_KEY);
  if (privateDeviceID == null || publicDeviceID == null) {
    // This would be very strange, if only half the ID was stored.
    if (privateDeviceID != publicDeviceID) {
      if (privateDeviceID == null) {
        Log.wtf(TAG, "Only one of private and public ID are stored! Public is stored, private is null.");
      } else {
        Log.wtf(TAG, "Only one of private and public ID are stored! Private is stored, public is null.");
      }
    }

    AsymmetricCipherKeyPair keypair = Crypto.generateUserID();
    privateDeviceID = bytesToBase64(Crypto.generatePrivateID(keypair));
    publicDeviceID = bytesToBase64(Crypto.generatePublicID(keypair));
    store.put(DEVICE_PRIVATE_ID_KEY, privateDeviceID);
    store.put(DEVICE_PUBLIC_ID_KEY, publicDeviceID);
  }
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * If the device has not previously generated and persisted its device ID (aka
 * public/private keypair for PSI), generates and stores said ID.
 *
 * If the ID is already stored, this harmlessly does nothing.
 */
private void generateAndStoreDeviceID(Context context, int encryption) {
    if(store == null) store = new StorageBase(context, encryption);
  String privateDeviceID = store.get(DEVICE_PRIVATE_ID_KEY);
  String publicDeviceID = store.get(DEVICE_PUBLIC_ID_KEY);
  if (privateDeviceID == null || publicDeviceID == null) {
    // This would be very strange, if only half the ID was stored.
    if (privateDeviceID != publicDeviceID) {
      if (privateDeviceID == null) {
        log.error( "Only one of private and public ID are stored! Public is stored, private is null.");
      } else {
        log.error( "Only one of private and public ID are stored! Private is stored, public is null.");
      }
    }

    AsymmetricCipherKeyPair keypair = Crypto.generateUserID();
    privateDeviceID = bytesToBase64(Crypto.generatePrivateID(keypair));
    publicDeviceID = bytesToBase64(Crypto.generatePublicID(keypair));

      store.put(DEVICE_PRIVATE_ID_KEY, privateDeviceID);
    store.put(DEVICE_PUBLIC_ID_KEY, publicDeviceID);
  }
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * A helper routine that verifies that a given Diffie-Hellman keypair is valid.
 *
 * @return Returns the private key as a BigInteger for further verification.
 */
public BigInteger validateDHKeyPair(AsymmetricCipherKeyPair pair) {
  DHPrivateKeyParameters priv = (DHPrivateKeyParameters) pair.getPrivate();
  DHPublicKeyParameters pub = (DHPublicKeyParameters) pair.getPublic();

  assertNotNull(priv);
  assertNotNull(pub);

  // Check that the public key == g^(private key) mod p.
  // This test is overkill, but validates that the we've hooked into the right library.
  BigInteger g = Crypto.DH_GROUP_PARAMETERS.getG();
  BigInteger p = Crypto.DH_GROUP_PARAMETERS.getP();

  assertEquals("Tests that the public key y == g^(private key x) mod p",
               pub.getY(), g.modPow(priv.getX(), p));

  BigInteger foo = new BigInteger(Crypto.DH_SUBGROUP_SIZE, Crypto.random);
  BigInteger gToTheFoo = g.modPow(foo, Crypto.DH_GROUP_PARAMETERS.getP());
  BigInteger fooInverse = foo.modInverse(Crypto.DH_GROUP_PARAMETERS.getQ());
  BigInteger newG = gToTheFoo.modPow(fooInverse, Crypto.DH_GROUP_PARAMETERS.getP());

  assertEquals("Tests that we can inverse group exponentiation", g, newG);

  return priv.getX();
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Check that the individual encode/decode private/public key methods reverse each other.
 * Check that the generatePublicID/generatePrivateID methods are reversed by the 
 * corresponding decode method.
 */
@Test
public void encodeDecodeKeysTest() throws IOException {
  AsymmetricCipherKeyPair keypair = Crypto.generateDHKeyPair();
  DHPrivateKeyParameters privKey = (DHPrivateKeyParameters) keypair.getPrivate();
  DHPublicKeyParameters pubKey = (DHPublicKeyParameters) keypair.getPublic();

  assertEquals(pubKey, Crypto.decodeDHPublicKey(Crypto.encodeDHPublicKey(pubKey)));
  assertEquals(privKey, Crypto.decodeDHPrivateKey(Crypto.encodeDHPrivateKey(privKey)));

  assertEquals(pubKey, Crypto.decodeDHPublicKey(Crypto.generatePublicID(keypair)));
  assertEquals(privKey, Crypto.decodeDHPrivateKey(Crypto.generatePrivateID(keypair)));

  // Took this out because sometimes pubkey is 129 and sometimes it's 128.
  // Not sure why that is (or what else to test here).
  // int BYTES_IN_PUBKEY = 128;
  // int BYTES_IN_PRIVKEY = 21;
  // assertEquals(BYTES_IN_PUBKEY, Crypto.encodeDHPublicKey(pubKey).length);
  // assertEquals(BYTES_IN_PRIVKEY, Crypto.encodeDHPrivateKey(privKey).length);
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates an entirely new keypair. Point compression is used so the resulting public key will be 33 bytes
 * (32 for the co-ordinate and 1 byte to represent the y bit).
 */
public ECKey() {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(CURVE, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    priv = privParams.getD();
    // Unfortunately Bouncy Castle does not let us explicitly change a point to be compressed, even though it
    // could easily do so. We must re-build it here so the ECPoints withCompression flag can be set to true.
    ECPoint uncompressed = pubParams.getQ();
    ECPoint compressed = compressPoint(uncompressed);
    pub = compressed.getEncoded();

    creationTimeSeconds = Utils.currentTimeMillis() / 1000;
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates an entirely new keypair. Point compression is used so the resulting public key will be 33 bytes
 * (32 for the co-ordinate and 1 byte to represent the y bit).
 */
public ECKey() {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(CURVE, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    priv = privParams.getD();
    // Unfortunately Bouncy Castle does not let us explicitly change a point to be compressed, even though it
    // could easily do so. We must re-build it here so the ECPoints withCompression flag can be set to true.
    ECPoint uncompressed = pubParams.getQ();
    ECPoint compressed = compressPoint(uncompressed);
    pub = compressed.getEncoded();
    
    creationTimeSeconds = Utils.currentTimeMillis() / 1000;
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates an entirely new keypair. Point compression is used so the resulting public key will be 33 bytes
 * (32 for the co-ordinate and 1 byte to represent the y bit).
 */
public ECKey() {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(CURVE, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    priv = privParams.getD();
    // Unfortunately Bouncy Castle does not let us explicitly change a point to be compressed, even though it
    // could easily do so. We must re-build it here so the ECPoints withCompression flag can be set to true.
    ECPoint uncompressed = pubParams.getQ();
    ECPoint compressed = compressPoint(uncompressed);
    pub = compressed.getEncoded();

    creationTimeSeconds = Utils.now().getTime() / 1000;
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates an entirely new keypair. Point compression is used so the resulting public key will be 33 bytes
 * (32 for the co-ordinate and 1 byte to represent the y bit).
 */
public ECKey() {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(CURVE, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    priv = privParams.getD();
    // Unfortunately Bouncy Castle does not let us explicitly change a point to be compressed, even though it
    // could easily do so. We must re-build it here so the ECPoints withCompression flag can be set to true.
    ECPoint uncompressed = pubParams.getQ();
    ECPoint compressed = compressPoint(uncompressed);
    pub = compressed.getEncoded();

    creationTimeSeconds = Utils.currentTimeSeconds();
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
@Override
public KeyPair generateAgreementKeyPair() {
	AsymmetricCipherKeyPair keyPair =
			agreementKeyPairGenerator.generateKeyPair();
	// Return a wrapper that uses the SEC 1 encoding
	ECPublicKeyParameters ecPublicKey =
			(ECPublicKeyParameters) keyPair.getPublic();
	PublicKey publicKey = new Sec1PublicKey(ecPublicKey
	);
	ECPrivateKeyParameters ecPrivateKey =
			(ECPrivateKeyParameters) keyPair.getPrivate();
	PrivateKey privateKey = new Sec1PrivateKey(ecPrivateKey,
			AGREEMENT_KEY_PAIR_BITS);
	return new KeyPair(publicKey, privateKey);
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
@Override
public KeyPair generateSignatureKeyPair() {
	AsymmetricCipherKeyPair keyPair =
			signatureKeyPairGenerator.generateKeyPair();
	// Return a wrapper that uses the SEC 1 encoding
	ECPublicKeyParameters ecPublicKey =
			(ECPublicKeyParameters) keyPair.getPublic();
	PublicKey publicKey = new Sec1PublicKey(ecPublicKey
	);
	ECPrivateKeyParameters ecPrivateKey =
			(ECPrivateKeyParameters) keyPair.getPrivate();
	PrivateKey privateKey = new Sec1PrivateKey(ecPrivateKey,
			SIGNATURE_KEY_PAIR_BITS);
	return new KeyPair(publicKey, privateKey);
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
KeyPair generateKeyPair() {
	AsymmetricCipherKeyPair keyPair = generator.generateKeyPair();
	// Return a wrapper that uses the SEC 1 encoding
	ECPublicKeyParameters ecPublicKey =
			(ECPublicKeyParameters) keyPair.getPublic();
	PublicKey publicKey = new Sec1PublicKey(ecPublicKey);
	ECPrivateKeyParameters ecPrivateKey =
			(ECPrivateKeyParameters) keyPair.getPrivate();
	PrivateKey privateKey =
			new Sec1PrivateKey(ecPrivateKey, MESSAGE_KEY_BITS);
	return new KeyPair(publicKey, privateKey);
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
public ECKey(SecureRandom secureRandom) {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(CURVE, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    priv = privParams.getD();
    pub = pubParams.getQ();
    creationTimeSeconds = System.currentTimeMillis();
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates an entirely new keypair with the given {@link SecureRandom} object. Point compression is used so the
 * resulting public key will be 33 bytes (32 for the co-ordinate and 1 byte to represent the y bit).
 *
 * @param secureRandom -
 */
public ECKey(SecureRandom secureRandom) {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(CURVE, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    priv = privParams.getD();
    pub = CURVE.getCurve().decodePoint(pubParams.getQ().getEncoded(true));
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates an entirely new keypair with the given {@link SecureRandom} object. Point compression is used so the
 * resulting public key will be 33 bytes (32 for the co-ordinate and 1 byte to represent the y bit).
 */
public ECKey(SecureRandom secureRandom) {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(CURVE, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    priv = privParams.getD();
    pub = new LazyECPoint(CURVE.getCurve(), pubParams.getQ().getEncoded(true));
    creationTimeSeconds = Utils.currentTimeSeconds();
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates an entirely new keypair with the given {@link SecureRandom}
 * object. Point compression is used so the resulting public key will be 33
 * bytes (32 for the co-ordinate and 1 byte to represent the y bit).
 */
public ECKey(SecureRandom secureRandom) {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(CURVE, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    priv = privParams.getD();
    pub = new LazyECPoint(CURVE.getCurve(), pubParams.getQ().getEncoded(true));
    creationTimeSeconds = CryptoUtils.currentTimeSeconds();
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates an entirely new keypair with the given {@link SecureRandom} object. Point compression is used so the
 * resulting public key will be 33 bytes (32 for the co-ordinate and 1 byte to represent the y bit).
 */
public BtcECKey(SecureRandom secureRandom) {
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(CURVE, secureRandom);
    generator.init(keygenParams);
    AsymmetricCipherKeyPair keypair = generator.generateKeyPair();
    ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate();
    ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic();
    priv = privParams.getD();
    pub = new LazyECPoint(CURVE.getCurve(), pubParams.getQ().getEncoded(true));
    creationTimeSeconds = Utils.currentTimeSeconds();
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates a Diffie-Hellman keypair of the default size.
 *
 * @return The generated Diffie-Hellman keypair or null upon failure.
 */
protected static AsymmetricCipherKeyPair generateDHKeyPair() {
  try {
    KeyGenerationParameters kgp = new DHKeyGenerationParameters(random, DH_GROUP_PARAMETERS);
    DHKeyPairGenerator gen = new DHKeyPairGenerator();
    gen.init(kgp);

    return gen.generateKeyPair();
  } catch (InvalidParameterException e) {
    Log.e(TAG, "InvalidParameterException while generating a Diffie-Hellman keypair " + e);
  }

  return null;
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Generates a Diffie-Hellman keypair of the default size.
 *
 * @return The generated Diffie-Hellman keypair or null upon failure.
 */
protected static AsymmetricCipherKeyPair generateDHKeyPair() {
  try {
    KeyGenerationParameters kgp = new DHKeyGenerationParameters(random, DH_GROUP_PARAMETERS);
    DHKeyPairGenerator gen = new DHKeyPairGenerator();
    gen.init(kgp);

    return gen.generateKeyPair();
  } catch (InvalidParameterException e) {
    log.error( "InvalidParameterException while generating a Diffie-Hellman keypair " + e);
  }

  return null;
}
 

import org.spongycastle.crypto.AsymmetricCipherKeyPair; //导入依赖的package包/类
/**
 * Tests that we can generate a valid Diffie-Hellman keypair, and that each
 * call creates a different keypair.
 */
@Test
public void generateDHPairTest() {
  AsymmetricCipherKeyPair pair1 = Crypto.generateDHKeyPair();
  assertNotNull(pair1);
  BigInteger priv1 = validateDHKeyPair(pair1);

  AsymmetricCipherKeyPair pair2 = Crypto.generateDHKeyPair();
  assertNotNull(pair2);
  BigInteger priv2 = validateDHKeyPair(pair2);

  assertNotEquals("Testing that two Diffie-Hellman keypairs have different private keys",
                  priv1, priv2);
}