[BugFix] reading (NOT)IF ops

Coding-Enthusiast · Coding-Enthusiast · commit 08ce036b5880 · 2019-12-02T18:05:50.000+03:30
diff --git a/BitcoinTransactionTool/Backend/Blockchain/Scripts/Script.cs b/BitcoinTransactionTool/Backend/Blockchain/Scripts/Script.cs
@@ -239,13 +239,14 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s
                         IFOp ifop = new IFOp();
                         List<IOperation> ifOps = new List<IOperation>();
                         offset++;
-                        while (data[offset] != (byte)OP.EndIf && data[offset] != (byte)OP.ELSE && offset < endIndex)
+                        // (offset < endIndex) needs to be first to prevent OutOfRange exception
+                        while (offset < endIndex && data[offset] != (byte)OP.EndIf && data[offset] != (byte)OP.ELSE)
                         {
                             if (!TryRead(data, ifOps, ref offset, out error))
                             {
                                 return false;
                             }
-                            if (offset > endIndex)
+                            if (offset >= endIndex)// there must be at least 1 more item remaining that is equal to EndIf
                             {
                                 error = "Bad format.";
                                 return false;
@@ -256,18 +257,19 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s
                                 return false;
                             }
                         }
-                        if (data[offset] == (byte)OP.ELSE)
+                        // (offset < endIndex) needs to be checked again to prevent another OutOfRange exception
+                        if (offset < endIndex && data[offset] == (byte)OP.ELSE)
                         {
                             List<IOperation> elseOps = new List<IOperation>();
                             offset++;
-                            while (data[offset] != (byte)OP.EndIf && offset < endIndex)
+                            while (offset < endIndex && data[offset] != (byte)OP.EndIf)
                             {
                                 if (!TryRead(data, elseOps, ref offset, out error))
                                 {
                                     return false;
                                 }
                             }
-                            if (offset > endIndex)
+                            if (offset >= endIndex)
                             {
                                 error = "Bad format.";
                                 return false;
@@ -279,8 +281,8 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s
                             }
                             ifop.elseOps = elseOps.ToArray();
                         }
