GetResourceStream() public method

public GetResourceStream ( ) : Stream
return Stream
Esempio n. 1
0
 static string ReadToken(EmbeddedResource resources, string token)
 {
     using (var resourceStream = resources.GetResourceStream())
     using (var resourceSet = new ResourceSet(resourceStream))
         return resourceSet.GetString(token, true);
 }
        private bool InitResourceGridRows(EmbeddedResource er)
        {
            ResourceReader rr;
            try
            {
                rr = new ResourceReader(er.GetResourceStream());
            }
            catch
            {
                rr = null;
            }

            if (rr == null)
                return false;

            DataRow dr;
            IDictionaryEnumerator de = rr.GetEnumerator();
            int count = 0;
            while (de.MoveNext())
            {
                dr = _dtResource.NewRow();
                string name = de.Key as string;
                dr["no"] = count.ToString();
                count++;
                dr["name"] = name;
                object value = de.Value;
                dr["type"] = value == null ? null : value.GetType().FullName;
                try
                {
                    DataGridViewTextAndImageCellValue cv = new DataGridViewTextAndImageCellValue(name, value);
                    cv.Image = ConvertToImage(name, value);
                    dr["value"] = cv;
                }
                catch //(Exception ex)
                {
                    dr["value"] = new DataGridViewTextAndImageCellValue(String.Empty, value);
                    //dr["value"] = new DataGridViewTextAndImageCellValue(String.Empty, String.Format("Error: {0}", ex.Message));
                    //dr["type"] = "System.String";
                }
                _dtResource.Rows.Add(dr);
            }

            rr.Close();
            return true;
        }
		private void CheckSatelliteResource (EmbeddedResource mainResource, EmbeddedResource satelliteResource, IMetadataTokenProvider satelliteAssembly)
		{
			using (Stream resourceStream = satelliteResource.GetResourceStream ())
			using (ResourceSet resourceSet = new ResourceSet (resourceStream)) {
				foreach (DictionaryEntry entry in resourceSet) {
					string resourceName = (string) entry.Key;
					object satelliteValue = entry.Value;
					object mainValue;
					if (!mainAssemblyResourceCache.TryGetMainResource (mainResource, resourceName, out mainValue)) {
						Runner.Report (satelliteAssembly, Severity.Low, Confidence.High,
							String.Format ("The resource {0} in the file {1} exist in the satellite assembly but not in the main assembly", resourceName, satelliteResource.Name));
						continue;
					}

					Type satelliteType = satelliteValue.GetType ();
					Type mainType = mainValue.GetType ();
					if (!satelliteType.Equals (mainType)) {
						Runner.Report (satelliteAssembly, Severity.High, Confidence.High,
							String.Format ("The resource {0} in the file {1} is of type {2} in the satellite assembly but of type {3} in the main assembly", resourceName, satelliteResource.Name, satelliteType, mainType));
						continue;
					}

					if (satelliteType.Equals (typeof (string))) {
						Bitmask<int> mainParameters = GetStringFormatExpectedParameters ((string) mainValue);
						Bitmask<int> satelliteParameters = GetStringFormatExpectedParameters ((string) satelliteValue);

						if (!mainParameters.Equals (satelliteParameters))
							Runner.Report (satelliteAssembly, Severity.High, Confidence.Normal,
								String.Format ("The string resource {0} in the file {1} does not use the same string format parameters in the satellite and main assemblies", resourceName, satelliteResource.Name));
					}
				}
			}
		}
 private static string[] GetRepackListFromResource(EmbeddedResource resource)
 {
     return (string[])new BinaryFormatter().Deserialize(resource.GetResourceStream());
 }
Esempio n. 5
0
 byte[] decryptResource(EmbeddedResource resource)
 {
     using (var rsrcStream = resource.GetResourceStream()) {
         using (var reader = new BinaryReader(rsrcStream)) {
             var key = reader.ReadString();
             var data = reader.ReadBytes((int)(rsrcStream.Length - rsrcStream.Position));
             var cryptoTransform = new DESCryptoServiceProvider {
                 Key = Encoding.ASCII.GetBytes(key),
                 IV = Encoding.ASCII.GetBytes(key),
             }.CreateDecryptor();
             var memStream = new MemoryStream(data);
             using (var reader2 = new BinaryReader(new CryptoStream(memStream, cryptoTransform, CryptoStreamMode.Read))) {
                 return reader2.ReadBytes((int)memStream.Length);
             }
         }
     }
 }
