public static String generateHallmark(String secretPhrase, String host, int weight, int date) {
if (host.length() == 0 || host.length() > 100) {
throw new IllegalArgumentException("Hostname length should be between 1 and 100");
}
if (weight <= 0 || weight > Constants.MAX_BALANCE_NXT) {
throw new IllegalArgumentException(
"Weight should be between 1 and " + Constants.MAX_BALANCE_NXT);
}
byte[] publicKey = Crypto.getPublicKey(secretPhrase);
byte[] hostBytes = Convert.toBytes(host);
ByteBuffer buffer = ByteBuffer.allocate(32 + 2 + hostBytes.length + 4 + 4 + 1);
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.put(publicKey);
buffer.putShort((short) hostBytes.length);
buffer.put(hostBytes);
buffer.putInt(weight);
buffer.putInt(date);
byte[] data = buffer.array();
data[data.length - 1] = (byte) ThreadLocalRandom.current().nextInt();
byte[] signature = Crypto.sign(data, secretPhrase);
return Convert.toHexString(data) + Convert.toHexString(signature);
}
private Account(long id) {
if (id != Crypto.rsDecode(Crypto.rsEncode(id))) {
Logger.logMessage("CRITICAL ERROR: Reed-Solomon encoding fails for " + id);
}
this.id = id;
this.dbKey = accountDbKeyFactory.newKey(this.id);
this.creationHeight = Nxt.getBlockchain().getHeight();
currentLeasingHeightFrom = Integer.MAX_VALUE;
}
public static boolean verify(
byte[] signature, byte[] message, byte[] publicKey, boolean enforceCanonical) {
try {
if (enforceCanonical && !Curve25519.isCanonicalSignature(signature)) {
Logger.logDebugMessage("Rejecting non-canonical signature");
return false;
}
if (enforceCanonical && !Curve25519.isCanonicalPublicKey(publicKey)) {
Logger.logDebugMessage("Rejecting non-canonical public key");
return false;
}
byte[] Y = new byte[32];
byte[] v = new byte[32];
System.arraycopy(signature, 0, v, 0, 32);
byte[] h = new byte[32];
System.arraycopy(signature, 32, h, 0, 32);
Curve25519.verify(Y, v, h, publicKey);
MessageDigest digest = Crypto.sha256();
byte[] m = digest.digest(message);
digest.update(m);
byte[] h2 = digest.digest(Y);
return Arrays.equals(h, h2);
} catch (RuntimeException e) {
Logger.logMessage("Error in Crypto verify", e);
return false;
}
}
private void loadPassPhrases() {
try {
List<String> passphrases =
Files.readAllLines(Paths.get("passphrases.txt"), Charset.forName("US-ASCII"));
for (String ps : passphrases) {
if (!ps.isEmpty()) {
byte[] publicKey = Crypto.getPublicKey(ps);
byte[] publicKeyHash = Crypto.sha256().digest(publicKey);
Long id = Convert.fullHashToId(publicKeyHash);
loadedPassPhrases.put(id, ps);
LOGGER.info("Added key: {" + ps + "} -> {" + Convert.toUnsignedLong(id) + "}");
}
}
} catch (IOException e) {
LOGGER.info("Warning: no passphrases.txt found");
}
}
@Override
JSONStreamAware processRequest(HttpServletRequest req) throws NxtException.ValidationException {
String transactionBytes = Convert.emptyToNull(req.getParameter("unsignedTransactionBytes"));
String transactionJSON = Convert.emptyToNull(req.getParameter("unsignedTransactionJSON"));
if (transactionBytes == null && transactionJSON == null) {
return MISSING_UNSIGNED_BYTES;
}
String secretPhrase = Convert.emptyToNull(req.getParameter("secretPhrase"));
if (secretPhrase == null) {
return MISSING_SECRET_PHRASE;
}
try {
Transaction transaction;
if (transactionBytes != null) {
byte[] bytes = Convert.parseHexString(transactionBytes);
transaction = Nxt.getTransactionProcessor().parseTransaction(bytes);
} else {
JSONObject json = (JSONObject) JSONValue.parse(transactionJSON);
transaction = Nxt.getTransactionProcessor().parseTransaction(json);
}
transaction.validate();
if (transaction.getSignature() != null) {
JSONObject response = new JSONObject();
response.put("errorCode", 4);
response.put(
"errorDescription",
"Incorrect \"unsignedTransactionBytes\" - transaction is already signed");
return response;
}
transaction.sign(secretPhrase);
JSONObject response = new JSONObject();
response.put("transaction", transaction.getStringId());
response.put("fullHash", transaction.getFullHash());
response.put("transactionBytes", Convert.toHexString(transaction.getBytes()));
response.put(
"signatureHash", Convert.toHexString(Crypto.sha256().digest(transaction.getSignature())));
response.put("verify", transaction.verifySignature());
return response;
} catch (NxtException.ValidationException | RuntimeException e) {
// Logger.logDebugMessage(e.getMessage(), e);
return INCORRECT_UNSIGNED_BYTES;
}
}
public static byte[] getPublicKey(String secretPhrase) {
try {
byte[] publicKey = new byte[32];
Curve25519.keygen(publicKey, null, Crypto.sha256().digest(secretPhrase.getBytes("UTF-8")));
if (!Curve25519.isCanonicalPublicKey(publicKey)) {
throw new RuntimeException("Public key not canonical");
}
return publicKey;
} catch (RuntimeException | UnsupportedEncodingException e) {
Logger.logMessage("Error getting public key", e);
return null;
}
}
public static byte[] sign(byte[] message, String secretPhrase) {
try {
byte[] P = new byte[32];
byte[] s = new byte[32];
MessageDigest digest = Crypto.sha256();
Curve25519.keygen(P, s, digest.digest(secretPhrase.getBytes("UTF-8")));
byte[] m = digest.digest(message);
digest.update(m);
byte[] x = digest.digest(s);
byte[] Y = new byte[32];
Curve25519.keygen(Y, null, x);
digest.update(m);
byte[] h = digest.digest(Y);
byte[] v = new byte[32];
Curve25519.sign(v, h, x, s);
byte[] signature = new byte[64];
System.arraycopy(v, 0, signature, 0, 32);
System.arraycopy(h, 0, signature, 32, 32);
if (!Curve25519.isCanonicalSignature(signature)) {
throw new RuntimeException("Signature not canonical");
}
return signature;
} catch (RuntimeException | UnsupportedEncodingException e) {
Logger.logMessage("Error in signing message", e);
return null;
}
}
public static Transaction create(
IAccount sender,
Long order,
short deadline,
int fee,
Long referencedTransaction,
NXTService nxt)
throws TransactionException, ValidationException {
String secretPhrase = sender.getPrivateKey();
byte[] publicKey = Crypto.getPublicKey(secretPhrase);
if ((fee <= 0) || (fee >= 1000000000L))
throw new TransactionException(TransactionException.INCORRECT_FEE);
if ((deadline < 1) || (deadline > 1440))
throw new TransactionException(TransactionException.INCORRECT_DEADLINE);
Account account = Account.getAccount(publicKey);
if (account == null) throw new TransactionException(TransactionException.INTERNAL_ERROR);
Order.Ask orderData = Order.Ask.getAskOrder(order);
if (orderData == null || !orderData.getAccount().getId().equals(account.getId()))
throw new TransactionException(TransactionException.UNKNOWN_ORDER);
Attachment attachment = new Attachment.ColoredCoinsAskOrderCancellation(order);
Transaction transaction =
Nxt.getTransactionProcessor()
.newTransaction(
deadline, publicKey, Genesis.CREATOR_ID, 0, fee, referencedTransaction, attachment);
transaction.sign(secretPhrase);
nxt.broacastTransaction(transaction);
return transaction;
}
public static Hallmark parseHallmark(String hallmarkString) {
byte[] hallmarkBytes = Convert.parseHexString(hallmarkString);
ByteBuffer buffer = ByteBuffer.wrap(hallmarkBytes);
buffer.order(ByteOrder.LITTLE_ENDIAN);
byte[] publicKey = new byte[32];
buffer.get(publicKey);
int hostLength = buffer.getShort();
if (hostLength > 300) {
throw new IllegalArgumentException("Invalid host length");
}
byte[] hostBytes = new byte[hostLength];
buffer.get(hostBytes);
String host = Convert.toString(hostBytes);
int weight = buffer.getInt();
int date = buffer.getInt();
buffer.get();
byte[] signature = new byte[64];
buffer.get(signature);
byte[] data = new byte[hallmarkBytes.length - 64];
System.arraycopy(hallmarkBytes, 0, data, 0, data.length);
boolean isValid =
host.length() < 100
&& weight > 0
&& weight <= Constants.MAX_BALANCE_NXT
&& Crypto.verify(signature, data, publicKey, true);
try {
return new Hallmark(hallmarkString, publicKey, signature, host, weight, date, isValid);
} catch (URISyntaxException e) {
throw new RuntimeException(e.toString(), e);
}
}
public byte[] decryptFrom(EncryptedData encryptedData, String recipientSecretPhrase) {
if (getPublicKey() == null) {
throw new IllegalArgumentException("Sender account doesn't have a public key set");
}
return encryptedData.decrypt(Crypto.getPrivateKey(recipientSecretPhrase), publicKey);
}
public EncryptedData encryptTo(byte[] data, String senderSecretPhrase) {
if (getPublicKey() == null) {
throw new IllegalArgumentException("Recipient account doesn't have a public key set");
}
return EncryptedData.encrypt(data, Crypto.getPrivateKey(senderSecretPhrase), publicKey);
}
public static long getId(byte[] publicKey) {
byte[] publicKeyHash = Crypto.sha256().digest(publicKey);
return Convert.fullHashToId(publicKeyHash);
}
