Example #1
0
 /** @throws HDDerivationException if privKeyBytes is invalid (0 or >= n). */
 public static DeterministicKey createMasterPrivKeyFromBytes(byte[] privKeyBytes, byte[] chainCode)
     throws HDDerivationException {
   BigInteger priv = new BigInteger(1, privKeyBytes);
   assertNonZero(priv, "Generated master key is invalid.");
   assertLessThanN(priv, "Generated master key is invalid.");
   return new DeterministicKey(ImmutableList.<ChildNumber>of(), chainCode, priv, null);
 }
Example #2
0
 private static RawKeyBytes deriveChildKeyBytesFromPublic(
     DeterministicKey parent, ChildNumber childNumber) throws HDDerivationException {
   checkArgument(!childNumber.isHardened(), "Can't use private derivation with public keys only.");
   byte[] parentPublicKey = ECKey.compressPoint(parent.getPubKeyPoint()).getEncoded();
   assert parentPublicKey.length == 33 : parentPublicKey.length;
   ByteBuffer data = ByteBuffer.allocate(37);
   data.put(parentPublicKey);
   data.putInt(childNumber.i());
   byte[] i = HDUtils.hmacSha512(parent.getChainCode(), data.array());
   assert i.length == 64 : i.length;
   byte[] il = Arrays.copyOfRange(i, 0, 32);
   byte[] chainCode = Arrays.copyOfRange(i, 32, 64);
   BigInteger ilInt = new BigInteger(1, il);
   assertLessThanN(ilInt, "Illegal derived key: I_L >= n");
   ECPoint Ki = ECKey.CURVE.getG().multiply(ilInt).add(parent.getPubKeyPoint());
   assertNonInfinity(Ki, "Illegal derived key: derived public key equals infinity.");
   return new RawKeyBytes(Ki.getEncoded(true), chainCode);
 }
Example #3
0
 private static RawKeyBytes deriveChildKeyBytesFromPrivate(
     DeterministicKey parent, ChildNumber childNumber) throws HDDerivationException {
   checkArgument(parent.hasPrivKey(), "Parent key must have private key bytes for this method.");
   byte[] parentPublicKey = ECKey.compressPoint(parent.getPubKeyPoint()).getEncoded();
   assert parentPublicKey.length == 33 : parentPublicKey.length;
   ByteBuffer data = ByteBuffer.allocate(37);
   if (childNumber.isHardened()) {
     data.put(parent.getPrivKeyBytes33());
   } else {
     data.put(parentPublicKey);
   }
   data.putInt(childNumber.i());
   byte[] i = HDUtils.hmacSha512(parent.getChainCode(), data.array());
   assert i.length == 64 : i.length;
   byte[] il = Arrays.copyOfRange(i, 0, 32);
   byte[] chainCode = Arrays.copyOfRange(i, 32, 64);
   BigInteger ilInt = new BigInteger(1, il);
   assertLessThanN(ilInt, "Illegal derived key: I_L >= n");
   final BigInteger priv = parent.getPrivKey();
   BigInteger ki = priv.add(ilInt).mod(ECKey.CURVE.getN());
   assertNonZero(ki, "Illegal derived key: derived private key equals 0.");
   return new RawKeyBytes(ki.toByteArray(), chainCode);
 }
Example #4
0
  private static RawKeyBytes deriveChildKeyBytes(DeterministicKey parent, ChildNumber childNumber)
      throws HDDerivationException {

    byte[] parentPublicKey = HDUtils.getBytes(parent.getPubPoint());
    assert parentPublicKey.length == 33 : parentPublicKey.length;
    ByteBuffer data = ByteBuffer.allocate(37);
    if (childNumber.isPrivateDerivation()) {
      data.put(parent.getPrivKeyBytes33());
    } else {
      data.put(parentPublicKey);
    }
    data.putInt(childNumber.getI());
    byte[] i = HDUtils.hmacSha512(parent.getChainCode(), data.array());
    assert i.length == 64 : i.length;
    byte[] il = Arrays.copyOfRange(i, 0, 32);
    byte[] chainCode = Arrays.copyOfRange(i, 32, 64);
    BigInteger ilInt = HDUtils.toBigInteger(il);
    assertLessThanN(ilInt, "Illegal derived key: I_L >= n");
    byte[] keyBytes;
    final BigInteger privAsFieldElement = parent.getPrivAsFieldElement();
    if (privAsFieldElement != null) {
      BigInteger ki = privAsFieldElement.add(ilInt).mod(HDUtils.getEcParams().getN());
      assertNonZero(ki, "Illegal derived key: derived private key equals 0.");
      keyBytes = ki.toByteArray();
    } else {
      checkArgument(
          !childNumber.isPrivateDerivation(),
          "Can't use private derivation with public keys only.");
      ECPoint Ki = HDUtils.getEcParams().getG().multiply(ilInt).add(parent.getPubPoint());
      checkArgument(
          !Ki.equals(HDUtils.getCurve().getInfinity()),
          "Illegal derived key: derived public key equals infinity.");
      keyBytes = HDUtils.toCompressed(Ki.getEncoded());
    }
    return new RawKeyBytes(keyBytes, chainCode);
  }