Esempio n. 6
0
        private void AddResource (EmbeddedResource resource)
        {
            if (embedded_resource_parser == null) {
                return;
            }

            if (Path.GetExtension (resource.Name) == ".resources") {
                using (var reader = new ResourceReader (resource.GetResourceStream ())) {
                    foreach (DictionaryEntry re in reader) {
                        if (embedded_resource_parser.SupportedFileExtensions.Contains (Path.GetExtension (re.Key as string))) {
                            embedded_resource_parser.Add (re.Value as Stream, re.Key as string);
                        }
                    }        
                }
            } else if (embedded_resource_parser.SupportedFileExtensions.Contains (Path.GetExtension(resource.Name))) {			
                embedded_resource_parser.Add (resource.GetResourceStream (), resource.Name);
            }
        }
        private void ProcessXamlResources(EmbeddedResource resource, ModuleDefinition module)
        {
            string targetDir = Path.GetDirectoryName(TargetPath);
            using (ResourceReader resourceReader = new ResourceReader(resource.GetResourceStream()))
            {
                foreach (System.Collections.DictionaryEntry resourceEntry in resourceReader)
                {
                    string xamlResourceKey = Utilities.GetXamlResourceKey(resourceEntry, module);

					bool isBamlResource = ((string)resourceEntry.Key).EndsWith(".baml", StringComparison.OrdinalIgnoreCase);

                    string xamlResourceRelativePath = xamlResourcesToPathsMap[xamlResourceKey];
                    string fullPath = Path.Combine(targetDir, xamlResourceRelativePath);

                    string fullClassName = TryWriteBamlResource(fullPath, isBamlResource, resourceEntry.Value as UnmanagedMemoryStream);
                    if (fullClassName != null)
                    {
                        fileGenContext.XamlFullNameToRelativePathMap.Add(fullClassName, xamlResourceRelativePath);
                    }
                    else
                    {
                        fileGenContext.OtherXamlResources.Add(new ProjectItemGroupResource() { Include = xamlResourceRelativePath });
                    }

					IFileGeneratedInfo args = new FileGeneratedInfo(fullPath, false);
                    OnProjectFileCreated(args);
                }
            }
        }
        private void ShowResource(EmbeddedResource er)
        {
            if (PathUtils.IsResourceExt(er.Name))
            {
                if (InitResourceGridRows(er))
                {
                    //ShowDetailsControl(DetailTypes.Resources);
                    if (_dtResource.Rows.Count == 0)
                    {
                        ShowText(String.Empty);
                    }
                    else
                    {
                        ShowText((string)null);
                    }
                }
                else
                {
                    ShowBinary(er, false);
                }
            }
            else if (ResourceFile.Default.IsTextResource(er.Name))
            {
                ShowText(er.GetResourceStream(), null, false);
            }
            else if (PathUtils.IsIconExt(er.Name))
            {
                Icon ico = new Icon(er.GetResourceStream());
                pbResource.Image = ico.ToBitmap();
                ShowDetailsControl(DetailTypes.ImageResource);
            }
            else if (PathUtils.IsCursorExt(er.Name))
            {
                Cursor c = LoadCursor(er.GetResourceStream());
                Bitmap bmp = ConvertToBitmap(c);
                pbResource.Image = bmp;
                ShowDetailsControl(DetailTypes.ImageResource);
            }
            else if (ResourceFile.Default.IsImageResource(er.Name))
            {
                //wmf size is wrong with Image.FromStream
                //pbResource.Image = new Bitmap(er.GetResourceStream());

                Bitmap bmp = new Bitmap(er.GetResourceStream());
                pbResource.Image = bmp;
                //if (!ImageAnimator.CanAnimate(bmp))
                //{
                //    pbResource.Image = bmp;
                //}
                //else
                //{
                //    pbResource.Image = new Bitmap(bmp.Width, bmp.Height);
                //}
                ShowDetailsControl(DetailTypes.ImageResource);
            }
            else
            {
                //always try to parse as .resources
                if (InitResourceGridRows(er))
                {
                    //ShowDetailsControl(DetailTypes.Resources);
                    if (_dtResource.Rows.Count == 0)
                    {
                        ShowText(String.Empty);
                    }
                    else
                    {
                        ShowText((string)null);
                    }
                }
                else
                {
                    ShowBinary(er, false);
                }
            }
        }
