Ejemplo n.º 1
0
        internal override StrongNameKeys CreateKeys(string keyFilePath, string keyContainerName, CommonMessageProvider messageProvider)
        {
            var    keyPair   = default(ImmutableArray <byte>);
            var    publicKey = default(ImmutableArray <byte>);
            string container = null;

            if (!string.IsNullOrEmpty(keyFilePath))
            {
                return(CommonCreateKeys(FileSystem, keyFilePath, _keyFileSearchPaths, messageProvider));
            }
            else if (!string.IsNullOrEmpty(keyContainerName))
            {
                try
                {
                    ReadKeysFromContainer(keyContainerName, out publicKey);
                    container = keyContainerName;
                }
                catch (ClrStrongNameMissingException)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName,
                                                                               new CodeAnalysisResourcesLocalizableErrorArgument(nameof(CodeAnalysisResources.AssemblySigningNotSupported)))));
                }
                catch (Exception ex)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName, ex.Message)));
                }
            }

            return(new StrongNameKeys(keyPair, publicKey, null, container, keyFilePath));
        }
Ejemplo n.º 2
0
        internal override void SignFile(StrongNameKeys keys, string filePath)
        {
            Debug.Assert(string.IsNullOrEmpty(keys.KeyFilePath) != string.IsNullOrEmpty(keys.KeyContainer));

            if (!string.IsNullOrEmpty(keys.KeyFilePath))
            {
                Sign(filePath, keys.KeyPair);
            }
            else
            {
                Sign(filePath, keys.KeyContainer);
            }
        }
        internal override StrongNameKeys CreateKeys(string keyFilePath, string keyContainerName, CommonMessageProvider messageProvider)
        {
            ImmutableArray <byte> keyPair   = default(ImmutableArray <byte>);
            ImmutableArray <byte> publicKey = default(ImmutableArray <byte>);
            string container = null;

            if (!string.IsNullOrEmpty(keyFilePath))
            {
                try
                {
                    string resolvedKeyFile = ResolveStrongNameKeyFile(keyFilePath);
                    if (resolvedKeyFile == null)
                    {
                        throw new FileNotFoundException(CodeAnalysisResources.FileNotFound, keyFilePath);
                    }

                    Debug.Assert(PathUtilities.IsAbsolute(resolvedKeyFile));
                    ImmutableArray <byte> fileContent = ImmutableArray.Create(ReadAllBytes(resolvedKeyFile));
                    return(StrongNameKeys.CreateHelper(fileContent, keyFilePath));
                }
                catch (Exception ex)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, ex.Message)));
                }
                // it turns out that we don't need IClrStrongName to retrieve a key file,
                // so there's no need for a catch of ClrStrongNameMissingException in this case
            }
            else if (!string.IsNullOrEmpty(keyContainerName))
            {
                try
                {
                    ReadKeysFromContainer(keyContainerName, out publicKey);
                    container = keyContainerName;
                }
                catch (ClrStrongNameMissingException)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName,
                                                                               new CodeAnalysisResourcesLocalizableErrorArgument(nameof(CodeAnalysisResources.AssemblySigningNotSupported)))));
                }
                catch (Exception ex)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName, ex.Message)));
                }
            }

            return(new StrongNameKeys(keyPair, publicKey, container, keyFilePath));
        }
            internal bool Complete(StrongNameKeys strongNameKeys, CommonMessageProvider messageProvider, DiagnosticBag diagnostics)
            {
                RoslynDebug.Assert(_stream != null);
                RoslynDebug.Assert(_emitStreamSignKind != EmitStreamSignKind.SignedWithFile || _tempInfo.HasValue);

                try
                {
                    if (_tempInfo.HasValue)
                    {
                        RoslynDebug.Assert(_emitStreamSignKind == EmitStreamSignKind.SignedWithFile);
                        RoslynDebug.Assert(_strongNameProvider is object);
                        var(tempStream, tempFilePath) = _tempInfo.GetValueOrDefault();

                        try
                        {
                            // Dispose the temp stream to ensure all of the contents are written to
                            // disk.
                            tempStream.Dispose();

                            _strongNameProvider.SignFile(strongNameKeys, tempFilePath);

                            using (var tempFileStream = new FileStream(tempFilePath, FileMode.Open))
                            {
                                tempFileStream.CopyTo(_stream);
                            }
                        }
                        catch (DesktopStrongNameProvider.ClrStrongNameMissingException)
                        {
                            diagnostics.Add(StrongNameKeys.GetError(strongNameKeys.KeyFilePath, strongNameKeys.KeyContainer,
                                                                    new CodeAnalysisResourcesLocalizableErrorArgument(nameof(CodeAnalysisResources.AssemblySigningNotSupported)), messageProvider));
                            return(false);
                        }
                        catch (IOException ex)
                        {
                            diagnostics.Add(StrongNameKeys.GetError(strongNameKeys.KeyFilePath, strongNameKeys.KeyContainer, ex.Message, messageProvider));
                            return(false);
                        }
                    }
                }
                finally
                {
                    Close();
                }

                return(true);
            }
