Page MenuHomePhabricator
Differential D1103 Diff 3275 src/script/interpreter.cpp

Changeset View

Standalone View

View Options

src/script/interpreter.cpp

Show First 20 Lines • Show All 298 Lines • ▼ Show 20 Lines if (fEnabledOpCodesMonolith) {
switch (opcode) { switch (opcode) {
case OP_CAT: case OP_CAT:
return true; return true;
case OP_SPLIT: case OP_SPLIT:
return true; return true;
case OP_BIN2NUM: case OP_BIN2NUM:
return true; return false;
case OP_NUM2BIN: case OP_NUM2BIN:
return true; return false;
case OP_AND: case OP_AND:
return true; return true;
case OP_OR: case OP_OR:
return true; return true;
case OP_XOR: case OP_XOR:
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesbool EvalScript(std::vector<valtype> &stack, const CScript &script,
std::vector<bool> vfExec; std::vector<bool> vfExec;
std::vector<valtype> altstack; std::vector<valtype> altstack;
set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR); set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
if (script.size() > MAX_SCRIPT_SIZE) { if (script.size() > MAX_SCRIPT_SIZE) {
return set_error(serror, SCRIPT_ERR_SCRIPT_SIZE); return set_error(serror, SCRIPT_ERR_SCRIPT_SIZE);
} }
int nOpCount = 0; int nOpCount = 0;
bool fRequireMinimal = (flags & SCRIPT_VERIFY_MINIMALDATA) != 0; bool fRequireMinimal = (flags & SCRIPT_VERIFY_MINIMALDATA) != 0;
bool fEnabledOpCodesMonolith =
(flags & SCRIPT_ENABLE_OPCODES_MONOLITH) != 0;
try { try {
while (pc < pend) { while (pc < pend) {
bool fExec = !count(vfExec.begin(), vfExec.end(), false); bool fExec = !count(vfExec.begin(), vfExec.end(), false);
// //
// Read instruction // Read instruction
// //
▲ Show 20 Lines • Show All 445 Lines • ▼ Show 20 Lines try {
} }
CScriptNum bn(stacktop(-1).size()); CScriptNum bn(stacktop(-1).size());
stack.push_back(bn.getvch()); stack.push_back(bn.getvch());
} break; } break;
// //
// Bitwise logic // Bitwise logic
// //
case OP_AND:
case OP_OR:
case OP_XOR: {
if (!fEnabledOpCodesMonolith) {
// Disabled opcodes.
return set_error(serror,
SCRIPT_ERR_DISABLED_OPCODE);
}
} break;
case OP_EQUAL: case OP_EQUAL:
case OP_EQUALVERIFY: case OP_EQUALVERIFY:
// case OP_NOTEQUAL: // use OP_NUMNOTEQUAL // case OP_NOTEQUAL: // use OP_NUMNOTEQUAL
{ {
// (x1 x2 - bool) // (x1 x2 - bool)
if (stack.size() < 2) { if (stack.size() < 2) {
return set_error( return set_error(
serror, SCRIPT_ERR_INVALID_STACK_OPERATION); serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines try {
break; break;
} }
popstack(stack); popstack(stack);
stack.push_back(bn.getvch()); stack.push_back(bn.getvch());
} break; } break;
case OP_ADD: case OP_ADD:
case OP_SUB: case OP_SUB:
case OP_DIV:
case OP_MOD:
case OP_BOOLAND: case OP_BOOLAND:
case OP_BOOLOR: case OP_BOOLOR:
case OP_NUMEQUAL: case OP_NUMEQUAL:
case OP_NUMEQUALVERIFY: case OP_NUMEQUALVERIFY:
case OP_NUMNOTEQUAL: case OP_NUMNOTEQUAL:
case OP_LESSTHAN: case OP_LESSTHAN:
case OP_GREATERTHAN: case OP_GREATERTHAN:
case OP_LESSTHANOREQUAL: case OP_LESSTHANOREQUAL:
Show All 12 Lines try {
case OP_ADD: case OP_ADD:
bn = bn1 + bn2; bn = bn1 + bn2;
break; break;
case OP_SUB: case OP_SUB:
bn = bn1 - bn2; bn = bn1 - bn2;
break; break;
case OP_DIV:
if (!fEnabledOpCodesMonolith) {
// Disabled opcode.
return set_error(
serror, SCRIPT_ERR_DISABLED_OPCODE);
}
break;
case OP_MOD:
if (!fEnabledOpCodesMonolith) {
// Disabled opcode.
return set_error(
serror, SCRIPT_ERR_DISABLED_OPCODE);
}
break;
case OP_BOOLAND: case OP_BOOLAND:
bn = (bn1 != bnZero && bn2 != bnZero); bn = (bn1 != bnZero && bn2 != bnZero);
break; break;
case OP_BOOLOR: case OP_BOOLOR:
bn = (bn1 != bnZero || bn2 != bnZero); bn = (bn1 != bnZero || bn2 != bnZero);
break; break;
case OP_NUMEQUAL: case OP_NUMEQUAL:
bn = (bn1 == bn2); bn = (bn1 == bn2);
▲ Show 20 Lines • Show All 277 Lines • ▼ Show 20 Lines try {
popstack(stack); popstack(stack);
} else { } else {
return set_error( return set_error(
serror, SCRIPT_ERR_CHECKMULTISIGVERIFY); serror, SCRIPT_ERR_CHECKMULTISIGVERIFY);
} }
} }
} break; } break;
//
// Conversion operations
//
case OP_BIN2NUM: {
// (in -- out)
if (stack.size() < 1) {
return set_error(
serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
}
valtype bin = stacktop(-1);
// big endian to little endian conversion
std::reverse(bin.begin(), bin.end());
CScriptNum num(bin, false);
if (num > (INT_MAX >> 1) || num < (INT_MIN >> 1)) {
return set_error(
serror, SCRIPT_ERR_INVALID_BIN2NUM_OPERATION);
}
stack.pop_back();
stack.push_back(num.getvch());
} break;
case OP_NUM2BIN: {
// (in size -- out)
if (stack.size() < 2) {
return set_error(
serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
}
CScriptNum num(stacktop(-2), fRequireMinimal);
int64_t size =
CScriptNum(stacktop(-1), fRequireMinimal).getint();
if (size < 1 ||
static_cast<uint64_t>(size) >
CScriptNum::nDefaultMaxNumSize) {
return set_error(
serror, SCRIPT_ERR_INVALID_NUM2BIN_OPERATION);
}
// Produces a byte vector of num and check if input size
// is valid
valtype vchNum = num.getvch();
if (size < vchNum.size()) {
return set_error(
serror, SCRIPT_ERR_INVALID_NUM2BIN_OPERATION);
}
// Initialize byte vector for result
valtype result;
result.reserve(size);
bool neg{false};
// Avoid negative zero
if (!vchNum.empty()) {
neg = *vchNum.rbegin() & 0x80;
*vchNum.rbegin() &= ~0x80;
}
// Pad result to declared input size
size_t pad = size - vchNum.size();
for (uint8_t i = 0; i < pad; ++i) {
result.push_back(0);
}
for (auto i = vchNum.rbegin(); i != vchNum.rend();
++i) {
result.push_back(*i);
}
if (neg) *result.begin() |= 0x80;
stack.pop_back();
stack.pop_back();
stack.push_back(result);
} break;
default: default:
return set_error(serror, SCRIPT_ERR_BAD_OPCODE); return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
} }
} }
// Size limits // Size limits
if (stack.size() + altstack.size() > 1000) { if (stack.size() + altstack.size() > 1000) {
return set_error(serror, SCRIPT_ERR_STACK_SIZE); return set_error(serror, SCRIPT_ERR_STACK_SIZE);
▲ Show 20 Lines • Show All 445 Lines • Show Last 20 Lines