public ECDSASignature Sign(uint256 hash) { var signature = _ECKey.Sign(hash); signature = signature.MakeCanonical(); return(signature); }
public byte[] Sign(uint256 hash) { var signature = _ECKey.Sign(hash); signature = signature.MakeCanonical(); return(signature.ToDER()); }
public EthECDSASignature SignAndCalculateV(byte[] hash, BigInteger chainId) { #if NETCOREAPP3_1 || NET5_0_OR_GREATER if (SignRecoverable) { var privKey = Context.Instance.CreateECPrivKey(GetPrivateKeyAsBytes()); privKey.TrySignRecoverable(hash, out var recSignature); recSignature.Deconstruct(out Scalar r, out var s, out var recId); var vChain = CalculateV(chainId, recId); return(EthECDSASignatureFactory.FromComponents(r.ToBytes(), s.ToBytes(), vChain.ToBytesForRLPEncoding())); } else { #endif var signature = _ecKey.Sign(hash); var recId = CalculateRecId(signature, hash); var vChain = CalculateV(chainId, recId); signature.V = vChain.ToBytesForRLPEncoding(); return(new EthECDSASignature(signature)); #if NETCOREAPP3_1 || NET5_0_OR_GREATER } #endif }
public NasECDSASignature SignAndCalculateV(byte[] hash) { var signature = _ecKey.Sign(hash); var recId = CalculateRecId(signature, hash); signature.V = new[] { (byte)(recId + 27) }; return(new NasECDSASignature(signature)); }
public EthECDSASignature SignAndCalculateV(byte[] hash, BigInteger chainId) { var signature = _ecKey.Sign(hash); var recId = CalculateRecId(signature, hash); var vChain = CalculateV(chainId, recId); signature.V = vChain.ToBytesForRLPEncoding(); return new EthECDSASignature(signature); }
public EthECDSASignature SignAndCalculateV(byte[] hash) { var signature = _ecKey.Sign(hash); var recId = CalculateRecId(signature, hash); signature.V = (byte)(recId + 27); return(new EthECDSASignature(signature)); }
public void Sign(byte[] privatekey) { ECKey ec_key = ECKey.FromPrivateKey(privatekey); ECDSASignature signature = ec_key.Sign(this.GetRawHash().Hash); this.block.BlockHeader.WitnessSignature = ByteString.CopyFrom(signature.ToByteArray()); }
public void AddSignature(byte[] privatekey, AccountStore account_store) { Transaction.Types.Contract contract = this.transaction.RawData.Contract[0]; byte[] owner = GetOwner(contract); int permission_id = contract.PermissionId; AccountCapsule account = account_store.Get(owner); if (account == null) { throw new PermissionException("Account is not exist."); } Permission permission = account.GetPermissionById(permission_id); if (permission == null) { throw new PermissionException("Permission is not exist"); } if (permission_id != 0) { if (permission.Type != Permission.Types.PermissionType.Active) { throw new PermissionException("Permission type is error"); } if (Wallet.CheckPermissionOperations(permission, contract)) { throw new PermissionException("Invalid permission"); } } List <ByteString> approves = new List <ByteString>(); ECKey ec_key = ECKey.FromPrivateKey(privatekey); byte[] address = Wallet.PublickKeyToAddress(ec_key.PublicKey); if (this.transaction.Signature.Count > 0) { CheckWeight(permission, new List <ByteString>(this.transaction.Signature), this.GetRawHash().Hash, approves); if (approves.Contains(ByteString.CopyFrom(address))) { throw new PermissionException(Wallet.AddressToBase58(address) + "had signed!"); } } long weight = GetWeight(permission, address); if (weight == 0) { throw new PermissionException( privatekey.ToHexString() + " address is " + Wallet.AddressToBase58(address) + "but it is not contained of permission."); } ECDSASignature signature = ec_key.Sign(this.GetRawHash().Hash); this.transaction.Signature.Add(ByteString.CopyFrom(signature.ToByteArray())); }
public void Signature(byte[] privatekey) { ECKey ec_key = ECKey.FromPrivateKey(privatekey); ECDSASignature signature = ec_key.Sign(GetRawHash().Hash); this.transaction.Signature.Add(ByteString.CopyFrom(signature.ToByteArray())); }
public static ECDSASignature SignAndCalculateV(this ECKey key, byte[] hash) { var signature = key.Sign(hash); var recId = key.CalculateRecId(signature, hash); signature.V = (byte)(recId + 27); return(signature); }
public void Signature() { ECKey key = ECKey.FromPrivateKey(this.privatekey); ECDSASignature signature = key.Sign(signature_message); signature.Should().NotBeNull(); key.Verify(signature_message, signature).Should().BeTrue(); }
public EthECDSASignature SignAndCalculateV(byte[] hash, BigInteger chainId) { #if NETCOREAPP3_1 var privKey = NBitcoin.Secp256k1.Context.Instance.CreateECPrivKey(GetPrivateKeyAsBytes()); NBitcoin.Secp256k1.SecpRecoverableECDSASignature recSignature; privKey.TrySignRecoverable(hash, out recSignature); NBitcoin.Secp256k1.Scalar r; NBitcoin.Secp256k1.Scalar s; int recId; recSignature.Deconstruct(out r, out s, out recId); var vChain = CalculateV(chainId, recId); return(EthECDSASignatureFactory.FromComponents(r.ToBytes(), s.ToBytes(), vChain.ToBytesForRLPEncoding())); #else var signature = _ecKey.Sign(hash); var recId = CalculateRecId(signature, hash); var vChain = CalculateV(chainId, recId); signature.V = vChain.ToBytesForRLPEncoding(); return(new EthECDSASignature(signature)); #endif }
public void RecoverySignature() { ECKey key = ECKey.FromPrivateKey(this.privatekey); ECDSASignature signature = key.Sign(signature_message); signature.Should().NotBeNull(); key.Verify(signature_message, signature).Should().BeTrue(); ECKey.RecoverFromSignature(signature, signature_message, false).PublicKey.SequenceEqual(key.PublicKey).Should().BeTrue(); }
public Transaction GetTransactionSign(Transaction transaction, string privateKey) { var ecKey = new ECKey(privateKey.HexToByteArray(), true); var transactionSigned = Transaction.Parser.ParseFrom(transaction.ToByteArray()); var rawdata = transactionSigned.RawData.ToByteArray(); var hash = rawdata.ToSHA256Hash(); var sign = ecKey.Sign(hash).ToByteArray(); transactionSigned.Signature.Add(ByteString.CopyFrom(sign)); return(transactionSigned); }
private byte[] SignTransaction2Byte(byte[] transaction, byte[] privateKey, Transaction transactionSigned) { var ecKey = new ECKey(privateKey, true); var transaction1 = Transaction.Parser.ParseFrom(transaction); var rawdata = transaction1.RawData.ToByteArray(); var hash = rawdata.ToSHA256Hash(); var sign = ecKey.Sign(hash).ToByteArray(); transaction1.Signature.Add(ByteString.CopyFrom(sign)); return(transaction1.ToByteArray()); }
public static byte[] Sign(byte[] msgHash, byte[] privatekey) { ECKey ecKey = new ECKey(privatekey, true); var sign = ecKey.Sign(msgHash); var recId = CalculateRecId(ecKey, sign, msgHash); sign.V = new[] { Convert.ToByte(recId) }; List <byte> signature = new List <byte>(); signature.AddRange(sign.R.ToByteArrayUnsigned()); signature.AddRange(sign.S.ToByteArrayUnsigned()); signature.AddRange(sign.V); return(signature.ToArray()); }
public void ShouldSignEncodeTransactionAndRecoverPublicAddress() { var privateKey = "b5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7"; var sendersAddress = "12890d2cce102216644c59daE5baed380d84830c"; var publicKey = "87977ddf1e8e4c3f0a4619601fc08ac5c1dcf78ee64e826a63818394754cef52457a10a599cb88afb7c5a6473b7534b8b150d38d48a11c9b515dd01434cceb08"; var key = new ECKey(privateKey.HexToByteArray(), true); var hash = "test".ToHexUTF8().HexToByteArray(); var signature = key.Sign(hash); Assert.True(key.Verify(hash, signature)); Assert.Equal(key.GetPubKeyNoPrefix().ToHex(), publicKey); Assert.Equal(sendersAddress.ToLower(), key.GetPublicAddress()); }
public byte[] GenerateInputSignature(ECKey privateKey, SigHash hashType, Script subScript, int inputIndex) { if (hashType.HasFlag(SigHash.None)) { throw new NotImplementedException(); } if (hashType.HasFlag(SigHash.Single)) { throw new NotImplementedException(); } if (hashType.HasFlag(SigHash.AnyoneCanPay)) { throw new NotImplementedException(); } return(ArrayHelpers.ConcatArrays(privateKey.Sign(InputHash(hashType, subScript, inputIndex)), new byte[] { (byte)hashType })); }
public ECDSASignature Sign(uint256 hash, bool useLowR) { return(_ECKey.Sign(hash, useLowR)); }
public ECDSASignature Sign(uint256 hash) { return(_ECKey.Sign(hash)); }