security system

UnitystationLauncher.Tests/UnitystationLauncher.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net7.0</TargetFramework>
         <Nullable>enable</Nullable>
 
         <IsPublishable>false</IsPublishable>

UnitystationLauncher/ContentScanning/AssemblyTypeChecker.Config.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using ILVerify;
+using Newtonsoft.Json;
+using Pidgin;
+
+namespace UnitystationLauncher.ContentScanning;
+
+internal sealed partial class AssemblyTypeChecker
+{
+    private static string pathToconfig = @"Q:\Fast programmes\DevStationHub\allowed.json"; //TODO!!!
+
+    private static SandboxConfig LoadConfig()
+    {
+        using (StreamReader file = File.OpenText(pathToconfig))
+        {
+            JsonSerializer serializer = new JsonSerializer();
+            var data = (SandboxConfig) serializer.Deserialize(file, typeof(SandboxConfig));
+            foreach (var Namespace in data.Types)
+            {
+                foreach (var Class in Namespace.Value)
+                {
+                    ParseTypeConfig(Class.Value);
+                }
+            }
+
+            return data;
+        }
+    }
+
+    private static void ParseTypeConfig(TypeConfig cfg)
+    {
+        if (cfg.Methods != null)
+        {
+            var list = new List<WhitelistMethodDefine>();
+            foreach (var m in cfg.Methods)
+            {
+                try
+                {
+                    list.Add(MethodParser.ParseOrThrow(m));
+                }
+                catch (ParseException e)
+                {
+                    Console.WriteLine("oh no..");
+                    // sawmill.Error($"Parse exception for '{m}': {e}");
+                }
+            }
+
+            cfg.MethodsParsed = list.ToArray();
+        }
+        else
+        {
+            cfg.MethodsParsed = Array.Empty<WhitelistMethodDefine>();
+        }
+
+        if (cfg.Fields != null)
+        {
+            var list = new List<WhitelistFieldDefine>();
+            foreach (var f in cfg.Fields)
+            {
+                // try
+                // {
+                list.Add(FieldParser.ParseOrThrow(f));
+                // }
+                // catch (ParseException e)
+                // {
+                //     //sawmill.Error($"Parse exception for '{f}': {e}");
+                //     
+                // }
+            }
+
+            cfg.FieldsParsed = list.ToArray();
+        }
+        else
+        {
+            cfg.FieldsParsed = Array.Empty<WhitelistFieldDefine>();
+        }
+
+        if (cfg.NestedTypes != null)
+        {
+            foreach (var nested in cfg.NestedTypes.Values)
+            {
+                ParseTypeConfig(nested);
+            }
+        }
+    }
+}

UnitystationLauncher/ContentScanning/AssemblyTypeChecker.Dump.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
+using Internal.TypeSystem.Ecma;
+
+namespace UnitystationLauncher.ContentScanning;
+
+internal sealed partial class AssemblyTypeChecker
+{
+    public static IEnumerable<string> DumpMetaMembers(Type type)
+    {
+        var assemblyLoc = type.Assembly.Location;
+
+        // Load assembly with System.Reflection.Metadata.
+        using var fs = File.OpenRead(assemblyLoc);
+        using var peReader = new PEReader(fs);
+
+        var metaReader = peReader.GetMetadataReader();
+
+        // Find type definition in raw assembly metadata.
+        // Is there a better way to do this than iterating??
+        TypeDefinition typeDef = default;
+        var found = false;
+        foreach (var typeDefHandle in metaReader.TypeDefinitions)
+        {
+            var tempTypeDef = metaReader.GetTypeDefinition(typeDefHandle);
+            var name = metaReader.GetString(tempTypeDef.Name);
+            var @namespace = NilNullString(metaReader, tempTypeDef.Namespace);
+            if (name == type.Name && @namespace == type.Namespace)
+            {
+                typeDef = tempTypeDef;
+                found = true;
+                break;
+            }
+        }
+
+        if (!found)
+        {
+            throw new InvalidOperationException("Type didn't exist??");
+        }
+
+        // Dump the list.
+        var provider = new TypeProvider();
+
+        foreach (var fieldHandle in typeDef.GetFields())
+        {
+            var fieldDef = metaReader.GetFieldDefinition(fieldHandle);
+
+            if ((fieldDef.Attributes & FieldAttributes.FieldAccessMask) != FieldAttributes.Public)
+            {
+                continue;
+            }
+
+            var fieldName = metaReader.GetString(fieldDef.Name);
+            var fieldType = fieldDef.DecodeSignature(provider, 0);
+
+            yield return $"{fieldType.WhitelistToString()} {fieldName}";
+        }
+
+        foreach (var methodHandle in typeDef.GetMethods())
+        {
+            var methodDef = metaReader.GetMethodDefinition(methodHandle);
+
+            if (!methodDef.Attributes.IsPublic())
+            {
+                continue;
+            }
+
+            var methodName = metaReader.GetString(methodDef.Name);
+            var methodSig = methodDef.DecodeSignature(provider, 0);
+
+            var paramString = string.Join(", ", methodSig.ParameterTypes.Select(t => t.WhitelistToString()));
+            var genericCount = methodSig.GenericParameterCount;
+            var typeParamString = genericCount == 0
+                ? ""
+                : $"<{new string(',', genericCount - 1)}>";
+
+            yield return $"{methodSig.ReturnType.WhitelistToString()} {methodName}{typeParamString}({paramString})";
+        }
+    }
+}

