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)); }