/// <summary>
/// Whether transaction inputs are standard.
/// Check for standard transaction types.
/// </summary>
/// <param name="tx">Transaction to verify.</param>
/// <param name="mapInputs">Map of previous transactions that have outputs we're spending.</param>
/// <returns>Whether all inputs (scriptSigs) use only standard transaction forms.</returns>
private bool AreInputsStandard(Network network, Transaction tx, MempoolCoinView mapInputs)
{
if (tx.IsCoinBase)
{
this.logger.LogTrace("(-)[IS_COINBASE]:true");
return(true); // Coinbases don't use vin normally
}
foreach (TxIn txin in tx.Inputs)
{
TxOut prev = mapInputs.GetOutputFor(txin);
ScriptTemplate template = network.StandardScriptsRegistry.GetTemplateFromScriptPubKey(prev.ScriptPubKey);
if (template == null)
{
this.logger.LogTrace("(-)[BAD_SCRIPT_TEMPLATE]:false");
return(false);
}
if (template.Type == TxOutType.TX_SCRIPTHASH)
{
if (prev.ScriptPubKey.GetSigOpCount(true) > 15) //MAX_P2SH_SIGOPS
{
this.logger.LogTrace("(-)[SIG_OP_MAX]:false");
return(false);
}
}
}
return(true);
}
/// <summary>
/// Whether transaction is witness standard.
/// <seealso cref="https://github.com/bitcoin/bitcoin/blob/aa624b61c928295c27ffbb4d27be582f5aa31b56/src/policy/policy.cpp#L196"/>
/// </summary>
/// <param name="tx">Transaction to verify.</param>
/// <param name="mapInputs">Map of previous transactions that have outputs we're spending.</param>
/// <returns>Whether transaction is witness standard.</returns>
private bool IsWitnessStandard(Transaction tx, MempoolCoinView mapInputs)
{
if (tx.IsCoinBase)
{
this.logger.LogTrace("(-)[IS_COINBASE]:true");
return(true); // Coinbases are skipped.
}
foreach (TxIn input in tx.Inputs)
{
// We don't care if witness for this input is empty, since it must not be bloated.
// If the script is invalid without witness, it would be caught sooner or later during validation.
if (input.WitScriptEmpty)
{
continue;
}
TxOut prev = mapInputs.GetOutputFor(input);
// Get the scriptPubKey corresponding to this input.
Script prevScript = prev.ScriptPubKey;
if (prevScript.IsPayToScriptHash(this.network))
{
// If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
// into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
// If the check fails at this stage, we know that this txid must be a bad one.
PayToScriptHashSigParameters sigParams = PayToScriptHashTemplate.Instance.ExtractScriptSigParameters(this.network, input.ScriptSig);
if (sigParams == null || sigParams.RedeemScript == null)
{
this.logger.LogTrace("(-)[BAD_TXID]:false");
return(false);
}
prevScript = sigParams.RedeemScript;
}
// Non-witness program must not be associated with any witness.
if (!prevScript.IsWitness(this.network))
{
this.logger.LogTrace("(-)[WITNESS_MISMATCH]:false");
return(false);
}
// Check P2WSH standard limits.
WitProgramParameters wit = PayToWitTemplate.Instance.ExtractScriptPubKeyParameters2(this.chainIndexer.Network, prevScript);
if (wit == null)
{
this.logger.LogTrace("(-)[BAD_WITNESS_PARAMS]:false");
return(false);
}
// Version 0 segregated witness program validation.
if (wit.Version == 0 && wit.Program.Length == WitnessV0ScriptHashSize)
{
WitScript witness = input.WitScript;
// Get P2WSH script from top of stack.
Script scriptPubKey = Script.FromBytesUnsafe(witness.GetUnsafePush(witness.PushCount - 1));
// Stack items are remainder of stack.
int sizeWitnessStack = witness.PushCount - 1;
// Get the witness stack items.
var stack = new List <byte[]>();
for (int i = 0; i < sizeWitnessStack; i++)
{
stack.Add(witness.GetUnsafePush(i));
}
// Validate P2WSH script isn't larger than max length.
if (scriptPubKey.ToBytes(true).Length > MaxStandardP2wshScriptSize)
{
this.logger.LogTrace("(-)[P2WSH_SCRIPT_SIZE]:false");
return(false);
}
// Validate number items in witness stack isn't larger than max.
if (sizeWitnessStack > MaxStandardP2wshStackItems)
{
this.logger.LogTrace("(-)[P2WSH_STACK_ITEMS]:false");
return(false);
}
// Validate size of each of the witness stack items.
for (int j = 0; j < sizeWitnessStack; j++)
{
if (stack[j].Length > MaxStandardP2wshStackItemSize)
{
this.logger.LogTrace("(-)[P2WSH_STACK_ITEM_SIZE]:false");
return(false);
}
}
}
}
return(true);
}
/// <summary>
/// Whether transaction inputs are standard.
/// Check for standard transaction types.
/// </summary>
/// <seealso>https://github.com/bitcoin/bitcoin/blob/febf3a856bcfb8fef2cb4ddcb8d1e0cab8a22580/src/policy/policy.cpp#L156</seealso>
/// <param name="tx">Transaction to verify.</param>
/// <param name="mapInputs">Map of previous transactions that have outputs we're spending.</param>
/// <returns>Whether all inputs (scriptSigs) use only standard transaction forms.</returns>
private bool AreInputsStandard(Network network, Transaction tx, MempoolCoinView mapInputs)
{
if (tx.IsCoinBase)
{
this.logger.LogTrace("(-)[IS_COINBASE]:true");
return(true); // Coinbases don't use vin normally.
}
for (int i = 0; i < tx.Inputs.Count; i++)
{
TxIn txin = tx.Inputs[i];
TxOut prev = mapInputs.GetOutputFor(txin);
ScriptTemplate template = network.StandardScriptsRegistry.GetTemplateFromScriptPubKey(prev.ScriptPubKey);
if (template == null) // i.e. the TX_NONSTANDARD case
{
this.logger.LogTrace("(-)[BAD_SCRIPT_TEMPLATE]:false");
return(false);
}
/* Check transaction inputs to mitigate two potential denial-of-service attacks:
*
* 1. scriptSigs with extra data stuffed into them, not consumed by scriptPubKey (or P2SH script)
* 2. P2SH scripts with a crazy number of expensive CHECKSIG/CHECKMULTISIG operations
*
* Why bother? To avoid denial-of-service attacks; an attacker can submit a standard HASH... OP_EQUAL transaction,
* which will get accepted into blocks. The redemption script can be anything; an attacker could use a very
* expensive-to-check-upon-redemption script like:
* DUP CHECKSIG DROP ... repeated 100 times... OP_1
*/
if (template.Type == TxOutType.TX_SCRIPTHASH)
{
// Convert the scriptSig into a stack, so we can inspect the redeemScript.
var ctx = new ScriptEvaluationContext(this.network)
{
ScriptVerify = ScriptVerify.None
};
if (!ctx.EvalScript(txin.ScriptSig, tx, i)) // TODO: Check the semantics of SigVersion::BASE from original code
{
return(false);
}
// TODO: Investigate why IsEmpty is failing to return true when there is nothing on the stack. It is possible that nowhere else in the codebase is using IsEmpty on an IEnumerable
if (ctx.Stack.IsEmpty() || ctx.Stack.Count == 0)
{
return(false);
}
// Get redeemScript from stack.
var redeemScript = new Script(ctx.Stack.Top(-1));
// TODO: Move this into a network-specific rule so that it only applies to Strax (the Cirrus validator already allows non-standard transactions)
if (redeemScript.GetSigOpCount(true, this.network) > MaxP2SHSigOps)
{
this.logger.LogTrace("(-)[SIG_OP_MAX]:false");
return(false);
}
}
}
return(true);
}
public GetSenderResult GetSender(Transaction tx, MempoolCoinView coinView)
{
TxOut output = coinView.GetOutputFor(tx.Inputs[0]);
return(this.GetAddressFromScript(output.ScriptPubKey));
}