UnitystationLauncher/ContentScanning/AssemblyTypeChecker.Parsing.cs

@@ -0,0 +1,177 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Globalization;
+using System.Linq;
+using System.Reflection.Metadata;
+using Pidgin;
+using static Pidgin.Parser;
+using static Pidgin.Parser<char>;
+
+namespace UnitystationLauncher.ContentScanning;
+
+internal sealed partial class AssemblyTypeChecker
+{
+    // Contains primary parsing code for method and field declarations in the sandbox whitelist.
+
+    private static readonly Parser<char, PrimitiveTypeCode> VoidTypeParser =
+        String("void").ThenReturn(PrimitiveTypeCode.Void);
+
+    private static readonly Parser<char, PrimitiveTypeCode> BooleanTypeParser =
+        String("bool").ThenReturn(PrimitiveTypeCode.Boolean);
+
+    private static readonly Parser<char, PrimitiveTypeCode> CharTypeParser =
+        String("char").ThenReturn(PrimitiveTypeCode.Char);
+
+    private static readonly Parser<char, PrimitiveTypeCode> SByteTypeParser =
+        String("sbyte").ThenReturn(PrimitiveTypeCode.SByte);
+
+    private static readonly Parser<char, PrimitiveTypeCode> ByteTypeParser =
+        String("byte").ThenReturn(PrimitiveTypeCode.Byte);
+
+    private static readonly Parser<char, PrimitiveTypeCode> Int16TypeParser =
+        String("short").ThenReturn(PrimitiveTypeCode.Int16);
+
+    private static readonly Parser<char, PrimitiveTypeCode> UInt16TypeParser =
+        String("ushort").ThenReturn(PrimitiveTypeCode.UInt32);
+
+    private static readonly Parser<char, PrimitiveTypeCode> Int32TypeParser =
+        String("int").ThenReturn(PrimitiveTypeCode.Int32);
+
+    private static readonly Parser<char, PrimitiveTypeCode> UInt32TypeParser =
+        String("uint").ThenReturn(PrimitiveTypeCode.UInt32);
+
+    private static readonly Parser<char, PrimitiveTypeCode> Int64TypeParser =
+        String("long").ThenReturn(PrimitiveTypeCode.Int64);
+
+    private static readonly Parser<char, PrimitiveTypeCode> UInt64TypeParser =
+        String("ulong").ThenReturn(PrimitiveTypeCode.UInt64);
+
+    private static readonly Parser<char, PrimitiveTypeCode> IntPtrTypeParser =
+        String("nint").ThenReturn(PrimitiveTypeCode.IntPtr);
+
+    private static readonly Parser<char, PrimitiveTypeCode> UIntPtrTypeParser =
+        String("nuint").ThenReturn(PrimitiveTypeCode.UIntPtr);
+
+    private static readonly Parser<char, PrimitiveTypeCode> SingleTypeParser =
+        String("float").ThenReturn(PrimitiveTypeCode.Single);
+
+    private static readonly Parser<char, PrimitiveTypeCode> DoubleTypeParser =
+        String("double").ThenReturn(PrimitiveTypeCode.Double);
+
+    private static readonly Parser<char, PrimitiveTypeCode> StringTypeParser =
+        String("string").ThenReturn(PrimitiveTypeCode.String);
+
+    private static readonly Parser<char, PrimitiveTypeCode> ObjectTypeParser =
+        String("object").ThenReturn(PrimitiveTypeCode.Object);
+
+    private static readonly Parser<char, PrimitiveTypeCode> TypedReferenceTypeParser =
+        String("typedref").ThenReturn(PrimitiveTypeCode.TypedReference);
+
+    private static readonly Parser<char, MType> PrimitiveTypeParser =
+        OneOf(
+                Try(VoidTypeParser),
+                Try(BooleanTypeParser),
+                Try(CharTypeParser),
+                Try(SByteTypeParser),
+                Try(ByteTypeParser),
+                Try(Int16TypeParser),
+                Try(UInt16TypeParser),
+                Try(Int32TypeParser),
+                Try(UInt32TypeParser),
+                Try(Int64TypeParser),
+                Try(UInt64TypeParser),
+                Try(IntPtrTypeParser),
+                Try(UIntPtrTypeParser),
+                Try(SingleTypeParser),
+                Try(DoubleTypeParser),
+                Try(StringTypeParser),
+                Try(ObjectTypeParser),
+                TypedReferenceTypeParser)
+            .Select(code => (MType) new MTypePrimitive(code)).Labelled("Primitive type");
+
+    private static readonly Parser<char, string> NamespacedIdentifier =
+        Token(c => char.IsLetterOrDigit(c) || c == '.' || c == '_' || c == '`')
+            .AtLeastOnceString()
+            .Labelled("valid identifier");
+
+    private static readonly Parser<char, IEnumerable<MType>> GenericParametersParser =
+        Rec(() => MaybeArrayTypeParser!)
+            .Between(SkipWhitespaces)
+            .Separated(Char(','))
+            .Between(Char('<'), Char('>'));
+
+    private static readonly Parser<char, MType> GenericMethodPlaceholderParser =
+        String("!!")
+            .Then(Digit.AtLeastOnceString())
+            .Select(p => (MType) new MTypeGenericMethodPlaceHolder(int.Parse(p, CultureInfo.InvariantCulture)));
+
+    private static readonly Parser<char, MType> GenericTypePlaceholderParser =
+        String("!")
+            .Then(Digit.AtLeastOnceString())
+            .Select(p => (MType) new MTypeGenericTypePlaceHolder(int.Parse(p, CultureInfo.InvariantCulture)));
+
+    private static readonly Parser<char, MType> GenericPlaceholderParser = Try(GenericTypePlaceholderParser)
+        .Or(Try(GenericMethodPlaceholderParser)).Labelled("Generic placeholder");
+
+    private static readonly Parser<char, MTypeParsed> TypeNameParser =
+        Parser.Map(
+            (a, b) => b.Aggregate(new MTypeParsed(a), (parsed, s) => new MTypeParsed(s, parsed)),
+            NamespacedIdentifier,
+            Char('/').Then(NamespacedIdentifier).Many());
+
+    private static readonly Parser<char, MType> ConstructedObjectTypeParser =
+        Parser.Map((arg1, arg2) =>
+            {
+                MType type = arg1;
+                if (arg2.HasValue)
+                {
+                    type = new MTypeGeneric(type, arg2.Value.ToImmutableArray());
+                }
+
+                return type;
+            },
+            TypeNameParser,
+            GenericParametersParser.Optional());
+
+    private static readonly Parser<char, MType> MaybeArrayTypeParser = Parser.Map(
+        (a, b) => b.Aggregate(a, (type, _) => new MTypeSZArray(type)),
+        Try(GenericPlaceholderParser).Or(Try(PrimitiveTypeParser)).Or(ConstructedObjectTypeParser),
+        String("[]").Many());
+
+    private static readonly Parser<char, MType> ByRefTypeParser =
+        String("ref")
+            .Then(SkipWhitespaces)
+            .Then(MaybeArrayTypeParser)
+            .Select(t => (MType) new MTypeByRef(t))
+            .Labelled("ByRef type");
+
+    private static readonly Parser<char, MType> TypeParser = Try(ByRefTypeParser).Or(MaybeArrayTypeParser);
+
+    private static readonly Parser<char, ImmutableArray<MType>> MethodParamsParser =
+        TypeParser
+            .Between(SkipWhitespaces)
+            .Separated(Char(','))
+            .Between(Char('('), Char(')'))
+            .Select(p => p.ToImmutableArray());
+
+    internal static readonly Parser<char, int> MethodGenericParameterCountParser =
+        Try(Char(',').Many().Select(p => p.Count() + 1).Between(Char('<'), Char('>'))).Or(Return(0));
+
+    internal static readonly Parser<char, WhitelistMethodDefine> MethodParser =
+        Parser.Map(
+            (a, b, d, c) => new WhitelistMethodDefine(b, a, c.ToList(), d),
+
+            SkipWhitespaces.Then(TypeParser),
+
+            SkipWhitespaces.Then(NamespacedIdentifier),
+
+            MethodGenericParameterCountParser,
+
+            SkipWhitespaces.Then(MethodParamsParser));
+
+    internal static readonly Parser<char, WhitelistFieldDefine> FieldParser = Parser.Map(
+        (a, b) => new WhitelistFieldDefine(b, a),
+        MaybeArrayTypeParser.Between(SkipWhitespaces),
+        NamespacedIdentifier);
+
+}