Esempio n. 9
0
		/// <summary>Tries to load assembly for other assembly resources.</summary>
		/// <param name="resource">The resource.</param>
		/// <param name="guid">The GUID.</param>
		/// <returns>Loaded assembly image.</returns>
		private static byte[] TryLoadAssembly(EmbeddedResource resource, string guid)
		{
			var match = ResourceNameRx.Match(resource.Name);
			if (!match.Success || match.Groups["guid"].Value != guid)
				return null;

			try
			{
				var flags = match.Groups["flags"].Value;
				var size = int.Parse(match.Groups["size"].Value);
				var compressed = flags.Contains("z");

				var buffer = new byte[size];

				using (var rstream = resource.GetResourceStream())
				{
					if (rstream == null)
						return null;
					using (var zstream = compressed ? new DeflateStream(rstream, CompressionMode.Decompress) : rstream)
					{
						zstream.Read(buffer, 0, size);
					}
				}

				return buffer;
			}
			catch
			{
				return null;
			}
		}
        private bool TryCreateResXFile(EmbeddedResource embeddedResource, string resourceFilePath)
        {
            List<System.Collections.DictionaryEntry> resourceEntries = new List<System.Collections.DictionaryEntry>();

            using (ResourceReader resourceReader = new ResourceReader(embeddedResource.GetResourceStream()))
            {
                IDictionaryEnumerator enumerator = resourceReader.GetEnumerator();

                while (enumerator.MoveNext())
                {
                    try
                    {
                        resourceEntries.Add(enumerator.Entry);
                    }
                    catch (Exception ex)
                    {
                        if (ResourceWritingFailure != null)
                        {
                            ResourceWritingFailure(this, embeddedResource.Name, ex);
                        }

						if (this.projectNotifier != null)
						{
							this.projectNotifier.OnResourceWritingFailure(embeddedResource.Name, ex);
						}
                    }
                }
            }

            string dirPath = Path.GetDirectoryName(resourceFilePath);
            if (!Directory.Exists(dirPath))
            {
                Directory.CreateDirectory(dirPath);
            }

#if !NET35
            using (ResXResourceWriter resXWriter = new ResXResourceWriter(resourceFilePath, ResourceTypeNameConverter))
#else
            using (ResXResourceWriter resXWriter = new ResXResourceWriter(resourceFilePath))
#endif
            {
                foreach (System.Collections.DictionaryEntry resourceEntry in resourceEntries)
                {
                    resXWriter.AddResource((string)resourceEntry.Key, resourceEntry.Value);
                }
            }

            return true;
        }
Esempio n. 11
0
        public void init(ResourceDecrypter resourceDecrypter)
        {
            if (decrypterType == null)
                return;

            encryptedResource = CoUtils.getResource(module, DotNetUtils.getCodeStrings(DotNetUtils.getMethod(decrypterType, ".cctor")));
            constantsData = resourceDecrypter.decrypt(encryptedResource.GetResourceStream());
        }
Esempio n. 12
0
        public void decrypt(ResourceDecrypter resourceDecrypter)
        {
            if (decryptMethod == null)
                return;

            resource = CoUtils.getResource(module, decrypterCctor);
            if (resource == null)
                return;
            var decrypted = resourceDecrypter.decrypt(resource.GetResourceStream());
            var reader = new BinaryReader(new MemoryStream(decrypted));
            int numEncrypted = reader.ReadInt32();
            Log.v("Restoring {0} encrypted methods", numEncrypted);
            Log.indent();
            for (int i = 0; i < numEncrypted; i++) {
                int delegateTypeToken = reader.ReadInt32();
                uint codeOffset = reader.ReadUInt32();
                var origOffset = reader.BaseStream.Position;
                reader.BaseStream.Position = codeOffset;
                decrypt(reader, delegateTypeToken);
                reader.BaseStream.Position = origOffset;
            }
            Log.deIndent();
        }
