public void TestComputeSha256()
{
var result = HashUtils.ComputeSha256(HashUtilsData.Data);
Assert.Equal(HashUtilsData.Sha256Hash.Length, result.Length);
Assert.Equal(HashUtilsData.Sha256Hash, result);
}
public static bool LoadSignKey(string desiredKeyName, byte[] keyData, out bool isNewKey, out string keyName)
{
isNewKey = false;
byte[] sha256Hash = HashUtils.ComputeSha256(keyData);
bool hashMatches = KnowsSignKeySHA256(sha256Hash, out keyName);
if (hashMatches && SignkeyStorage[keyName].HasKeyData)
{
// Duplicate key, already loaded
Console.WriteLine($"SignKey {keyName} is already loaded");
return(false);
}
if (hashMatches)
{
SignkeyStorage[keyName].SetKey(keyData);
return(true);
}
// New key, using user-set keyname
isNewKey = true;
SignkeyStorage[desiredKeyName] = new DurangoKeyEntry(KeyType.Odk, keyData);
return(true);
}
public DurangoKeyEntry(KeyType keyType, byte[] keyData)
{
KeyType = keyType;
SHA256Hash = HashUtils.ComputeSha256(keyData);
DataSize = keyData.Length;
KeyData = keyData;
}
public void Unsigned_XVD_Encrypt_Test()
{
const string dest = @"F:\XBone\XVDs\TestXVDs\xvd2_encrypted_temp";
const string fileToCompare = @"F:\XBone\XVDs\TestXVDs\xvd2";
if (File.Exists(dest))
{
File.Delete(dest);
}
File.Copy(@"F:\XBone\XVDs\TestXVDs\xvd2_decrypted_orig_mod", dest); // modded with CIK used in xvd2
using (var file = new XvdFile(dest))
{
Assert.True(file.Load());
/*
* Assert.False(file.Header.IsSignedWithRedKey);
*/
Assert.False(file.IsEncrypted);
Assert.False(file.IsDataIntegrityEnabled);
// Assert.True(file.Encrypt());
Assert.True(file.IsEncrypted);
// copy values from file being compared so the hashes match
file.Header.PDUID = new byte[] { 0xEA, 0xC8, 0xE2, 0x82, 0x2F, 0x58, 0x32, 0x4F, 0x92, 0x29, 0xE1, 0xAB, 0x6E, 0x8F, 0x91, 0x63 };
using (FileStream stream = File.OpenRead(fileToCompare))
{
stream.Position = 0;
stream.Read(file.Header.Signature, 0, 0x200);
}
Assert.True(file.AddHashTree());
ulong[] invalid = file.VerifyDataHashTree();
Assert.True(invalid.Length == 0);
Assert.True(file.VerifyHashTree());
}
byte[] generatedHash;
using (FileStream stream = File.OpenRead(dest))
{
generatedHash = HashUtils.ComputeSha256(stream);
}
File.Delete(dest);
byte[] expectedHash;
using (FileStream stream = File.OpenRead(fileToCompare))
{
expectedHash = HashUtils.ComputeSha256(stream);
}
Assert.True(generatedHash.IsEqualTo(expectedHash));
}
public void Unsigned_XVD_Decrypt_Test()
{
const string dest = @"F:\XBone\XVDs\TestXVDs\xvd2_decrypted_temp";
const string fileToCompare = @"F:\XBone\XVDs\TestXVDs\xvd2_decrypted";
if (File.Exists(dest))
{
File.Delete(dest);
}
File.Copy(@"F:\XBone\XVDs\TestXVDs\xvd2", dest);
using (var file = new XvdFile(dest))
{
Assert.True(file.Load());
/*
* Assert.True(file.Header.IsSignedWithRedKey);
*/
Assert.True(file.IsEncrypted);
Assert.True(file.IsDataIntegrityEnabled);
Assert.True(file.HashTreeValid);
Assert.True(file.DataHashTreeValid);
Assert.True(file.Decrypt());
Assert.False(file.IsEncrypted);
ulong[] invalid = file.VerifyDataHashTree();
Assert.True(invalid.Length == 0);
Assert.True(file.VerifyHashTree());
byte[] ntfsString = file.Read(0x75003, 4);
byte[] expectedString = { 0x4E, 0x54, 0x46, 0x53 };
Assert.True(ntfsString.IsEqualTo(expectedString));
}
byte[] generatedHash;
using (FileStream stream = File.OpenRead(dest))
{
generatedHash = HashUtils.ComputeSha256(stream);
}
File.Delete(dest);
byte[] expectedHash;
using (FileStream stream = File.OpenRead(fileToCompare))
{
expectedHash = HashUtils.ComputeSha256(stream);
}
Assert.True(generatedHash.IsEqualTo(expectedHash));
}
private byte[] ComputeDataHash()
{
BlockData blockData = new BlockData
{
Index = Index,
Transactions = Transactions.Select(t => new TransactionData(t)).ToArray(),
Difficulty = Difficulty,
PreviousBlockHash = IsGenesis ? null : PreviousBlockHash,
MinedBy = MinedBy
};
string json = JsonUtils.Serialize(blockData, false);
return(HashUtils.ComputeSha256(json.GetBytes()));
}
public void Dev_Signed_XVC_Encrypt_Test()
{
const string dest = @"F:\XBone\XVDs\TestXVDs\xvd1_encrypted_temp";
const string fileToCompare = @"F:\XBone\XVDs\TestXVDs\xvd1";
if (File.Exists(dest))
{
File.Delete(dest);
}
File.Copy(@"F:\XBone\XVDs\TestXVDs\xvd1_decrypted", dest);
using (var file = new XvdFile(dest))
{
Assert.True(file.Load());
Assert.False(file.IsEncrypted);
Assert.True(file.IsDataIntegrityEnabled);
Assert.True(file.HashTreeValid);
Assert.True(file.DataHashTreeValid);
// Assert.True(file.Encrypt());
Assert.True(file.IsEncrypted);
ulong[] invalid = file.VerifyDataHashTree();
Assert.True(invalid.Length == 0);
Assert.True(file.VerifyHashTree());
}
byte[] generatedHash;
using (FileStream stream = File.OpenRead(dest))
{
generatedHash = HashUtils.ComputeSha256(stream);
}
File.Delete(dest);
byte[] expectedHash;
using (FileStream stream = File.OpenRead(fileToCompare))
{
expectedHash = HashUtils.ComputeSha256(stream);
}
Assert.True(generatedHash.IsEqualTo(expectedHash));
}
public static int LoadCikKeys(byte[] keyData, out Guid[] loadedKeys)
{
int foundCount = 0;
if (keyData.Length < 0x30 || keyData.Length % 0x30 != 0)
{
throw new Exception("Misaligned CIK, expecting array of 0x30 bytes: 0x10 bytes: GUID, 0x20 bytes: Key");
}
int cikKeyCount = keyData.Length / 0x30;
loadedKeys = new Guid[cikKeyCount];
using (BinaryReader br = new BinaryReader(new MemoryStream(keyData)))
{
for (int keyIndex = 0; keyIndex < cikKeyCount; keyIndex++)
{
var guid = new Guid(br.ReadBytes(0x10));
var cikKeyData = br.ReadBytes(0x20);
var sha256Hash = HashUtils.ComputeSha256(cikKeyData);
bool hashMatches = KnowsCikSHA256(sha256Hash, out Guid verifyGuid);
var hashString = sha256Hash.ToHexString("");
if (hashMatches && verifyGuid != guid)
{
Console.WriteLine($"CIK {guid} with hash {hashString} is known as {verifyGuid}");
continue;
}
if (hashMatches && CikStorage[guid].HasKeyData)
{
// Duplicate key, already loaded
Console.WriteLine($"CIK {guid} is already loaded");
continue;
}
CikStorage[guid] = new DurangoKeyEntry(KeyType.Cik, cikKeyData);
foundCount++;
}
}
return(foundCount);
}
public static bool LoadOdkKey(OdkIndex keyId, byte[] keyData, out bool isNewKey)
{
isNewKey = false;
byte[] sha256Hash = HashUtils.ComputeSha256(keyData);
DurangoKeyEntry existingKey = GetOdkById(keyId);
if (existingKey != null)
{
bool hashMatches = KnowsOdkSHA256(sha256Hash, out OdkIndex verifyKeyId);
if (hashMatches && verifyKeyId != keyId)
{
var hashString = sha256Hash.ToHexString("");
Console.WriteLine($"ODK {keyId} with hash {hashString} is known as ODK {verifyKeyId}");
return(false);
}
if (hashMatches && OdkStorage[keyId].HasKeyData)
{
// Duplicate key, already loaded
Console.WriteLine($"ODK {keyId} is already loaded");
return(false);
}
if (!hashMatches)
{
Console.WriteLine($"ODK {keyId} does not match expected hash");
return(false);
}
OdkStorage[keyId].SetKey(keyData);
return(true);
}
isNewKey = true;
OdkStorage[keyId] = new DurangoKeyEntry(KeyType.Odk, keyData);
return(true);
}
private static void VerifyTransaction(CreateTransactionRequest request)
{
TransactionData transaction = new TransactionData
{
From = request.From,
To = request.To,
Value = request.Value,
Fee = request.Fee,
DateCreated = request.DateCreated,
Data = request.Data,
SenderPubKey = request.SenderPubKey
};
string transactionJson = JsonUtils.Serialize(transaction, false);
byte[] transactionDataHash = HashUtils.ComputeSha256(transactionJson.GetBytes());
BigInteger r = new BigInteger(request.SenderSignature[0], 16);
BigInteger s = new BigInteger(request.SenderSignature[1], 16);
ECPoint publicKey = EncryptionUtils.DecompressKey(request.SenderPubKey);
bool valid = EncryptionUtils.VerifySignature(publicKey, r, s, transactionDataHash);
Console.WriteLine("Signature valid: " + valid);
}
byte[] CalculateHash()
{
byte[] data = Shared.StructToBytes(this);
return(HashUtils.ComputeSha256(data, 0, DataToHash));
}
public int PullKeysFromFile()
{
var exeData = File.ReadAllBytes(FilePath);
int foundCount = 0;
for (int i = 0; i < exeData.Length - 32; i++)
{
byte[] hash32 = HashUtils.ComputeSha256(exeData, i, 32);
DurangoKeyEntry keyEntry;
foreach (var kvp in DurangoKeys.GetAllXvdSigningKeys())
{
string keyName = kvp.Key;
keyEntry = kvp.Value;
if (keyEntry.HasKeyData)
{
continue;
}
if (keyEntry.DataSize > exeData.Length - i)
{
continue;
}
byte[] signKeyHash = HashUtils.ComputeSha256(exeData, i, keyEntry.DataSize);
if (!keyEntry.SHA256Hash.IsEqualTo(signKeyHash))
{
continue;
}
Console.WriteLine($"Found {keyEntry.KeyType} \"{keyName}\" at offset 0x{i:X}");
byte[] keyData = new byte[keyEntry.DataSize];
Array.Copy(exeData, i, keyData, 0, keyData.Length);
DurangoKeys.LoadSignKey(keyName, keyData, out bool newKey, out keyName);
foundCount++;
}
foreach (var kvp in DurangoKeys.GetAllODK())
{
OdkIndex keyId = kvp.Key;
keyEntry = kvp.Value;
if (keyEntry.HasKeyData)
{
continue;
}
if (!hash32.IsEqualTo(keyEntry.SHA256Hash))
{
continue;
}
Console.WriteLine($"Found {keyEntry.KeyType} \"{keyId}\" at offset 0x{i:X}");
byte[] keyData = new byte[keyEntry.DataSize];
Array.Copy(exeData, i, keyData, 0, keyData.Length);
DurangoKeys.LoadOdkKey(keyId, keyData, out bool newKey);
foundCount++;
}
foreach (var kvp in DurangoKeys.GetAllCIK())
{
Guid keyId = kvp.Key;
keyEntry = kvp.Value;
if (keyEntry.HasKeyData)
{
continue;
}
if (!hash32.IsEqualTo(keyEntry.SHA256Hash))
{
continue;
}
Console.WriteLine($"Found {keyEntry.KeyType} \"{keyId}\" at offset 0x{i:X}");
byte[] keyData = new byte[0x10 + keyEntry.DataSize];
Array.Copy(keyId.ToByteArray(), 0, keyData, 0, 0x10);
Array.Copy(exeData, i, keyData, 0x10, keyEntry.DataSize);
DurangoKeys.LoadCikKeys(keyData, out Guid[] keyGuid);
foundCount++;
}
}
return(foundCount);
}
private static void SignAndVerifyTransaction(
string privateKey,
string recipientAddress,
string dateCreatedIso8601,
int value,
int fee)
{
Console.WriteLine("Generate and sign a transaction");
Console.WriteLine("-------------------------------");
Console.WriteLine("Sender private key:\r\n" + privateKey);
BigInteger senderPrivateKey = new BigInteger(privateKey, 16);
ECPoint senderPublicKey = EncryptionUtils.GetPublicKey(senderPrivateKey);
string senderPublicKeyCompressed = HashUtils.ToHexCompressed(senderPublicKey);
Console.WriteLine("Sender public key compressed (65 hex digits):\r\n" +
senderPublicKeyCompressed);
string senderAddress = HashUtils.ComputeRIPEMD160(
Utils.GetBytes(senderPublicKeyCompressed)).ToHex();
Console.WriteLine("Sender address (40 hex digits):\r\n" + senderAddress);
Transaction transaction = new Transaction
{
Sender = senderAddress,
Recipient = recipientAddress,
SenderPublicKey = senderPublicKeyCompressed,
Value = value,
Fee = fee,
DateCreatedIso8601 = dateCreatedIso8601
};
string transactionJsonFormatted = JsonUtils.Serialize(transaction);
Console.WriteLine("Transaction (JSON, formatted):\r\n" + transactionJsonFormatted);
string transactionJson = JsonUtils.Serialize(transaction, false);
Console.WriteLine("Transaction (JSON):\r\n" + transactionJson);
byte[] transactionHash = HashUtils.ComputeSha256(Utils.GetBytes(transactionJson));
Console.WriteLine("Transaction hash (SHA256):\r\n" + transactionHash.ToHex());
ECDSASignature transactionSignature =
EncryptionUtils.Sign(transactionHash, senderPrivateKey);
string r = transactionSignature.R.ToString(16);
string s = transactionSignature.S.ToString(16);
Console.WriteLine("Transaction signature:\r\n({0}, {1})", r, s);
transaction.Signature = new Signature
{
R = r,
S = s
};
string signedTransactionJson = JsonUtils.Serialize(transaction);
Console.WriteLine("Signed transaction (JSON):\r\n" + signedTransactionJson);
ECPublicKeyParameters parameters =
EncryptionUtils.GetPublicKeyParameters(privateKey);
bool valid = EncryptionUtils.VerifySignature(
transactionHash, transactionSignature, parameters);
Console.WriteLine("Signature valid: " + valid);
}
private static CreateTransactionRequest CreateAndSignTransaction(
string privateKey,
string recipientAddress,
string dateCreatedIso8601,
long value,
long fee,
string data)
{
Console.WriteLine("Generate and sign a transaction");
Console.WriteLine("-------------------------------");
Console.WriteLine("Sender private key:\r\n" + privateKey);
BigInteger senderPrivateKey = new BigInteger(privateKey, 16);
ECPoint senderPublicKey = EncryptionUtils.GetPublicKey(senderPrivateKey);
string senderPublicKeyCompressed = EncryptionUtils.ToHexCompressed(senderPublicKey);
Console.WriteLine("Sender public key compressed (65 hex digits):\r\n" +
senderPublicKeyCompressed);
string senderAddress = HashUtils.ComputeRIPEMD160(
senderPublicKeyCompressed.GetBytes()).ToHex();
Console.WriteLine("Sender address (40 hex digits):\r\n" + senderAddress);
TransactionData transaction = new TransactionData
{
From = senderAddress,
To = recipientAddress,
Value = value,
Fee = fee,
DateCreated = dateCreatedIso8601,
Data = data,
SenderPubKey = senderPublicKeyCompressed
};
string transactionJsonFormatted = JsonUtils.Serialize(transaction);
Console.WriteLine("Transaction (JSON, formatted):\r\n" + transactionJsonFormatted);
string transactionJson = JsonUtils.Serialize(transaction, false);
Console.WriteLine("Transaction (JSON):\r\n" + transactionJson);
byte[] transactionDataHash = HashUtils.ComputeSha256(transactionJson.GetBytes());
Console.WriteLine("Transaction data hash (SHA256):\r\n" + transactionDataHash.ToHex());
BigInteger[] transactionSignature =
EncryptionUtils.Sign(transactionDataHash, senderPrivateKey);
string r = transactionSignature[0].ToString(16);
string s = transactionSignature[1].ToString(16);
Console.WriteLine("Transaction signature:\r\n({0}, {1})", r, s);
CreateTransactionRequest request =
CreateTransactionRequest.FromTransactionData(transaction);
request.SenderSignature = new string[] { r, s };
string signedTransactionJson = JsonUtils.Serialize(request);
Console.WriteLine("Signed transaction (JSON):\r\n" + signedTransactionJson);
return(request);
}
public static async Task CreateAndSignFaucetTransaction(string recipientAddress, long value)
{
Console.WriteLine("--------------------------------");
Console.WriteLine("CREATING TRANSACTION FROM FAUCET");
Console.WriteLine("--------------------------------\n");
string dateTime = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
TransactionData transactionData = new TransactionData
{
From = faucetAddress,
To = recipientAddress,
Value = value,
Fee = 10,
DateCreated = dateTime,
Data = "faucetTX",
SenderPubKey = faucetPublicKey
};
string transactionJson = JsonUtils.Serialize(transactionData, false);
Console.WriteLine("Transaction (JSON): {0}\n\n", transactionJson);
byte[] transactionDataHash = HashUtils.ComputeSha256(transactionJson.GetBytes());
var tranSignature = EncryptionUtils.Sign(transactionDataHash, faucetPrivateKey);
CreateTransactionRequest signedTransaction = CreateTransactionRequest.FromTransactionData(transactionData);
signedTransaction.SenderSignature = new string[]
{
tranSignature[0].ToString(16),
tranSignature[1].ToString(16)
};
string signedTranJson = JsonUtils.Serialize(signedTransaction);
Console.WriteLine("\nSigned transaction (JSON):");
Console.WriteLine(signedTranJson);
var nodeClient = new NodeClient("http://localhost:64149");
Response <Transaction> response;
int retries = 0;
do
{
response = await nodeClient.CreateTransaction(signedTransaction).ConfigureAwait(false);
retries++;
} while (response.Status == Status.Failed && retries <= 5);
if (response.Status == Status.Success)
{
Console.WriteLine("Transaction submitted to blockchain!");
}
else
{
Console.WriteLine("Transaction unsuccessful!");
foreach (var error in response.Errors)
{
Console.WriteLine($"Error: {error}");
}
}
}
private byte[] ComputeDataHash()
{
string json = JsonUtils.Serialize(new TransactionDataBase(this), false);
return(HashUtils.ComputeSha256(json.GetBytes()));
}
