Script header

neo.UnitTests/UT_ScriptFile.cs

@@ -0,0 +1,68 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Cryptography;
+using Neo.IO;
+using Neo.SmartContract;
+using System;
+
+namespace Neo.UnitTests
+{
+    [TestClass]
+    public class UT_ScriptFile
+    {
+        [TestMethod]
+        public void ParseTest()
+        {
+            var script = new ScriptFile()
+            {
+                Engine = ScriptFile.ScriptEngine.NeoVM,
+                Compiler = "".PadLeft(byte.MaxValue, ' '),
+                Version = new Version(1, 2, 3, 4),
+                Script = new byte[] { 0x01, 0x02, 0x03 }
+            };
+
+            script.ScriptHash = script.Script.ToScriptHash();
+
+            var data = script.ToArray();
+            script = ScriptFile.FromByteArray(data);
+
+            Assert.AreEqual(ScriptFile.ScriptEngine.NeoVM, script.Engine);
+            Assert.AreEqual("".PadLeft(byte.MaxValue, ' '), script.Compiler);
+            Assert.AreEqual(new Version(1, 2, 3, 4), script.Version);
+            Assert.AreEqual(script.Script.ToScriptHash(), script.ScriptHash);
+            CollectionAssert.AreEqual(new byte[] { 0x01, 0x02, 0x03 }, script.Script);
+        }
+
+        [TestMethod]
+        public void LimitTest()
+        {
+            var script = new ScriptFile()
+            {
+                Engine = ScriptFile.ScriptEngine.NeoVM,
+                Compiler = "".PadLeft(byte.MaxValue + 1, ' '),
+                Version = new Version(1, 2, 3, 4),
+                Script = new byte[1024 * 1024],
+                ScriptHash = new byte[1024 * 1024].ToScriptHash()
+            };
+
+            // Wrong compiler
+
+            var data = script.ToArray();
+            Assert.ThrowsException<FormatException>(() => ScriptFile.FromByteArray(data));
+
+            // Wrong script
+
+            script.Script = new byte[(1024 * 1024) + 1];
+            script.ScriptHash = script.Script.ToScriptHash();
+            data = script.ToArray();
+
+            Assert.ThrowsException<FormatException>(() => ScriptFile.FromByteArray(data));
+
+            // Wrong script hash
+
+            script.Script = new byte[1024 * 1024];
+            data = script.ToArray();
+
+            Assert.ThrowsException<FormatException>(() => ScriptFile.FromByteArray(data));
+        }
+    }
+}

neo/SmartContract/InteropService.NEO.cs

