static bool Validation(string validateKey, string iv, string cypher, string hash)
{
var needToHash = CryptoExtensions.HexToBinary(iv + cypher);
if (needToHash == null)
{
return(false);
}
var key = CryptoExtensions.HexToBinary(validateKey);
if (key == null)
{
return(false);
}
var hashData = CryptoExtensions.HexToBinary(hash);
if (hashData == null)
{
return(false);
}
using (var keyedValidationAlgorithm = new HMACSHA256(key))
{
var computed = keyedValidationAlgorithm.ComputeHash(needToHash);
return(CryptoExtensions.BuffersAreEqual(hashData, 0, hashData.Length, computed, 0, hashData.Length));
}
}
/// <summary>
/// Kullanıcı giriş servisi
/// </summary>
/// <param name="userModel"></param>
/// <returns></returns>
public Token Login(UserModel userModel)
{
using var uow = new UnitOfWork <MasterContext>();
var user = uow.GetRepository <UserModel>()
.GetAll(x => x.UserName.Equals(userModel.UserName, StringComparison.OrdinalIgnoreCase) &&
x.Password.Equals(CryptoExtensions.Encrypt(userModel.Password))).FirstOrDefault();
if (user != null)
{
//Token üretiliyor.
var token = TokenHandler.Instance.CreateAccessToken(user);
token.UserTokenDto = ObjectMapper.Map <UserTokenDto>(user);
//Refresh token Users tablosuna işleniyor.
user.RefreshToken = token.RefreshToken;
user.AccessToken = token.AccessToken;
user.RefreshTokenEndDate = token.Expiration;
uow.GetRepository <UserModel>().Update(user);
uow.SaveChanges();
return(token);
}
return(null);
}
public void ECDsaSecP256k1()
{
var address = "0x66571c32d77c4852be4c282eb952ba94efbeac20";
var key = "6f6784731c4e526c97fa6a97b6f22e96f307588c5868bc2c545248bc31207eb1";
Assert.IsTrue(key.Length == 64);
var curve = ECCurve.Secp256k1;
var privateKey = key.HexToByteArray();
var pKey = ECCurve.Secp256k1.G * privateKey;
var publicKey = pKey.EncodePoint(true).ToArray();
var uncompressedPublicKey = pKey.EncodePoint(false).Skip(1).ToArray();
var kak = new Phantasma.Ethereum.Util.Sha3Keccack().CalculateHash(uncompressedPublicKey);
var Address = "0x" + Base16.Encode(kak.Skip(12).ToArray()).ToLower();
Console.WriteLine("Address: " + Address);
Console.WriteLine("address: " + address);
Assert.IsTrue(Address == address);
var msgBytes = Encoding.ASCII.GetBytes("Phantasma");
var signature = CryptoExtensions.SignECDsa(msgBytes, privateKey, publicKey, ECDsaCurve.Secp256k1);
Assert.IsNotNull(signature);
var signatureUncompressed = CryptoExtensions.SignECDsa(msgBytes, privateKey, uncompressedPublicKey, ECDsaCurve.Secp256k1);
Assert.IsNotNull(signatureUncompressed);
Assert.IsTrue(CryptoExtensions.VerifySignatureECDsa(msgBytes, signature, publicKey, ECDsaCurve.Secp256k1));
Assert.IsTrue(CryptoExtensions.VerifySignatureECDsa(msgBytes, signature, uncompressedPublicKey, ECDsaCurve.Secp256k1));
}
public Address GetTopUpAddress(Address from)
{
var bytes = Encoding.UTF8.GetBytes(from.Text + ".relay");
var hash = CryptoExtensions.SHA256(bytes);
return(new Address(hash));
}
public CustomContract(byte[] script, byte[] ABI) : base()
{
Throw.IfNull(script, nameof(script));
this.Script = script;
_name = new Hash(CryptoExtensions.SHA256(script)).ToString(); // TODO do something better here
}
public string ChangePassword(ApplicationUser user, string currentPassword, string newPassword)
{
string s = "";
if (string.IsNullOrEmpty(user.Id))
{
s = "錯誤!無此帳號!";
return(s);
}
int id = Convert.ToInt32(user.Id);
var ur = _context.AppUsers.Find(id);
if (ur != null)
{
// user's password encrypt by DES.
string DESKey = "84203025";
var checkPW = CryptoExtensions.DESEncrypt(currentPassword, DESKey);
if (ur.Password == checkPW)
{
var encryptPW = CryptoExtensions.DESEncrypt(newPassword, DESKey); // Encrypt and check password.
ur.Password = encryptPW;
_context.Entry(ur).State = EntityState.Modified;
_context.SaveChanges();
s = "成功";
return(s);
}
}
s = "錯誤!原密碼輸入不正確!";
return(s);
}
private void UpdateHash()
{
var data = this.ToByteArray(false);
var hash = CryptoExtensions.SHA256(data);
this.Hash = new Hash(hash);
}
public byte[] GenerateSignature(byte[] message)
{
if (privateKey == null)
{
throw new InvalidOperationException();
}
BigInteger e = CalculateE(curve.N, message);
BigInteger d = BigInteger.FromSignedArray(privateKey.Reverse().Concat(new byte[1]).ToArray());
BigInteger r, s;
do
{
BigInteger k;
do
{
do
{
k = CryptoExtensions.NextBigInteger(curve.N.GetBitLength());
}while (k.Sign == 0 || k.CompareTo(curve.N) >= 0);
ECPoint p = ECPoint.Multiply(curve.G, k);
BigInteger x = p.X.Value;
r = x.Mod(curve.N);
}while (r.Sign == 0);
s = (k.ModInverse(curve.N) * (e + d * r)).Mod(curve.N);
if (s > curve.N / 2)
{
s = curve.N - s;
}
}while (s.Sign == 0);
return(EncodeSignatureDER(r, s));
}
public async Task ValidateCryptoHandshake()
{
var server = new WsServer();
var serverKey = CryptoExtensions.GenerateKey();
var clientKey = CryptoExtensions.GenerateKey();
ECPoint serverPub, clientPub = new ECPoint();
await server.StartAsync(new IPEndPoint(IPAddress.Loopback, 0), async stream =>
{
clientPub = await stream.EncryptAsync(serverKey);
});
await Task.Delay(500);
// start client
var client = new WsClient();
var conn = await client.ConnectAsync(new Uri($"ws://" + server.ListeningAddresses[0].Substring(7)));
serverPub = await conn.EncryptAsync(clientKey);
await Task.Delay(500);
Assert.Equal(serverKey.Q.X, serverPub.X);
Assert.Equal(clientKey.Q.X, clientPub.X);
server.Dispose();
client.Dispose();
}
internal void UpdateHash()
{
var data = ToByteArray();
var hashBytes = CryptoExtensions.SHA256(data);
this.Hash = new Hash(hashBytes);
}
internal void UpdateHash()
{
var data = ToByteArray();
var hashBytes = CryptoExtensions.SHA256(data);
_hash = new Hash(hashBytes);
_dirty = false;
}
public static byte[] ExpandedPrivateKeyFromSeed(byte[] privateKeySeed)
{
byte[] privateKey;
byte[] publicKey;
KeyPairFromSeed(out publicKey, out privateKey, privateKeySeed);
CryptoExtensions.Wipe(publicKey);
return(privateKey);
}
// TODO - Optimize this to avoid recalculating the arrays if only the nonce changed
internal void UpdateHash(byte[] payload)
{
this.Payload = payload;
var data = ToByteArray();
var hashBytes = CryptoExtensions.SHA256(data);
this.Hash = new Hash(hashBytes);
}
public static KeyPair GenerateInteropKeys(KeyPair genesisKeys, string platformName)
{
var temp = $"{platformName.ToUpper()}!{genesisKeys.ToWIF()}{Seed}";
var privateKey = CryptoExtensions.Sha256(temp);
var key = new KeyPair(privateKey);
return(key);
}
public void Update(byte[] data, int offset, int count)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException("offset");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException("count");
}
if (data.Length - offset < count)
{
throw new ArgumentException("Requires offset + count <= data.Length");
}
Array16 <ulong> block;
int bytesInBuffer = (int)_totalBytes & (BlockSize - 1);
_totalBytes += (uint)count;
if (_totalBytes >= ulong.MaxValue / 8)
{
throw new InvalidOperationException("Too much data");
}
// Fill existing buffer
if (bytesInBuffer != 0)
{
var toCopy = System.Math.Min(BlockSize - bytesInBuffer, count);
ByteArrayUtils.CopyBytes(data, offset, _buffer, bytesInBuffer, toCopy);
offset += toCopy;
count -= toCopy;
bytesInBuffer += toCopy;
if (bytesInBuffer == BlockSize)
{
ByteIntegerConverter.Array16LoadBigEndian64(out block, _buffer, 0);
Core(out _state, ref _state, ref block);
CryptoExtensions.InternalWipe(_buffer, 0, _buffer.Length);
bytesInBuffer = 0;
}
}
// Hash complete blocks without copying
while (count >= BlockSize)
{
ByteIntegerConverter.Array16LoadBigEndian64(out block, data, offset);
Core(out _state, ref _state, ref block);
offset += BlockSize;
count -= BlockSize;
}
// Copy remainder into buffer
if (count > 0)
{
ByteArrayUtils.CopyBytes(data, offset, _buffer, bytesInBuffer, count);
}
}
public byte[] Decrypt(byte[] chunk, PhantasmaKeys keys)
{
if (keys.Address != this.Address)
{
throw new ChainException("decryption public address does not match");
}
return(CryptoExtensions.AESGCMDecrypt(chunk, keys.PrivateKey, ContentInitializationVector));
}
protected override void DeserializePayload(BEReader reader)
{
Flags = (DeviceFlags)reader.ReadUInt32();
DeviceType = (DeviceType)reader.ReadUInt16();
Name = reader.ReadString();
HardwareId = Guid.Parse(reader.ReadString());
LastError = reader.ReadUInt32();
Certificate = CryptoExtensions.DeserializeCertificateAsn(reader.ReadBlob());
}
public string DecryptName(string name, PhantasmaKeys keys)
{
if (keys.Address != this.Address)
{
throw new ChainException("encryption public address does not match");
}
return(System.Text.Encoding.UTF8.GetString(CryptoExtensions.AESGCMDecrypt(Numerics.Base58.Decode(name), keys.PrivateKey, NameInitializationVector)));
}
public async Task Test()
{
// create the server
var server = new WsServer();
var serverKey = CryptoExtensions.GenerateKey();
var clientKey = CryptoExtensions.GenerateKey();
Console.WriteLine($"Server key is: [{serverKey.Q.GetFingerprintString()}]");
Console.WriteLine($"Client key is: [{clientKey.Q.GetFingerprintString()}]");
await server.StartAsync(new IPEndPoint(IPAddress.Any, 8080), async stream =>
{
// encrypt
// called when a client connects
var br = new BinaryWriter(stream);
var ct = Encoding.ASCII.GetBytes($"Hello from Server! {DateTime.Now}");
br.Write(ct.Length);
br.Write(ct);
var res = await stream.EncryptAsync(serverKey);
Console.WriteLine($"Client connected with fingerprint of [{res.GetFingerprintString()}]");
while (stream.Connected)
{
var bytes = Encoding.ASCII.GetBytes($"Hello from Server! {DateTime.Now}");
br.Write(bytes.Length);
br.Write(bytes);
await Task.Delay(1000);
}
await stream.CloseAsync();
});
// start client
var client = new WsClient();
var connection = await client.ConnectAsync(new Uri("ws://localhost:8080"));
// measure client data
// read data
var binReader = new BinaryReader(connection);
int e = binReader.ReadInt32();
var g = binReader.ReadBytes(e);
Console.WriteLine(Encoding.ASCII.GetString(g));
var serverRes = await connection.EncryptAsync(clientKey);
Console.WriteLine($"Connected to server with fingerprint of [{serverRes.GetFingerprintString()}]");
for (int i = 0; i < 100; i++)
{
int b = binReader.ReadInt32();
var bytesRead = binReader.ReadBytes(b);
Console.WriteLine(Encoding.ASCII.GetString(bytesRead));
}
// cleanup
client.Dispose();
server.Dispose();
}
public void TestCryptoSetup()
{
byte[] cert = ResourcesProvider.GetBytes("selfsigned_cert.bin", ResourceType.Misc);
var x509 = CryptoExtensions.DeserializeCertificateAsn(cert);
CryptoContext context = new CryptoContext(x509);
Assert.NotNull(context);
Assert.Equal <PublicKeyType>(PublicKeyType.EC_DH_P256, context.PublicKeyType);
}
public static PhantasmaKeys GenerateInteropKeys(PhantasmaKeys genesisKeys, Hash genesisHash, string platformName)
{
var temp = $"{genesisKeys.ToWIF()}{genesisHash.ToString()}{platformName}";
temp = temp.ToUpper();
var privateKey = CryptoExtensions.Sha256(temp);
var key = new PhantasmaKeys(privateKey);
return(key);
}
public void ECDsaSecP256k1()
{
var address = "0x66571c32d77c4852be4c282eb952ba94efbeac20";
var key = "6f6784731c4e526c97fa6a97b6f22e96f307588c5868bc2c545248bc31207eb1";
Assert.IsTrue(key.Length == 64);
var curve = ECCurve.Secp256k1;
var privateKey = key.HexToByteArray();
var pKey = ECCurve.Secp256k1.G * privateKey;
var publicKey = pKey.EncodePoint(true).ToArray();
var uncompressedPublicKey = pKey.EncodePoint(false).Skip(1).ToArray();
var kak = new Phantasma.Ethereum.Util.Sha3Keccack().CalculateHash(uncompressedPublicKey);
var Address = "0x" + Base16.Encode(kak.Skip(12).ToArray()).ToLower();
Console.WriteLine("Address: " + Address);
Console.WriteLine("address: " + address);
Assert.IsTrue(Address == address);
var msgBytes = Encoding.ASCII.GetBytes("Phantasma");
// CryptoExtensions.SignECDsa()/.VerifySignatureECDsa() tests.
var signature = CryptoExtensions.SignECDsa(msgBytes, privateKey, publicKey, ECDsaCurve.Secp256k1);
Assert.IsNotNull(signature);
Console.WriteLine("CryptoExtensions.SignECDsa() signature: " + Base16.Encode(signature));
var signatureUncompressed = CryptoExtensions.SignECDsa(msgBytes, privateKey, uncompressedPublicKey, ECDsaCurve.Secp256k1);
Assert.IsNotNull(signatureUncompressed);
Assert.IsTrue(CryptoExtensions.VerifySignatureECDsa(msgBytes, signature, publicKey, ECDsaCurve.Secp256k1));
Assert.IsTrue(CryptoExtensions.VerifySignatureECDsa(msgBytes, signature, uncompressedPublicKey, ECDsaCurve.Secp256k1));
// ECDsaSignature.Generate()/ECDsaSignature.Verify() tests.
var ethKeys = Ethereum.EthereumKey.FromPrivateKey(key);
// Verifying previous signature, received from CryptoExtensions.SignECDsa().
var ecdsaSignature = new ECDsaSignature(signature, ECDsaCurve.Secp256k1);
Console.WriteLine("ECDsaSignature() signature: " + Base16.Encode(ecdsaSignature.ToByteArray()));
Assert.IsTrue(ecdsaSignature.Verify(msgBytes, Phantasma.Cryptography.Address.FromKey(ethKeys)));
// Generating new signature with ECDsaSignature.Generate() and verifying it.
var ecdsaSignature2 = ECDsaSignature.Generate(ethKeys, msgBytes, ECDsaCurve.Secp256k1);
Console.WriteLine("ECDsaSignature() signature2: " + Base16.Encode(ecdsaSignature2.ToByteArray()));
Assert.IsTrue(ecdsaSignature.Verify(msgBytes, Phantasma.Cryptography.Address.FromKey(ethKeys)));
}
public void Decode_AfterEncode_ReturnsOriginalValue()
{
var original = "ZWNBAgL5cLH6UaDs";
var key = CryptoExtensions.GenerateKey();
var encoded = original.Encode(key);
var decoded = encoded.Decode(key);
encoded.Should().NotBe(decoded).And.Should().NotBe(original);
decoded.Should().Be(original);
}
public void TestCertificateDeserialize()
{
byte[] cert = ResourcesProvider.GetBytes("selfsigned_cert.bin", ResourceType.Misc);
var x509 = CryptoExtensions.DeserializeCertificateAsn(cert);
var publicKey = x509.GetPublicKey();
Assert.NotNull(x509);
Assert.Equal <int>(3, x509.Version);
Assert.Equal <string>("CN=Rust", x509.IssuerDN.ToString());
Assert.Equal <string>("CN=FFFFFFFFFFF", x509.SubjectDN.ToString());
Assert.NotNull(publicKey);
}
public static ECDsaSignature Generate(IKeyPair keypair, byte[] message, ECDsaCurve curve)
{
Throw.If(curve != ECDsaCurve.Secp256r1, "curve support not implemented for " + curve);
if (keypair.PublicKey.Length != 33)
{
throw new System.Exception("public key must be 33 bytes");
}
var signature = CryptoExtensions.SignECDsa(message, keypair.PrivateKey, keypair.PublicKey);
return(new ECDsaSignature(signature, curve));
}
public Chain(Nexus nexus, string name, IEnumerable <SmartContract> contracts, Logger log = null, Chain parentChain = null, Block parentBlock = null)
{
Throw.IfNull(nexus, "nexus required");
Throw.If(contracts == null || !contracts.Any(), "contracts required");
if (parentChain != null)
{
Throw.IfNull(parentBlock, "parent block required");
Throw.IfNot(nexus.ContainsChain(parentChain), "invalid chain");
//Throw.IfNot(parentChain.ContainsBlock(parentBlock), "invalid block"); // TODO should this be required?
}
var bytes = System.Text.Encoding.UTF8.GetBytes(name.ToLower());
var hash = CryptoExtensions.SHA256(bytes);
this.Address = new Address(hash);
foreach (var contract in contracts)
{
if (this._contracts.ContainsKey(contract.Name))
{
throw new ChainException("Duplicated contract name: " + contract.Name);
}
this._contracts[contract.Name] = contract;
this._contractContexts[contract.Name] = new NativeExecutionContext(contract);
}
this.Name = name;
this.Nexus = nexus;
this.ParentChain = parentChain;
this.ParentBlock = parentBlock;
// TODO support persistence storage
this.Storage = new MemoryStorageContext();
this.Log = Logger.Init(log);
if (parentChain != null)
{
parentChain._childChains[name] = this;
_level = ParentChain.Level + 1;
}
else
{
_level = 1;
}
}
private static ExecutionState Runtime_AESEncrypt(RuntimeVM vm)
{
vm.ExpectStackSize(2);
var data = vm.PopBytes("data");
var key = vm.PopBytes("key");
var encryptedData = CryptoExtensions.AESGCMEncrypt(data, key);
var result = new VMObject();
result.SetValue(encryptedData);
vm.Stack.Push(result);
return(ExecutionState.Running);
}
public static string ProtectData(string encryptKey, string validateKey, string clearData, string ivStr = null)
{
using (var rj = new RijndaelManaged())
{
rj.Padding = PaddingMode.PKCS7;
rj.Mode = CipherMode.CBC;
rj.KeySize = 256;// 128;
rj.BlockSize = 128;
rj.Key = CryptoExtensions.HexToBinary(encryptKey);
byte[] iv;
if (ivStr == null)
{
rj.GenerateIV();
iv = rj.IV;
}
else
{
iv = CryptoExtensions.HexToBinary(ivStr);
rj.IV = iv;
}
var data = Encoding.UTF8.GetBytes(clearData);
using (var memoryStream = new MemoryStream())
{
//先将向量写入加密流头部
memoryStream.Write(iv, 0, iv.Length);
using (var encryptor = rj.CreateEncryptor())
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
//写入加密字节流
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
//计算当前字节流的Hash值，并写入流末端
using (KeyedHashAlgorithm validationAlgorithm
= new HMACSHA256(CryptoExtensions.HexToBinary(validateKey)))
{
var hash = validationAlgorithm.ComputeHash(
memoryStream.GetBuffer(), 0, checked ((int)memoryStream.Length));
memoryStream.Write(hash, 0, 8);
return(CryptoExtensions.BinaryToHex(memoryStream.ToArray()));
}
}
}
}
}
protected async Task <MediaFile[]> CreateAllFilesAsync(string name = null, bool saveToDisk = false, string userId = null)
{
if (saveToDisk)
{
return(await SaveAllFilesAsync(name, userId));
}
var files = GetUploadedFiles(name);
if (files?.Length > 0L)
{
var index = 0;
var array = new MediaFile[files.Length];
if (string.IsNullOrWhiteSpace(userId))
{
userId = await GetUserIdAsync();
}
foreach (var file in files)
{
using (var ms = new MemoryStream())
{
await file.CopyToAsync(ms);
var content = ms.ToArray();
array[index++] = new MediaFile
{
UserId = userId,
HasContent = true,
Content = content,
ContentType = file.ContentType,
FileName = file.FileName,
DateCreated = DateTime.Now,
Length = file.Length,
HashCode = CryptoExtensions.ComputeHash(content)
};
}
}
return(array);
}
return(null);
}
public static ECDsaSignature Generate(IKeyPair keypair, byte[] message, ECDsaCurve curve, Func <byte[], byte[], byte[], byte[]> customSignFunction = null)
{
if (keypair.PublicKey.Length != 32 && keypair.PublicKey.Length != 33 && keypair.PublicKey.Length != 64)
{
throw new System.Exception($"public key must be 32, 33 or 64 bytes, given key's length: {keypair.PublicKey.Length}");
}
byte[] signature;
if (customSignFunction != null)
{
signature = customSignFunction(message, keypair.PrivateKey, keypair.PublicKey);
}
else
{
signature = CryptoExtensions.SignECDsa(message, keypair.PrivateKey, keypair.PublicKey, curve);
}
return(new ECDsaSignature(signature, curve));
}
