eaglercraft/ayuncraft-1.5
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

break stuff

Browse Source
This commit is contained in:
ayunami2000 2022-01-21 23:16:04 -05:00
parent 4017fbc580
commit 90813e96ba
26 changed files with 389923 additions and 21158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
build.gradle
View File

@ -37,12 +37,12 @@ dependencies {
teavm { teavm {
compileScopes = null; compileScopes = null;
minifying = true; minifying = false;
maxTopLevelNames = 10000; maxTopLevelNames = 10000;
properties = null; properties = null;
debugInformationGenerated = false; debugInformationGenerated = false;
sourceMapsGenerated = true; sourceMapsGenerated = true;
sourceFilesCopied = false; sourceFilesCopied = true;
incremental = false; incremental = false;
transformers = null; transformers = null;

409679
javascript/classes.js
View File

File diff suppressed because one or more lines are too long

2
javascript/classes.js.map
View File

File diff suppressed because one or more lines are too long

1
javascript/index.html
View File

@ -2,6 +2,7 @@
<head> <head>
<title>eagler</title> <title>eagler</title>
<script type="text/javascript" src="classes.js"></script> <script type="text/javascript" src="classes.js"></script>
<!--script src="https://unpkg.com/@peculiar/x509"></script-->
<script type="text/javascript"> <script type="text/javascript">
window.addEventListener("load", function(){ window.minecraftOpts = [ window.addEventListener("load", function(){ window.minecraftOpts = [
"game_frame","assets.epk", "game_frame","assets.epk",

21
src/lwjgl/java/me/ayunami2000/ayuncraft/CryptManager.java
View File

@ -5,25 +5,24 @@ import java.io.OutputStream;
import java.io.UnsupportedEncodingException; import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset; import java.nio.charset.Charset;
import java.security.InvalidKeyException; import java.security.InvalidKeyException;
import java.security.Key; import me.ayunami2000.ayuncraft.java.security.Key;
import java.security.KeyFactory; import java.security.KeyFactory;
import java.security.KeyPair; import java.security.KeyPair;
import java.security.KeyPairGenerator; import java.security.KeyPairGenerator;
import java.security.MessageDigest; import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException; import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey; import me.ayunami2000.ayuncraft.java.security.PrivateKey;
import java.security.PublicKey; import me.ayunami2000.ayuncraft.java.security.PublicKey;
import java.security.SecureRandom; import java.security.SecureRandom;
import java.security.Security; import java.security.Security;
import java.security.spec.InvalidKeySpecException; import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec; import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
import javax.crypto.BadPaddingException; import javax.crypto.BadPaddingException;
import javax.crypto.Cipher; import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException; import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException; import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey; import me.ayunami2000.ayuncraft.javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec; import me.ayunami2000.ayuncraft.javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.crypto.BufferedBlockCipher; import org.bouncycastle.crypto.BufferedBlockCipher;
import org.bouncycastle.crypto.CipherKeyGenerator; import org.bouncycastle.crypto.CipherKeyGenerator;
import org.bouncycastle.crypto.KeyGenerationParameters; import org.bouncycastle.crypto.KeyGenerationParameters;
@ -47,7 +46,7 @@ public class CryptManager
{ {
CipherKeyGenerator var0 = new CipherKeyGenerator(); CipherKeyGenerator var0 = new CipherKeyGenerator();
var0.init(new KeyGenerationParameters(new SecureRandom(), 128)); var0.init(new KeyGenerationParameters(new SecureRandom(), 128));
return new SecretKeySpec(var0.generateKey(), "AES"); return (SecretKey) new SecretKeySpec(var0.generateKey(), "AES");
} }
public static KeyPair createNewKeyPair() public static KeyPair createNewKeyPair()
@ -117,7 +116,7 @@ public class CryptManager
{ {
X509EncodedKeySpec var1 = new X509EncodedKeySpec(par0ArrayOfByte); X509EncodedKeySpec var1 = new X509EncodedKeySpec(par0ArrayOfByte);
KeyFactory var2 = KeyFactory.getInstance("RSA"); KeyFactory var2 = KeyFactory.getInstance("RSA");
return var2.generatePublic(var1); return (PublicKey) var2.generatePublic(var1);
} }
catch (NoSuchAlgorithmException var3) catch (NoSuchAlgorithmException var3)
{ {
@ -137,7 +136,7 @@ public class CryptManager
*/ */
public static SecretKey decryptSharedKey(PrivateKey par0PrivateKey, byte[] par1ArrayOfByte) public static SecretKey decryptSharedKey(PrivateKey par0PrivateKey, byte[] par1ArrayOfByte)
{ {
return new SecretKeySpec(decryptData(par0PrivateKey, par1ArrayOfByte), "AES"); return (SecretKey) new SecretKeySpec(decryptData((Key) par0PrivateKey, par1ArrayOfByte), "AES");
} }
/** /**
@ -218,12 +217,12 @@ public class CryptManager
public static OutputStream encryptOuputStream(SecretKey par0SecretKey, OutputStream par1OutputStream) public static OutputStream encryptOuputStream(SecretKey par0SecretKey, OutputStream par1OutputStream)
{ {
return new CipherOutputStream(par1OutputStream, createBufferedBlockCipher(true, par0SecretKey)); return new CipherOutputStream(par1OutputStream, createBufferedBlockCipher(true, (Key) par0SecretKey));
} }
public static InputStream decryptInputStream(SecretKey par0SecretKey, InputStream par1InputStream) public static InputStream decryptInputStream(SecretKey par0SecretKey, InputStream par1InputStream)
{ {
return new CipherInputStream(par1InputStream, createBufferedBlockCipher(false, par0SecretKey)); return new CipherInputStream(par1InputStream, createBufferedBlockCipher(false, (Key) par0SecretKey));
} }
public static OutputStream encryptOuputStream(BufferedBlockCipher bufferedBlockCipher, OutputStream par1OutputStream) public static OutputStream encryptOuputStream(BufferedBlockCipher bufferedBlockCipher, OutputStream par1OutputStream)

32
src/lwjgl/java/me/ayunami2000/ayuncraft/ModifiablePublicKey.java Normal file
View File

@ -0,0 +1,32 @@
package me.ayunami2000.ayuncraft;
import me.ayunami2000.ayuncraft.java.security.PublicKey;
import java.security.Key;
public class ModifiablePublicKey implements PublicKey, Key {
private String algorithm;
private String format;
private byte[] encoded;
@Override
public String getAlgorithm() {
return algorithm;
}
@Override
public String getFormat() {
return format;
}
@Override
public byte[] getEncoded() {
return encoded;
}
public ModifiablePublicKey(String algo,String form,byte[] data){
algorithm=algo;
format=form;
encoded=data;
}
}

34
src/lwjgl/java/me/ayunami2000/ayuncraft/java/security/Key.java Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package me.ayunami2000.ayuncraft.java.security;
public interface Key {
public String getAlgorithm();
public String getFormat();
public byte[] getEncoded();
}

31
src/lwjgl/java/me/ayunami2000/ayuncraft/java/security/PrivateKey.java Normal file
View File

@ -0,0 +1,31 @@
/*
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package me.ayunami2000.ayuncraft.java.security;
import me.ayunami2000.ayuncraft.javax.security.auth.Destroyable;
public interface PrivateKey extends Key, Destroyable {
}

29
src/lwjgl/java/me/ayunami2000/ayuncraft/java/security/PublicKey.java Normal file
View File

@ -0,0 +1,29 @@
/*
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package me.ayunami2000.ayuncraft.java.security;
public interface PublicKey extends Key {
}

28
src/lwjgl/java/me/ayunami2000/ayuncraft/java/security/spec/KeySpec.java Normal file
View File

@ -0,0 +1,28 @@
/*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package me.ayunami2000.ayuncraft.java.security.spec;
public interface KeySpec { }

6
src/lwjgl/java/me/ayunami2000/ayuncraft/javax/crypto/SecretKey.java Normal file
View File

@ -0,0 +1,6 @@
package me.ayunami2000.ayuncraft.javax.crypto;
import me.ayunami2000.ayuncraft.java.security.Key;
public interface SecretKey extends Key {
}

80
src/lwjgl/java/me/ayunami2000/ayuncraft/javax/crypto/spec/SecretKeySpec.java Normal file
View File

@ -0,0 +1,80 @@
package me.ayunami2000.ayuncraft.javax.crypto.spec;
import me.ayunami2000.ayuncraft.java.security.spec.KeySpec;
import me.ayunami2000.ayuncraft.javax.crypto.SecretKey;
public class SecretKeySpec implements KeySpec, SecretKey {
private String algorithm;
private byte[] key;
public String getAlgorithm() {
return this.algorithm;
}
public String getFormat() {
return "RAW";
}
public byte[] getEncoded() {
byte[] tmp = new byte[this.key.length];
System.arraycopy(this.key, 0, tmp, 0, tmp.length);
return tmp;
}
public int hashCode() {
int code = this.algorithm.toUpperCase().hashCode();
for(int i = 0; i != this.key.length; ++i) {
code ^= this.key[i] << 8 * (i % 4);
}
return code;
}
public boolean equals(Object obj) {
if (obj != null && obj instanceof SecretKeySpec) {
SecretKeySpec spec = (SecretKeySpec)obj;
if (!this.algorithm.equalsIgnoreCase(spec.algorithm)) {
return false;
} else if (this.key.length != spec.key.length) {
return false;
} else {
for(int i = 0; i != this.key.length; ++i) {
if (this.key[i] != spec.key[i]) {
return false;
}
}
return true;
}
} else {
return false;
}
}
public SecretKeySpec(byte[] key, String algorithm) {
if (key == null) {
throw new IllegalArgumentException("null key passed");
} else if (algorithm == null) {
throw new IllegalArgumentException("null algorithm passed");
} else {
this.key = new byte[key.length];
System.arraycopy(key, 0, this.key, 0, key.length);
this.algorithm = algorithm;
}
}
public SecretKeySpec(byte[] key, int offset, int len, String algorithm) {
if (key == null) {
throw new IllegalArgumentException("Null key passed");
} else if (key.length - offset < len) {
throw new IllegalArgumentException("Bad offset/len");
} else if (algorithm == null) {
throw new IllegalArgumentException("Null algorithm string passed");
} else {
this.key = new byte[len];
System.arraycopy(key, offset, this.key, 0, len);
this.algorithm = algorithm;
}
}
}

39
src/lwjgl/java/me/ayunami2000/ayuncraft/javax/security/auth/DestroyFailedException.java Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package me.ayunami2000.ayuncraft.javax.security.auth;
public class DestroyFailedException extends Exception {
private static final long serialVersionUID = -7790152857282749162L;
public DestroyFailedException() {
super();
}
public DestroyFailedException(String msg) {
super(msg);
}
}

36
src/lwjgl/java/me/ayunami2000/ayuncraft/javax/security/auth/Destroyable.java Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package me.ayunami2000.ayuncraft.javax.security.auth;
public interface Destroyable {
public default void destroy() throws DestroyFailedException {
throw new DestroyFailedException();
}
public default boolean isDestroyed() {
return false;
}
}

12
src/main/java/net/lax1dude/eaglercraft/WebsocketNetworkManager.java
View File

@ -4,6 +4,7 @@ import java.io.*;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
import java.util.LinkedList; import java.util.LinkedList;
import me.ayunami2000.ayuncraft.java.security.Key;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.src.*; import net.minecraft.src.*;
import me.ayunami2000.ayuncraft.CryptManager; import me.ayunami2000.ayuncraft.CryptManager;
@ -58,6 +59,7 @@ public class WebsocketNetworkManager implements INetworkManager {
//yee=this.encryptOuputStream(yee); //yee=this.encryptOuputStream(yee);
} }
Packet.writePacket(var1, yee); Packet.writePacket(var1, yee);
if(logpackets)System.out.println("SENDING: "+var1);
yee.flush(); yee.flush();
EaglerAdapter.writePacket(sendBuffer.toByteArray()); EaglerAdapter.writePacket(sendBuffer.toByteArray());
} catch (IOException e) { } catch (IOException e) {
@ -184,9 +186,9 @@ public class WebsocketNetworkManager implements INetworkManager {
if(logpackets)System.out.println("RECEIVING: " + pkt); if(logpackets)System.out.println("RECEIVING: " + pkt);
pkt.processPacket(this.netHandler); pkt.processPacket(this.netHandler);
if(change){ if(change){
//processReadPackets(); processReadPackets();
//return; return;
break; //break;
} }
} }
} catch (EOFException e) { } catch (EOFException e) {
@ -219,7 +221,7 @@ public class WebsocketNetworkManager implements INetworkManager {
{ {
this.isInputBeingDecrypted = true; this.isInputBeingDecrypted = true;
if(this.inputBufferedBlockCipher==null){ if(this.inputBufferedBlockCipher==null){
this.inputBufferedBlockCipher = CryptManager.createBufferedBlockCipher(false,this.sharedKeyForEncryption); this.inputBufferedBlockCipher = CryptManager.createBufferedBlockCipher(false, (Key) this.sharedKeyForEncryption);
} }
return new DataInputStream(CryptManager.decryptInputStream(this.inputBufferedBlockCipher, var1)); return new DataInputStream(CryptManager.decryptInputStream(this.inputBufferedBlockCipher, var1));
} }
@ -237,7 +239,7 @@ public class WebsocketNetworkManager implements INetworkManager {
private DataOutputStream encryptOuputStream() throws IOException private DataOutputStream encryptOuputStream() throws IOException
{ {
if(this.outputBufferedBlockCipher==null){ if(this.outputBufferedBlockCipher==null){
this.outputBufferedBlockCipher = CryptManager.createBufferedBlockCipher(true,this.sharedKeyForEncryption); this.outputBufferedBlockCipher = CryptManager.createBufferedBlockCipher(true, (Key) this.sharedKeyForEncryption);
} }
BufferedOutputStream var1 = new BufferedOutputStream(CryptManager.encryptOuputStream(this.outputBufferedBlockCipher, sendBuffer), 5120); BufferedOutputStream var1 = new BufferedOutputStream(CryptManager.encryptOuputStream(this.outputBufferedBlockCipher, sendBuffer), 5120);
return new DataOutputStream(var1); return new DataOutputStream(var1);

8
src/main/java/net/minecraft/src/Packet252SharedKey.java
View File

@ -5,6 +5,8 @@ import me.ayunami2000.ayuncraft.CryptManager;
import java.io.DataInputStream; import java.io.DataInputStream;
import java.io.DataOutputStream; import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
import me.ayunami2000.ayuncraft.java.security.Key;
import me.ayunami2000.ayuncraft.java.security.PrivateKey; import me.ayunami2000.ayuncraft.java.security.PrivateKey;
import me.ayunami2000.ayuncraft.java.security.PublicKey; import me.ayunami2000.ayuncraft.java.security.PublicKey;
import me.ayunami2000.ayuncraft.javax.crypto.SecretKey; import me.ayunami2000.ayuncraft.javax.crypto.SecretKey;
@ -24,8 +26,8 @@ public class Packet252SharedKey extends Packet
public Packet252SharedKey(SecretKey par1SecretKey, PublicKey par2PublicKey, byte[] par3ArrayOfByte) public Packet252SharedKey(SecretKey par1SecretKey, PublicKey par2PublicKey, byte[] par3ArrayOfByte)
{ {
this.sharedKey = par1SecretKey; this.sharedKey = par1SecretKey;
this.sharedSecret = CryptManager.encryptData(par2PublicKey, par1SecretKey.getEncoded()); this.sharedSecret = CryptManager.encryptData((Key) par2PublicKey, par1SecretKey.getEncoded());
this.verifyToken = CryptManager.encryptData(par2PublicKey, par3ArrayOfByte); this.verifyToken = CryptManager.encryptData((Key) par2PublicKey, par3ArrayOfByte);
} }
/** /**
@ -83,6 +85,6 @@ public class Packet252SharedKey extends Packet
*/ */
public byte[] getVerifyToken(PrivateKey par1PrivateKey) public byte[] getVerifyToken(PrivateKey par1PrivateKey)
{ {
return par1PrivateKey == null ? this.verifyToken : CryptManager.decryptData(par1PrivateKey, this.verifyToken); return par1PrivateKey == null ? this.verifyToken : CryptManager.decryptData((Key) par1PrivateKey, this.verifyToken);
} }
} }

15
src/teavm/java/com/rhg/rsa/RSABaseInterface.java Normal file
View File

@ -0,0 +1,15 @@
package com.rhg.rsa;
/**
* Write a description of interface RSABaseInterface here.
*
* @author Rob
* @version 06/01/2010
*/
public interface RSABaseInterface
{
byte PUBLIC_KEY = 1;
byte PRIVATE_KEY = 2;
byte COMPLETE_KEY = 3;
}

209
src/teavm/java/com/rhg/rsa/RSACompleteKey.java Normal file
View File

@ -0,0 +1,209 @@
package com.rhg.rsa;
import java.math.BigInteger;
/**
* Class representing full private and public RSA keys.
*
* @author Rob
* @version 05/31/2010
*/
public class RSACompleteKey extends RSAPrivateKey
{
/** The first CRT exponent. */
private BigInteger dP;
/** The second CRT exponent. */
private BigInteger dQ;
/** The public exponent. */
private BigInteger e;
/** The larger prime factor of the modulus. */
private BigInteger p;
/** The LCM of the primes. */
private BigInteger phi;
/** The smaller prime factor of the modulus. */
private BigInteger q;
/** The CRT coefficient. */
private BigInteger qInv;
/** Default constructor. */
public RSACompleteKey() {
super(null, null);
setPubExp(null);
setPrimes(null, null);
setCRTExpOne(null);
setCRTExpTwo(null);
setCRTCoeff(null);
return;
}
/** Main constructor. */
public RSACompleteKey(BigInteger prime1,
BigInteger prime2,
BigInteger modulus,
BigInteger pubExp,
BigInteger priExp,
BigInteger crtExp1,
BigInteger crtExp2,
BigInteger crtCoeff) {
super(modulus, priExp);
setPubExp(pubExp);
setPrimes(prime1, prime2);
setCRTExpOne(crtExp1);
setCRTExpTwo(crtExp2);
setCRTCoeff(crtCoeff);
return;
}
/** Computes the LCM of the primes. */
protected void computePhi() {
phi = lcm(pMinusOne(), qMinusOne());
}
/** Performs the classical RSA computation. */
protected BigInteger decrypt(BigInteger c) {
BigInteger m1, m2, dm, h;
m1 = c.modPow(getCRTExpOne(), getPrimeOne());
m2 = c.modPow(getCRTExpTwo(), getPrimeTwo());
dm = m1.subtract(m2).abs();
h = getCRTCoeff().multiply(dm).mod(getPrimeOne());
return m2.add(getPrimeTwo().multiply(h));
}
/** Returns the first CRT exponent. */
public BigInteger getCRTExpOne() {
return dP;
}
/** Returns the second CRT exponent. */
public BigInteger getCRTExpTwo() {
return dQ;
}
/** Returns the CRT coefficient. */
public BigInteger getCRTCoeff() {
return qInv;
}
/** Returns phi. */
public BigInteger getPhi() {
return phi;
}
/** Returns the larger prime factor. */
public BigInteger getPrimeOne() {
return p;
}
/** Returns the smaller prime factor. */
public BigInteger getPrimeTwo() {
return q;
}
/** Returns the public exponent. */
public BigInteger getPubExp() {
return e;
}
/** Returns true when key is valid. */
public boolean isValid() {
if (noValuesNull() && isPrime(p) && isPrime(q)) {
computePhi();
return p.multiply(q).equals(getModulus()) &&
e.compareTo(THREE) >= 0 &&
e.compareTo(getModulus()) < 0 &&
e.gcd(phi).equals(ONE) &&
getPriExp().compareTo(getModulus()) < 0 &&
getPriExp().equals(e.modInverse(phi)) &&
dP.compareTo(p) < 0 &&
dQ.compareTo(q) < 0 &&
dP.equals(e.modInverse(pMinusOne())) &&
dQ.equals(e.modInverse(qMinusOne())) &&
qInv.compareTo(p) < 0 &&
qInv.equals(q.modInverse(p));
} else {
return false;
}
}
/** Returns true when no fields are null. */
private boolean noValuesNull() {
return !(isNull(p) || isNull(q) || isNull(getModulus()) ||
isNull(e) || isNull(getPriExp()) || isNull(dP) ||
isNull(dQ) || isNull(qInv));
}
/** Returns p minus one. */
protected BigInteger pMinusOne() {
if (isNull(p)) {
return null;
} else {
return p.subtract(ONE);
}
}
/** Returns q minus one. */
protected BigInteger qMinusOne() {
if (isNull(q)) {
return null;
} else {
return q.subtract(ONE);
}
}
/** Sets the CRT exponent. */
public void setCRTCoeff(BigInteger crtCoeff) {
qInv = weedOut(crtCoeff);
return;
}
/** Sets the first CRT exponent. */
public void setCRTExpOne(BigInteger crtExp1) {
dP = weedOut(crtExp1);
return;
}
/** Sets the second CRT exponent. */
public void setCRTExpTwo(BigInteger crtExp2) {
dQ = weedOut(crtExp2);
return;
}
/** Sets phi. */
public void setPhi(BigInteger phi) {
this.phi = weedOut(phi);
}
/** Sets the prime factors. */
public void setPrimes(BigInteger prime1, BigInteger prime2) {
if (isNull(prime1 = weedOut(prime1)) || isNull(prime2 = weedOut(prime2))) {
return;
} else {
if (isPositive(prime1.subtract(prime2))) {
p = prime1;
q = prime2;
} else if (isPositive(prime2.subtract(prime1))) {
p = prime2;
q = prime1;
} else {
return;
}
}
return;
}
/** Sets the public exponent. */
public void setPubExp(BigInteger pubExp) {
e = weedOut(pubExp);
return;
}
}

18
src/teavm/java/com/rhg/rsa/RSAConstants.java Normal file
View File

@ -0,0 +1,18 @@
package com.rhg.rsa;
import java.math.BigInteger;
/**
* Interface providing often used BigInteger constants.
*
* @author Rob
* @version 05/30/2010
*/
public interface RSAConstants
{
BigInteger ZERO = BigInteger.ZERO;
BigInteger ONE = BigInteger.ONE;
BigInteger TWO = BigInteger.valueOf(2);
BigInteger THREE = BigInteger.valueOf(3);
BigInteger TWO_FIFTY_SIX = BigInteger.valueOf(256);
}

203
src/teavm/java/com/rhg/rsa/RSAKey.java Normal file
View File

@ -0,0 +1,203 @@
package com.rhg.rsa;
import java.math.BigInteger;
import java.io.*;
import java.util.Random;
/**
* Abstract class representing common features of RSA keys.
*
* @author Rob
* @version 06/01/2010
*/
public abstract class RSAKey implements RSAConstants, RSABaseInterface
{
/** The modulus. */
private BigInteger n;
/** Default constructor. */
protected RSAKey() {
setModulus(null);
return;
}
/** Main constructor. */
protected RSAKey(BigInteger modulus) {
setModulus(modulus);
return;
}
/** Returns the contents of a file as a byte array. */
/*
protected byte[] getBytes(String fileName) {
File fIn = new File(fileName);
if (!fIn.canRead()) {
System.err.println("Can't read " + fileName);
return null;
}
FileInputStream in = null;
byte[] bytes = null;
try {
in = new FileInputStream(fIn);
long fileSize = fIn.length();
if (fileSize > Integer.MAX_VALUE) {
System.out.println("Sorry, file was too large!");
}
bytes = new byte[(int) fileSize];
int offset = 0;
int numRead = 0;
while (offset < bytes.length
&& (numRead = in.read(bytes, offset, bytes.length - offset)) >= 0) {
offset += numRead;
}
} catch (IOException e) {
} finally {
try {
if (in != null) in.close();
} catch (IOException e) {
}
}
return bytes;
}
*/
/** Returns the modulus. */
public BigInteger getModulus() {
return n;
}
/** Returns the number of bytes required to store the modulus. */
protected int getModulusByteSize() {
return (int) Math.ceil(getModulus().bitLength() / 8.0);
}
/** Returns a portion of the array argument. */
protected byte[] getSubArray(byte[] inBytes, int start, int end) {
if (start >= inBytes.length) {
return null;
}
if (end > inBytes.length) {
end = inBytes.length;
}
int bytesToGet = end - start;
if (bytesToGet < 1) {
return null;
}
byte[] outBytes = new byte[bytesToGet];
for (int i = start; i < end; i++) {
outBytes[i - start] = inBytes[i];
}
return outBytes;
}
/** Returns true when the argument is null. */
public final boolean isNull(Object obj) {
return !(obj != null);
}
/** Returns true when the argument is greater than zero. */
public final boolean isPositive(BigInteger number) {
return (number.compareTo(ZERO) > 0);
}
/** Returns true when the argument is prime. */
public boolean isPrime(BigInteger number) {
return number.isProbablePrime(100);
}
/** Computes the least common multiple. */
public BigInteger lcm(BigInteger a, BigInteger b) {
return (a.multiply(b).divide(a.gcd(b)));
}
/** Generates an array of pseudo-random nonzero bytes. */
protected byte[] makePaddingString(int len) {
if (len < 8) return null;
Random rndm = new Random();
byte[] PS = new byte[len];
for (int i = 0; i < len; i++) {
PS[i] = (byte)(rndm.nextInt(255) + 1);
}
return PS;
}
/** Reshapes a byte array into an array of byte arrays. */
protected byte[][] reshape(byte[] inBytes, int colSize) {
if (colSize < 1) {
colSize = 1;
}
int rowSize = (int) Math.ceil((double)inBytes.length / (double)colSize);
if (rowSize == 0) {
return null;
}
byte[][] outBytes = new byte[rowSize][];
for (int i = 0; i < rowSize; i++) {
outBytes[i] = getSubArray(inBytes, i * colSize, (i + 1) * colSize);
}
return outBytes;
}
/** Sets the modulus. */
public void setModulus(BigInteger modulus) {
n = weedOut(modulus);
if (isNull(n) || n.bitLength() < 96) {
n = null;
}
return;
}
/** Converts a BigInteger into a byte array of the specified length. */
protected byte[] toByteArray(BigInteger x, int numBytes) {
if (x.compareTo(TWO_FIFTY_SIX.pow(numBytes)) >= 0) {
return null; // number is to big to fit in the byte array
}
byte[] ba = new byte[numBytes--];
BigInteger[] divAndRem = new BigInteger[2];
for (int power = numBytes; power >= 0; power--) {
divAndRem = x.divideAndRemainder(TWO_FIFTY_SIX.pow(power));
ba[numBytes - power] = (byte) divAndRem[0].intValue();
x = divAndRem[1];
}
return ba;
}
/** Converts a byte array into a BigInteger. */
protected BigInteger toInteger(byte[] X) {
BigInteger x = ZERO;
for (int i = 0; i < X.length; i++) {
x = x.add(BigInteger.valueOf(X[i]).multiply(TWO_FIFTY_SIX.pow(X.length - 1 - i)));
}
return x;
}
/** Uses the key and returns true if use was successful. */
//public abstract boolean use(String source, String destination);
public abstract boolean use(byte[] sourceBytes, ByteArrayOutputStream baos);
/** Weeds out bad inputs. */
public final BigInteger weedOut(BigInteger arg) {
if (!isNull(arg) && isPositive(arg)) {
return arg;
} else {
return null;
}
}
}

104
src/teavm/java/com/rhg/rsa/RSAKeyGenerator.java Normal file
View File

@ -0,0 +1,104 @@
package com.rhg.rsa;
import java.math.BigInteger;
import java.security.SecureRandom;
/**
* Class representing private and public keys with the ability to generate new keys.
*
* @author Rob
* @version 05/31/2010
*/
public class RSAKeyGenerator extends RSACompleteKey
{
/** Minimum number of bits in the modulus allowed. */
private static final int MIN_BIT_LENGTH = 1024;
/** Source of securely (pseudo-) random bits. */
SecureRandom rand = new SecureRandom();
/** The number of bits required in the modulus. */
private int bitLength;
/** Default constructor. */
public RSAKeyGenerator() {
super();
setBitLength(MIN_BIT_LENGTH);
generateNewKeys();
return;
}
/** Main constructor. */
public RSAKeyGenerator(int bitLength) {
super();
setBitLength(bitLength);
generateNewKeys();
return;
}
/** Generates new private and public keys. */
public void generateNewKeys() {
setPrimes(BigInteger.probablePrime(75 * bitLength / 100, rand),
BigInteger.probablePrime(25 * bitLength / 100, rand));
setModulus(getPrimeOne().multiply(getPrimeTwo()));
computePhi();
BigInteger i;
for (i = BigInteger.probablePrime((bitLength / 10), rand);
i.compareTo(getModulus()) < 0;
i = i.nextProbablePrime()) {
if (i.gcd(getPhi()).equals(ONE)) {
setPubExp(i);
break;
}
}
setPriExp(getPubExp().modInverse(getPhi()));
setCRTExpOne(getPubExp().modInverse(pMinusOne()));
setCRTExpTwo(getPubExp().modInverse(qMinusOne()));
setCRTCoeff(getPrimeTwo().modInverse(getPrimeOne()));
return;
}
/** Makes a new RSA key. */
public RSAKey makeKey(byte whichKey) {
switch (whichKey) {
case PUBLIC_KEY:
return makePublicKey();
case PRIVATE_KEY:
return makePrivateKey();
case COMPLETE_KEY:
return makeCompleteKey();
default:
return null;
}
}
/** Makes complete RSA key objects. */
private RSACompleteKey makeCompleteKey() {
return new RSACompleteKey(getPrimeOne(),
getPrimeTwo(),
getModulus(),
getPubExp(),
getPriExp(),
getCRTExpOne(),
getCRTExpTwo(),
getCRTCoeff());
}
/** Makes private RSA key objects. */
private RSAPrivateKey makePrivateKey() {
return new RSAPrivateKey(getModulus(), getPriExp());
}
/** Makes public RSA key objects. */
private RSAPublicKey makePublicKey() {
return new RSAPublicKey(getModulus(), getPubExp());
}
/** Sets the number of bits in the modulus. */
public void setBitLength(int bitLength) {
this.bitLength = (bitLength >= MIN_BIT_LENGTH ? bitLength : MIN_BIT_LENGTH);
return;
}
}

137
src/teavm/java/com/rhg/rsa/RSAPrivateKey.java Normal file
View File

@ -0,0 +1,137 @@
package com.rhg.rsa;
import java.math.BigInteger;
import java.io.*;
import java.util.Arrays;
/**
* Class representing a private RSA key.
*
* @author Rob
* @version 05/31/2010
*/
public class RSAPrivateKey extends RSAKey
{
/** The private exponent. */
private BigInteger d;
/** Default constructor. */
public RSAPrivateKey() {
super();
setPriExp(null);
return;
}
/** Main constructor. */
public RSAPrivateKey(BigInteger modulus, BigInteger priExp) {
super(modulus);
setPriExp(priExp);
return;
}
/** Performs the classical RSA computation. */
protected BigInteger decrypt(BigInteger c) {
return c.modPow(getPriExp(), getModulus());
}
/** Extracts the data portion of the byte array. */
protected byte[] extractData(byte[] EB) {
if (EB.length < 12 || EB[0] != 0x00 || EB[1] != 0x02) {
return null;
}
int index = 2;
do {} while (EB[index++] != 0x00);
return getSubArray(EB, index, EB.length);
}
/** Returns the private exponent. */
public BigInteger getPriExp() {
return d;
}
/** Sets the private exponent. */
public void setPriExp(BigInteger priExp)
{
d = weedOut(priExp);
return;
}
/** Uses key and returns true if decryption was successful. */
/*
public boolean use(String source, String destination) {
byte[] sourceBytes = getBytes(source);
if (isNull(sourceBytes)) {
return false;
}
int k = getModulusByteSize();
BigInteger c, m;
byte[] EB, M;
byte[][] C = reshape(sourceBytes, k);
BufferedOutputStream out = null;
try {
out = new BufferedOutputStream(new FileOutputStream(destination));
for (int i = 0; i < C.length; i++) {
if (C[i].length != k) return false;
c = new BigInteger(C[i]);
m = decrypt(c);
EB = toByteArray(m, k);
M = extractData(EB);
out.write(M);
}
out.close();
} catch (IOException e) {
return false;
} finally {
try {
if (isNull(out)) out.close();
} catch (IOException e) {
return false;
}
}
return true;
}
*/
public boolean use(byte[] sourceBytes, ByteArrayOutputStream out) {
System.out.println(1);
int k = getModulusByteSize();
System.out.println(2);
BigInteger c, m;
byte[] EB, M;
byte[][] C = reshape(sourceBytes, k);
System.out.println(3);
try {
for (int i = 0; i < C.length; i++) {
System.out.println(4);
if (C[i].length != k) return false;
c = new BigInteger(C[i]);
System.out.println(5);
m = decrypt(c);
System.out.println(6);
EB = toByteArray(m, k);
System.out.println(7);
M = extractData(EB);
System.out.println(8);
out.write(M);
System.out.println("FARD: "+Arrays.toString(M));
}
System.out.println(9);
out.flush();
//out.close();
} catch (Exception e) {
/*
String errMsg = "An exception occured!%n%s%n%s%n%s";
System.err.println(String.format(errMsg, e.getClass(), e.getMessage(), Arrays.toString(e.getStackTrace())));
*/
System.err.println(e.getClass().getName()+"\n"+e.getMessage());
return false;
}
return true;
}
}

135
src/teavm/java/com/rhg/rsa/RSAPublicKey.java Normal file
View File

@ -0,0 +1,135 @@
package com.rhg.rsa;
import java.math.BigInteger;
import java.io.*;
import java.util.Arrays;
/**
* Class representing a public RSA key.
*
* @author Rob
* @version 05/30/2010
*/
public class RSAPublicKey extends RSAKey
{
/** The public exponent. */
private BigInteger e;
/** Default constructor. */
public RSAPublicKey() {
super(null);
setPubExp(null);
return;
}
/** Main constructor. */
public RSAPublicKey(BigInteger modulus, BigInteger pubExp)
{
super(modulus);
setPubExp(pubExp);
return;
}
/** Performs the classical RSA computation. */
protected BigInteger encrypt(BigInteger m) {
return m.modPow(getPubExp(), getModulus());
}
/** Returns the public exponent. */
public BigInteger getPubExp() {
return e;
}
/** Sets the public exponent. */
public void setPubExp(BigInteger pubExp)
{
e = weedOut(pubExp);
return;
}
/** Uses the key and returns true if encryption was successful. */
/*
public boolean use(String source, String destination) {
byte[] sourceBytes = getBytes(source);
if (isNull(sourceBytes)) {
System.err.println(String.format("%s contained nothing.", source));
return false;
}
int k = getModulusByteSize();
byte BT = 0x02;
byte[] C, M;
byte[][] D = reshape(sourceBytes, k - 11);
ByteArrayOutputStream EB = new ByteArrayOutputStream(k);
FileOutputStream out = null;
BigInteger m, c;
try {
out = new FileOutputStream(destination);
for (int i = 0; i < D.length; i++) {
EB.reset();
EB.write(0x00); EB.write(BT); EB.write(makePaddingString(k - D[i].length - 3));
EB.write(0x00); EB.write(D[i]);
M = EB.toByteArray();
m = new BigInteger(M);
c = encrypt(m);
C = toByteArray(c, k);
out.write(C);
}
out.close();
} catch (Exception e) {
String errMsg = "An exception occured!%n%s%n%s%n%s";
System.err.println(String.format(errMsg, e.getClass(), e.getMessage(), e.getStackTrace()));
return false;
}
return true;
}
*/
public boolean use(byte[] sourceBytes, ByteArrayOutputStream out) {
System.out.println(1);
int k = getModulusByteSize();
System.out.println(2);
byte BT = 0x02;
byte[] C, M;
byte[][] D = reshape(sourceBytes, k - 11);
System.out.println(3);
ByteArrayOutputStream EB = new ByteArrayOutputStream(k);
System.out.println(4);
BigInteger m, c;
try {
for (int i = 0; i < D.length; i++) {
System.out.println(5);
EB.reset();
System.out.println(6);
EB.write(0x00); EB.write(BT); EB.write(makePaddingString(k - D[i].length - 3));
System.out.println(7);
EB.write(0x00); EB.write(D[i]);
System.out.println(8);
M = EB.toByteArray();
System.out.println(9);
m = new BigInteger(M);
System.out.println(10);
c = encrypt(m);
System.out.println(11);
C = toByteArray(c, k);
System.out.println(12);
out.write(C);
System.out.println("FARD: "+Arrays.toString(C));
}
out.flush();
//out.close();
} catch (Exception e) {
/*
String errMsg = "An exception occured!%n%s%n%s%n%s";
System.err.println(String.format(errMsg, e.getClass(), e.getMessage(), Arrays.toString(e.getStackTrace())));
*/
System.err.println(e.getClass().getName()+"\n"+e.getMessage());
return false;
}
return true;
}
}

99
src/teavm/java/me/ayunami2000/ayuncraft/CryptManager.java
View File

@ -1,12 +1,20 @@
package me.ayunami2000.ayuncraft; package me.ayunami2000.ayuncraft;
import java.io.ByteArrayOutputStream;
import java.io.InputStream; import java.io.InputStream;
import java.io.OutputStream; import java.io.OutputStream;
import java.math.BigInteger; import java.math.BigInteger;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
import com.rhg.rsa.RSAPrivateKey;
import com.rhg.rsa.RSAPublicKey;
import me.ayunami2000.ayuncraft.java.security.Key; import me.ayunami2000.ayuncraft.java.security.Key;
import me.ayunami2000.ayuncraft.java.security.PrivateKey; import me.ayunami2000.ayuncraft.java.security.PrivateKey;
import me.ayunami2000.ayuncraft.java.security.PublicKey; import me.ayunami2000.ayuncraft.java.security.PublicKey;
import net.lax1dude.eaglercraft.Base64;
import org.bouncycastle.crypto.BufferedBlockCipher; import org.bouncycastle.crypto.BufferedBlockCipher;
import org.bouncycastle.crypto.engines.AESFastEngine; import org.bouncycastle.crypto.engines.AESFastEngine;
import org.bouncycastle.crypto.io.CipherInputStream; import org.bouncycastle.crypto.io.CipherInputStream;
@ -17,6 +25,9 @@ import org.bouncycastle.crypto.params.ParametersWithIV;
import me.ayunami2000.ayuncraft.javax.crypto.SecretKey; import me.ayunami2000.ayuncraft.javax.crypto.SecretKey;
import me.ayunami2000.ayuncraft.javax.crypto.spec.SecretKeySpec; import me.ayunami2000.ayuncraft.javax.crypto.spec.SecretKeySpec;
import org.teavm.jso.JSBody;
import org.teavm.jso.typedarrays.ArrayBuffer;
import org.teavm.jso.typedarrays.Uint8Array;
public class CryptManager public class CryptManager
{ {
@ -24,16 +35,41 @@ public class CryptManager
/** /**
* Generate a new shared secret AES key from a static preset key * Generate a new shared secret AES key from a static preset key
*/ */
private static final byte[] baseSharedKey = new byte[] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; private static final byte[] baseSharedKey = new byte[] {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
public static SecretKey createNewSharedKey(){ public static SecretKey createNewSharedKey(){
return new SecretKeySpec(baseSharedKey,"AES"); return new SecretKeySpec(baseSharedKey,"AES");
} }
/*
@JSBody(params = {"base64enc"}, script = "window.servercertraw=base64enc;window.servercert=new x509.X509Certificate(base64enc);")
private static native void setupDecode(String base64enc);
@JSBody(params = {}, script = "return window.servercert.publickey.algorithm.name;")
private static native String decodeAlgorithm();
@JSBody(params = {}, script = "return window.servercert.publickey.algorithm.publicExponent;")
private static native Uint8Array decodePublicExponent();
@JSBody(params = {}, script = "return window.servercert.publickey.algorithm.modulusLength;")
private static native int decodeModulusLength();
@JSBody(params = {}, script = "return new Uint8Array(window.servercert.publickey.rawData);")
private static native Uint8Array decodeData();
*/
/** /**
* Create a new PublicKey from encoded X.509 data * Create a new PublicKey from encoded X.509 data
*/ */
public static PublicKey decodePublicKey(byte[] par0ArrayOfByte) public static PublicKey decodePublicKey(byte[] par0ArrayOfByte)
{ {
/*
setupDecode(Base64.encodeBase64String(par0ArrayOfByte));
Uint8Array a = decodeData();
byte[] b = new byte[a.getByteLength()];
for(int i = 0; i < b.length; ++i) {
b[i] = (byte) (a.get(i) & 0xFF);
}
*/
return new ModifiablePublicKey("RSA","X.509",par0ArrayOfByte); return new ModifiablePublicKey("RSA","X.509",par0ArrayOfByte);
} }
@ -45,16 +81,44 @@ public class CryptManager
return new SecretKeySpec(decryptData(par0PrivateKey, par1ArrayOfByte), "AES"); return new SecretKeySpec(decryptData(par0PrivateKey, par1ArrayOfByte), "AES");
} }
private static RSA rsa=new RSA(2048); /*
private static RSA rsa=new RSA(1024);
static {
rsa.setModulus(BigInteger.valueOf(16));
}
*/
/** /**
* Encrypt byte[] data with RSA public key * Encrypt byte[] data with RSA public key
*/ */
public static byte[] encryptData(Key par0Key, byte[] par1ArrayOfByte) public static byte[] encryptData(Key par0Key, byte[] par1ArrayOfByte)
{ {
rsa.setPublicKey(new BigInteger(par0Key.getEncoded())); ///*
BigInteger res=rsa.encrypt(new BigInteger(par1ArrayOfByte)); try {
return res.toByteArray(); //System.out.println(Arrays.toString(par0Key.getEncoded()));
//System.out.println(Arrays.toString(par1ArrayOfByte));
RSAPublicKey rsaPublicKey = new RSAPublicKey(BigInteger.valueOf(16), new BigInteger(par0Key.getEncoded()));
ByteArrayOutputStream baos = new ByteArrayOutputStream();
rsaPublicKey.use(par1ArrayOfByte, baos);
return baos.toByteArray();
}catch(Exception e){
System.err.println(e.getClass().getName() + "\n" + e.getMessage());
//e.printStackTrace();
return null;
}
//*/
/*
try {
rsa.setPublicKey(new BigInteger(par0Key.getEncoded()));
BigInteger res = rsa.encrypt(new BigInteger(par1ArrayOfByte));
return res.toByteArray();
}catch(Exception e){
System.err.println(e.getClass().getName() + "\n" + e.getMessage());
//e.printStackTrace();
return null;
}
*/
} }
/** /**
@ -62,9 +126,28 @@ public class CryptManager
*/ */
public static byte[] decryptData(Key par0Key, byte[] par1ArrayOfByte) public static byte[] decryptData(Key par0Key, byte[] par1ArrayOfByte)
{ {
rsa.setPrivateKey(new BigInteger(par0Key.getEncoded())); ///*
BigInteger res=rsa.decrypt(new BigInteger(par1ArrayOfByte)); try{
return res.toByteArray(); RSAPrivateKey rsaPrivateKey = new RSAPrivateKey(BigInteger.valueOf(16),new BigInteger(par0Key.getEncoded()));
ByteArrayOutputStream baos = new ByteArrayOutputStream();
rsaPrivateKey.use(par1ArrayOfByte,baos);
return baos.toByteArray();
}catch(Exception e){
System.err.println(e.getClass().getName() + "\n" + e.getMessage());
return null;
}
//*/
/*
try {
rsa.setPrivateKey(new BigInteger(par0Key.getEncoded()));
BigInteger res = rsa.decrypt(new BigInteger(par1ArrayOfByte));
return res.toByteArray();
}catch(Exception e){
System.err.println(e.getClass().getName() + "\n" + e.getMessage());
//e.printStackTrace();
return null;
}
*/
} }
/** /**

14
src/teavm/java/me/ayunami2000/ayuncraft/RSA.java
View File

@ -44,7 +44,7 @@ public class RSA {
BigInteger q = BigInteger.probablePrime(N/2, random); BigInteger q = BigInteger.probablePrime(N/2, random);
BigInteger phi = (p.subtract(one)).multiply(q.subtract(one)); BigInteger phi = (p.subtract(one)).multiply(q.subtract(one));
modulus = p.multiply(q); modulus = p.multiply(q);
publicKey = new BigInteger("65537"); // common value in practice = 2^16 + 1 publicKey = new BigInteger("65537"); // common value in practice = 2^16 + 1
privateKey = publicKey.modInverse(phi); privateKey = publicKey.modInverse(phi);
} }
@ -67,6 +67,14 @@ public class RSA {
privateKey=k; privateKey=k;
} }
void setModulus(BigInteger k) {
modulus=k;
}
void setModulus() {
modulus=one;
}
BigInteger getPublicKey() { BigInteger getPublicKey() {
return publicKey; return publicKey;
@ -76,6 +84,10 @@ public class RSA {
return privateKey; return privateKey;
} }
BigInteger getModulus() {
return modulus;
}
public String toString() { public String toString() {
String s = ""; String s = "";
s += "public = " + publicKey + "\n"; s += "public = " + publicKey + "\n";

105
src/teavm/java/me/ayunami2000/ayuncraft/java/security/spec/RSAPublicKeySpec.java Normal file
View File

@ -0,0 +1,105 @@
/*
* Copyright (c) 1998, 2020, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package java.security.spec;
import java.math.BigInteger;
/**
* This class specifies an RSA public key.
*
* @author Jan Luehe
*
*
* @see java.security.Key
* @see java.security.KeyFactory
* @see KeySpec
* @see X509EncodedKeySpec
* @see RSAPrivateKeySpec
* @see RSAPrivateCrtKeySpec
*/
public class RSAPublicKeySpec implements KeySpec {
private final BigInteger modulus;
private final BigInteger publicExponent;
private final AlgorithmParameterSpec params;
/**
* Creates a new RSAPublicKeySpec.
*
* @param modulus the modulus
* @param publicExponent the public exponent
*/
public RSAPublicKeySpec(BigInteger modulus, BigInteger publicExponent) {
this(modulus, publicExponent, null);
}
/**
* Creates a new RSAPublicKeySpec with additional key parameters.
*
* @param modulus the modulus
* @param publicExponent the public exponent
* @param params the parameters associated with this key, may be null
* @since 8
*/
public RSAPublicKeySpec(BigInteger modulus, BigInteger publicExponent,
AlgorithmParameterSpec params) {
this.modulus = modulus;
this.publicExponent = publicExponent;
this.params = params;
}
/**
* Returns the modulus.
*
* @return the modulus
*/
public BigInteger getModulus() {
return this.modulus;
}
/**
* Returns the public exponent.
*
* @return the public exponent
*/
public BigInteger getPublicExponent() {
return this.publicExponent;
}
/**
* Returns the parameters associated with this key, may be null if not
* present.
*
* @return the parameters associated with this key
* @since 8
*/
public AlgorithmParameterSpec getParams() {
return this.params;
}
}