@@ -244,31 +244,29 @@ private static bool Account_IsStandard(ApplicationEngine engine)
         private static bool Contract_Create(ApplicationEngine engine)
         {
             byte[] script = engine.CurrentContext.EvaluationStack.Pop().GetByteArray();
-            if (script.Length > 1024 * 1024) return false;
+            var header = ScriptFile.FromByteArray(script);
 
             var manifest = engine.CurrentContext.EvaluationStack.Pop().GetString();
             if (manifest.Length > ContractManifest.MaxLength) return false;
 
-            UInt160 hash = script.ToScriptHash();
-            ContractState contract = engine.Snapshot.Contracts.TryGet(hash);
+            ContractState contract = engine.Snapshot.Contracts.TryGet(header.ScriptHash);
             if (contract != null) return false;
             contract = new ContractState
             {
-                Script = script,
+                Script = header.Script,
                 Manifest = ContractManifest.Parse(manifest)
             };
 
-            if (!contract.Manifest.IsValid(hash)) return false;
+            if (!contract.Manifest.IsValid(header.ScriptHash)) return false;
 
-            engine.Snapshot.Contracts.Add(hash, contract);
+            engine.Snapshot.Contracts.Add(header.ScriptHash, contract);
             engine.CurrentContext.EvaluationStack.Push(StackItem.FromInterface(contract));
             return true;
         }
 
         private static bool Contract_Update(ApplicationEngine engine)
         {
             byte[] script = engine.CurrentContext.EvaluationStack.Pop().GetByteArray();
-            if (script.Length > 1024 * 1024) return false;
             var manifest = engine.CurrentContext.EvaluationStack.Pop().GetString();
             if (manifest.Length > ContractManifest.MaxLength) return false;
 
@@ -277,23 +275,24 @@ private static bool Contract_Update(ApplicationEngine engine)
 
             if (script.Length > 0)
             {
-                UInt160 hash_new = script.ToScriptHash();
-                if (hash_new.Equals(engine.CurrentScriptHash)) return false;
-                if (engine.Snapshot.Contracts.TryGet(hash_new) != null) return false;
+                var header = ScriptFile.FromByteArray(script);
+
+                if (header.ScriptHash.Equals(engine.CurrentScriptHash)) return false;
+                if (engine.Snapshot.Contracts.TryGet(header.ScriptHash) != null) return false;
                 contract = new ContractState
                 {
-                    Script = script,
+                    Script = header.Script,
                     Manifest = contract.Manifest
                 };
-                contract.Manifest.Abi.Hash = hash_new;
-                engine.Snapshot.Contracts.Add(hash_new, contract);
+                contract.Manifest.Abi.Hash = header.ScriptHash;
+                engine.Snapshot.Contracts.Add(header.ScriptHash, contract);
                 if (contract.HasStorage)
                 {
                     foreach (var pair in engine.Snapshot.Storages.Find(engine.CurrentScriptHash.ToArray()).ToArray())
                     {
                         engine.Snapshot.Storages.Add(new StorageKey
                         {
-                            ScriptHash = hash_new,
+                            ScriptHash = header.ScriptHash,
                             Key = pair.Key.Key
                         }, new StorageItem
                         {

neo/SmartContract/ScriptFile.cs

@@ -0,0 +1,89 @@
+using Neo.IO;
+using System;
+using System.IO;
+
+namespace Neo.SmartContract
+{
+    public class ScriptFile : ISerializable
+    {
+        public enum ScriptEngine : int
+        {
+            NeoVM = 0x4E454F00 // NEO\0
+        }
+
+        /// <summary>
+        /// Engine
+        /// </summary>
+        public ScriptEngine Engine { get; set; }
+
+        /// <summary>
+        /// Compiler
+        /// </summary>
+        public string Compiler { get; set; }
+
+        /// <summary>
+        /// Version
+        /// </summary>
+        public Version Version { get; set; }
+
+        /// <summary>
+        /// Script
+        /// </summary>
+        public byte[] Script { get; set; }
+
+        /// <summary>
+        /// Script Hash
+        /// </summary>
+        public UInt160 ScriptHash { get; set; }
+
+        public int Size =>
+            sizeof(ScriptEngine) +      // Engine
+            Compiler.GetVarSize() +     // Compiler
+            (sizeof(int) * 4) +         // Version
+            Script.GetVarSize() +       // Script
+            ScriptHash.Size;            // ScriptHash (CRC)
+
+        /// <summary>
+        /// Read Script Header from a binary
+        /// </summary>
+        /// <param name="script">Script</param>
+        /// <returns>Return script header</returns>
+        public static ScriptFile FromByteArray(byte[] script)
+        {
+            using (var stream = new MemoryStream(script))
+            using (var reader = new BinaryReader(stream))
+            {
+                return reader.ReadSerializable<ScriptFile>();
+            }
+        }
+
+        public void Serialize(BinaryWriter writer)
+        {
+            writer.Write((int)Engine);
+            writer.WriteVarString(Compiler);
+
+            // Version
+            writer.Write(Version.Major);
+            writer.Write(Version.Minor);
+            writer.Write(Version.Build);
+            writer.Write(Version.Revision);
+
+            writer.WriteVarBytes(Script);
+            writer.Write(ScriptHash);
+        }
+
+        public void Deserialize(BinaryReader reader)
+        {
+            Engine = (ScriptEngine)reader.ReadInt32();
+            Compiler = reader.ReadVarString(byte.MaxValue);
+            Version = new Version(reader.ReadInt32(), reader.ReadInt32(), reader.ReadInt32(), reader.ReadInt32());
+            Script = reader.ReadVarBytes(1024 * 1024);
+            ScriptHash = reader.ReadSerializable<UInt160>();
+
+            if (Script.ToScriptHash() != ScriptHash)
+            {
+                throw new FormatException("CRC verification fail");
+            }
+        }
+    }
+}