-
-                        if (data[offset] != (byte)OP.EndIf)
+                        // (offset < endIndex) needs to be checked again to prevent another OutOfRange exception
+                        if (offset >= endIndex || data[offset] != (byte)OP.EndIf)
                         {
                             error = "No OP_ENDIF was found.";//this may never happen!
                             return false;
@@ -295,35 +297,37 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s
                         NotIfOp notifOp = new NotIfOp();
                         List<IOperation> ifOps2 = new List<IOperation>();
                         offset++;
-                        while (data[offset] != (byte)OP.EndIf && data[offset] != (byte)OP.ELSE && offset < endIndex)
+                        // (offset < endIndex) needs to be first to prevent OutOfRange exception
+                        while (offset < endIndex && data[offset] != (byte)OP.EndIf && data[offset] != (byte)OP.ELSE)
                         {
                             if (!TryRead(data, ifOps2, ref offset, out error))
                             {
                                 return false;
                             }
-                            if (offset > endIndex)
+                            if (offset >= endIndex)// there must be at least 1 more item remaining that is equal to EndIf
                             {
                                 error = "Bad format.";
                                 return false;
                             }
                             if (ifOps2.Count == 0)
                             {
-                                error = "Empty OP_IF";
+                                error = "Empty OP_NotIf";
                                 return false;
                             }
                         }
+                        // (offset < endIndex) needs to be first to prevent OutOfRange exception
                         if (data[offset] == (byte)OP.ELSE)
                         {
                             List<IOperation> elseOps2 = new List<IOperation>();
                             offset++;
-                            while (data[offset] != (byte)OP.EndIf && offset < endIndex)
+                            while (offset < endIndex && data[offset] != (byte)OP.EndIf)
                             {
                                 if (!TryRead(data, elseOps2, ref offset, out error))
                                 {
                                     return false;
                                 }
                             }
-                            if (offset > endIndex)
+                            if (offset >= endIndex)
                             {
                                 error = "Bad format.";
                                 return false;
@@ -335,8 +339,8 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s
                             }
                             notifOp.elseOps = elseOps2.ToArray();
                         }
-
-                        if (data[offset] != (byte)OP.EndIf)
+                        // (offset < endIndex) needs to be checked again to prevent another OutOfRange exception
+                        if (offset >= endIndex || data[offset] != (byte)OP.EndIf)
                         {
                             error = "No OP_ENDIF was found.";//this may never happen!
                             return false;
@@ -346,6 +350,7 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s
 
                         opList.Add(notifOp);
                         break;
+
                     case OP.ELSE:
                         error = "OP_ELSE found without prior OP_IF or OP_NOTIF.";
                         return false;

Original file line number	Diff line number	Diff line change
`@@ -239,13 +239,14 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s`
`239`	`239`	`IFOp ifop = new IFOp();`
`240`	`240`	`List<IOperation> ifOps = new List<IOperation>();`
`241`	`241`	`offset++;`
`242`		`- while (data[offset] != (byte)OP.EndIf && data[offset] != (byte)OP.ELSE && offset < endIndex)`
	`242`	`+ // (offset < endIndex) needs to be first to prevent OutOfRange exception`
	`243`	`+ while (offset < endIndex && data[offset] != (byte)OP.EndIf && data[offset] != (byte)OP.ELSE)`
`243`	`244`	`{`
`244`	`245`	`if (!TryRead(data, ifOps, ref offset, out error))`
`245`	`246`	`{`
`246`	`247`	`return false;`
`247`	`248`	`}`
`248`		`- if (offset > endIndex)`
	`249`	`+ if (offset >= endIndex)// there must be at least 1 more item remaining that is equal to EndIf`
`249`	`250`	`{`
`250`	`251`	`error = "Bad format.";`
`251`	`252`	`return false;`
`@@ -256,18 +257,19 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s`
`256`	`257`	`return false;`
`257`	`258`	`}`
`258`	`259`	`}`
`259`		`- if (data[offset] == (byte)OP.ELSE)`
	`260`	`+ // (offset < endIndex) needs to be checked again to prevent another OutOfRange exception`
	`261`	`+ if (offset < endIndex && data[offset] == (byte)OP.ELSE)`
`260`	`262`	`{`
`261`	`263`	`List<IOperation> elseOps = new List<IOperation>();`
`262`	`264`	`offset++;`
`263`		`- while (data[offset] != (byte)OP.EndIf && offset < endIndex)`
	`265`	`+ while (offset < endIndex && data[offset] != (byte)OP.EndIf)`
`264`	`266`	`{`
`265`	`267`	`if (!TryRead(data, elseOps, ref offset, out error))`
`266`	`268`	`{`
`267`	`269`	`return false;`
`268`	`270`	`}`
`269`	`271`	`}`
`270`		`- if (offset > endIndex)`
	`272`	`+ if (offset >= endIndex)`
`271`	`273`	`{`
`272`	`274`	`error = "Bad format.";`
`273`	`275`	`return false;`
`@@ -279,8 +281,8 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s`
`279`	`281`	`}`
`280`	`282`	`ifop.elseOps = elseOps.ToArray();`
`281`	`283`	`}`
`282`		`-`
`283`		`- if (data[offset] != (byte)OP.EndIf)`
	`284`	`+ // (offset < endIndex) needs to be checked again to prevent another OutOfRange exception`
	`285`	`+ if (offset >= endIndex \|\| data[offset] != (byte)OP.EndIf)`
`284`	`286`	`{`
`285`	`287`	`error = "No OP_ENDIF was found.";//this may never happen!`
`286`	`288`	`return false;`
`@@ -295,35 +297,37 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s`
`295`	`297`	`NotIfOp notifOp = new NotIfOp();`
`296`	`298`	`List<IOperation> ifOps2 = new List<IOperation>();`
`297`	`299`	`offset++;`
`298`		`- while (data[offset] != (byte)OP.EndIf && data[offset] != (byte)OP.ELSE && offset < endIndex)`
	`300`	`+ // (offset < endIndex) needs to be first to prevent OutOfRange exception`
	`301`	`+ while (offset < endIndex && data[offset] != (byte)OP.EndIf && data[offset] != (byte)OP.ELSE)`
`299`	`302`	`{`
`300`	`303`	`if (!TryRead(data, ifOps2, ref offset, out error))`
`301`	`304`	`{`
`302`	`305`	`return false;`
`303`	`306`	`}`
`304`		`- if (offset > endIndex)`
	`307`	`+ if (offset >= endIndex)// there must be at least 1 more item remaining that is equal to EndIf`
`305`	`308`	`{`
`306`	`309`	`error = "Bad format.";`
`307`	`310`	`return false;`
`308`	`311`	`}`
`309`	`312`	`if (ifOps2.Count == 0)`
`310`	`313`	`{`
`311`		`- error = "Empty OP_IF";`
	`314`	`+ error = "Empty OP_NotIf";`
`312`	`315`	`return false;`
`313`	`316`	`}`
`314`	`317`	`}`
	`318`	`+ // (offset < endIndex) needs to be first to prevent OutOfRange exception`
`315`	`319`	`if (data[offset] == (byte)OP.ELSE)`
`316`	`320`	`{`
`317`	`321`	`List<IOperation> elseOps2 = new List<IOperation>();`
`318`	`322`	`offset++;`
`319`		`- while (data[offset] != (byte)OP.EndIf && offset < endIndex)`
	`323`	`+ while (offset < endIndex && data[offset] != (byte)OP.EndIf)`
`320`	`324`	`{`
`321`	`325`	`if (!TryRead(data, elseOps2, ref offset, out error))`
`322`	`326`	`{`
`323`	`327`	`return false;`
`324`	`328`	`}`
`325`	`329`	`}`
`326`		`- if (offset > endIndex)`
	`330`	`+ if (offset >= endIndex)`
`327`	`331`	`{`
`328`	`332`	`error = "Bad format.";`
`329`	`333`	`return false;`
`@@ -335,8 +339,8 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s`
`335`	`339`	`}`
`336`	`340`	`notifOp.elseOps = elseOps2.ToArray();`
`337`	`341`	`}`
`338`		`-`
`339`		`- if (data[offset] != (byte)OP.EndIf)`
	`342`	`+ // (offset < endIndex) needs to be checked again to prevent another OutOfRange exception`
	`343`	`+ if (offset >= endIndex \|\| data[offset] != (byte)OP.EndIf)`
`340`	`344`	`{`
`341`	`345`	`error = "No OP_ENDIF was found.";//this may never happen!`
`342`	`346`	`return false;`
`@@ -346,6 +350,7 @@ private bool TryRead(byte[] data, List<IOperation> opList, ref int offset, out s`
`346`	`350`
`347`	`351`	`opList.Add(notifOp);`
`348`	`352`	`break;`
	`353`	`+`
`349`	`354`	`case OP.ELSE:`
`350`	`355`	`error = "OP_ELSE found without prior OP_IF or OP_NOTIF.";`
`351`	`356`	`return false;`