Esempio n. 13
0
 byte[] getMethodsData(EmbeddedResource resource)
 {
     var reader = new BinaryReader(resource.GetResourceStream());
     reader.BaseStream.Position = startOffset;
     if ((reader.ReadInt32() & 1) != 0)
         return decompress(reader);
     else
         return reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
 }
        public EmbeddedResource RemoveResource(EmbeddedResource er, string[] keys)
        {
            try
            {
                Cursor.Current = Cursors.WaitCursor;

                var rr = new ResourceReader(er.GetResourceStream());
                var ms = new MemoryStream();
                var rw = new ResourceWriter(ms);

                var de = rr.GetEnumerator();
                while (de.MoveNext())
                {
                    string deKey = de.Key as string;
                    bool toBeDeleted = false;
                    foreach (string key in keys)
                    {
                        if (key == deKey)
                        {
                            toBeDeleted = true;
                            break;
                        }
                    }
                    if (toBeDeleted) continue;
                    rw.AddResource(deKey, de.Value);
                }

                rw.Generate();
                rw.Close();
                rr.Close();
                var newEr = new EmbeddedResource(er.Name, er.Attributes, ms.ToArray());
                ms.Close();
                return newEr;
            }
            catch
            {
                throw;
            }
            finally
            {
                Cursor.Current = Cursors.Default;
            }
        }
Esempio n. 15
0
		static XPathDocument GetExternalDescriptor (EmbeddedResource resource)
		{
			using (var sr = new StreamReader (resource.GetResourceStream ())) {
				return new XPathDocument (new StringReader (sr.ReadToEnd ()));
			}
		}
        public EmbeddedResource ReplaceResource(EmbeddedResource er, string key, byte[] data)
        {
            try
            {
                Cursor.Current = Cursors.WaitCursor;

                var rr = new ResourceReader(er.GetResourceStream());
                var ms = new MemoryStream();
                var rw = new ResourceWriter(ms);

                var de = rr.GetEnumerator();
                while (de.MoveNext())
                {
                    string deKey = de.Key as string;
                    if (key == deKey)
                    {
                        object o = RestoreResourceObject(key, de.Value.GetType().FullName, data);
                        rw.AddResource(key, o);
                    }
                    else
                    {
                        rw.AddResource(deKey, de.Value);
                    }
                }

                rw.Generate();
                rw.Close();
                rr.Close();
                var newEr = new EmbeddedResource(er.Name, er.Attributes, ms.ToArray());
                ms.Close();
                return newEr;
            }
            catch
            {
                throw;
            }
            finally
            {
                Cursor.Current = Cursors.Default;
            }
        }
        private void SaveResourceFile(EmbeddedResource er, string outputFile)
        {
            byte[] bytes = er.GetResourceData();
            using (FileStream fs = File.Create(outputFile))
            {
                fs.Write(bytes, 0, bytes.Length);
            }
            _form.SetStatusText(String.Format("{0} saved.", outputFile));

            if (PathUtils.IsResourceExt(outputFile))
            {
                using (ResourceReader rr = new ResourceReader(er.GetResourceStream()))
                {
                    string resxFile = Path.ChangeExtension(outputFile, ".resx");
                    using (ResXResourceWriter xw = new ResXResourceWriter(resxFile))
                    {
                        IDictionaryEnumerator de = rr.GetEnumerator();
                        while (de.MoveNext())
                        {
                            bool handled = false;
                            if (de.Value != null)
                            {
                                Type type = de.Value.GetType();
                                if (type.FullName.EndsWith("Stream"))
                                {
                                    Stream s = de.Value as Stream;
                                    if (s != null)
                                    {
                                        byte[] tmpBytes = new byte[s.Length];
                                        if (s.CanSeek) s.Seek(0, SeekOrigin.Begin);
                                        s.Read(tmpBytes, 0, tmpBytes.Length);
                                        xw.AddResource(de.Key.ToString(), new MemoryStream(tmpBytes));
                                        handled = true;
                                    }
                                }
                            }
                            if (handled) continue;
                            xw.AddResource(de.Key.ToString(), de.Value);
                        }
                    }
                }
            }
            else if (PathUtils.IsBamlExt(outputFile))
            {
                try
                {
                    using (StreamWriter sw = File.CreateText(Path.ChangeExtension(outputFile, ".xaml")))
                    {
                        sw.WriteLine(_form.ResourceHandler.DecompileBaml(new MemoryStream(bytes)));
                    }
                }
                catch (Exception ex)
                {
                    _form.SetStatusText(String.Format("Failed to translate {0}: {1}", er.Name, ex.Message));
                }
            }
        }
