// Copyright (c) 2013-2015 Conformal Systems LLC. // Use of this source code is governed by an ISC // license that can be found in the LICENSE file. package txscript import ( "bytes" "crypto/sha1" "encoding/binary" "encoding/hex" "fmt" "hash" "math/big" "github.com/btcsuite/btcd/btcec" "github.com/btcsuite/btcd/wire" "github.com/btcsuite/fastsha256" "github.com/btcsuite/golangcrypto/ripemd160" ) // An opcode defines the information related to a txscript opcode. // opfunc if present is the function to call to perform the opcode on // the script. The current script is passed in as a slice with the firs // member being the opcode itself. type opcode struct { value byte name string length int opfunc func(*parsedOpcode, *Engine) error parsefunc func(*opcode, *Engine, []byte) error } // These constants are the values of the official opcodes used on the btc wiki, // in bitcoin core and in most if not all other references and software related // to handling BTC scripts. const ( OP_0 = 0x00 // 0 OP_FALSE = 0x00 // 0 - AKA OP_0 OP_DATA_1 = 0x01 // 1 OP_DATA_2 = 0x02 // 2 OP_DATA_3 = 0x03 // 3 OP_DATA_4 = 0x04 // 4 OP_DATA_5 = 0x05 // 5 OP_DATA_6 = 0x06 // 6 OP_DATA_7 = 0x07 // 7 OP_DATA_8 = 0x08 // 8 OP_DATA_9 = 0x09 // 9 OP_DATA_10 = 0x0a // 10 OP_DATA_11 = 0x0b // 11 OP_DATA_12 = 0x0c // 12 OP_DATA_13 = 0x0d // 13 OP_DATA_14 = 0x0e // 14 OP_DATA_15 = 0x0f // 15 OP_DATA_16 = 0x10 // 16 OP_DATA_17 = 0x11 // 17 OP_DATA_18 = 0x12 // 18 OP_DATA_19 = 0x13 // 19 OP_DATA_20 = 0x14 // 20 OP_DATA_21 = 0x15 // 21 OP_DATA_22 = 0x16 // 22 OP_DATA_23 = 0x17 // 23 OP_DATA_24 = 0x18 // 24 OP_DATA_25 = 0x19 // 25 OP_DATA_26 = 0x1a // 26 OP_DATA_27 = 0x1b // 27 OP_DATA_28 = 0x1c // 28 OP_DATA_29 = 0x1d // 29 OP_DATA_30 = 0x1e // 30 OP_DATA_31 = 0x1f // 31 OP_DATA_32 = 0x20 // 32 OP_DATA_33 = 0x21 // 33 OP_DATA_34 = 0x22 // 34 OP_DATA_35 = 0x23 // 35 OP_DATA_36 = 0x24 // 36 OP_DATA_37 = 0x25 // 37 OP_DATA_38 = 0x26 // 38 OP_DATA_39 = 0x27 // 39 OP_DATA_40 = 0x28 // 40 OP_DATA_41 = 0x29 // 41 OP_DATA_42 = 0x2a // 42 OP_DATA_43 = 0x2b // 43 OP_DATA_44 = 0x2c // 44 OP_DATA_45 = 0x2d // 45 OP_DATA_46 = 0x2e // 46 OP_DATA_47 = 0x2f // 47 OP_DATA_48 = 0x30 // 48 OP_DATA_49 = 0x31 // 49 OP_DATA_50 = 0x32 // 50 OP_DATA_51 = 0x33 // 51 OP_DATA_52 = 0x34 // 52 OP_DATA_53 = 0x35 // 53 OP_DATA_54 = 0x36 // 54 OP_DATA_55 = 0x37 // 55 OP_DATA_56 = 0x38 // 56 OP_DATA_57 = 0x39 // 57 OP_DATA_58 = 0x3a // 58 OP_DATA_59 = 0x3b // 59 OP_DATA_60 = 0x3c // 60 OP_DATA_61 = 0x3d // 61 OP_DATA_62 = 0x3e // 62 OP_DATA_63 = 0x3f // 63 OP_DATA_64 = 0x40 // 64 OP_DATA_65 = 0x41 // 65 OP_DATA_66 = 0x42 // 66 OP_DATA_67 = 0x43 // 67 OP_DATA_68 = 0x44 // 68 OP_DATA_69 = 0x45 // 69 OP_DATA_70 = 0x46 // 70 OP_DATA_71 = 0x47 // 71 OP_DATA_72 = 0x48 // 72 OP_DATA_73 = 0x49 // 73 OP_DATA_74 = 0x4a // 74 OP_DATA_75 = 0x4b // 75 OP_PUSHDATA1 = 0x4c // 76 OP_PUSHDATA2 = 0x4d // 77 OP_PUSHDATA4 = 0x4e // 78 OP_1NEGATE = 0x4f // 79 OP_RESERVED = 0x50 // 80 OP_1 = 0x51 // 81 - AKA OP_TRUE OP_TRUE = 0x51 // 81 OP_2 = 0x52 // 82 OP_3 = 0x53 // 83 OP_4 = 0x54 // 84 OP_5 = 0x55 // 85 OP_6 = 0x56 // 86 OP_7 = 0x57 // 87 OP_8 = 0x58 // 88 OP_9 = 0x59 // 89 OP_10 = 0x5a // 90 OP_11 = 0x5b // 91 OP_12 = 0x5c // 92 OP_13 = 0x5d // 93 OP_14 = 0x5e // 94 OP_15 = 0x5f // 95 OP_16 = 0x60 // 96 OP_NOP = 0x61 // 97 OP_VER = 0x62 // 98 OP_IF = 0x63 // 99 OP_NOTIF = 0x64 // 100 OP_VERIF = 0x65 // 101 OP_VERNOTIF = 0x66 // 102 OP_ELSE = 0x67 // 103 OP_ENDIF = 0x68 // 104 OP_VERIFY = 0x69 // 105 OP_RETURN = 0x6a // 106 OP_TOALTSTACK = 0x6b // 107 OP_FROMALTSTACK = 0x6c // 108 OP_2DROP = 0x6d // 109 OP_2DUP = 0x6e // 110 OP_3DUP = 0x6f // 111 OP_2OVER = 0x70 // 112 OP_2ROT = 0x71 // 113 OP_2SWAP = 0x72 // 114 OP_IFDUP = 0x73 // 115 OP_DEPTH = 0x74 // 116 OP_DROP = 0x75 // 117 OP_DUP = 0x76 // 118 OP_NIP = 0x77 // 119 OP_OVER = 0x78 // 120 OP_PICK = 0x79 // 121 OP_ROLL = 0x7a // 122 OP_ROT = 0x7b // 123 OP_SWAP = 0x7c // 124 OP_TUCK = 0x7d // 125 OP_CAT = 0x7e // 126 OP_SUBSTR = 0x7f // 127 OP_LEFT = 0x80 // 128 OP_RIGHT = 0x81 // 129 OP_SIZE = 0x82 // 130 OP_INVERT = 0x83 // 131 OP_AND = 0x84 // 132 OP_OR = 0x85 // 133 OP_XOR = 0x86 // 134 OP_EQUAL = 0x87 // 135 OP_EQUALVERIFY = 0x88 // 136 OP_RESERVED1 = 0x89 // 137 OP_RESERVED2 = 0x8a // 138 OP_1ADD = 0x8b // 139 OP_1SUB = 0x8c // 140 OP_2MUL = 0x8d // 141 OP_2DIV = 0x8e // 142 OP_NEGATE = 0x8f // 143 OP_ABS = 0x90 // 144 OP_NOT = 0x91 // 145 OP_0NOTEQUAL = 0x92 // 146 OP_ADD = 0x93 // 147 OP_SUB = 0x94 // 148 OP_MUL = 0x95 // 149 OP_DIV = 0x96 // 150 OP_MOD = 0x97 // 151 OP_LSHIFT = 0x98 // 152 OP_RSHIFT = 0x99 // 153 OP_BOOLAND = 0x9a // 154 OP_BOOLOR = 0x9b // 155 OP_NUMEQUAL = 0x9c // 156 OP_NUMEQUALVERIFY = 0x9d // 157 OP_NUMNOTEQUAL = 0x9e // 158 OP_LESSTHAN = 0x9f // 159 OP_GREATERTHAN = 0xa0 // 160 OP_LESSTHANOREQUAL = 0xa1 // 161 OP_GREATERTHANOREQUAL = 0xa2 // 162 OP_MIN = 0xa3 // 163 OP_MAX = 0xa4 // 164 OP_WITHIN = 0xa5 // 165 OP_RIPEMD160 = 0xa6 // 166 OP_SHA1 = 0xa7 // 167 OP_SHA256 = 0xa8 // 168 OP_HASH160 = 0xa9 // 169 OP_HASH256 = 0xaa // 170 OP_CODESEPARATOR = 0xab // 171 OP_CHECKSIG = 0xac // 172 OP_CHECKSIGVERIFY = 0xad // 173 OP_CHECKMULTISIG = 0xae // 174 OP_CHECKMULTISIGVERIFY = 0xaf // 175 OP_NOP1 = 0xb0 // 176 OP_NOP2 = 0xb1 // 177 OP_NOP3 = 0xb2 // 178 OP_NOP4 = 0xb3 // 179 OP_NOP5 = 0xb4 // 180 OP_NOP6 = 0xb5 // 181 OP_NOP7 = 0xb6 // 182 OP_NOP8 = 0xb7 // 183 OP_NOP9 = 0xb8 // 184 OP_NOP10 = 0xb9 // 185 OP_UNKNOWN186 = 0xba // 186 OP_UNKNOWN187 = 0xbb // 187 OP_UNKNOWN188 = 0xbc // 188 OP_UNKNOWN189 = 0xbd // 189 OP_UNKNOWN190 = 0xbe // 190 OP_UNKNOWN191 = 0xbf // 191 OP_UNKNOWN192 = 0xc0 // 192 OP_UNKNOWN193 = 0xc1 // 193 OP_UNKNOWN194 = 0xc2 // 194 OP_UNKNOWN195 = 0xc3 // 195 OP_UNKNOWN196 = 0xc4 // 196 OP_UNKNOWN197 = 0xc5 // 197 OP_UNKNOWN198 = 0xc6 // 198 OP_UNKNOWN199 = 0xc7 // 199 OP_UNKNOWN200 = 0xc8 // 200 OP_UNKNOWN201 = 0xc9 // 201 OP_UNKNOWN202 = 0xca // 202 OP_UNKNOWN203 = 0xcb // 203 OP_UNKNOWN204 = 0xcc // 204 OP_UNKNOWN205 = 0xcd // 205 OP_UNKNOWN206 = 0xce // 206 OP_UNKNOWN207 = 0xcf // 207 OP_UNKNOWN208 = 0xd0 // 208 OP_UNKNOWN209 = 0xd1 // 209 OP_UNKNOWN210 = 0xd2 // 210 OP_UNKNOWN211 = 0xd3 // 211 OP_UNKNOWN212 = 0xd4 // 212 OP_UNKNOWN213 = 0xd5 // 213 OP_UNKNOWN214 = 0xd6 // 214 OP_UNKNOWN215 = 0xd7 // 215 OP_UNKNOWN216 = 0xd8 // 216 OP_UNKNOWN217 = 0xd9 // 217 OP_UNKNOWN218 = 0xda // 218 OP_UNKNOWN219 = 0xdb // 219 OP_UNKNOWN220 = 0xdc // 220 OP_UNKNOWN221 = 0xdd // 221 OP_UNKNOWN222 = 0xde // 222 OP_UNKNOWN223 = 0xdf // 223 OP_UNKNOWN224 = 0xe0 // 224 OP_UNKNOWN225 = 0xe1 // 225 OP_UNKNOWN226 = 0xe2 // 226 OP_UNKNOWN227 = 0xe3 // 227 OP_UNKNOWN228 = 0xe4 // 228 OP_UNKNOWN229 = 0xe5 // 229 OP_UNKNOWN230 = 0xe6 // 230 OP_UNKNOWN231 = 0xe7 // 231 OP_UNKNOWN232 = 0xe8 // 232 OP_UNKNOWN233 = 0xe9 // 233 OP_UNKNOWN234 = 0xea // 234 OP_UNKNOWN235 = 0xeb // 235 OP_UNKNOWN236 = 0xec // 236 OP_UNKNOWN237 = 0xed // 237 OP_UNKNOWN238 = 0xee // 238 OP_UNKNOWN239 = 0xef // 239 OP_UNKNOWN240 = 0xf0 // 240 OP_UNKNOWN241 = 0xf1 // 241 OP_UNKNOWN242 = 0xf2 // 242 OP_UNKNOWN243 = 0xf3 // 243 OP_UNKNOWN244 = 0xf4 // 244 OP_UNKNOWN245 = 0xf5 // 245 OP_UNKNOWN246 = 0xf6 // 246 OP_UNKNOWN247 = 0xf7 // 247 OP_UNKNOWN248 = 0xf8 // 248 OP_SMALLDATA = 0xf9 // 249 - bitcoin core internal OP_SMALLINTEGER = 0xfa // 250 - bitcoin core internal OP_PUBKEYS = 0xfb // 251 - bitcoin core internal OP_UNKNOWN252 = 0xfc // 252 OP_PUBKEYHASH = 0xfd // 253 - bitcoin core internal OP_PUBKEY = 0xfe // 254 - bitcoin core internal OP_INVALIDOPCODE = 0xff // 255 - bitcoin core internal ) // conditional execution constants const ( OpCondFalse = 0 OpCondTrue = 1 OpCondSkip = 2 ) // Some of the functions in opcodemap call things that themselves then will // reference the opcodemap to make decisions (things like op_checksig which // needs to parse scripts to remove opcodes, for example). // The go compiler is very conservative in this matter and will think there // is an initialisation loop. In order to work around this we have the fake // ``prevariable'' opcodemapPreinit and then set the real variable to the // preinit in init() var opcodemap map[byte]*opcode func init() { opcodemap = opcodemapPreinit } var opcodemapPreinit = map[byte]*opcode{ OP_FALSE: {value: OP_FALSE, name: "OP_0", length: 1, opfunc: opcodeFalse}, OP_DATA_1: {value: OP_DATA_1, name: "OP_DATA_1", length: 2, opfunc: opcodePushData}, OP_DATA_2: {value: OP_DATA_2, name: "OP_DATA_2", length: 3, opfunc: opcodePushData}, OP_DATA_3: {value: OP_DATA_3, name: "OP_DATA_3", length: 4, opfunc: opcodePushData}, OP_DATA_4: {value: OP_DATA_4, name: "OP_DATA_4", length: 5, opfunc: opcodePushData}, OP_DATA_5: {value: OP_DATA_5, name: "OP_DATA_5", length: 6, opfunc: opcodePushData}, OP_DATA_6: {value: OP_DATA_6, name: "OP_DATA_6", length: 7, opfunc: opcodePushData}, OP_DATA_7: {value: OP_DATA_7, name: "OP_DATA_7", length: 8, opfunc: opcodePushData}, OP_DATA_8: {value: OP_DATA_8, name: "OP_DATA_8", length: 9, opfunc: opcodePushData}, OP_DATA_9: {value: OP_DATA_9, name: "OP_DATA_9", length: 10, opfunc: opcodePushData}, OP_DATA_10: {value: OP_DATA_10, name: "OP_DATA_10", length: 11, opfunc: opcodePushData}, OP_DATA_11: {value: OP_DATA_11, name: "OP_DATA_11", length: 12, opfunc: opcodePushData}, OP_DATA_12: {value: OP_DATA_12, name: "OP_DATA_12", length: 13, opfunc: opcodePushData}, OP_DATA_13: {value: OP_DATA_13, name: "OP_DATA_13", length: 14, opfunc: opcodePushData}, OP_DATA_14: {value: OP_DATA_14, name: "OP_DATA_14", length: 15, opfunc: opcodePushData}, OP_DATA_15: {value: OP_DATA_15, name: "OP_DATA_15", length: 16, opfunc: opcodePushData}, OP_DATA_16: {value: OP_DATA_16, name: "OP_DATA_16", length: 17, opfunc: opcodePushData}, OP_DATA_17: {value: OP_DATA_17, name: "OP_DATA_17", length: 18, opfunc: opcodePushData}, OP_DATA_18: {value: OP_DATA_18, name: "OP_DATA_18", length: 19, opfunc: opcodePushData}, OP_DATA_19: {value: OP_DATA_19, name: "OP_DATA_19", length: 20, opfunc: opcodePushData}, OP_DATA_20: {value: OP_DATA_20, name: "OP_DATA_20", length: 21, opfunc: opcodePushData}, OP_DATA_21: {value: OP_DATA_21, name: "OP_DATA_21", length: 22, opfunc: opcodePushData}, OP_DATA_22: {value: OP_DATA_22, name: "OP_DATA_22", length: 23, opfunc: opcodePushData}, OP_DATA_23: {value: OP_DATA_23, name: "OP_DATA_23", length: 24, opfunc: opcodePushData}, OP_DATA_24: {value: OP_DATA_24, name: "OP_DATA_24", length: 25, opfunc: opcodePushData}, OP_DATA_25: {value: OP_DATA_25, name: "OP_DATA_25", length: 26, opfunc: opcodePushData}, OP_DATA_26: {value: OP_DATA_26, name: "OP_DATA_26", length: 27, opfunc: opcodePushData}, OP_DATA_27: {value: OP_DATA_27, name: "OP_DATA_27", length: 28, opfunc: opcodePushData}, OP_DATA_28: {value: OP_DATA_28, name: "OP_DATA_28", length: 29, opfunc: opcodePushData}, OP_DATA_29: {value: OP_DATA_29, name: "OP_DATA_29", length: 30, opfunc: opcodePushData}, OP_DATA_30: {value: OP_DATA_30, name: "OP_DATA_30", length: 31, opfunc: opcodePushData}, OP_DATA_31: {value: OP_DATA_31, name: "OP_DATA_31", length: 32, opfunc: opcodePushData}, OP_DATA_32: {value: OP_DATA_32, name: "OP_DATA_32", length: 33, opfunc: opcodePushData}, OP_DATA_33: {value: OP_DATA_33, name: "OP_DATA_33", length: 34, opfunc: opcodePushData}, OP_DATA_34: {value: OP_DATA_34, name: "OP_DATA_34", length: 35, opfunc: opcodePushData}, OP_DATA_35: {value: OP_DATA_35, name: "OP_DATA_35", length: 36, opfunc: opcodePushData}, OP_DATA_36: {value: OP_DATA_36, name: "OP_DATA_36", length: 37, opfunc: opcodePushData}, OP_DATA_37: {value: OP_DATA_37, name: "OP_DATA_37", length: 38, opfunc: opcodePushData}, OP_DATA_38: {value: OP_DATA_38, name: "OP_DATA_38", length: 39, opfunc: opcodePushData}, OP_DATA_39: {value: OP_DATA_39, name: "OP_DATA_39", length: 40, opfunc: opcodePushData}, OP_DATA_40: {value: OP_DATA_40, name: "OP_DATA_40", length: 41, opfunc: opcodePushData}, OP_DATA_41: {value: OP_DATA_41, name: "OP_DATA_41", length: 42, opfunc: opcodePushData}, OP_DATA_42: {value: OP_DATA_42, name: "OP_DATA_42", length: 43, opfunc: opcodePushData}, OP_DATA_43: {value: OP_DATA_43, name: "OP_DATA_43", length: 44, opfunc: opcodePushData}, OP_DATA_44: {value: OP_DATA_44, name: "OP_DATA_44", length: 45, opfunc: opcodePushData}, OP_DATA_45: {value: OP_DATA_45, name: "OP_DATA_45", length: 46, opfunc: opcodePushData}, OP_DATA_46: {value: OP_DATA_46, name: "OP_DATA_46", length: 47, opfunc: opcodePushData}, OP_DATA_47: {value: OP_DATA_47, name: "OP_DATA_47", length: 48, opfunc: opcodePushData}, OP_DATA_48: {value: OP_DATA_48, name: "OP_DATA_48", length: 49, opfunc: opcodePushData}, OP_DATA_49: {value: OP_DATA_49, name: "OP_DATA_49", length: 50, opfunc: opcodePushData}, OP_DATA_50: {value: OP_DATA_50, name: "OP_DATA_50", length: 51, opfunc: opcodePushData}, OP_DATA_51: {value: OP_DATA_51, name: "OP_DATA_51", length: 52, opfunc: opcodePushData}, OP_DATA_52: {value: OP_DATA_52, name: "OP_DATA_52", length: 53, opfunc: opcodePushData}, OP_DATA_53: {value: OP_DATA_53, name: "OP_DATA_53", length: 54, opfunc: opcodePushData}, OP_DATA_54: {value: OP_DATA_54, name: "OP_DATA_54", length: 55, opfunc: opcodePushData}, OP_DATA_55: {value: OP_DATA_55, name: "OP_DATA_55", length: 56, opfunc: opcodePushData}, OP_DATA_56: {value: OP_DATA_56, name: "OP_DATA_56", length: 57, opfunc: opcodePushData}, OP_DATA_57: {value: OP_DATA_57, name: "OP_DATA_57", length: 58, opfunc: opcodePushData}, OP_DATA_58: {value: OP_DATA_58, name: "OP_DATA_58", length: 59, opfunc: opcodePushData}, OP_DATA_59: {value: OP_DATA_59, name: "OP_DATA_59", length: 60, opfunc: opcodePushData}, OP_DATA_60: {value: OP_DATA_60, name: "OP_DATA_60", length: 61, opfunc: opcodePushData}, OP_DATA_61: {value: OP_DATA_61, name: "OP_DATA_61", length: 62, opfunc: opcodePushData}, OP_DATA_62: {value: OP_DATA_62, name: "OP_DATA_62", length: 63, opfunc: opcodePushData}, OP_DATA_63: {value: OP_DATA_63, name: "OP_DATA_63", length: 64, opfunc: opcodePushData}, OP_DATA_64: {value: OP_DATA_64, name: "OP_DATA_64", length: 65, opfunc: opcodePushData}, OP_DATA_65: {value: OP_DATA_65, name: "OP_DATA_65", length: 66, opfunc: opcodePushData}, OP_DATA_66: {value: OP_DATA_66, name: "OP_DATA_66", length: 67, opfunc: opcodePushData}, OP_DATA_67: {value: OP_DATA_67, name: "OP_DATA_67", length: 68, opfunc: opcodePushData}, OP_DATA_68: {value: OP_DATA_68, name: "OP_DATA_68", length: 69, opfunc: opcodePushData}, OP_DATA_69: {value: OP_DATA_69, name: "OP_DATA_69", length: 70, opfunc: opcodePushData}, OP_DATA_70: {value: OP_DATA_70, name: "OP_DATA_70", length: 71, opfunc: opcodePushData}, OP_DATA_71: {value: OP_DATA_71, name: "OP_DATA_71", length: 72, opfunc: opcodePushData}, OP_DATA_72: {value: OP_DATA_72, name: "OP_DATA_72", length: 73, opfunc: opcodePushData}, OP_DATA_73: {value: OP_DATA_73, name: "OP_DATA_73", length: 74, opfunc: opcodePushData}, OP_DATA_74: {value: OP_DATA_74, name: "OP_DATA_74", length: 75, opfunc: opcodePushData}, OP_DATA_75: {value: OP_DATA_75, name: "OP_DATA_75", length: 76, opfunc: opcodePushData}, OP_PUSHDATA1: {value: OP_PUSHDATA1, name: "OP_PUSHDATA1", length: -1, opfunc: opcodePushData}, OP_PUSHDATA2: {value: OP_PUSHDATA2, name: "OP_PUSHDATA2", length: -2, opfunc: opcodePushData}, OP_PUSHDATA4: {value: OP_PUSHDATA4, name: "OP_PUSHDATA4", length: -4, opfunc: opcodePushData}, OP_1NEGATE: {value: OP_1NEGATE, name: "OP_1NEGATE", length: 1, opfunc: opcode1Negate}, OP_RESERVED: {value: OP_RESERVED, name: "OP_RESERVED", length: 1, opfunc: opcodeReserved}, OP_TRUE: {value: OP_TRUE, name: "OP_1", length: 1, opfunc: opcodeN}, OP_2: {value: OP_2, name: "OP_2", length: 1, opfunc: opcodeN}, OP_3: {value: OP_3, name: "OP_3", length: 1, opfunc: opcodeN}, OP_4: {value: OP_4, name: "OP_4", length: 1, opfunc: opcodeN}, OP_5: {value: OP_5, name: "OP_5", length: 1, opfunc: opcodeN}, OP_6: {value: OP_6, name: "OP_6", length: 1, opfunc: opcodeN}, OP_7: {value: OP_7, name: "OP_7", length: 1, opfunc: opcodeN}, OP_8: {value: OP_8, name: "OP_8", length: 1, opfunc: opcodeN}, OP_9: {value: OP_9, name: "OP_9", length: 1, opfunc: opcodeN}, OP_10: {value: OP_10, name: "OP_10", length: 1, opfunc: opcodeN}, OP_11: {value: OP_11, name: "OP_11", length: 1, opfunc: opcodeN}, OP_12: {value: OP_12, name: "OP_12", length: 1, opfunc: opcodeN}, OP_13: {value: OP_13, name: "OP_13", length: 1, opfunc: opcodeN}, OP_14: {value: OP_14, name: "OP_14", length: 1, opfunc: opcodeN}, OP_15: {value: OP_15, name: "OP_15", length: 1, opfunc: opcodeN}, OP_16: {value: OP_16, name: "OP_16", length: 1, opfunc: opcodeN}, OP_NOP: {value: OP_NOP, name: "OP_NOP", length: 1, opfunc: opcodeNop}, OP_VER: {value: OP_VER, name: "OP_VER", length: 1, opfunc: opcodeReserved}, OP_IF: {value: OP_IF, name: "OP_IF", length: 1, opfunc: opcodeIf}, OP_NOTIF: {value: OP_NOTIF, name: "OP_NOTIF", length: 1, opfunc: opcodeNotIf}, OP_VERIF: {value: OP_VERIF, name: "OP_VERIF", length: 1, opfunc: opcodeReserved}, OP_VERNOTIF: {value: OP_VERNOTIF, name: "OP_VERNOTIF", length: 1, opfunc: opcodeReserved}, OP_ELSE: {value: OP_ELSE, name: "OP_ELSE", length: 1, opfunc: opcodeElse}, OP_ENDIF: {value: OP_ENDIF, name: "OP_ENDIF", length: 1, opfunc: opcodeEndif}, OP_VERIFY: {value: OP_VERIFY, name: "OP_VERIFY", length: 1, opfunc: opcodeVerify}, OP_RETURN: {value: OP_RETURN, name: "OP_RETURN", length: 1, opfunc: opcodeReturn}, OP_TOALTSTACK: {value: OP_TOALTSTACK, name: "OP_TOALTSTACK", length: 1, opfunc: opcodeToAltStack}, OP_FROMALTSTACK: {value: OP_FROMALTSTACK, name: "OP_FROMALTSTACK", length: 1, opfunc: opcodeFromAltStack}, OP_2DROP: {value: OP_2DROP, name: "OP_2DROP", length: 1, opfunc: opcode2Drop}, OP_2DUP: {value: OP_2DUP, name: "OP_2DUP", length: 1, opfunc: opcode2Dup}, OP_3DUP: {value: OP_3DUP, name: "OP_3DUP", length: 1, opfunc: opcode3Dup}, OP_2OVER: {value: OP_2OVER, name: "OP_2OVER", length: 1, opfunc: opcode2Over}, OP_2ROT: {value: OP_2ROT, name: "OP_2ROT", length: 1, opfunc: opcode2Rot}, OP_2SWAP: {value: OP_2SWAP, name: "OP_2SWAP", length: 1, opfunc: opcode2Swap}, OP_IFDUP: {value: OP_IFDUP, name: "OP_IFDUP", length: 1, opfunc: opcodeIfDup}, OP_DEPTH: {value: OP_DEPTH, name: "OP_DEPTH", length: 1, opfunc: opcodeDepth}, OP_DROP: {value: OP_DROP, name: "OP_DROP", length: 1, opfunc: opcodeDrop}, OP_DUP: {value: OP_DUP, name: "OP_DUP", length: 1, opfunc: opcodeDup}, OP_NIP: {value: OP_NIP, name: "OP_NIP", length: 1, opfunc: opcodeNip}, OP_OVER: {value: OP_OVER, name: "OP_OVER", length: 1, opfunc: opcodeOver}, OP_PICK: {value: OP_PICK, name: "OP_PICK", length: 1, opfunc: opcodePick}, OP_ROLL: {value: OP_ROLL, name: "OP_ROLL", length: 1, opfunc: opcodeRoll}, OP_ROT: {value: OP_ROT, name: "OP_ROT", length: 1, opfunc: opcodeRot}, OP_SWAP: {value: OP_SWAP, name: "OP_SWAP", length: 1, opfunc: opcodeSwap}, OP_TUCK: {value: OP_TUCK, name: "OP_TUCK", length: 1, opfunc: opcodeTuck}, OP_CAT: {value: OP_CAT, name: "OP_CAT", length: 1, opfunc: opcodeDisabled}, OP_SUBSTR: {value: OP_SUBSTR, name: "OP_SUBSTR", length: 1, opfunc: opcodeDisabled}, OP_LEFT: {value: OP_LEFT, name: "OP_LEFT", length: 1, opfunc: opcodeDisabled}, OP_RIGHT: {value: OP_RIGHT, name: "OP_RIGHT", length: 1, opfunc: opcodeDisabled}, OP_SIZE: {value: OP_SIZE, name: "OP_SIZE", length: 1, opfunc: opcodeSize}, OP_INVERT: {value: OP_INVERT, name: "OP_INVERT", length: 1, opfunc: opcodeDisabled}, OP_AND: {value: OP_AND, name: "OP_AND", length: 1, opfunc: opcodeDisabled}, OP_OR: {value: OP_OR, name: "OP_OR", length: 1, opfunc: opcodeDisabled}, OP_XOR: {value: OP_XOR, name: "OP_XOR", length: 1, opfunc: opcodeDisabled}, OP_EQUAL: {value: OP_EQUAL, name: "OP_EQUAL", length: 1, opfunc: opcodeEqual}, OP_EQUALVERIFY: {value: OP_EQUALVERIFY, name: "OP_EQUALVERIFY", length: 1, opfunc: opcodeEqualVerify}, OP_RESERVED1: {value: OP_RESERVED1, name: "OP_RESERVED1", length: 1, opfunc: opcodeReserved}, OP_RESERVED2: {value: OP_RESERVED2, name: "OP_RESERVED2", length: 1, opfunc: opcodeReserved}, OP_1ADD: {value: OP_1ADD, name: "OP_1ADD", length: 1, opfunc: opcode1Add}, OP_1SUB: {value: OP_1SUB, name: "OP_1SUB", length: 1, opfunc: opcode1Sub}, OP_2MUL: {value: OP_2MUL, name: "OP_2MUL", length: 1, opfunc: opcodeDisabled}, OP_2DIV: {value: OP_2DIV, name: "OP_2DIV", length: 1, opfunc: opcodeDisabled}, OP_NEGATE: {value: OP_NEGATE, name: "OP_NEGATE", length: 1, opfunc: opcodeNegate}, OP_ABS: {value: OP_ABS, name: "OP_ABS", length: 1, opfunc: opcodeAbs}, OP_NOT: {value: OP_NOT, name: "OP_NOT", length: 1, opfunc: opcodeNot}, OP_0NOTEQUAL: {value: OP_0NOTEQUAL, name: "OP_0NOTEQUAL", length: 1, opfunc: opcode0NotEqual}, OP_ADD: {value: OP_ADD, name: "OP_ADD", length: 1, opfunc: opcodeAdd}, OP_SUB: {value: OP_SUB, name: "OP_SUB", length: 1, opfunc: opcodeSub}, OP_MUL: {value: OP_MUL, name: "OP_MUL", length: 1, opfunc: opcodeDisabled}, OP_DIV: {value: OP_DIV, name: "OP_DIV", length: 1, opfunc: opcodeDisabled}, OP_MOD: {value: OP_MOD, name: "OP_MOD", length: 1, opfunc: opcodeDisabled}, OP_LSHIFT: {value: OP_LSHIFT, name: "OP_LSHIFT", length: 1, opfunc: opcodeDisabled}, OP_RSHIFT: {value: OP_RSHIFT, name: "OP_RSHIFT", length: 1, opfunc: opcodeDisabled}, OP_BOOLAND: {value: OP_BOOLAND, name: "OP_BOOLAND", length: 1, opfunc: opcodeBoolAnd}, OP_BOOLOR: {value: OP_BOOLOR, name: "OP_BOOLOR", length: 1, opfunc: opcodeBoolOr}, OP_NUMEQUAL: {value: OP_NUMEQUAL, name: "OP_NUMEQUAL", length: 1, opfunc: opcodeNumEqual}, OP_NUMEQUALVERIFY: {value: OP_NUMEQUALVERIFY, name: "OP_NUMEQUALVERIFY", length: 1, opfunc: opcodeNumEqualVerify}, OP_NUMNOTEQUAL: {value: OP_NUMNOTEQUAL, name: "OP_NUMNOTEQUAL", length: 1, opfunc: opcodeNumNotEqual}, OP_LESSTHAN: {value: OP_LESSTHAN, name: "OP_LESSTHAN", length: 1, opfunc: opcodeLessThan}, OP_GREATERTHAN: {value: OP_GREATERTHAN, name: "OP_GREATERTHAN", length: 1, opfunc: opcodeGreaterThan}, OP_LESSTHANOREQUAL: {value: OP_LESSTHANOREQUAL, name: "OP_LESSTHANOREQUAL", length: 1, opfunc: opcodeLessThanOrEqual}, OP_GREATERTHANOREQUAL: {value: OP_GREATERTHANOREQUAL, name: "OP_GREATERTHANOREQUAL", length: 1, opfunc: opcodeGreaterThanOrEqual}, OP_MIN: {value: OP_MIN, name: "OP_MIN", length: 1, opfunc: opcodeMin}, OP_MAX: {value: OP_MAX, name: "OP_MAX", length: 1, opfunc: opcodeMax}, OP_WITHIN: {value: OP_WITHIN, name: "OP_WITHIN", length: 1, opfunc: opcodeWithin}, OP_RIPEMD160: {value: OP_RIPEMD160, name: "OP_RIPEMD160", length: 1, opfunc: opcodeRipemd160}, OP_SHA1: {value: OP_SHA1, name: "OP_SHA1", length: 1, opfunc: opcodeSha1}, OP_SHA256: {value: OP_SHA256, name: "OP_SHA256", length: 1, opfunc: opcodeSha256}, OP_HASH160: {value: OP_HASH160, name: "OP_HASH160", length: 1, opfunc: opcodeHash160}, OP_HASH256: {value: OP_HASH256, name: "OP_HASH256", length: 1, opfunc: opcodeHash256}, OP_CODESEPARATOR: {value: OP_CODESEPARATOR, name: "OP_CODESEPARATOR", length: 1, opfunc: opcodeCodeSeparator}, OP_CHECKSIG: {value: OP_CHECKSIG, name: "OP_CHECKSIG", length: 1, opfunc: opcodeCheckSig}, OP_CHECKSIGVERIFY: {value: OP_CHECKSIGVERIFY, name: "OP_CHECKSIGVERIFY", length: 1, opfunc: opcodeCheckSigVerify}, OP_CHECKMULTISIG: {value: OP_CHECKMULTISIG, name: "OP_CHECKMULTISIG", length: 1, opfunc: opcodeCheckMultiSig}, OP_CHECKMULTISIGVERIFY: {value: OP_CHECKMULTISIGVERIFY, name: "OP_CHECKMULTISIGVERIFY", length: 1, opfunc: opcodeCheckMultiSigVerify}, OP_NOP1: {value: OP_NOP1, name: "OP_NOP1", length: 1, opfunc: opcodeNop}, OP_NOP2: {value: OP_NOP2, name: "OP_NOP2", length: 1, opfunc: opcodeNop}, OP_NOP3: {value: OP_NOP3, name: "OP_NOP3", length: 1, opfunc: opcodeNop}, OP_NOP4: {value: OP_NOP4, name: "OP_NOP4", length: 1, opfunc: opcodeNop}, OP_NOP5: {value: OP_NOP5, name: "OP_NOP5", length: 1, opfunc: opcodeNop}, OP_NOP6: {value: OP_NOP6, name: "OP_NOP6", length: 1, opfunc: opcodeNop}, OP_NOP7: {value: OP_NOP7, name: "OP_NOP7", length: 1, opfunc: opcodeNop}, OP_NOP8: {value: OP_NOP8, name: "OP_NOP8", length: 1, opfunc: opcodeNop}, OP_NOP9: {value: OP_NOP9, name: "OP_NOP9", length: 1, opfunc: opcodeNop}, OP_NOP10: {value: OP_NOP10, name: "OP_NOP10", length: 1, opfunc: opcodeNop}, OP_UNKNOWN186: {value: OP_UNKNOWN186, name: "OP_UNKNOWN186", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN187: {value: OP_UNKNOWN187, name: "OP_UNKNOWN187", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN188: {value: OP_UNKNOWN188, name: "OP_UNKNOWN188", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN189: {value: OP_UNKNOWN189, name: "OP_UNKNOWN189", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN190: {value: OP_UNKNOWN190, name: "OP_UNKNOWN190", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN191: {value: OP_UNKNOWN191, name: "OP_UNKNOWN191", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN192: {value: OP_UNKNOWN192, name: "OP_UNKNOWN192", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN193: {value: OP_UNKNOWN193, name: "OP_UNKNOWN193", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN194: {value: OP_UNKNOWN194, name: "OP_UNKNOWN194", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN195: {value: OP_UNKNOWN195, name: "OP_UNKNOWN195", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN196: {value: OP_UNKNOWN196, name: "OP_UNKNOWN196", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN197: {value: OP_UNKNOWN197, name: "OP_UNKNOWN197", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN198: {value: OP_UNKNOWN198, name: "OP_UNKNOWN198", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN199: {value: OP_UNKNOWN199, name: "OP_UNKNOWN199", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN200: {value: OP_UNKNOWN200, name: "OP_UNKNOWN200", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN201: {value: OP_UNKNOWN201, name: "OP_UNKNOWN201", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN202: {value: OP_UNKNOWN202, name: "OP_UNKNOWN202", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN203: {value: OP_UNKNOWN203, name: "OP_UNKNOWN203", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN204: {value: OP_UNKNOWN204, name: "OP_UNKNOWN204", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN205: {value: OP_UNKNOWN205, name: "OP_UNKNOWN205", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN206: {value: OP_UNKNOWN206, name: "OP_UNKNOWN206", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN207: {value: OP_UNKNOWN207, name: "OP_UNKNOWN207", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN208: {value: OP_UNKNOWN208, name: "OP_UNKNOWN208", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN209: {value: OP_UNKNOWN209, name: "OP_UNKNOWN209", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN210: {value: OP_UNKNOWN210, name: "OP_UNKNOWN210", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN211: {value: OP_UNKNOWN211, name: "OP_UNKNOWN211", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN212: {value: OP_UNKNOWN212, name: "OP_UNKNOWN212", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN213: {value: OP_UNKNOWN213, name: "OP_UNKNOWN213", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN214: {value: OP_UNKNOWN214, name: "OP_UNKNOWN214", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN215: {value: OP_UNKNOWN215, name: "OP_UNKNOWN215", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN216: {value: OP_UNKNOWN216, name: "OP_UNKNOWN216", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN217: {value: OP_UNKNOWN217, name: "OP_UNKNOWN217", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN218: {value: OP_UNKNOWN218, name: "OP_UNKNOWN218", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN219: {value: OP_UNKNOWN219, name: "OP_UNKNOWN219", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN220: {value: OP_UNKNOWN220, name: "OP_UNKNOWN220", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN221: {value: OP_UNKNOWN221, name: "OP_UNKNOWN221", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN222: {value: OP_UNKNOWN222, name: "OP_UNKNOWN222", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN223: {value: OP_UNKNOWN223, name: "OP_UNKNOWN223", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN224: {value: OP_UNKNOWN224, name: "OP_UNKNOWN224", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN225: {value: OP_UNKNOWN225, name: "OP_UNKNOWN225", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN226: {value: OP_UNKNOWN226, name: "OP_UNKNOWN226", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN227: {value: OP_UNKNOWN227, name: "OP_UNKNOWN227", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN228: {value: OP_UNKNOWN228, name: "OP_UNKNOWN228", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN229: {value: OP_UNKNOWN229, name: "OP_UNKNOWN229", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN230: {value: OP_UNKNOWN230, name: "OP_UNKNOWN230", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN231: {value: OP_UNKNOWN231, name: "OP_UNKNOWN231", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN232: {value: OP_UNKNOWN232, name: "OP_UNKNOWN232", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN233: {value: OP_UNKNOWN233, name: "OP_UNKNOWN233", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN234: {value: OP_UNKNOWN234, name: "OP_UNKNOWN234", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN235: {value: OP_UNKNOWN235, name: "OP_UNKNOWN235", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN236: {value: OP_UNKNOWN236, name: "OP_UNKNOWN236", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN237: {value: OP_UNKNOWN237, name: "OP_UNKNOWN237", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN238: {value: OP_UNKNOWN238, name: "OP_UNKNOWN238", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN239: {value: OP_UNKNOWN239, name: "OP_UNKNOWN239", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN240: {value: OP_UNKNOWN240, name: "OP_UNKNOWN240", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN241: {value: OP_UNKNOWN241, name: "OP_UNKNOWN241", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN242: {value: OP_UNKNOWN242, name: "OP_UNKNOWN242", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN243: {value: OP_UNKNOWN243, name: "OP_UNKNOWN243", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN244: {value: OP_UNKNOWN244, name: "OP_UNKNOWN244", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN245: {value: OP_UNKNOWN245, name: "OP_UNKNOWN245", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN246: {value: OP_UNKNOWN246, name: "OP_UNKNOWN246", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN247: {value: OP_UNKNOWN247, name: "OP_UNKNOWN247", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN248: {value: OP_UNKNOWN248, name: "OP_UNKNOWN248", length: 1, opfunc: opcodeInvalid}, OP_SMALLDATA: {value: OP_SMALLDATA, name: "OP_SMALLDATA", length: 1, opfunc: opcodeInvalid}, OP_SMALLINTEGER: {value: OP_SMALLINTEGER, name: "OP_SMALLINTEGER", length: 1, opfunc: opcodeInvalid}, OP_PUBKEYS: {value: OP_PUBKEYS, name: "OP_PUBKEYS", length: 1, opfunc: opcodeInvalid}, OP_UNKNOWN252: {value: OP_UNKNOWN252, name: "OP_UNKNOWN252", length: 1, opfunc: opcodeInvalid}, OP_PUBKEYHASH: {value: OP_PUBKEYHASH, name: "OP_PUBKEYHASH", length: 1, opfunc: opcodeInvalid}, OP_PUBKEY: {value: OP_PUBKEY, name: "OP_PUBKEY", length: 1, opfunc: opcodeInvalid}, OP_INVALIDOPCODE: {value: OP_INVALIDOPCODE, name: "OP_INVALIDOPCODE", length: 1, opfunc: opcodeInvalid}, } // opcodeOnelineRepls defines opcode names which are replaced when doing a // one-line disassembly. This is done to match the output of the reference // implementation while not changing the opcode names in the nicer full // disassembly. var opcodeOnelineRepls = map[string]string{ "OP_1NEGATE": "-1", "OP_0": "0", "OP_1": "1", "OP_2": "2", "OP_3": "3", "OP_4": "4", "OP_5": "5", "OP_6": "6", "OP_7": "7", "OP_8": "8", "OP_9": "9", "OP_10": "10", "OP_11": "11", "OP_12": "12", "OP_13": "13", "OP_14": "14", "OP_15": "15", "OP_16": "16", } type parsedOpcode struct { opcode *opcode data []byte } // The following opcodes are disabled and are thus always bad to see in the // instruction stream (even if turned off by a conditional). func (pop *parsedOpcode) disabled() bool { switch pop.opcode.value { case OP_CAT: return true case OP_SUBSTR: return true case OP_LEFT: return true case OP_RIGHT: return true case OP_INVERT: return true case OP_AND: return true case OP_OR: return true case OP_XOR: return true case OP_2MUL: return true case OP_2DIV: return true case OP_MUL: return true case OP_DIV: return true case OP_MOD: return true case OP_LSHIFT: return true case OP_RSHIFT: return true default: return false } } // The following opcodes are always illegal when passed over by the program // counter even if in a non-executed branch. (it isn't a coincidence that they // are conditionals). func (pop *parsedOpcode) alwaysIllegal() bool { switch pop.opcode.value { case OP_VERIF: return true case OP_VERNOTIF: return true default: return false } } // The following opcode are conditional and thus change the conditional // execution stack state when passed. func (pop *parsedOpcode) conditional() bool { switch pop.opcode.value { case OP_IF: return true case OP_NOTIF: return true case OP_ELSE: return true case OP_ENDIF: return true default: return false } } // checkMinimalDataPush returns whether or not the current data // push uses the correct opcode. func (pop *parsedOpcode) checkMinimalDataPush() error { data := pop.data dataLen := len(data) opcode := pop.opcode.value if dataLen == 0 && opcode != OP_0 { return ErrStackMinimalData } else if dataLen == 1 && data[0] >= 1 && data[0] <= 16 { if opcode != OP_1+data[0]-1 { // Should have used OP_1 .. OP_16 return ErrStackMinimalData } } else if dataLen == 1 && data[0] == 0x81 { if opcode != OP_1NEGATE { return ErrStackMinimalData } } else if dataLen <= 75 { if int(opcode) != dataLen { // Should have used a direct push return ErrStackMinimalData } } else if dataLen <= 255 { if opcode != OP_PUSHDATA1 { return ErrStackMinimalData } } else if dataLen <= 65535 { if opcode != OP_PUSHDATA2 { return ErrStackMinimalData } } return nil } // exec peforms execution on the opcode. It takes into account whether or not // it is hidden by conditionals, but some rules still must be tested in this // case. func (pop *parsedOpcode) exec(vm *Engine) error { // Disabled opcodes are ``fail on program counter''. if pop.disabled() { return ErrStackOpDisabled } // Always-illegal opcodes are ``fail on program counter''. if pop.alwaysIllegal() { return ErrStackReservedOpcode } // Note that this includes OP_RESERVED which counts as a push operation. if pop.opcode.value > OP_16 { vm.numOps++ if vm.numOps > MaxOpsPerScript { return ErrStackTooManyOperations } } else if len(pop.data) > MaxScriptElementSize { return ErrStackElementTooBig } // If we are not a conditional opcode and we aren't executing, then // we are done now. if vm.condStack[0] != OpCondTrue && !pop.conditional() { return nil } // Ensure all executed data push opcodes use the minimal encoding when // the minimal data verification is set. if vm.dstack.verifyMinimalData && vm.condStack[0] == OpCondTrue && pop.opcode.value >= 0 && pop.opcode.value <= OP_PUSHDATA4 { if err := pop.checkMinimalDataPush(); err != nil { return err } } return pop.opcode.opfunc(pop, vm) } func (pop *parsedOpcode) print(oneline bool) string { // The reference implementation one-line disassembly replaces opcodes // which represent values (e.g. OP_0 through OP_16 and OP_1NEGATE) // with the raw value. However, when not doing a one-line dissassembly, // we prefer to show the actual opcode names. Thus, only replace the // opcodes in question when the oneline flag is set. opcodeName := pop.opcode.name if oneline { if replName, ok := opcodeOnelineRepls[opcodeName]; ok { opcodeName = replName } } retString := opcodeName if pop.opcode.length == 1 { return retString } if oneline { retString = "" } if !oneline && pop.opcode.length < 0 { //add length to the end of retString retString += fmt.Sprintf(" 0x%0*x", 2*-pop.opcode.length, len(pop.data)) } for _, val := range pop.data { if !oneline { retString += " " } retString += fmt.Sprintf("%02x", val) } return retString } func (pop *parsedOpcode) bytes() ([]byte, error) { var retbytes []byte if pop.opcode.length > 0 { retbytes = make([]byte, 1, pop.opcode.length) } else { retbytes = make([]byte, 1, 1+len(pop.data)- pop.opcode.length) } retbytes[0] = pop.opcode.value if pop.opcode.length == 1 { if len(pop.data) != 0 { return nil, ErrStackInvalidOpcode } return retbytes, nil } nbytes := pop.opcode.length if pop.opcode.length < 0 { l := len(pop.data) // tempting just to hardcode to avoid the complexity here. switch pop.opcode.length { case -1: retbytes = append(retbytes, byte(l)) nbytes = int(retbytes[1]) + len(retbytes) case -2: retbytes = append(retbytes, byte(l&0xff), byte(l>>8&0xff)) nbytes = int(binary.LittleEndian.Uint16(retbytes[1:])) + len(retbytes) case -4: retbytes = append(retbytes, byte(l&0xff), byte((l>>8)&0xff), byte((l>>16)&0xff), byte((l>>24)&0xff)) nbytes = int(binary.LittleEndian.Uint32(retbytes[1:])) + len(retbytes) } } retbytes = append(retbytes, pop.data...) if len(retbytes) != nbytes { return nil, ErrStackInvalidOpcode } return retbytes, nil } // opcode implementation functions from here func opcodeDisabled(op *parsedOpcode, vm *Engine) error { return ErrStackOpDisabled } func opcodeReserved(op *parsedOpcode, vm *Engine) error { return ErrStackReservedOpcode } // Recognised opcode, but for bitcoind internal use only. func opcodeInvalid(op *parsedOpcode, vm *Engine) error { return ErrStackInvalidOpcode } func opcodeFalse(op *parsedOpcode, vm *Engine) error { vm.dstack.PushByteArray([]byte("")) return nil } func opcodePushData(op *parsedOpcode, vm *Engine) error { vm.dstack.PushByteArray(op.data) return nil } func opcode1Negate(op *parsedOpcode, vm *Engine) error { vm.dstack.PushInt(big.NewInt(-1)) return nil } func opcodeN(op *parsedOpcode, vm *Engine) error { // 16 consecutive opcodes add increasing numbers to the stack. vm.dstack.PushInt(big.NewInt(int64(op.opcode.value - (OP_1 - 1)))) return nil } func opcodeNop(op *parsedOpcode, vm *Engine) error { switch op.opcode.value { case OP_NOP1, OP_NOP2, OP_NOP3, OP_NOP4, OP_NOP5, OP_NOP6, OP_NOP7, OP_NOP8, OP_NOP9, OP_NOP10: if vm.hasFlag(ScriptDiscourageUpgradableNops) { return fmt.Errorf("%s reserved for soft-fork upgrades", opcodemap[op.opcode.value].name) } } return nil } // opcodeIf computes true/false based on the value on the stack and pushes // the condition on the condStack (conditional execution stack) func opcodeIf(op *parsedOpcode, vm *Engine) error { // opcodeIf will be executed even if it is on the non-execute side // of the conditional, this is so proper nesting is maintained var condval int if vm.condStack[0] == OpCondTrue { ok, err := vm.dstack.PopBool() if err != nil { return err } if ok { condval = OpCondTrue } } else { condval = OpCondSkip } cond := []int{condval} // push condition to the 'head' of the slice vm.condStack = append(cond, vm.condStack...) // TODO(drahn) check if a maximum condtitional stack limit exists return nil } // opcodeNotIf computes true/false based on the value on the stack and pushes // the (inverted) condition on the condStack (conditional execution stack) func opcodeNotIf(op *parsedOpcode, vm *Engine) error { // opcodeIf will be executed even if it is on the non-execute side // of the conditional, this is so proper nesting is maintained var condval int if vm.condStack[0] == OpCondTrue { ok, err := vm.dstack.PopBool() if err != nil { return err } if !ok { condval = OpCondTrue } } else { condval = OpCondSkip } cond := []int{condval} // push condition to the 'head' of the slice vm.condStack = append(cond, vm.condStack...) // TODO(drahn) check if a maximum condtitional stack limit exists return nil } // opcodeElse inverts conditional execution for other half of if/else/endif func opcodeElse(op *parsedOpcode, vm *Engine) error { if len(vm.condStack) < 2 { // intial true cannot be toggled, only pushed conditionals return ErrStackNoIf } switch vm.condStack[0] { case OpCondTrue: vm.condStack[0] = OpCondFalse case OpCondFalse: vm.condStack[0] = OpCondTrue case OpCondSkip: // value doesn't change in skip } return nil } // opcodeEndif terminates a conditional block, removing the value from the // conditional execution stack. func opcodeEndif(op *parsedOpcode, vm *Engine) error { if len(vm.condStack) < 2 { // intial true cannot be popped, only pushed conditionals return ErrStackNoIf } stk := make([]int, len(vm.condStack)-1, len(vm.condStack)-1) copy(stk, vm.condStack[1:]) vm.condStack = stk return nil } func opcodeVerify(op *parsedOpcode, vm *Engine) error { verified, err := vm.dstack.PopBool() if err != nil { return err } if verified != true { return ErrStackVerifyFailed } return nil } func opcodeReturn(op *parsedOpcode, vm *Engine) error { return ErrStackEarlyReturn } func opcodeToAltStack(op *parsedOpcode, vm *Engine) error { so, err := vm.dstack.PopByteArray() if err != nil { return err } vm.astack.PushByteArray(so) return nil } func opcodeFromAltStack(op *parsedOpcode, vm *Engine) error { so, err := vm.astack.PopByteArray() if err != nil { return err } vm.dstack.PushByteArray(so) return nil } func opcode2Drop(op *parsedOpcode, vm *Engine) error { return vm.dstack.DropN(2) } func opcode2Dup(op *parsedOpcode, vm *Engine) error { return vm.dstack.DupN(2) } func opcode3Dup(op *parsedOpcode, vm *Engine) error { return vm.dstack.DupN(3) } func opcode2Over(op *parsedOpcode, vm *Engine) error { return vm.dstack.OverN(2) } func opcode2Rot(op *parsedOpcode, vm *Engine) error { return vm.dstack.RotN(2) } func opcode2Swap(op *parsedOpcode, vm *Engine) error { return vm.dstack.SwapN(2) } func opcodeIfDup(op *parsedOpcode, vm *Engine) error { val, err := vm.dstack.PeekInt(0) if err != nil { return err } // Push copy of data iff it isn't zero if val.Sign() != 0 { vm.dstack.PushInt(val) } return nil } func opcodeDepth(op *parsedOpcode, vm *Engine) error { vm.dstack.PushInt(big.NewInt(int64(vm.dstack.Depth()))) return nil } func opcodeDrop(op *parsedOpcode, vm *Engine) error { return vm.dstack.DropN(1) } func opcodeDup(op *parsedOpcode, vm *Engine) error { return vm.dstack.DupN(1) } func opcodeNip(op *parsedOpcode, vm *Engine) error { return vm.dstack.NipN(1) } func opcodeOver(op *parsedOpcode, vm *Engine) error { return vm.dstack.OverN(1) } // Copy object N items back in the stack to the top. Where N is the value in // the top of the stack. func opcodePick(op *parsedOpcode, vm *Engine) error { pidx, err := vm.dstack.PopInt() if err != nil { return err } // PopInt promises that the int returned is 32 bit. val := int(pidx.Int64()) return vm.dstack.PickN(val) } // Move object N items back in the stack to the top. Where N is the value in // the top of the stack. func opcodeRoll(op *parsedOpcode, vm *Engine) error { ridx, err := vm.dstack.PopInt() if err != nil { return err } // PopInt promises that the int returned is 32 bit. val := int(ridx.Int64()) return vm.dstack.RollN(val) } // Rotate top three items on the stack to the left. // e.g. 1,2,3 -> 2,3,1 func opcodeRot(op *parsedOpcode, vm *Engine) error { return vm.dstack.RotN(1) } // Swap the top two items on the stack: 1,2 -> 2,1 func opcodeSwap(op *parsedOpcode, vm *Engine) error { return vm.dstack.SwapN(1) } // The item at the top of the stack is copied and inserted before the // second-to-top item. e.g.: 2,1, -> 2,1,2 func opcodeTuck(op *parsedOpcode, vm *Engine) error { return vm.dstack.Tuck() } // Push the size of the item on top of the stack onto the stack. func opcodeSize(op *parsedOpcode, vm *Engine) error { i, err := vm.dstack.PeekByteArray(0) if err != nil { return err } vm.dstack.PushInt(big.NewInt(int64(len(i)))) return nil } func opcodeEqual(op *parsedOpcode, vm *Engine) error { a, err := vm.dstack.PopByteArray() if err != nil { return err } b, err := vm.dstack.PopByteArray() if err != nil { return err } vm.dstack.PushBool(bytes.Equal(a, b)) return nil } func opcodeEqualVerify(op *parsedOpcode, vm *Engine) error { err := opcodeEqual(op, vm) if err == nil { err = opcodeVerify(op, vm) } return err } func opcode1Add(op *parsedOpcode, vm *Engine) error { m, err := vm.dstack.PopInt() if err != nil { return err } vm.dstack.PushInt(new(big.Int).Add(m, big.NewInt(1))) return nil } func opcode1Sub(op *parsedOpcode, vm *Engine) error { m, err := vm.dstack.PopInt() if err != nil { return err } vm.dstack.PushInt(new(big.Int).Sub(m, big.NewInt(1))) return nil } func opcodeNegate(op *parsedOpcode, vm *Engine) error { // XXX when we remove types just flip the 0x80 bit of msb m, err := vm.dstack.PopInt() if err != nil { return err } vm.dstack.PushInt(new(big.Int).Neg(m)) return nil } func opcodeAbs(op *parsedOpcode, vm *Engine) error { // XXX when we remove types just &= ~0x80 on msb m, err := vm.dstack.PopInt() if err != nil { return err } vm.dstack.PushInt(new(big.Int).Abs(m)) return nil } // If then input is 0 or 1, it is flipped. Otherwise the output will be 0. // (n.b. official client just has 1 is 0, else 0) func opcodeNot(op *parsedOpcode, vm *Engine) error { m, err := vm.dstack.PopInt() if err != nil { return err } if m.Sign() == 0 { vm.dstack.PushInt(big.NewInt(1)) } else { vm.dstack.PushInt(big.NewInt(0)) } return nil } // opcode returns 0 if the input is 0, 1 otherwise. func opcode0NotEqual(op *parsedOpcode, vm *Engine) error { m, err := vm.dstack.PopInt() if err != nil { return err } if m.Sign() != 0 { m.SetInt64(1) } vm.dstack.PushInt(m) return nil } // Push result of adding top two entries on stack func opcodeAdd(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } vm.dstack.PushInt(new(big.Int).Add(v0, v1)) return nil } // Push result of subtracting 2nd entry on stack from first. func opcodeSub(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } vm.dstack.PushInt(new(big.Int).Sub(v1, v0)) return nil } // If both of the top two entries on the stack are not zero output is 1. // Otherwise, 0. func opcodeBoolAnd(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } if v0.Sign() != 0 && v1.Sign() != 0 { vm.dstack.PushInt(big.NewInt(1)) } else { vm.dstack.PushInt(big.NewInt(0)) } return nil } // If either of the top two entries on the stack are not zero output is 1. // Otherwise, 0. func opcodeBoolOr(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } if v0.Sign() != 0 || v1.Sign() != 0 { vm.dstack.PushInt(big.NewInt(1)) } else { vm.dstack.PushInt(big.NewInt(0)) } return nil } func opcodeNumEqual(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } if v0.Cmp(v1) == 0 { vm.dstack.PushInt(big.NewInt(1)) } else { vm.dstack.PushInt(big.NewInt(0)) } return nil } func opcodeNumEqualVerify(op *parsedOpcode, vm *Engine) error { err := opcodeNumEqual(op, vm) if err == nil { err = opcodeVerify(op, vm) } return err } func opcodeNumNotEqual(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } if v0.Cmp(v1) != 0 { vm.dstack.PushInt(big.NewInt(1)) } else { vm.dstack.PushInt(big.NewInt(0)) } return nil } func opcodeLessThan(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } if v1.Cmp(v0) == -1 { vm.dstack.PushInt(big.NewInt(1)) } else { vm.dstack.PushInt(big.NewInt(0)) } return nil } func opcodeGreaterThan(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } if v1.Cmp(v0) == 1 { vm.dstack.PushInt(big.NewInt(1)) } else { vm.dstack.PushInt(big.NewInt(0)) } return nil } func opcodeLessThanOrEqual(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } if v1.Cmp(v0) <= 0 { vm.dstack.PushInt(big.NewInt(1)) } else { vm.dstack.PushInt(big.NewInt(0)) } return nil } func opcodeGreaterThanOrEqual(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } if v1.Cmp(v0) >= 0 { vm.dstack.PushInt(big.NewInt(1)) } else { vm.dstack.PushInt(big.NewInt(0)) } return nil } func opcodeMin(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } if v1.Cmp(v0) == -1 { vm.dstack.PushInt(new(big.Int).Set(v1)) } else { vm.dstack.PushInt(new(big.Int).Set(v0)) } return nil } func opcodeMax(op *parsedOpcode, vm *Engine) error { v0, err := vm.dstack.PopInt() if err != nil { return err } v1, err := vm.dstack.PopInt() if err != nil { return err } if v1.Cmp(v0) == 1 { vm.dstack.PushInt(new(big.Int).Set(v1)) } else { vm.dstack.PushInt(new(big.Int).Set(v0)) } return nil } // stack input: x, min, max. Returns 1 if x is within specified range // (left inclusive), 0 otherwise func opcodeWithin(op *parsedOpcode, vm *Engine) error { maxVal, err := vm.dstack.PopInt() if err != nil { return err } minVal, err := vm.dstack.PopInt() if err != nil { return err } x, err := vm.dstack.PopInt() if err != nil { return err } if x.Cmp(minVal) >= 0 && x.Cmp(maxVal) == -1 { vm.dstack.PushInt(big.NewInt(1)) } else { vm.dstack.PushInt(big.NewInt(0)) } return nil } // Calculate the hash of hasher over buf. func calcHash(buf []byte, hasher hash.Hash) []byte { hasher.Write(buf) return hasher.Sum(nil) } // calculate hash160 which is ripemd160(sha256(data)) func calcHash160(buf []byte) []byte { return calcHash(calcHash(buf, fastsha256.New()), ripemd160.New()) } func opcodeRipemd160(op *parsedOpcode, vm *Engine) error { buf, err := vm.dstack.PopByteArray() if err != nil { return err } vm.dstack.PushByteArray(calcHash(buf, ripemd160.New())) return nil } func opcodeSha1(op *parsedOpcode, vm *Engine) error { buf, err := vm.dstack.PopByteArray() if err != nil { return err } vm.dstack.PushByteArray(calcHash(buf, sha1.New())) return nil } func opcodeSha256(op *parsedOpcode, vm *Engine) error { buf, err := vm.dstack.PopByteArray() if err != nil { return err } vm.dstack.PushByteArray(calcHash(buf, fastsha256.New())) return nil } func opcodeHash160(op *parsedOpcode, vm *Engine) error { buf, err := vm.dstack.PopByteArray() if err != nil { return err } vm.dstack.PushByteArray(calcHash160(buf)) return nil } func opcodeHash256(op *parsedOpcode, vm *Engine) error { buf, err := vm.dstack.PopByteArray() if err != nil { return err } vm.dstack.PushByteArray(wire.DoubleSha256(buf)) return nil } func opcodeCodeSeparator(op *parsedOpcode, vm *Engine) error { vm.lastcodesep = vm.scriptOff return nil } func opcodeCheckSig(op *parsedOpcode, vm *Engine) error { pkStr, err := vm.dstack.PopByteArray() if err != nil { return err } sigStr, err := vm.dstack.PopByteArray() if err != nil { return err } // Signature actually needs needs to be longer than this, but we need // at least 1 byte for the below. btcec will check full length upon // parsing the signature. if len(sigStr) < 1 { vm.dstack.PushBool(false) return nil } // Trim off hashtype from the signature string. hashType := SigHashType(sigStr[len(sigStr)-1]) sigStr = sigStr[:len(sigStr)-1] if err := vm.checkHashTypeEncoding(hashType); err != nil { return err } if err := vm.checkSignatureEncoding(sigStr); err != nil { return err } if err := vm.checkPubKeyEncoding(pkStr); err != nil { return err } // Get script from the last OP_CODESEPARATOR and without any subsequent // OP_CODESEPARATORs subScript := vm.subScript() // Unlikely to hit any cases here, but remove the signature from // the script if present. subScript = removeOpcodeByData(subScript, sigStr) hash := calcScriptHash(subScript, hashType, &vm.tx, vm.txIdx) pubKey, err := btcec.ParsePubKey(pkStr, btcec.S256()) if err != nil { vm.dstack.PushBool(false) return nil } var signature *btcec.Signature if vm.hasFlag(ScriptVerifyStrictEncoding) || vm.hasFlag(ScriptVerifyDERSignatures) { signature, err = btcec.ParseDERSignature(sigStr, btcec.S256()) } else { signature, err = btcec.ParseSignature(sigStr, btcec.S256()) } if err != nil { vm.dstack.PushBool(false) return nil } log.Tracef("%v", newLogClosure(func() string { return fmt.Sprintf("op_checksig\n"+ "pubKey:\n%v"+ "pubKey.X: %v\n"+ "pubKey.Y: %v\n"+ "signature.R: %v\n"+ "signature.S: %v\n"+ "checkScriptHash:\n%v", hex.Dump(pkStr), pubKey.X, pubKey.Y, signature.R, signature.S, hex.Dump(hash)) })) ok := signature.Verify(hash, pubKey) vm.dstack.PushBool(ok) return nil } func opcodeCheckSigVerify(op *parsedOpcode, vm *Engine) error { err := opcodeCheckSig(op, vm) if err == nil { err = opcodeVerify(op, vm) } return err } // parsedSigInfo houses a raw signature along with its parsed form and a flag // for whether or not it has already been parsed. It is used to prevent parsing // the same signature multiple times when verify a multisig. type parsedSigInfo struct { signature []byte parsedSignature *btcec.Signature parsed bool } // stack; sigs pubkeys func opcodeCheckMultiSig(op *parsedOpcode, vm *Engine) error { numKeys, err := vm.dstack.PopInt() if err != nil { return err } // PopInt promises that the int returned is 32 bit. numPubKeys := int(numKeys.Int64()) if numPubKeys < 0 || numPubKeys > MaxPubKeysPerMultiSig { return ErrStackTooManyPubkeys } vm.numOps += numPubKeys if vm.numOps > MaxOpsPerScript { return ErrStackTooManyOperations } pubKeys := make([][]byte, 0, numPubKeys) for i := 0; i < numPubKeys; i++ { pubKey, err := vm.dstack.PopByteArray() if err != nil { return err } pubKeys = append(pubKeys, pubKey) } numSigs, err := vm.dstack.PopInt() if err != nil { return err } // PopInt promises that the int returned is 32 bit. numSignatures := int(numSigs.Int64()) if numSignatures < 0 { return fmt.Errorf("number of signatures '%d' is less than 0", numSignatures) } if numSignatures > numPubKeys { return fmt.Errorf("more signatures than pubkeys: %d > %d", numSignatures, numPubKeys) } signatures := make([]*parsedSigInfo, 0, numSignatures) for i := 0; i < numSignatures; i++ { signature, err := vm.dstack.PopByteArray() if err != nil { return err } sigInfo := &parsedSigInfo{signature: signature} signatures = append(signatures, sigInfo) } // bug in bitcoind means we pop one more stack value than should be // used. dummy, err := vm.dstack.PopByteArray() if err != nil { return err } if vm.hasFlag(ScriptStrictMultiSig) && len(dummy) != 0 { return fmt.Errorf("multisig dummy argument is not zero length: %d", len(dummy)) } // Trim OP_CODESEPARATORs script := vm.subScript() // Remove any of the signatures that happen to be in the script. // can't sign somthing containing the signature you're making, after // all for _, sigInfo := range signatures { script = removeOpcodeByData(script, sigInfo.signature) } success := true numPubKeys++ pubKeyIdx := -1 signatureIdx := 0 for numSignatures > 0 { // When there are more signatures than public keys remaining, // there is no way to succeed since too many signatures are // invalid, so exit early. pubKeyIdx++ numPubKeys-- if numSignatures > numPubKeys { success = false break } sigInfo := signatures[signatureIdx] pubKey := pubKeys[pubKeyIdx] // The order of the signature and public key evaluation is // important here since it can be distinguished by an // OP_CHECKMULTISIG NOT when the strict encoding flag is set. rawSig := sigInfo.signature if len(rawSig) == 0 { // Skip to the next pubkey if signature is empty. continue } // Split the signature into hash type and signature components. hashType := SigHashType(rawSig[len(rawSig)-1]) signature := rawSig[:len(rawSig)-1] // Only parse and check the signature encoding once. var parsedSig *btcec.Signature if !sigInfo.parsed { if err := vm.checkHashTypeEncoding(hashType); err != nil { return err } if err := vm.checkSignatureEncoding(signature); err != nil { return err } // Parse the signature. var err error if vm.hasFlag(ScriptVerifyStrictEncoding) || vm.hasFlag(ScriptVerifyDERSignatures) { parsedSig, err = btcec.ParseDERSignature(signature, btcec.S256()) } else { parsedSig, err = btcec.ParseSignature(signature, btcec.S256()) } sigInfo.parsed = true if err != nil { continue } sigInfo.parsedSignature = parsedSig } else { // Skip to the next pubkey if the signature is invalid. if sigInfo.parsedSignature == nil { continue } // Use the already parsed signature. parsedSig = sigInfo.parsedSignature } if err := vm.checkPubKeyEncoding(pubKey); err != nil { return err } // Parse the pubkey. parsedPubKey, err := btcec.ParsePubKey(pubKey, btcec.S256()) if err != nil { continue } hash := calcScriptHash(script, hashType, &vm.tx, vm.txIdx) if parsedSig.Verify(hash, parsedPubKey) { // PubKey verified, move on to the next signature. signatureIdx++ numSignatures-- } } vm.dstack.PushBool(success) return nil } func opcodeCheckMultiSigVerify(op *parsedOpcode, vm *Engine) error { err := opcodeCheckMultiSig(op, vm) if err == nil { err = opcodeVerify(op, vm) } return err }