BouncyEdDSAKeyPair.java
/*******************************************************************************
* GordianKnot: Security Suite
* Copyright 2012,2025 Tony Washer
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy
* of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
******************************************************************************/
package net.sourceforge.joceanus.gordianknot.impl.bc;
import net.sourceforge.joceanus.gordianknot.api.base.GordianException;
import net.sourceforge.joceanus.gordianknot.api.keypair.GordianKeyPair;
import net.sourceforge.joceanus.gordianknot.api.keypair.GordianKeyPairSpec;
import net.sourceforge.joceanus.gordianknot.api.sign.GordianSignatureSpec;
import net.sourceforge.joceanus.gordianknot.impl.bc.BouncyKeyPair.BouncyPrivateKey;
import net.sourceforge.joceanus.gordianknot.impl.bc.BouncyKeyPair.BouncyPublicKey;
import net.sourceforge.joceanus.gordianknot.impl.core.exc.GordianCryptoException;
import net.sourceforge.joceanus.gordianknot.impl.core.keypair.GordianKeyPairValidity;
import net.sourceforge.joceanus.gordianknot.impl.core.sign.GordianCoreSignature;
import org.bouncycastle.asn1.ASN1Encoding;
import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.crypto.CryptoException;
import org.bouncycastle.crypto.Signer;
import org.bouncycastle.crypto.generators.Ed25519KeyPairGenerator;
import org.bouncycastle.crypto.generators.Ed448KeyPairGenerator;
import org.bouncycastle.crypto.params.AsymmetricKeyParameter;
import org.bouncycastle.crypto.params.Ed25519KeyGenerationParameters;
import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;
import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;
import org.bouncycastle.crypto.params.Ed448KeyGenerationParameters;
import org.bouncycastle.crypto.params.Ed448PrivateKeyParameters;
import org.bouncycastle.crypto.params.Ed448PublicKeyParameters;
import org.bouncycastle.crypto.signers.Ed25519Signer;
import org.bouncycastle.crypto.signers.Ed448Signer;
import org.bouncycastle.crypto.util.PrivateKeyFactory;
import org.bouncycastle.crypto.util.PrivateKeyInfoFactory;
import org.bouncycastle.crypto.util.PublicKeyFactory;
import org.bouncycastle.crypto.util.SubjectPublicKeyInfoFactory;
import java.io.IOException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
/**
* EdwardsCurve DSA KeyPair classes.
*/
public final class BouncyEdDSAKeyPair {
/**
* Private constructor.
*/
private BouncyEdDSAKeyPair() {
}
/**
* Bouncy EdwardsDSA25519 PublicKey.
*/
public static class BouncyEd25519PublicKey
extends BouncyPublicKey<Ed25519PublicKeyParameters> {
/**
* Constructor.
* @param pKeySpec the keySpec
* @param pPublicKey the public key
*/
BouncyEd25519PublicKey(final GordianKeyPairSpec pKeySpec,
final Ed25519PublicKeyParameters pPublicKey) {
super(pKeySpec, pPublicKey);
}
@Override
protected boolean matchKey(final AsymmetricKeyParameter pThat) {
/* Access keys */
final Ed25519PublicKeyParameters myThis = getPublicKey();
final Ed25519PublicKeyParameters myThat = (Ed25519PublicKeyParameters) pThat;
/* Compare keys */
return Arrays.equals(myThis.getEncoded(), myThat.getEncoded());
}
}
/**
* Bouncy EdwardsDSA25519 PrivateKey.
*/
public static class BouncyEd25519PrivateKey
extends BouncyPrivateKey<Ed25519PrivateKeyParameters> {
/**
* Constructor.
* @param pKeySpec the keySpec
* @param pPrivateKey the private key
*/
BouncyEd25519PrivateKey(final GordianKeyPairSpec pKeySpec,
final Ed25519PrivateKeyParameters pPrivateKey) {
super(pKeySpec, pPrivateKey);
}
@Override
protected boolean matchKey(final AsymmetricKeyParameter pThat) {
/* Access keys */
final Ed25519PrivateKeyParameters myThis = getPrivateKey();
final Ed25519PrivateKeyParameters myThat = (Ed25519PrivateKeyParameters) pThat;
/* Compare keys */
return Arrays.equals(myThis.getEncoded(), myThat.getEncoded());
}
}
/**
* Bouncy EdwardsDSA448 PublicKey.
*/
public static class BouncyEd448PublicKey
extends BouncyPublicKey<Ed448PublicKeyParameters> {
/**
* Constructor.
* @param pKeySpec the keySpec
* @param pPublicKey the public key
*/
BouncyEd448PublicKey(final GordianKeyPairSpec pKeySpec,
final Ed448PublicKeyParameters pPublicKey) {
super(pKeySpec, pPublicKey);
}
@Override
protected boolean matchKey(final AsymmetricKeyParameter pThat) {
/* Access keys */
final Ed448PublicKeyParameters myThis = getPublicKey();
final Ed448PublicKeyParameters myThat = (Ed448PublicKeyParameters) pThat;
/* Compare keys */
return Arrays.equals(myThis.getEncoded(), myThat.getEncoded());
}
}
/**
* Bouncy EdwardsDSA448 PrivateKey.
*/
public static class BouncyEd448PrivateKey
extends BouncyPrivateKey<Ed448PrivateKeyParameters> {
/**
* Constructor.
* @param pKeySpec the keySpec
* @param pPrivateKey the private key
*/
BouncyEd448PrivateKey(final GordianKeyPairSpec pKeySpec,
final Ed448PrivateKeyParameters pPrivateKey) {
super(pKeySpec, pPrivateKey);
}
@Override
protected boolean matchKey(final AsymmetricKeyParameter pThat) {
/* Access keys */
final Ed448PrivateKeyParameters myThis = getPrivateKey();
final Ed448PrivateKeyParameters myThat = (Ed448PrivateKeyParameters) pThat;
/* Compare keys */
return Arrays.equals(myThis.getEncoded(), myThat.getEncoded());
}
}
/**
* BouncyCastle EdwardsDSA25519 KeyPair generator.
*/
public static class BouncyEd25519KeyPairGenerator
extends BouncyKeyPairGenerator {
/**
* Generator.
*/
private final Ed25519KeyPairGenerator theGenerator;
/**
* Constructor.
* @param pFactory the Security Factory
* @param pKeySpec the keySpec
* @throws GordianException on error
*/
BouncyEd25519KeyPairGenerator(final BouncyFactory pFactory,
final GordianKeyPairSpec pKeySpec) throws GordianException {
/* Initialise underlying class */
super(pFactory, pKeySpec);
/* Create the generator */
theGenerator = new Ed25519KeyPairGenerator();
/* Initialise the generator */
final Ed25519KeyGenerationParameters myParams = new Ed25519KeyGenerationParameters(getRandom());
theGenerator.init(myParams);
}
@Override
public BouncyKeyPair generateKeyPair() {
/* Generate and return the keyPair */
final AsymmetricCipherKeyPair myPair = theGenerator.generateKeyPair();
final BouncyEd25519PublicKey myPublic = new BouncyEd25519PublicKey(getKeySpec(), (Ed25519PublicKeyParameters) myPair.getPublic());
final BouncyEd25519PrivateKey myPrivate = new BouncyEd25519PrivateKey(getKeySpec(), (Ed25519PrivateKeyParameters) myPair.getPrivate());
return new BouncyKeyPair(myPublic, myPrivate);
}
@Override
public PKCS8EncodedKeySpec getPKCS8Encoding(final GordianKeyPair pKeyPair) throws GordianException {
/* Protect against exceptions */
try {
/* Check the keyPair type and keySpecs */
BouncyKeyPair.checkKeyPair(pKeyPair, getKeySpec());
/* build and return the encoding */
final BouncyEd25519PrivateKey myPrivateKey = (BouncyEd25519PrivateKey) getPrivateKey(pKeyPair);
final Ed25519PrivateKeyParameters myParms = myPrivateKey.getPrivateKey();
final PrivateKeyInfo myInfo = PrivateKeyInfoFactory.createPrivateKeyInfo(myParms);
return new PKCS8EncodedKeySpec(myInfo.getEncoded());
} catch (IOException e) {
throw new GordianCryptoException(ERROR_PARSE, e);
}
}
@Override
public BouncyKeyPair deriveKeyPair(final X509EncodedKeySpec pPublicKey,
final PKCS8EncodedKeySpec pPrivateKey) throws GordianException {
/* Protect against exceptions */
try {
/* Check the keySpecs */
checkKeySpec(pPrivateKey);
/* derive keyPair */
final BouncyEd25519PublicKey myPublic = derivePublicKey(pPublicKey);
final PrivateKeyInfo myInfo = PrivateKeyInfo.getInstance(pPrivateKey.getEncoded());
final Ed25519PrivateKeyParameters myParms = (Ed25519PrivateKeyParameters) PrivateKeyFactory.createKey(myInfo);
final BouncyEd25519PrivateKey myPrivate = new BouncyEd25519PrivateKey(getKeySpec(), myParms);
final BouncyKeyPair myPair = new BouncyKeyPair(myPublic, myPrivate);
/* Check that we have a matching pair */
GordianKeyPairValidity.checkValidity(getFactory(), myPair);
/* Return the keyPair */
return myPair;
} catch (IOException e) {
throw new GordianCryptoException(ERROR_PARSE, e);
}
}
@Override
public X509EncodedKeySpec getX509Encoding(final GordianKeyPair pKeyPair) throws GordianException {
/* Protect against exceptions */
try {
/* Check the keyPair type and keySpecs */
BouncyKeyPair.checkKeyPair(pKeyPair, getKeySpec());
/* build and return the encoding */
final BouncyEd25519PublicKey myPublicKey = (BouncyEd25519PublicKey) getPublicKey(pKeyPair);
final Ed25519PublicKeyParameters myParms = myPublicKey.getPublicKey();
final SubjectPublicKeyInfo myInfo = SubjectPublicKeyInfoFactory.createSubjectPublicKeyInfo(myParms);
final byte[] myBytes = myInfo.getEncoded(ASN1Encoding.DER);
return new X509EncodedKeySpec(myBytes);
} catch (IOException e) {
throw new GordianCryptoException(ERROR_PARSE, e);
}
}
@Override
public BouncyKeyPair derivePublicOnlyKeyPair(final X509EncodedKeySpec pEncodedKey) throws GordianException {
final BouncyEd25519PublicKey myPublic = derivePublicKey(pEncodedKey);
return new BouncyKeyPair(myPublic);
}
/**
* Derive public key from encoded.
* @param pEncodedKey the encoded key
* @return the public key
* @throws GordianException on error
*/
private BouncyEd25519PublicKey derivePublicKey(final X509EncodedKeySpec pEncodedKey) throws GordianException {
/* Protect against exceptions */
try {
/* Check the keySpecs */
checkKeySpec(pEncodedKey);
/* derive publicKey */
final SubjectPublicKeyInfo myInfo = SubjectPublicKeyInfo.getInstance(pEncodedKey.getEncoded());
final Ed25519PublicKeyParameters myParms = (Ed25519PublicKeyParameters) PublicKeyFactory.createKey(myInfo);
return new BouncyEd25519PublicKey(getKeySpec(), myParms);
} catch (IOException e) {
throw new GordianCryptoException(ERROR_PARSE, e);
}
}
}
/**
* BouncyCastle EdwardsDSA448 KeyPair generator.
*/
public static class BouncyEd448KeyPairGenerator
extends BouncyKeyPairGenerator {
/**
* Generator.
*/
private final Ed448KeyPairGenerator theGenerator;
/**
* Constructor.
* @param pFactory the Security Factory
* @param pKeySpec the keySpec
* @throws GordianException on error
*/
BouncyEd448KeyPairGenerator(final BouncyFactory pFactory,
final GordianKeyPairSpec pKeySpec) throws GordianException {
/* Initialise underlying class */
super(pFactory, pKeySpec);
/* Create the generator */
theGenerator = new Ed448KeyPairGenerator();
/* Initialise the generator */
final Ed448KeyGenerationParameters myParams = new Ed448KeyGenerationParameters(getRandom());
theGenerator.init(myParams);
}
@Override
public BouncyKeyPair generateKeyPair() {
final AsymmetricCipherKeyPair myPair = theGenerator.generateKeyPair();
final BouncyEd448PublicKey myPublic = new BouncyEd448PublicKey(getKeySpec(), (Ed448PublicKeyParameters) myPair.getPublic());
final BouncyEd448PrivateKey myPrivate = new BouncyEd448PrivateKey(getKeySpec(), (Ed448PrivateKeyParameters) myPair.getPrivate());
return new BouncyKeyPair(myPublic, myPrivate);
}
@Override
public PKCS8EncodedKeySpec getPKCS8Encoding(final GordianKeyPair pKeyPair) throws GordianException {
try {
BouncyKeyPair.checkKeyPair(pKeyPair, getKeySpec());
final BouncyEd448PrivateKey myPrivateKey = (BouncyEd448PrivateKey) getPrivateKey(pKeyPair);
final Ed448PrivateKeyParameters myParms = myPrivateKey.getPrivateKey();
final PrivateKeyInfo myInfo = PrivateKeyInfoFactory.createPrivateKeyInfo(myParms);
return new PKCS8EncodedKeySpec(myInfo.getEncoded());
} catch (IOException e) {
throw new GordianCryptoException(ERROR_PARSE, e);
}
}
@Override
public BouncyKeyPair deriveKeyPair(final X509EncodedKeySpec pPublicKey,
final PKCS8EncodedKeySpec pPrivateKey) throws GordianException {
try {
checkKeySpec(pPrivateKey);
final BouncyEd448PublicKey myPublic = derivePublicKey(pPublicKey);
final PrivateKeyInfo myInfo = PrivateKeyInfo.getInstance(pPrivateKey.getEncoded());
final Ed448PrivateKeyParameters myParms = (Ed448PrivateKeyParameters) PrivateKeyFactory.createKey(myInfo);
final BouncyEd448PrivateKey myPrivate = new BouncyEd448PrivateKey(getKeySpec(), myParms);
final BouncyKeyPair myPair = new BouncyKeyPair(myPublic, myPrivate);
GordianKeyPairValidity.checkValidity(getFactory(), myPair);
return myPair;
} catch (IOException e) {
throw new GordianCryptoException(ERROR_PARSE, e);
}
}
@Override
public X509EncodedKeySpec getX509Encoding(final GordianKeyPair pKeyPair) throws GordianException {
try {
BouncyKeyPair.checkKeyPair(pKeyPair, getKeySpec());
final BouncyEd448PublicKey myPublicKey = (BouncyEd448PublicKey) getPublicKey(pKeyPair);
final Ed448PublicKeyParameters myParms = myPublicKey.getPublicKey();
final SubjectPublicKeyInfo myInfo = SubjectPublicKeyInfoFactory.createSubjectPublicKeyInfo(myParms);
final byte[] myBytes = myInfo.getEncoded(ASN1Encoding.DER);
return new X509EncodedKeySpec(myBytes);
} catch (IOException e) {
throw new GordianCryptoException(ERROR_PARSE, e);
}
}
@Override
public BouncyKeyPair derivePublicOnlyKeyPair(final X509EncodedKeySpec pEncodedKey) throws GordianException {
final BouncyEd448PublicKey myPublic = derivePublicKey(pEncodedKey);
return new BouncyKeyPair(myPublic);
}
/**
* Derive public key from encoded.
* @param pEncodedKey the encoded key
* @return the public key
* @throws GordianException on error
*/
private BouncyEd448PublicKey derivePublicKey(final X509EncodedKeySpec pEncodedKey) throws GordianException {
try {
checkKeySpec(pEncodedKey);
final SubjectPublicKeyInfo myInfo = SubjectPublicKeyInfo.getInstance(pEncodedKey.getEncoded());
final Ed448PublicKeyParameters myParms = (Ed448PublicKeyParameters) PublicKeyFactory.createKey(myInfo);
return new BouncyEd448PublicKey(getKeySpec(), myParms);
} catch (IOException e) {
throw new GordianCryptoException(ERROR_PARSE, e);
}
}
}
/**
* EdDSA signature.
*/
public static class BouncyEdDSASignature
extends GordianCoreSignature {
/**
* The Signer.
*/
private Signer theSigner;
/**
* Constructor.
* @param pFactory the factory
* @param pSpec the signatureSpec.
* @throws GordianException on error
*/
BouncyEdDSASignature(final BouncyFactory pFactory,
final GordianSignatureSpec pSpec) throws GordianException {
/* Initialise underlying class */
super(pFactory, pSpec);
}
/**
* Create the signer according to the keyPair.
* @param pKeyPair the keyPair
* @return the signer
*/
private static Signer createSigner(final GordianKeyPair pKeyPair) {
/* Determine the EdwardsCurve */
final boolean is25519 = pKeyPair.getKeyPairSpec().getEdwardsElliptic().is25519();
final byte[] myContext = new byte[0];
/* Create the internal digests */
return is25519
? new Ed25519Signer()
: new Ed448Signer(myContext);
}
@Override
public void initForSigning(final GordianKeyPair pKeyPair) throws GordianException {
/* Initialise detail */
BouncyKeyPair.checkKeyPair(pKeyPair);
super.initForSigning(pKeyPair);
/* Initialise and set the signer */
theSigner = createSigner(pKeyPair);
final BouncyPrivateKey<?> myPrivate = getKeyPair().getPrivateKey();
theSigner.init(true, myPrivate.getPrivateKey());
}
@Override
public void initForVerify(final GordianKeyPair pKeyPair) throws GordianException {
/* Initialise detail */
BouncyKeyPair.checkKeyPair(pKeyPair);
super.initForVerify(pKeyPair);
/* Initialise and set the signer */
theSigner = createSigner(pKeyPair);
final BouncyPublicKey<?> myPublic = getKeyPair().getPublicKey();
theSigner.init(false, myPublic.getPublicKey());
}
@Override
public void update(final byte[] pBytes,
final int pOffset,
final int pLength) {
theSigner.update(pBytes, pOffset, pLength);
}
@Override
public void update(final byte pByte) {
theSigner.update(pByte);
}
@Override
public void update(final byte[] pBytes) {
theSigner.update(pBytes, 0, pBytes.length);
}
@Override
public void reset() {
theSigner.reset();
}
@Override
protected BouncyKeyPair getKeyPair() {
return (BouncyKeyPair) super.getKeyPair();
}
@Override
public BouncyFactory getFactory() {
return (BouncyFactory) super.getFactory();
}
@Override
public byte[] sign() throws GordianException {
/* Check that we are in signing mode */
checkMode(GordianSignatureMode.SIGN);
/* Sign the message */
try {
return theSigner.generateSignature();
} catch (CryptoException e) {
throw new GordianCryptoException(BouncySignature.ERROR_SIGGEN, e);
}
}
@Override
public boolean verify(final byte[] pSignature) throws GordianException {
/* Check that we are in verify mode */
checkMode(GordianSignatureMode.VERIFY);
/* Verify the message */
return theSigner.verifySignature(pSignature);
}
}
}