Esempio n. 18
0
        void rename(TypeDefinition type, EmbeddedResource resource)
        {
            newNames.Clear();
            var resourceSet = ResourceReader.read(module, resource.GetResourceStream());
            var renamed = new List<RenameInfo>();
            foreach (var elem in resourceSet.ResourceElements) {
                if (nameChecker.isValidResourceKeyName(elem.Name)) {
                    newNames.Add(elem.Name, true);
                    continue;
                }

                renamed.Add(new RenameInfo(elem, getNewName(elem)));
            }

            if (renamed.Count == 0)
                return;

            rename(type, renamed);

            var outStream = new MemoryStream();
            ResourceWriter.write(module, outStream, resourceSet);
            outStream.Position = 0;
            var newResource = new EmbeddedResource(resource.Name, resource.Attributes, outStream);
            int resourceIndex = module.Resources.IndexOf(resource);
            if (resourceIndex < 0)
                throw new ApplicationException("Could not find index of resource");
            module.Resources[resourceIndex] = newResource;
        }
 private static Dictionary<string, List<int>> GetIkvmExportsListsFromResource(EmbeddedResource extra)
 {
     Dictionary<string, List<int>> ikvmExportsLists = new Dictionary<string, List<int>>();
     BinaryReader rdr = new BinaryReader(extra.GetResourceStream());
     int assemblyCount = rdr.ReadInt32();
     for (int i = 0; i < assemblyCount; i++)
     {
         var str = rdr.ReadString();
         int typeCount = rdr.ReadInt32();
         if (typeCount == 0)
         {
             ikvmExportsLists.Add(str, null);
         }
         else
         {
             var types = new List<int>();
             ikvmExportsLists.Add(str, types);
             for (int j = 0; j < typeCount; j++)
                 types.Add(rdr.ReadInt32());
         }
     }
     return ikvmExportsLists;
 }
Esempio n. 20
0
        public void init(ResourceDecrypter resourceDecrypter)
        {
            if (decryptedData != null)
                return;

            var resourceName = getResourceName();
            stringResource = DotNetUtils.getResource(module, resourceName) as EmbeddedResource;
            if (stringResource == null)
                return;
            Log.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(stringResource.Name));

            decryptedData = resourceDecrypter.decrypt(stringResource.GetResourceStream());
        }
        private Resource FixResxResource(
            AssemblyDefinition containingAssembly,
            EmbeddedResource er,
            List<IResProcessor> resourcePrcessors,
            IEmbeddedResourceProcessor embeddedResourceProcessor)
        {
            MemoryStream stream = (MemoryStream)er.GetResourceStream();
            var output = new MemoryStream((int)stream.Length);
            var rw = new ResourceWriter(output);

            using (var rr = new ResReader(stream))
            {
                foreach (var res in rr)
                {
                    foreach (var processor in resourcePrcessors)
                    {
                        if (processor.Process(containingAssembly, res, rr, rw))
                            break;
                    }
                }
            }

            // do a final processing, if any, on the embeddedResource itself
            embeddedResourceProcessor?.Process(er, rw);

            rw.Generate();
            output.Position = 0;
            return new EmbeddedResource(er.Name, er.Attributes, output);
        }
Esempio n. 22
0
 void dumpEmbeddedFile(EmbeddedResource resource, string assemblyName, string extension, string reason)
 {
     DeobfuscatedFile.createAssemblyFile(resourceDecrypter.decrypt(resource.GetResourceStream()), Utils.getAssemblySimpleName(assemblyName), extension);
     addResourceToBeRemoved(resource, reason);
 }
			public bool TryGetMainResource (EmbeddedResource embeddedResource, string resourceName, out object value)
			{
				value = null;

				if (values == null) {
					// Build cache of resources values
					values = new Dictionary<EmbeddedResource, Dictionary<string, object>> ();
				}

				Dictionary<string, object> fileResources;
				if (!values.TryGetValue (embeddedResource, out fileResources)) {
					fileResources = new Dictionary<string, object> ();
					using (Stream resourceStream = embeddedResource.GetResourceStream ())
					using (ResourceSet resourceSet = new ResourceSet (resourceStream)) {
						foreach (DictionaryEntry entry in resourceSet)
							fileResources.Add ((string) entry.Key, entry.Value);
					}
					values.Add (embeddedResource, fileResources);
				}

				return fileResources.TryGetValue (resourceName, out value);
			}