BouncyNTRUPlusKeyPair.java
/*
* GordianKnot: Security Suite
* Copyright 2026. 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 io.github.tonywasher.joceanus.gordianknot.impl.bc;
import io.github.tonywasher.joceanus.gordianknot.api.base.GordianException;
import io.github.tonywasher.joceanus.gordianknot.api.keypair.GordianKeyPair;
import io.github.tonywasher.joceanus.gordianknot.api.keypair.spec.GordianKeyPairSpec;
import io.github.tonywasher.joceanus.gordianknot.impl.bc.BouncyKeyPair.BouncyPrivateKey;
import io.github.tonywasher.joceanus.gordianknot.impl.bc.BouncyKeyPair.BouncyPublicKey;
import io.github.tonywasher.joceanus.gordianknot.impl.core.agree.GordianCoreAgreementFactory;
import io.github.tonywasher.joceanus.gordianknot.impl.core.base.GordianBaseFactory;
import io.github.tonywasher.joceanus.gordianknot.impl.core.exc.GordianCryptoException;
import io.github.tonywasher.joceanus.gordianknot.impl.core.exc.GordianIOException;
import io.github.tonywasher.joceanus.gordianknot.impl.core.keypair.GordianKeyPairValidity;
import io.github.tonywasher.joceanus.gordianknot.impl.core.spec.agree.GordianCoreAgreementSpec;
import io.github.tonywasher.joceanus.gordianknot.impl.core.spec.keypair.GordianCoreKeyPairSpec;
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.SecretWithEncapsulation;
import org.bouncycastle.crypto.params.AsymmetricKeyParameter;
import org.bouncycastle.pqc.crypto.ntruplus.NTRUPlusKEMExtractor;
import org.bouncycastle.pqc.crypto.ntruplus.NTRUPlusKEMGenerator;
import org.bouncycastle.pqc.crypto.ntruplus.NTRUPlusKeyGenerationParameters;
import org.bouncycastle.pqc.crypto.ntruplus.NTRUPlusKeyPairGenerator;
import org.bouncycastle.pqc.crypto.ntruplus.NTRUPlusParameters;
import org.bouncycastle.pqc.crypto.ntruplus.NTRUPlusPrivateKeyParameters;
import org.bouncycastle.pqc.crypto.ntruplus.NTRUPlusPublicKeyParameters;
import org.bouncycastle.pqc.crypto.util.PrivateKeyFactory;
import org.bouncycastle.pqc.crypto.util.PrivateKeyInfoFactory;
import org.bouncycastle.pqc.crypto.util.PublicKeyFactory;
import org.bouncycastle.pqc.crypto.util.SubjectPublicKeyInfoFactory;
import javax.security.auth.DestroyFailedException;
import java.io.IOException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
/**
* NTRUPlus KeyPair classes.
*/
public final class BouncyNTRUPlusKeyPair {
/**
* Private constructor.
*/
private BouncyNTRUPlusKeyPair() {
}
/**
* Bouncy NTRUPlus PublicKey.
*/
public static class BouncyNTRUPlusPublicKey
extends BouncyPublicKey<NTRUPlusPublicKeyParameters> {
/**
* Constructor.
*
* @param pKeySpec the keySpec
* @param pPublicKey the public key
*/
BouncyNTRUPlusPublicKey(final GordianKeyPairSpec pKeySpec,
final NTRUPlusPublicKeyParameters pPublicKey) {
super(pKeySpec, pPublicKey);
}
@Override
protected boolean matchKey(final AsymmetricKeyParameter pThat) {
/* Access keys */
final NTRUPlusPublicKeyParameters myThis = getPublicKey();
final NTRUPlusPublicKeyParameters myThat = (NTRUPlusPublicKeyParameters) pThat;
/* Compare keys */
return Arrays.equals(myThis.getEncoded(), myThat.getEncoded());
}
}
/**
* Bouncy NTRUPlus PrivateKey.
*/
public static class BouncyNTRUPlusPrivateKey
extends BouncyPrivateKey<NTRUPlusPrivateKeyParameters> {
/**
* Constructor.
*
* @param pKeySpec the keySpec
* @param pPrivateKey the private key
*/
BouncyNTRUPlusPrivateKey(final GordianKeyPairSpec pKeySpec,
final NTRUPlusPrivateKeyParameters pPrivateKey) {
super(pKeySpec, pPrivateKey);
}
@Override
protected boolean matchKey(final AsymmetricKeyParameter pThat) {
/* Access keys */
final NTRUPlusPrivateKeyParameters myThis = getPrivateKey();
final NTRUPlusPrivateKeyParameters myThat = (NTRUPlusPrivateKeyParameters) pThat;
/* Compare keys */
return Arrays.equals(myThis.getEncoded(), myThat.getEncoded());
}
}
/**
* BouncyCastle NTRUPlus KeyPair generator.
*/
public static class BouncyNTRUPlusKeyPairGenerator
extends BouncyKeyPairGenerator {
/**
* Generator.
*/
private final NTRUPlusKeyPairGenerator theGenerator;
/**
* Constructor.
*
* @param pFactory the Security Factory
* @param pKeySpec the keySpec
*/
BouncyNTRUPlusKeyPairGenerator(final GordianBaseFactory pFactory,
final GordianKeyPairSpec pKeySpec) {
/* Initialise underlying class */
super(pFactory, pKeySpec);
/* Create the generator */
theGenerator = new NTRUPlusKeyPairGenerator();
/* Determine the parameters */
final GordianCoreKeyPairSpec myKeySpec = (GordianCoreKeyPairSpec) pKeySpec;
final NTRUPlusParameters myParms = myKeySpec.getNTRUPlusSpec().getParameters();
/* Initialise the generator */
final NTRUPlusKeyGenerationParameters myParams = new NTRUPlusKeyGenerationParameters(getRandom(), myParms);
theGenerator.init(myParams);
}
@Override
public BouncyKeyPair generateKeyPair() {
/* Generate and return the keyPair */
final AsymmetricCipherKeyPair myPair = theGenerator.generateKeyPair();
final BouncyNTRUPlusPublicKey myPublic = new BouncyNTRUPlusPublicKey(getKeySpec(), (NTRUPlusPublicKeyParameters) myPair.getPublic());
final BouncyNTRUPlusPrivateKey myPrivate = new BouncyNTRUPlusPrivateKey(getKeySpec(), (NTRUPlusPrivateKeyParameters) 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 BouncyNTRUPlusPrivateKey myPrivateKey = (BouncyNTRUPlusPrivateKey) getPrivateKey(pKeyPair);
final NTRUPlusPrivateKeyParameters 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 BouncyNTRUPlusPublicKey myPublic = derivePublicKey(pPublicKey);
final PrivateKeyInfo myInfo = PrivateKeyInfo.getInstance(pPrivateKey.getEncoded());
final NTRUPlusPrivateKeyParameters myParms = (NTRUPlusPrivateKeyParameters) PrivateKeyFactory.createKey(myInfo);
final BouncyNTRUPlusPrivateKey myPrivate = new BouncyNTRUPlusPrivateKey(getKeySpec(), myParms);
final BouncyKeyPair myPair = new BouncyKeyPair(myPublic, myPrivate);
/* Check that we have a matching pair */
GordianKeyPairValidity.checkValidity(getFactory(), myPair);
/* Return the derived 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 BouncyNTRUPlusPublicKey myPublicKey = (BouncyNTRUPlusPublicKey) getPublicKey(pKeyPair);
final NTRUPlusPublicKeyParameters 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 BouncyNTRUPlusPublicKey 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 BouncyNTRUPlusPublicKey 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 NTRUPlusPublicKeyParameters myParms = (NTRUPlusPublicKeyParameters) PublicKeyFactory.createKey(myInfo);
return new BouncyNTRUPlusPublicKey(getKeySpec(), myParms);
} catch (IOException e) {
throw new GordianCryptoException(ERROR_PARSE, e);
}
}
}
/**
* NTRUPlus Agreement Engine.
*/
public static class BouncyNTRUPlusAgreementEngine
extends BouncyAgreementBase {
/**
* Constructor.
*
* @param pFactory the security factory
* @param pSpec the agreementSpec
* @throws GordianException on error
*/
BouncyNTRUPlusAgreementEngine(final GordianCoreAgreementFactory pFactory,
final GordianCoreAgreementSpec pSpec) throws GordianException {
/* Initialize underlying class */
super(pFactory, pSpec);
}
@Override
public void buildClientHello() throws GordianException {
/* Protect against exceptions */
try {
/* Create encapsulation */
final BouncyNTRUPlusPublicKey myPublic = (BouncyNTRUPlusPublicKey) getPublicKey(getServerKeyPair());
final NTRUPlusKEMGenerator myGenerator = new NTRUPlusKEMGenerator(getRandom());
final SecretWithEncapsulation myResult = myGenerator.generateEncapsulated(myPublic.getPublicKey());
/* Store the encapsulation */
setEncapsulated(myResult.getEncapsulation());
/* Store secret and create initVector */
storeSecret(myResult.getSecret());
myResult.destroy();
} catch (DestroyFailedException e) {
throw new GordianIOException("Failed to destroy secret", e);
}
}
@Override
public void processClientHello() throws GordianException {
/* Create encapsulation */
final BouncyNTRUPlusPrivateKey myPrivate = (BouncyNTRUPlusPrivateKey) getPrivateKey(getServerKeyPair());
final NTRUPlusKEMExtractor myExtractor = new NTRUPlusKEMExtractor(myPrivate.getPrivateKey());
/* Parse encapsulated message and store secret */
final byte[] myMessage = getEncapsulated();
storeSecret(myExtractor.extractSecret(myMessage));
}
}
}