public void SignatureSwap()
{
var rawTx = Base16.Decode("80000001AA2F638AE527480F6976CBFC268E06048040F77328F78A8F269F9DAB660715C70000029B7CFFDAA674BEAE0F930EBE6085AF9093E5FE56B34A5C220CCDCF6EFC336FC500E1F50500000000D9020CC50B04E75027E19A5D5A9E377A042A0BB59B7CFFDAA674BEAE0F930EBE6085AF9093E5FE56B34A5C220CCDCF6EFC336FC500C2EB0B000000005B1258432BE2AB39C5CD1CAAFBD2B7AAA4B0F034014140A24433C702A47174B9DC1CC6DA90611AA8895B09A5BAD82406CCEF77D594A7343F79084D42BBF8D7C818C4540B38A2E168A7B932D2C0999059A0B3A3B43F6D31232102FC1D6F42B05D00E6AEDA82DF286EB6E2578042F6CAEBE72144342466113BD81EAC");
var tx = Neo.Core.Transaction.Unserialize(rawTx);
var wif = "KwVG94yjfVg1YKFyRxAGtug93wdRbmLnqqrFV6Yd2CiA9KZDAp4H";
var neoKeys = Phantasma.Neo.Core.NeoKeys.FromWIF(wif);
Assert.IsTrue(tx.witnesses.Any());
var wit = tx.witnesses.First();
var witAddress = wit.ExtractAddress();
var transposedAddress = Address.FromKey(neoKeys);
Assert.IsTrue(transposedAddress.IsUser);
Assert.IsTrue(transposedAddress == witAddress);
var msg = "Hello Phantasma!";
var payload = Encoding.UTF8.GetBytes(msg);
var neoSig = ECDsaSignature.Generate(neoKeys, payload, ECDsaCurve.Secp256r1);
var validateNeoSig = neoSig.Verify(payload, transposedAddress);
Assert.IsTrue(validateNeoSig);
}
public T Decrypt <T>(PhantasmaKeys privateKey)
{
var curve = this.Curve.GetCurve();
var pubBytes = ECDsaSignature.ExtractPublicKeyFromAddress(this.Address);
var publicKey = ECC.ECPoint.DecodePoint(pubBytes, curve);
return(Decrypt <T>(this.Payload, privateKey, publicKey));
}
private void button1_Click(object sender, EventArgs e)
{
signer = new ECDsaSignature(); //creating signer object
signer.CreateKeyPair(); //generating public-private key pair
tb_privKey.Text = signer.PrivateKey;
tb_pubKey.Text = signer.PublicKey;
}
public static SharedSecret Encrypt <T>(T message, PhantasmaKeys privateKey, Address publicAddress, ECDsaCurve curve)
{
var ecdCurve = curve.GetCurve();
var pubBytes = ECDsaSignature.ExtractPublicKeyFromAddress(publicAddress);
var publicKey = ECC.ECPoint.DecodePoint(pubBytes, ecdCurve);
var secret = GetSharedSecret(privateKey, publicKey);
var payload = Encrypt(message, secret);
return(new SharedSecret(curve, publicAddress, payload));
}
public static string getSignature(string textToSign, string publicKey, string privateKey)
{
ECDsaSignature signer;
signer = ECDsaSignature.FromKeys(publicKey, privateKey);
byte[] byteStr = Encoding.Default.GetBytes(textToSign);
byte[] byteSignature = signer.SignData(byteStr);
return(Encoding.Default.GetString(byteSignature));
}
public static bool CheckSignature(Input inp)
{
List <string> stringList = inp.ScriptSign.Split(' ').ToList();
string signature = stringList[0];
string receiverPublicKey = stringList[1];
string stringToVerify = inp.PrevTransactionHash + " " + inp.OutputIndex.ToString();
ECDsaSignature verifier = ECDsaSignature.FromKeys(receiverPublicKey);
return(verifier.VerifyData(Encoding.Default.GetBytes(stringToVerify), Encoding.Default.GetBytes(signature)));
}
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)));
}
private void button_validate_Click(object sender, EventArgs e)
{
if (textBox_Verifier_PublicKey.Text == string.Empty || textBox_Verifier_Message.Text == string.Empty || textBox_verifier_signature.Text == string.Empty)
{
MessageBox.Show("Please check input parameters");
return;
}
///DATA SIGNATURE VERIFICATION-SERVER SIDE Parameters needed: Public Key, The Signature, The Message
string publicKey = textBox_Verifier_PublicKey.Text;
string message = textBox_Verifier_Message.Text;
byte[] byteMessage = Encoding.Default.GetBytes(message);
byte[] byteSignature = signature;
ECDsaSignature verifier = ECDsaSignature.FromKeys(publicKey); //creating a verifier object
bool result = verifier.VerifyData(byteMessage, byteSignature); //result if the signature was created by true public key
MessageBox.Show(result?"the signature is valid":"signature is invalid");
}
private void button_sign_Click(object sender, EventArgs e)
{
if (textBox_prover_message.Text == string.Empty || textBox_prover_privateKey.Text == string.Empty || textBox_prover_message.Text == string.Empty)
{
MessageBox.Show("Please check input parameters");
return;
}
///DATA SIGNING OPERATION-CLIENT SIDE Parameters needed: Private Key, Public Key, the Message(to sign)
string message = textBox_prover_message.Text; //string(message object) to sign
string privateKey = textBox_prover_privateKey.Text; //private key generated by KeyGen
string publicKey = textBox_prover_PublicKey.Text; //public key generated by KeyGen
signer = ECDsaSignature.FromKeys(publicKey, privateKey); //creating signer object with public and private key parameters
byte[] byteMessage = Encoding.Default.GetBytes(message); //converting the message object to byteArray to enable signing operation
byte[] byteSignature = signer.SignData(byteMessage); //signing operation with signer object
signature = signer.SignData(byteMessage);
string signatureStr = Encoding.Default.GetString(byteSignature); //converting signature from byteArray to string
textBox_prover_signature.Text = signatureStr;
textBox_verifier_signature.Text = signatureStr;
}
public static Signature ReadSignature(this BinaryReader reader)
{
var kind = (SignatureKind)reader.ReadByte();
Signature signature;
switch (kind)
{
case SignatureKind.None: return(null);
case SignatureKind.Ed25519: signature = new Ed25519Signature(); break;
case SignatureKind.ECDSA: signature = new ECDsaSignature(); break;
case SignatureKind.Ring: signature = new RingSignature(); break;
default:
throw new NotImplementedException("read signature: " + kind);
}
signature.UnserializeData(reader);
return(signature);
}
public Signature Sign(byte[] msg, Func <byte[], byte[], byte[], byte[]> customSignFunction = null)
{
return(ECDsaSignature.Generate(this, msg, ECDsaCurve.Secp256r1));
}
public IActionResult CreateLicense(string format, string sign, [FromBody] LicenseModel model)
{
ILicense license = null;
format = format.ToUpperInvariant();
switch (format)
{
case "XML":
license = new XmlLicense();
break;
case "ASCII":
case "BASE32":
license = new StringLicense();
break;
default:
return(BadRequest());
}
ISignatureProvider signature = null;
switch (sign.ToUpperInvariant())
{
case "ECDSA":
var ecdsa = new ECDsaSignature(ECDsaKeySize.KeySize112bit);
ecdsa.CreateKeyPair();
// Embed public key information in the license
ecdsa.GenerateKeyInfo = true;
model.PublicKey = ecdsa.PublicKey;
signature = ecdsa;
break;
case "RSA":
var rsa = new RSASignature(1024);
rsa.CreateKeyPair();
signature = rsa;
break;
default:
return(BadRequest());
}
// Fill license
license.WithId(model.Id ?? "1")
.IssuedAt(DateTime.UtcNow)
.WithType(model.Type ?? string.Empty)
.ForProduct(model.Product ?? string.Empty, model.Version ?? string.Empty)
.LicensedTo(model.Licensee ?? string.Empty);
if (model.ExpireDate.HasValue)
{
license.ExpiresAt(model.ExpireDate.Value.ToUniversalTime());
}
if (model.SupportExpireDate.HasValue)
{
license.SupportExpiresAt(model.SupportExpireDate.Value.ToUniversalTime());
}
// Sign license
var licenseBuilder = license.SignWith(signature);
var stringBuilder = licenseBuilder as StringLicenseBuilder;
if (stringBuilder != null)
{
switch (format)
{
case "ASCII":
stringBuilder.Format = StringFormat.Ascii;
break;
case "BASE32":
stringBuilder.Format = StringFormat.Base32;
break;
}
}
// Get license key
model.LicenseKey = licenseBuilder.ToReadableString();
return(Ok(model));
}
public Signature Sign(byte[] msg)
{
return(ECDsaSignature.Generate(this, msg, ECDsaCurve.Secp256r1));
}