Ejemplo n.º 5
0
        internal override StrongNameKeys CreateKeys(string keyFilePath, string keyContainerName, bool hasCounterSignature, CommonMessageProvider messageProvider)
        {
            var    keyPair   = default(ImmutableArray <byte>);
            var    publicKey = default(ImmutableArray <byte>);
            string container = null;

            if (!string.IsNullOrEmpty(keyFilePath))
            {
                try
                {
                    string resolvedKeyFile = ResolveStrongNameKeyFile(keyFilePath, FileSystem, _keyFileSearchPaths);
                    if (resolvedKeyFile == null)
                    {
                        return(new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, CodeAnalysisResources.FileNotFound)));
                    }

                    Debug.Assert(PathUtilities.IsAbsolute(resolvedKeyFile));
                    var fileContent = ImmutableArray.Create(FileSystem.ReadAllBytes(resolvedKeyFile));
                    return(StrongNameKeys.CreateHelper(fileContent, keyFilePath, hasCounterSignature));
                }
                catch (Exception ex)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, ex.Message)));
                }
            }
            else if (!string.IsNullOrEmpty(keyContainerName))
            {
                try
                {
                    ReadKeysFromContainer(keyContainerName, out publicKey);
                    container = keyContainerName;
                }
                catch (ClrStrongNameMissingException)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName,
                                                                               new CodeAnalysisResourcesLocalizableErrorArgument(nameof(CodeAnalysisResources.AssemblySigningNotSupported)))));
                }
                catch (Exception ex)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName, ex.Message)));
                }
            }

            return(new StrongNameKeys(keyPair, publicKey, privateKey: null, container, keyFilePath, hasCounterSignature));
        }
Ejemplo n.º 6
0
        internal StrongNameKeys CommonCreateKeys(StrongNameFileSystem fileSystem, string keyFilePath, ImmutableArray <string> keyFileSearchPaths, CommonMessageProvider messageProvider)
        {
            try
            {
                string resolvedKeyFile = fileSystem.ResolveStrongNameKeyFile(keyFilePath, keyFileSearchPaths);
                if (resolvedKeyFile == null)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, CodeAnalysisResources.FileNotFound)));
                }

                Debug.Assert(PathUtilities.IsAbsolute(resolvedKeyFile));
                var fileContent = ImmutableArray.Create(fileSystem.ReadAllBytes(resolvedKeyFile));
                return(StrongNameKeys.CreateHelper(fileContent, keyFilePath));
            }
            catch (Exception ex)
            {
                return(new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, ex.Message)));
            }
        }
        internal override StrongNameKeys CreateKeys(string keyFilePath, string keyContainerName, CommonMessageProvider messageProvider)
        {
            var    keyPair   = default(ImmutableArray <byte>);
            var    publicKey = default(ImmutableArray <byte>);
            string container = null;

            if (!string.IsNullOrEmpty(keyFilePath))
            {
                try
                {
                    string resolvedKeyFile = ResolveStrongNameKeyFile(keyFilePath);
                    if (resolvedKeyFile == null)
                    {
                        throw new FileNotFoundException(CodeAnalysisResources.FileNotFound, keyFilePath);
                    }

                    Debug.Assert(PathUtilities.IsAbsolute(resolvedKeyFile));
                    var fileContent = ImmutableArray.Create(ReadAllBytes(resolvedKeyFile));
                    return(StrongNameKeys.CreateHelper(fileContent, keyFilePath));
                }
                catch (IOException ex)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, ex.Message)));
                }
            }
            else if (!string.IsNullOrEmpty(keyContainerName))
            {
                try
                {
                    ReadKeysFromContainer(keyContainerName, out publicKey);
                    container = keyContainerName;
                }
                catch (IOException ex)
                {
                    return(new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName, ex.Message)));
                }
            }

            return(new StrongNameKeys(keyPair, publicKey, container, keyFilePath));
        }
        /// <exception cref="IOException"></exception>
        internal override void SignAssembly(StrongNameKeys keys, Stream inputStream, Stream outputStream)
        {
            Debug.Assert(inputStream is TempFileStream);

            var    tempStream       = (TempFileStream)inputStream;
            string assemblyFilePath = tempStream.Path;

            tempStream.DisposeUnderlyingStream();

            if (keys.KeyContainer != null)
            {
                Sign(assemblyFilePath, keys.KeyContainer);
            }
            else
            {
                Sign(assemblyFilePath, keys.KeyPair);
            }

            using (var fileToSign = PortableShim.FileStream.Create(assemblyFilePath, PortableShim.FileMode.Open))
            {
                fileToSign.CopyTo(outputStream);
            }
        }
Ejemplo n.º 9
0
 internal virtual void SignStream(StrongNameKeys keys, Stream inputStream, Stream outputStream)
 {
     throw new NotSupportedException();
 }
        /// <exception cref="IOException"></exception>
        internal override void SignAssembly(StrongNameKeys keys, Stream inputStream, Stream outputStream)
        {
            Debug.Assert(inputStream is TempFileStream);

            var tempStream = (TempFileStream)inputStream;
            string assemblyFilePath = tempStream.Name;
            tempStream.DisposeUnderlyingStream();

            if (keys.KeyContainer != null)
            {
                Sign(assemblyFilePath, keys.KeyContainer);
            }
            else
            {
                Sign(assemblyFilePath, keys.KeyPair);
            }

            using (var fileToSign = new FileStream(assemblyFilePath, FileMode.Open))
            {
                fileToSign.CopyTo(outputStream);
            }
        }
Ejemplo n.º 11
0
 internal abstract void SignAssembly(StrongNameKeys keys, Stream inputStream, Stream outputStream);
Ejemplo n.º 12
0
 /// <summary>
 /// Signs the <paramref name="filePath"/> value using <paramref name="keys"/>.
 /// </summary>
 internal abstract void SignFile(StrongNameKeys keys, string filePath);