Differential D1103 Diff 3299 src/script/interpreter.cpp

Changeset View

Standalone View

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 914 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);
		valtype res = MinimalizeBigEndianArray(bin);

		if (res.size() > DEFAULT_MAX_NUM_BYTES) {
		return set_error(
		serror, SCRIPT_ERR_INVALID_BIN2NUM_OPERATION);
		}

		// big endian to little endian conversion
		std::reverse(res.begin(), res.end());

		CScriptNum num(res, false);
		if (num > (INT_MAX >> 1) \|\| num < (INT_MIN >> 1)) {
		return set_error(
		serror, SCRIPT_ERR_INVALID_BIN2NUM_OPERATION);
		}
		popstack(stack);
		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) >
		DEFAULT_MAX_NUM_BYTES) {
		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 < static_cast<int64_t>(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
		jasonbcoxUnsubmitted Not Done Inline Actions Is this comment misplaced? The code immediately below it is just recording neg. I don't actually see any code in this function that protects against -0. jasonbcox: Is this comment misplaced? The code immediately below it is just recording neg. I don't…
		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) {
		shaddersUnsubmitted Not Done Inline Actions i is a uint8_t. This is implicitly limiting padding to 255 bytes. The spec doesn't imply any limitation other than that the result must me less than DEFAULT_MAX_NUM_BYTES shadders: i is a uint8_t. This is implicitly limiting padding to 255 bytes. The spec doesn't imply any…
		result.push_back(0);
		}
		for (auto i = vchNum.rbegin(); i != vchNum.rend();
		++i) {
		result.push_back(*i);
		}
		if (neg) *result.begin() \|= 0x80;
		popstack(stack);
		popstack(stack);
		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