public void ShouldRecoverGethPrefix()
{
//signed message using geth 1.5^
var signature = "0x0976a177078198a261faf206287b8bb93ebb233347ab09a57c8691733f5772f67f398084b30fc6379ffee2cc72d510fd0f8a7ac2ee0162b95dc5d61146b40ffa1c";
var text = "test";
var hasher = new Sha3Keccack();
var hash = hasher.CalculateHash(text);
var byteList = new List <byte>();
var bytePrefix = "0x19".HexToByteArray();
var textBytePrefix = Encoding.UTF8.GetBytes("Ethereum Signed Message:\n" + hash.HexToByteArray().Length);
var bytesMessage = hash.HexToByteArray();
byteList.AddRange(bytePrefix);
byteList.AddRange(textBytePrefix);
byteList.AddRange(bytesMessage);
var hashPrefix2 = hasher.CalculateHash(byteList.ToArray()).ToHex();
var signer = new MessageSigner();
var account = signer.EcRecover(hashPrefix2.HexToByteArray(), signature);
Assert.Equal("0x12890d2cce102216644c59dae5baed380d84830c", account.EnsureHexPrefix().ToLower());
signature = signer.Sign(hashPrefix2.HexToByteArray(),
"0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7");
account = signer.EcRecover(hashPrefix2.HexToByteArray(), signature);
Assert.Equal("0x12890d2cce102216644c59dae5baed380d84830c".ToLower(), account.EnsureHexPrefix().ToLower());
}
/// <summary>
/// Sign an Offchain payment as a Peer
/// </summary>
/// <param name="offchainTransaction">The transaction to be signed</param>
/// <returns>The Transaction signed by wallet owner as Peer </returns>
public SignedOffchainTransaction signOffchainPayment(SignedOffchainTransaction offchainTransaction)
{
var signer = new MessageSigner();
var encoder = new ABIEncode();
ABIValue[] ABIValues = new ABIValue[] {
new ABIValue("address", offchainTransaction.beneficiary),
new ABIValue("bytes32", offchainTransaction.nonce),
new ABIValue("uint256", offchainTransaction.amount),
new ABIValue("uint", offchainTransaction.fee)
};
var payloadEncoded = encoder.GetABIEncodedPacked(ABIValues);
var proof = Sha3Keccack.Current.CalculateHash(payloadEncoded);
offchainTransaction.h = proof;
var signedTx = signer.Sign(offchainTransaction.h, _wallet.PK);
var signature = MessageSigner.ExtractEcdsaSignature(signedTx);
offchainTransaction.v = signature.V.FirstOrDefault();
offchainTransaction.r = signature.R;
offchainTransaction.s = signature.S;
if (offchainTransaction.s.Length < 32)
{
var tmpS = offchainTransaction.s.ToList();
tmpS.Insert(0, 0);
offchainTransaction.s = tmpS.ToArray();
}
offchainTransaction.signer = _wallet.address;
return(offchainTransaction);
}
void signContent(MessageSigner messageSigner, Byte[] content)
{
hashAlgId = new AlgorithmIdentifier(messageSigner.HashingAlgorithm.ToOid(), new Byte[0]);
pubKeyAlgId = new AlgorithmIdentifier(messageSigner.PublicKeyAlgorithm, new Byte[0]);
prepareSigning(content);
SignedContentBlob signedBlob;
if (_authAttributes.Any())
{
// auth attributes are encoded as IMPLICIT (OPTIONAL), but RFC2315 ยง9.3 requires signature computation for SET
var attrBytes = _authAttributes.Encode();
attrBytes[0] = 0x31;
signedBlob = new SignedContentBlob(attrBytes, ContentBlobType.ToBeSignedBlob);
}
else
{
if (content == null)
{
throw new ArgumentException("'content' parameter cannot be null if no authenticated attributes present.");
}
signedBlob = new SignedContentBlob(content, ContentBlobType.ToBeSignedBlob);
}
signerCert = new PkcsSubjectIdentifier(messageSigner.SignerCertificate, SubjectIdentifier);
signedBlob.Sign(messageSigner);
hashValue = signedBlob.Signature.Value;
}
// Checks to see if the key is valid by signing dummy data. Returns 0 if valid, 1 otherwise.
public static int verifyKey(string key)
{
key = addHexPrefix(key);
var dummyMessage = "test dummy message";
var signer = new MessageSigner();
var signature = "";
var address = "";
try
{
signature = signer.HashAndSign(dummyMessage, key);
}
catch (Exception sign)
{
Debug.Log("Key appears to be invalid! Cannot sign data. " + sign);
return(1);
}
try
{
address = signer.HashAndEcRecover(dummyMessage, signature);
}
catch (Exception recover)
{
Debug.Log("Key appears to be invalid! Cannot recover data. " + recover);
return(1);
}
//Debug.Log("Verification successful: " + address + ". Private key appears to be valid.");
return(0);
}
/// <summary>
/// Signs <see cref="ToBeSignedData"/> data by using client-provided message signer.
/// </summary>
/// <param name="signerInfo">Configured message signer object which is used to sign the data.</param>
public void Sign(MessageSigner signerInfo)
{
var signature = signerInfo.SignData(ToBeSignedData).ToList();
if (signerInfo.SignerCertificate.PublicKey.Oid.Value == AlgorithmOids.RSA)
{
signature.Insert(0, 0);
Signature = new Asn1BitString(Asn1Utils.Encode(signature.ToArray(), 3));
}
else
{
// ECDSA, DSA signature consist of two parts, r and s.
Int32 divider = signature.Count / 2;
List <Byte> r = signature.Skip(0).Take(divider).ToList();
// check if most significant bit is set to 1. If set, prepend value with extra 0 byte.
if (r[0] > 127)
{
r.Insert(0, 0);
}
List <Byte> s = signature.Skip(divider).Take(divider).ToList();
// check if most significant bit is set to 1. If set, prepend value with extra 0 byte.
if (s[0] > 127)
{
s.Insert(0, 0);
}
var builder = new List <Byte>();
builder.AddRange(Asn1Utils.Encode(r.ToArray(), (Byte)Asn1Type.INTEGER));
builder.AddRange(Asn1Utils.Encode(s.ToArray(), (Byte)Asn1Type.INTEGER));
builder = new List <Byte>(Asn1Utils.Encode(builder.ToArray(), 48));
builder.Insert(0, 0);
Signature = new Asn1BitString(Asn1Utils.Encode(builder.ToArray(), 3));
}
SignatureAlgorithm = signerInfo.GetAlgorithmIdentifier();
BlobType = ContentBlobType.SignedBlob;
}
void verifyAll(Asn1Reader tbsResponseData, Byte[] signature, Oid signatureAlgorithm)
{
verifyHeaders();
decodeTbsResponse(tbsResponseData);
if (NonceReceived)
{
if (Request.NonceValue != NonceValue)
{
ResponseErrorInformation |= OCSPResponseComplianceError.NonceMismatch;
}
}
if (SignerCertificates.Count > 0)
{
using (var signerInfo = new MessageSigner(SignerCertificates[0], new Oid2(signatureAlgorithm, false))) {
SignatureIsValid = signerInfo.VerifyData(tbsResponseData.GetRawData(), signature);
}
}
else
{
findCertInStore();
if (SignerCertificates.Count > 0)
{
using (var signerInfo =
new MessageSigner(SignerCertificates[0], new Oid2(signatureAlgorithm, false))) {
SignatureIsValid = signerInfo.VerifyData(tbsResponseData.GetRawData(), signature);
}
}
else
{
ResponseErrorInformation |= OCSPResponseComplianceError.MissingCert;
}
}
verifyResponses();
}
void signRequest(X509Certificate2 signerCert)
{
List <Byte> tbsRequest = buildTbsRequest(signerCert.SubjectName);
Byte[] signature;
using (var signerInfo = new MessageSigner(signerCert, new Oid2(signatureAlgID, false))) {
signature = signerInfo.SignData(tbsRequest.ToArray());
}
SignerCertificate = signerCert;
if (includeFullSigChain)
{
buildSignerCertChain();
}
else
{
_signerChain.Add(signerCert);
}
AlgorithmIdentifier algId = new AlgorithmIdentifier(signatureAlgID);
List <Byte> signatureInfo = new List <Byte>(algId.RawData);
signatureInfo.AddRange(new Asn1BitString(signature, false).RawData);
signatureInfo.AddRange(Asn1Utils.Encode(_signerChain.Encode(), 0xa0));
tbsRequest.AddRange(Asn1Utils.Encode(Asn1Utils.Encode(signatureInfo.ToArray(), 48), 0xa0));
RawData = Asn1Utils.Encode(tbsRequest.ToArray(), 48);
IsReadOnly = true;
}
/// <summary>
/// Sign a prroof that a free service provider provided free content to a Witness. Should be signed by wallet owner as Witness
/// </summary>
/// <param name="offchainTransaction"></param>
/// <returns></returns>
public SignedOffchainFreeServiceTransaction signFreeServiceProviderMbs(SignedOffchainFreeServiceTransaction offchainTransaction)
{
var signer = new MessageSigner();
var encoder = new ABIEncode();
ABIValue[] ABIValues = new ABIValue[] {
new ABIValue("uint", offchainTransaction.epoch),
new ABIValue("address", offchainTransaction.freeServiceProvider),
new ABIValue("address", offchainTransaction.validator),
new ABIValue("uint256", offchainTransaction.freeMb)
};
var payloadEncoded = encoder.GetABIEncodedPacked(ABIValues);
var proof = Sha3Keccack.Current.CalculateHash(payloadEncoded);
offchainTransaction.h = proof;
var signedTx = signer.Sign(offchainTransaction.h, _wallet.PK);
var signature = MessageSigner.ExtractEcdsaSignature(signedTx);
offchainTransaction.v = signature.V.FirstOrDefault();
offchainTransaction.r = signature.R;
offchainTransaction.s = signature.S;
if (offchainTransaction.s.Length < 32)
{
var tmpS = offchainTransaction.s.ToList();
tmpS.Insert(0, 0);
offchainTransaction.s = tmpS.ToArray();
}
offchainTransaction.signer = _wallet.address;
return(offchainTransaction);
}
X509Certificate2 build(X509Certificate2 signer)
{
MessageSigner signerInfo = signer == null
? new MessageSigner(PrivateKeyInfo, HashingAlgorithm)
: new MessageSigner(signer, HashingAlgorithm);
signerInfo.PaddingScheme = AlternateSignatureFormat
? SignaturePadding.PSS
: SignaturePadding.PKCS1;
// initialize from v3 version
var rawData = new List <Byte>(_versionBytes);
// serial number
rawData.AddRange(Asn1Utils.Encode(serialNumber, (Byte)Asn1Type.INTEGER));
// algorithm identifier
rawData.AddRange(signerInfo.GetAlgorithmIdentifier(AlternateSignatureFormat).RawData);
// issuer
rawData.AddRange(signer == null
? SubjectName.RawData
: signer.SubjectName.RawData);
// NotBefore and NotAfter
List <Byte> date = Asn1Utils.EncodeDateTime(NotBefore).ToList();
date.AddRange(Asn1Utils.EncodeDateTime(NotAfter));
rawData.AddRange(Asn1Utils.Encode(date.ToArray(), 48));
// subject
rawData.AddRange(SubjectName.RawData);
rawData.AddRange(PrivateKeyInfo.GetPublicKey().Encode());
rawData.AddRange(Asn1Utils.Encode(finalExtensions.Encode(), 0xa3));
var blob = new SignedContentBlob(Asn1Utils.Encode(rawData.ToArray(), 48), ContentBlobType.ToBeSignedBlob);
blob.Sign(signerInfo);
return(new X509Certificate2(blob.Encode()));
}
public void ShouldRecoverSimple()
{
var signer = new MessageSigner();
var account = signer.EcRecover("0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470".HexToByteArray(), "0xbd685c98ec39490f50d15c67ba2a8e9b5b1d6d7601fca80b295e7d717446bd8b7127ea4871e996cdc8cae7690408b4e800f60ddac49d2ad34180e68f1da0aaf001");
Assert.Equal("0x8a3106a3e50576d4b6794a0e74d3bb5f8c9acaab".ToLower(), account.EnsureHexPrefix().ToLower());
}
private static async Task Main(string[] args)
{
try
{
CompileContract(args);
var web3 = CreateWeb3();
var contract = await DeployContractAsync(web3);
var function = contract.GetFunction("callEcRecover");
var message = new Sha3Keccack().CalculateHash(Encoding.ASCII.GetBytes("Hello"));
var messageSigner = new MessageSigner();
var ecdsaSignature = messageSigner.SignAndCalculateV(message, PrivateKey);
var address = await function.CallAsync <string>(new object[]
{
message,
ecdsaSignature.V[0],
ecdsaSignature.R,
ecdsaSignature.S
});
Log($"Received: {address.Substring(2).ToLowerInvariant()}; Our: {Address.Substring(2).ToLowerInvariant()} Correct: {string.Equals(address.Substring(2), Address.Substring(2), StringComparison.OrdinalIgnoreCase)}");
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public byte[] Sign(byte[] key, byte[] bytesToSign)
{
var messageSigner = new MessageSigner();
var hash256 = CalculateHash(bytesToSign);
var ecKey = new EthECKey(key, true);
return(messageSigner.Sign(hash256, ecKey).HexToByteArray());
}
public static string SignCooperativeClose(CooperativeSignDto cooperativeDto, string privateKey)
{
var resultHash = Sha3ForCooperative(cooperativeDto);
var ms = new MessageSigner();
var signature = ms.Sign(resultHash.HexToByteArray(), privateKey);
return(signature);
}
public static string SignReceipts(ReceiptDto receiptDto, string privateKey)
{
var resultHash = Sha3ForReceipts(receiptDto);
var ms = new MessageSigner();
var signature = ms.Sign(resultHash.HexToByteArray(), privateKey);
return(signature);
}
/// <summary>
/// Method used to get message signature.
/// </summary>
/// <param name="message"></param>
/// <param name="privateKey"></param>
/// <returns>Signature</returns>
public static string Sign(string message, string privateKey)
{
MessageSigner messageSigner = new MessageSigner();
string sig = messageSigner.HashAndSign(message, privateKey);
return(sig.Substring(2));
}
public static string SignAuditClose(AuditSignDto signDto, string privateKey)
{
var resultHash = Sha3ForAudit(signDto);
var ms = new MessageSigner();
var signature = ms.Sign(resultHash.HexToByteArray(), privateKey);
return(signature);
}
public static bool VerifyAuditClose(AuditVerifyDto verifyDto)
{
var resultHash = Sha3ForAudit(verifyDto);
var ms = new MessageSigner();
var address = ms.EcRecover(resultHash.HexToByteArray(), verifyDto.Signature);
return(address == verifyDto.Address);
}
internal Order CreateOrder(OrderType orderType, BigInteger expires, BigInteger price, BigInteger amount)
{
var amountBigNum = orderType == OrderType.Buy ? amount / price : amount;
var amountBaseBigNum = amount * price;
var contractAddr = Config.AddressEtherDelta;
var tokenGet = orderType == OrderType.Buy ? Config.Token : ZeroToken;
var tokenGive = orderType == OrderType.Sell ? Config.Token : ZeroToken;
var amountGet = orderType == OrderType.Buy ? amountBigNum : amountBaseBigNum;
var amountGive = orderType == OrderType.Sell ? amountBigNum : amountBaseBigNum;
var orderNonce = new Random().Next();
var plainData = new object[] {
Config.AddressEtherDelta,
tokenGive,
amountGet,
tokenGive,
amountGive,
expires,
orderNonce
};
var prms = new[] {
new Parameter("address", 1),
new Parameter("address", 1),
new Parameter("uint256", 1),
new Parameter("address", 1),
new Parameter("uint256", 1),
new Parameter("uint256", 1),
new Parameter("uint256", 1)
};
var pe = new ParametersEncoder();
var data = pe.EncodeParameters(prms, plainData);
var ms = new MessageSigner();
var signature = ms.HashAndSign(data, Config.PrivateKey);
var ethEcdsa = MessageSigner.ExtractEcdsaSignature(signature);
var order = new Order
{
AmountGet = new HexBigInteger(amountGet),
AmountGive = new HexBigInteger(amountGive),
TokenGet = tokenGet,
TokenGive = tokenGive,
ContractAddr = contractAddr,
Expires = expires,
Nonce = orderNonce,
User = Config.User,
V = ethEcdsa.V,
R = ethEcdsa.R.ToHex(true),
S = ethEcdsa.S.ToHex(true)
};
return(order);
}
/// <summary>
/// Verifies whether the specified certificate is an issuer of this CRL by verifying CRL signature
/// against specified certificate's public key.
/// </summary>
/// <param name="issuer">
/// A potential issuer's certificate.
/// </param>
/// <param name="strict">
/// Specifies whether to perform CRL issuer and certificate's subject name binary comparison.
/// </param>
/// <exception cref="CryptographicException">
/// The data is invalid.
/// </exception>
/// <exception cref="UninitializedObjectException">An object is not initialized.</exception>
/// <returns>
/// <strong>True</strong> if the specified certificate is signed this CRL. Otherwise <strong>False</strong>.
/// </returns>
public Boolean VerifySignature(X509Certificate2 issuer, Boolean strict = false)
{
if (RawData == null)
{
throw new UninitializedObjectException();
}
var signedInfo = new SignedContentBlob(RawData, ContentBlobType.SignedBlob);
return(MessageSigner.VerifyData(signedInfo, issuer.PublicKey));
}
public static string GenerateNewNonce()
{
var currentChallenge = DateTime.Now.ToString("O") + "- Challenge";
//creating a random key, hashing, signing and hashing again to be truly random
var key = EthECKey.GenerateKey();
var currentKey = key.GetPrivateKey(); // random key to sign message
var signer = new MessageSigner();
return(Util.Sha3Keccack.Current.CalculateHash(signer.HashAndSign(currentChallenge, currentKey)));
}
public EthECDSASignature Sign(string contract, string makerAddress, string makerToken,
string takerToken, string makerAmount, string takerAmount, string expires, string nonce)
{
var plainData = new Object[]
{
contract,
takerToken,
BigInteger.Parse(takerAmount),
makerToken,
BigInteger.Parse(makerAmount),
BigInteger.Parse(expires),
BigInteger.Parse(nonce)
};
var prms = new[] {
new Parameter("address", 1),
new Parameter("address", 1),
new Parameter("uint256", 1),
new Parameter("address", 1),
new Parameter("uint256", 1),
new Parameter("uint256", 1),
new Parameter("uint256", 1)
};
var data = SolidityPack(plainData, prms);
var keystoreCrypto = new KeyStoreCrypto();
//for etherDelta its SHA256, for IDEX just change with SHA3
var hashed = keystoreCrypto.CalculateSha256Hash(data);
var signer = new EthereumMessageSigner();
var newHash = signer.HashPrefixedMessage(hashed);
var signatureRaw = signer.SignAndCalculateV(newHash, _userDataProvider.PrivateKey);
var signature = EthECDSASignature.CreateStringSignature(signatureRaw);
var probe = signer.EcRecover(hashed, signature);
var ethEcdsa = MessageSigner.ExtractEcdsaSignature(signature);
if (probe == makerAddress)
{
return(ethEcdsa);
}
//depending on usage, but it would be better to throw exc here if fails
return(null);
//throw new Exception("Signing failed");
}
static async Task Main(string[] args)
{
var signer = new MessageSigner();
var message = "10583fab2c57224d8a0d0d7d418386da159b158b02e656efc72f9398b1bb1c05";
var signature = "aef94afeff3ff3c53a33b4fc7aabc6c94b8b5cffae813d60b606bc6b04ec861b16a21225a3d7cfaa54b33a070b18b1455618d1c2b7be827b75e5a68bf18ce1611c";
var addressRec1 = signer.EcRecover(StringToByteArray(message), signature);
Console.WriteLine(message);
Console.WriteLine(signature);
Console.WriteLine(addressRec1);
//Everything below is testing for creating the message on the back end.
// var messageObj = new MessageData
// {
// types = new Types
// {
// EIP712Domain = new Domain[]
// {
// new Domain
// {
// name = "name",
// type = "string"
// },
// new Domain
// {
// name = "verifyingContract",
// type = "address"
// }
// },
// Identity = new Identity[]
// {
// new Identity
// {
// name = "account",
// type = "uint256"
// }
// }
// },
// domain = new DomainData
// {
// name = "Artix App",
// verifyingContract = "0xeb391f33b7da0abb89a68adcb92ae10ee7b24e78"
// },
// primaryType = "Identity",
// message = new Message
// {
// account = "0x13922b3f63f80f683207da9bb2b848a1b87bc7ed"
// //contract = "0xeb391f33b7da0abb89a68adcb92ae10ee7b24e78",
// //tokenId = "1",
// //info = "Sign to verify that you own the selected NFT"
// }
//};
}
private bool AuthCheck(string address, string signature)
{
MessageSigner signer = new MessageSigner();
string signerAddress = signer.EcRecover(ownershipProofMessage.HexToByteArray(), signature);
if (signerAddress.Equals(address, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(EIP1271AuthCheck(address, rawMessage, signature));
}
public TransactionInput CreateSetTopScoreTransactionInput(string addressFrom, string addressOwner, string privateKey, BigInteger score, HexBigInteger gas = null, HexBigInteger valueAmount = null)
{
var numberBytes = new IntTypeEncoder().Encode(score);
var sha3 = new Nethereum.Util.Sha3Keccack();
var hash = sha3.CalculateHashFromHex(addressFrom, addressOwner, numberBytes.ToHex());
var signer = new MessageSigner();
var signature = signer.Sign(hash.HexToByteArray(), privateKey);
var ethEcdsa = MessageSigner.ExtractEcdsaSignature(signature);
var function = GetFunctionSetTopScore();
return(function.CreateTransactionInput(addressFrom, gas, valueAmount, score, ethEcdsa.V, ethEcdsa.R, ethEcdsa.S));
}
/// <summary>
/// eth Sign
/// </summary>
/// <param name="macdata"></param>
/// <param name="ecdsaPrivateKey"></param>
/// <returns>r,s,v</returns>
public static Tuple <byte[], byte[], byte[]> Sign(byte[] macdata, ECPrivateKeyParameters ecdsaPrivateKey)
{
MessageSigner signer = new MessageSigner();
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(ecdsaPrivateKey);
PemObject pemObj = new PemObject("PRIVATE KEY", privateKeyInfo.ToAsn1Object().GetEncoded());
StringWriter strPri = new StringWriter();
Org.BouncyCastle.Utilities.IO.Pem.PemWriter pemW = new Org.BouncyCastle.Utilities.IO.Pem.PemWriter(strPri);
pemW.WriteObject(pemObj);
var signData = signer.SignAndCalculateV(macdata, ConvertPrikToHexString(strPri.ToString()));
return(new Tuple <byte[], byte[], byte[]>(signData.R, signData.S, signData.V));
}
/// <summary>
/// Encodes and signs current trust list using signer certificate and optional certificate chain to include in CTL.
/// </summary>
/// <param name="signer">signing object that contains public certificate, private key and signing configuration.</param>
/// <param name="chain">
/// Signing certificate chain to add to CMS. This parameter is optional. If not specified, only leaf (signing) certificate
/// is added to certificate list.
/// </param>
/// <returns>
/// An instance of <see cref="X509CertificateTrustList"/> class that represents signed certificate trust list.
/// </returns>
public X509CertificateTrustList Sign(MessageSigner signer, X509Certificate2Collection chain)
{
var cmsBuilder = new SignedCmsBuilder(oid, encodeCTL());
cmsBuilder.DigestAlgorithms.Add(new AlgorithmIdentifier(signer.HashingAlgorithm.ToOid(), new Byte[0]));
foreach (X509CertificateTrustListEntry entry in Entries.Where(x => x.Certificate != null))
{
cmsBuilder.Certificates.Add(entry.Certificate);
}
var signedCms = cmsBuilder.Sign(signer, chain);
return(new X509CertificateTrustList(signedCms.RawData));
}
public string GetNewChallenge(string message = null)
{
if (message == null)
{
message = _prefix;
}
var currentChallenge = DateTime.Now.ToString("O") + "- Challenge";
var key = EthECKey.GenerateKey();
var currentKey = key.GetPrivateKey(); // random key to sign message
var signer = new MessageSigner();
_currentChallenge = signer.HashAndSign(currentChallenge, currentKey);
return(message + _currentChallenge);
}
public string GetDefault(string key, ConfigCollector cfgColl = null)
{
TextAsset textAsset = Resources.Load(baseDir + "/" + key) as TextAsset;
if (textAsset == null)
{
return(null);
}
if (!MessageSigner.Verify(textAsset.text))
{
throw new SystemException("Tampered content for: " + key);
}
return(MessageSigner.Content(textAsset.text));
}
Boolean checkSingleSignature(PkcsSignerInfo signerInfo, Boolean validOnly)
{
X509Certificate2Collection certs;
X509Certificate2 signerCert = null;
switch (signerInfo.Issuer.Type)
{
case SubjectIdentifierType.IssuerAndSerialNumber:
var issuerAndSerial = (X509IssuerSerial)signerInfo.Issuer.Value;
certs = Certificates.Find(X509FindType.FindBySerialNumber, issuerAndSerial.SerialNumber, validOnly);
certs = certs.Find(X509FindType.FindByIssuerDistinguishedName, issuerAndSerial.Issuer, validOnly);
if (certs.Count > 0)
{
signerCert = certs[0];
}
break;
case SubjectIdentifierType.SubjectKeyIdentifier:
String si = signerInfo.Issuer.Value.ToString();
certs = Certificates.Find(X509FindType.FindBySubjectKeyIdentifier, si, true);
if (certs.Count > 0)
{
signerCert = certs[0];
}
break;
case SubjectIdentifierType.NoSignature:
return(checkSingleHash(signerInfo));
default:
throw new ArgumentOutOfRangeException();
}
// return False if we can't find signer certificate.
if (signerCert == null)
{
return(false);
}
// if hash check passed, do hash signature validation.
var signer = new MessageSigner(signerCert, new Oid2(signerInfo.HashAlgorithm.AlgorithmId, false));
Byte[] data = signerInfo.AuthenticatedAttributes.Encode();
data[0] = 0x31;
if (validOnly)
{
return(signer.VerifyData(data, signerInfo.EncryptedHash) && checkCertChain(signerCert));
}
return(signer.VerifyData(data, signerInfo.EncryptedHash));
}
public TransactionInput closeRoomInput(string addressFrom, string privateKey, HexBigInteger gas, int id, HexBigInteger valueAmount = null)
{
var numberBytes = new IntTypeEncoder().Encode(id);
var sha3 = new Nethereum.Util.Sha3Keccack();
var hash = sha3.CalculateHashFromHex(addressFrom, numberBytes.ToHex());
var signer = new MessageSigner();
var signature = signer.Sign(hash.HexToByteArray(), privateKey);
var ethEcdsa = MessageSigner.ExtractEcdsaSignature(signature);
object[] array = new object[] { id };
var
function = closeRoomFunction();
return(function.CreateTransactionInput(addressFrom, gas, valueAmount, array));
}
