diff --git a/Config/Unsigned/App.config b/Config/Unsigned/App.config index 408035d..bc6748d 100644 --- a/Config/Unsigned/App.config +++ b/Config/Unsigned/App.config @@ -1,18 +1,17 @@
- - + diff --git a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/clone_tags.txt b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/clone_tags.txt deleted file mode 100644 index 3a57217..0000000 --- a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/clone_tags.txt +++ /dev/null @@ -1 +0,0 @@ -fails:Array#clone copies untrusted status from the original diff --git a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/compact_tags.txt b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/compact_tags.txt index 66499ee..a8b61a3 100644 --- a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/compact_tags.txt +++ b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/compact_tags.txt @@ -1,2 +1 @@ -fails:Array#compact keeps untrusted status even if all elements are removed fails:Array#compact! raises a RuntimeError on a frozen array diff --git a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/dup_tags.txt b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/dup_tags.txt deleted file mode 100644 index eaa9db3..0000000 --- a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/dup_tags.txt +++ /dev/null @@ -1 +0,0 @@ -fails:Array#dup copies untrusted status from the original diff --git a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/multiply_tags.txt b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/multiply_tags.txt index 5299c93..e3922cc 100644 --- a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/multiply_tags.txt +++ b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/multiply_tags.txt @@ -1,6 +1,3 @@ -fails:Array#* with an integer copies the untrusted status of the original array even if the passed count is 0 -fails:Array#* with an integer copies the untrusted status of the original array even if the array is empty -fails:Array#* with an integer copies the untrusted status of the original array if the passed count is not 0 fails:Array#* with a string returns a string formed by concatenating each element.to_str separated by separator without trailing separator fails:Array#* with a string raises an ArgumentError when the Array is recursive fails:Array#* with a string returns a string which would be infected with untrustworthiness of the array, its elements or the separator when the array is not empty diff --git a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/pack_tags.txt b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/pack_tags.txt index 52bf4f0..c1dd9da 100644 --- a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/pack_tags.txt +++ b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/pack_tags.txt @@ -1,21 +1,19 @@ fails:Array#pack sequentially processes each pack format, which consumes element in the array, and finally concatenates their result fails:Array#pack ignores white spaces fails:Array#pack returns a tainted string when the format is tainted fails:Array#pack returns a tainted string when the format is tainted even if the given format is empty -fails:Array#pack returns a untrusted string when the format is untrusted -fails:Array#pack returns a untrusted string when the format is untrusted even if the given format is empty fails:Array#pack returns a string in encoding of common to the concatenated results fails:Array#pack with the empty format returns an empty String in US-ASCII fails:Array#pack with format 'A' treats a multibyte character just as a byte sequence fails:Array#pack with format 'A' returns result in ASCII-8BIT fails:Array#pack with format 'A' cuts byte sequence even if it breaks a multibyte character fails:Array#pack with format 'a' treats a multibyte character just as a byte sequence fails:Array#pack with format 'a' returns result in ASCII-8BIT fails:Array#pack with format 'a' cuts byte sequence even if it breaks a multibyte character fails:Array#pack with format 'Z' returns the whole argument string with star parameter fails:Array#pack with format 'Z' comsumres only one array item per a format fails:Array#pack with format 'Z' treats a multibyte character just as a byte sequence fails:Array#pack with format 'Z' returns result in ASCII-8BIT fails:Array#pack with format 'Z' cuts byte sequence even if it breaks a multibyte character fails:Array#pack with format 'B' returns packed bit-string descending order fails:Array#pack with format 'B' treats the pack argument as a byte sequence when its characters are other than 0 or 1 diff --git a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/pop_tags.txt b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/pop_tags.txt deleted file mode 100644 index e760809..0000000 --- a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/array/pop_tags.txt +++ /dev/null @@ -1,13 +0,0 @@ -fails:Array#pop raises a RuntimeError on a frozen array -fails:Array#pop passed a number n as an argument removes and returns an array with the last n element of the array -fails:Array#pop passed a number n as an argument returns a new empty array if there are no more elements -fails:Array#pop passed a number n as an argument returns whole elements if n exceeds size of the array -fails:Array#pop passed a number n as an argument does not return self even when it returns whole elements -fails:Array#pop passed a number n as an argument tries to convert n to an Integer using #to_int -fails:Array#pop passed a number n as an argument raises a TypeError when the passed n can be coerced to Integer -fails:Array#pop passed a number n as an argument does not return subclass instances with Array subclass -fails:Array#pop passed a number n as an argument returns an untainted array even if the array is tainted -fails:Array#pop passed a number n as an argument keeps taint status -fails:Array#pop passed a number n as an argument returns a trusted array even if the array is untrusted -fails:Array#pop passed a number n as an argument raises a RuntimeError on a frozen array -fails:Array#pop passed a number n as an argument keeps untrusted status diff --git a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/object/clone_tags.txt b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/object/clone_tags.txt deleted file mode 100644 index 4eb2d5a..0000000 --- a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/object/clone_tags.txt +++ /dev/null @@ -1 +0,0 @@ -fails:Object#clone preserves untrusted state from the original diff --git a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/object/dup_tags.txt b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/object/dup_tags.txt deleted file mode 100644 index 0e97d08..0000000 --- a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/object/dup_tags.txt +++ /dev/null @@ -1 +0,0 @@ -fails:Object#dup preserves untrusted state from the original diff --git a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/object/match_tags.txt b/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/object/match_tags.txt deleted file mode 100644 index 0d6721a..0000000 --- a/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags-19/core/object/match_tags.txt +++ /dev/null @@ -1 +0,0 @@ -fails:Object =~ returns nil matching any object diff --git a/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs b/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs index 15370d1..9b89a85 100644 --- a/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs +++ b/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs @@ -424,33 +424,33 @@ namespace IronRuby.Builtins { site.Target(site, e, backtrace); } return e; } } throw RubyExceptions.CreateTypeError("exception class/object expected"); } #endregion #region ===, =~, !~, eql?, hash, to_s, inspect, to_a [RubyMethod("=~")] - public static bool Match(object self, object other) { + public static object Match(object self, object other) { // Default implementation of match that is overridden in descendents (notably String and Regexp) - return false; + return null; } [RubyMethod("!~")] public static bool NotMatch(CallSiteStorage>/*!*/ match, object self, object other) { var site = match.GetCallSite("=~", 1); return RubyOps.IsFalse(site.Target(site, self, other)); } // calls == by default [RubyMethod("===")] public static bool CaseEquals(BinaryOpStorage/*!*/ equals, object self, object other) { return Protocols.IsEqual(equals, self, other); } [RubyMethod("==")] @@ -546,30 +546,33 @@ namespace IronRuby.Builtins { return Clone(initializeCopyStorage, allocateStorage, false, self); } private static object/*!*/ Clone( CallSiteStorage>/*!*/ initializeCopyStorage, CallSiteStorage>/*!*/ allocateStorage, bool isClone, object self) { var context = allocateStorage.Context; object result; if (!RubyUtils.TryDuplicateObject(initializeCopyStorage, allocateStorage, self, isClone, out result)) { throw RubyExceptions.CreateTypeError("can't {0} {1}", isClone ? "clone" : "dup", context.GetClassDisplayName(self)); } + if (context.IsObjectUntrusted(self)) { + context.SetObjectTrustiness(result, true); + } return context.TaintObjectBy(result, self); } #endregion #region class, type, extend, instance_of?, is_a?, kind_of? (thread-safe) [RubyMethod("class")] public static RubyClass/*!*/ GetClass(RubyContext/*!*/ context, object self) { return context.GetClassOf(self); } [RubyMethod("type")] public static RubyClass/*!*/ GetClassObsolete(RubyContext/*!*/ context, object self) { context.ReportWarning("Object#type will be deprecated; use Object#class"); @@ -640,72 +643,86 @@ namespace IronRuby.Builtins { if (!RubyUtils.HasObjectState(self)) { return self; // can't freeze value types } context.FreezeObject(self); return self; } [RubyMethod("tainted?")] public static bool Tainted(RubyContext/*!*/ context, object self) { if (!RubyUtils.HasObjectState(self)) { return false; // can't taint value types } return context.IsObjectTainted(self); } - [RubyMethod("taint")] - public static object Taint(RubyContext/*!*/ context, object self) { - if (!RubyUtils.HasObjectState(self)) { - return self; + private static object SetObjectTaint(RubyContext/*!*/ context, object self, bool taint) { + // TODO: move check and operations on frozen objects to RubyContext.SetObjectTaint() + if (context.IsObjectFrozen(self)) { + if (context.IsObjectTainted(self) != taint) { + throw RubyExceptions.CreateObjectFrozenError(); + } + } + else { + if (RubyUtils.HasObjectState(self)) { + context.SetObjectTaint(self, taint); + } } - context.SetObjectTaint(self, true); return self; } + [RubyMethod("taint")] + public static object Taint(RubyContext/*!*/ context, object self) { + return SetObjectTaint(context, self, true); + } + [RubyMethod("untaint")] public static object Untaint(RubyContext/*!*/ context, object self) { - if (!RubyUtils.HasObjectState(self)) { - return self; - } - context.SetObjectTaint(self, false); - return self; + return SetObjectTaint(context, self, false); } [RubyMethod("untrusted?")] public static bool Untrusted(RubyContext/*!*/ context, object self) { if (!RubyUtils.HasObjectState(self)) { return false; // can't untrust value types } return context.IsObjectUntrusted(self); } - [RubyMethod("trust")] - public static object Trust(RubyContext/*!*/ context, object self) { - if (!RubyUtils.HasObjectState(self)) { - return self; + private static object SetObjectTrustiness(RubyContext/*!*/ context, object self, bool untrusted) { + // TODO: move check and operations on frozen objects to RubyContext.SetObjectTrustiness() + if (context.IsObjectFrozen(self)) { + if (context.IsObjectUntrusted(self) != untrusted) { + throw RubyExceptions.CreateObjectFrozenError(); + } + } + else { + if (RubyUtils.HasObjectState(self)) { + context.SetObjectTrustiness(self, untrusted); + } } - context.SetObjectTrustiness(self, false); return self; } + [RubyMethod("trust")] + public static object Trust(RubyContext/*!*/ context, object self) { + return SetObjectTrustiness(context, self, false); + } + [RubyMethod("untrust")] public static object Untrust(RubyContext/*!*/ context, object self) { - if (!RubyUtils.HasObjectState(self)) { - return self; - } - context.SetObjectTrustiness(self, true); - return self; + return SetObjectTrustiness(context, self, true); } #endregion #region eval [RubyMethod("eval", RubyMethodAttributes.PrivateInstance)] [RubyMethod("eval", RubyMethodAttributes.PublicSingleton)] public static object Evaluate(RubyScope/*!*/ scope, object self, [NotNull]MutableString/*!*/ code, [Optional]Binding binding, [Optional, NotNull]MutableString file, [DefaultParameterValue(1)]int line) { RubyScope targetScope; object targetSelf; if (binding != null) { targetScope = binding.LocalScope; diff --git a/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/RubyEncoder.cs b/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/RubyEncoder.cs index 7f48389..fb89eaf 100644 --- a/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/RubyEncoder.cs +++ b/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/RubyEncoder.cs @@ -1170,31 +1170,35 @@ namespace IronRuby.Builtins { case 'x': count = 0; int len4 = directive.Count.HasValue ? directive.Count.Value : 0; stream.String.Write((int)stream.Position, 0, len4); stream.Position += len4; break; default: count = 0; break; } i += count; } stream.SetLength(stream.Position); - return stream.String; + var result = stream.String; + if (format.IsUntrusted) { + tosConversion.Context.SetObjectTrustiness(result, true); + } + return result; } } private static MutableString ToMutableString(ConversionStorage/*!*/ stringCast, MutableStringStream/*!*/ stream, object value) { var site = stringCast.GetSite(ConvertToStrAction.Make(stringCast.Context)); var result = site.Target(site, value); if (result != null) { stream.String.TaintBy(result); } return result; } private static object GetPackArg(RubyArray/*!*/ array, int index) { if (index >= array.Count) { throw RubyExceptions.CreateArgumentError("too few arguments"); diff --git a/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/IListOps.cs b/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/IListOps.cs index 2d1d252..f326029 100644 --- a/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/IListOps.cs +++ b/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/IListOps.cs @@ -230,31 +230,35 @@ namespace IronRuby.Builtins { if (repeat < 0) { throw RubyExceptions.CreateArgumentError("negative argument"); } IList result = CreateResultArray(allocateStorage, self); RubyArray array = result as RubyArray; if (array != null) { array.AddCapacity(self.Count * repeat); } for (int i = 0; i < repeat; ++i) { AddRange(result, self); } - allocateStorage.Context.TaintObjectBy(result, self); + var context = allocateStorage.Context; + if (context.IsObjectUntrusted(self)) { + context.SetObjectTrustiness(result, true); + } + context.TaintObjectBy(result, self); return result; } [RubyMethod("*")] public static MutableString Repetition(ConversionStorage/*!*/ tosConversion, IList/*!*/ self, [NotNull]MutableString/*!*/ separator) { return Join(tosConversion, self, separator); } [RubyMethod("*")] public static object Repetition( CallSiteStorage>/*!*/ allocateStorage, ConversionStorage/*!*/ tosConversion, IList/*!*/ self, [DefaultProtocol, NotNull]Union repeat) { @@ -672,31 +676,35 @@ namespace IronRuby.Builtins { } return self; } [RubyMethod("compact")] public static IList/*!*/ Compact(CallSiteStorage>/*!*/ allocateStorage, IList/*!*/ self) { IList result = CreateResultArray(allocateStorage, self); foreach (object item in self) { if (item != null) { result.Add(item); } } - allocateStorage.Context.TaintObjectBy(result, self); + var context = allocateStorage.Context; + if (context.IsObjectUntrusted(self)) { + context.SetObjectTrustiness(result, true); + } + context.TaintObjectBy(result, self); return result; } [RubyMethod("compact!")] public static IList CompactInPlace(IList/*!*/ self) { RequireNotFrozen(self); bool changed = false; int i = 0; while (i < self.Count) { if (self[i] == null) { changed = true; self.RemoveAt(i); } else { @@ -1440,40 +1448,66 @@ namespace IronRuby.Builtins { AddRange(self, args); return self; } InsertRange(self, index, args, 0, args.Length); return self; } [RubyMethod("push")] public static IList/*!*/ Push(IList/*!*/ self, params object[]/*!*/ values) { AddRange(self, values); return self; } [RubyMethod("pop")] - public static object Pop(IList/*!*/ self) { + public static object Pop(RubyContext/*!*/ context, IList/*!*/ self) { + if (context.IsObjectFrozen(self)) { + throw RubyExceptions.CreateRuntimeError("can't modify frozen array"); + } + if (self.Count == 0) { return null; } object result = self[self.Count - 1]; self.RemoveAt(self.Count - 1); return result; } + [RubyMethod("pop")] + public static object Pop(RubyContext/*!*/ context, IList/*!*/ self, [DefaultProtocol]int count) { + if (context.IsObjectFrozen(self)) { + throw RubyExceptions.CreateRuntimeError("can't modify frozen array"); + } + + if (count < 0) { + throw RubyExceptions.CreateArgumentError("negative array size"); + } + + if (count == 0 || self.Count == 0) { + return new RubyArray(); + } + + var normalizedCount = count <= self.Count ? count : self.Count; + var index = self.Count - normalizedCount; + + var result = new RubyArray(self, index, normalizedCount); + IListOps.RemoveRange(self, index, normalizedCount); + return result; + } + [RubyMethod("shift")] public static object Shift(IList/*!*/ self) { if (self.Count == 0) { return null; } object result = self[0]; self.RemoveAt(0); return result; } [RubyMethod("unshift")] public static IList/*!*/ Unshift(IList/*!*/ self, object/*!*/ arg) { self.Insert(0, arg); return self; diff --git a/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs b/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs index f4e7e13..8db2d68 100644 --- a/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs +++ b/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs @@ -3701,31 +3701,31 @@ namespace IronRuby.Builtins { new Func(IronRuby.Builtins.KernelOps.SendMessage), new Func(IronRuby.Builtins.KernelOps.SendMessage), new Func(IronRuby.Builtins.KernelOps.SendMessage), new Func(IronRuby.Builtins.KernelOps.SendMessage) ); #if !SILVERLIGHT DefineLibraryMethod(module, "`", 0x52, 0x00020004U, new Func(IronRuby.Builtins.KernelOps.ExecuteCommand) ); #endif DefineLibraryMethod(module, "=~", 0x51, 0x00000000U, - new Func(IronRuby.Builtins.KernelOps.Match) + new Func(IronRuby.Builtins.KernelOps.Match) ); DefineLibraryMethod(module, "==", 0x51, 0x00000001U, 0x00000000U, new Func(IronRuby.Builtins.KernelOps.ValueEquals), new Func(IronRuby.Builtins.KernelOps.ValueEquals) ); DefineLibraryMethod(module, "===", 0x51, 0x00000000U, new Func(IronRuby.Builtins.KernelOps.CaseEquals) ); DefineLibraryMethod(module, "abort", 0x52, 0x00000000U, 0x00020004U, @@ -7401,32 +7401,33 @@ namespace IronRuby.Builtins { 0x00000000U, new Func(IronRuby.Builtins.IListOps.Length) ); DefineLibraryMethod(module, "map!", 0x51, 0x00000000U, new Func(IronRuby.Builtins.IListOps.CollectInPlace) ); DefineLibraryMethod(module, "nitems", 0x51, 0x00000000U, new Func(IronRuby.Builtins.IListOps.NumberOfNonNilItems) ); DefineLibraryMethod(module, "pop", 0x51, - 0x00000000U, - new Func(IronRuby.Builtins.IListOps.Pop) + 0x00000000U, 0x00020000U, + new Func(IronRuby.Builtins.IListOps.Pop), + new Func(IronRuby.Builtins.IListOps.Pop) ); DefineLibraryMethod(module, "push", 0x51, 0x80000000U, new Func(IronRuby.Builtins.IListOps.Push) ); DefineLibraryMethod(module, "rassoc", 0x51, 0x00000000U, new Func(IronRuby.Builtins.IListOps.GetContainerOfSecondItem) ); DefineLibraryMethod(module, "reject", 0x51, 0x00000000U, new Func>, IronRuby.Runtime.CallSiteStorage>, IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.Reject)