Refactor signature object to add support for repository countersignat…

…ures (#2006) * Refactor signature object to add support for repository countersignatures * move verification logic to signature classes
NuGet · Feb 9, 2018 · 894388a · 894388a
1 parent 6e5f350
commit 894388a
Show file tree

Hide file tree

Showing 41 changed files with 983 additions and 542 deletions.
diff --git a/src/NuGet.Core/NuGet.Common/Errors/NuGetLogCode.cs b/src/NuGet.Core/NuGet.Common/Errors/NuGetLogCode.cs
@@ -369,6 +369,21 @@ public enum NuGetLogCode
         /// </summary>
         NU3030 = 3030,
 
+        /// <summary>
+        /// The repository countersignature is invalid.
+        /// </summary>
+        NU3031 = 3031,
+
+        /// <summary>
+        /// The package signature contains multiple repository countersignatures.
+        /// </summary>
+        NU3032 = 3032,
+
+        /// <summary>
+        /// A repository primary signature must not have a repository countersignature.
+        /// </summary>
+        NU3033 = 3033,
+
         /// <summary>
         /// Undefined Package Error.
         /// </summary>

diff --git a/src/NuGet.Core/NuGet.Packaging/PackageArchiveReader.cs b/src/NuGet.Core/NuGet.Packaging/PackageArchiveReader.cs
@@ -227,7 +227,7 @@ public IEnumerable<ZipFilePair> EnumeratePackageEntries(IEnumerable<string> pack
             }
         }
 
-        public override async Task<Signature> GetSignatureAsync(CancellationToken token)
+        public override async Task<PrimarySignature> GetPrimarySignatureAsync(CancellationToken token)
         {
             token.ThrowIfCancellationRequested();
 
@@ -236,7 +236,7 @@ public override async Task<Signature> GetSignatureAsync(CancellationToken token)
                 throw new SignatureException(Strings.SignedPackageUnableToAccessSignature);
             }
 
-            Signature signature = null;
+            PrimarySignature signature = null;
 
             if (await IsSignedAsync(token))
             {
@@ -246,7 +246,7 @@ public override async Task<Signature> GetSignatureAsync(CancellationToken token)
                     using (var signatureEntryStream = signatureEntry.Open())
                     {
 #if IS_DESKTOP
-                        signature = Signature.Load(signatureEntryStream);
+                        signature = PrimarySignature.Load(signatureEntryStream);
 #endif
                     }
                 }

diff --git a/src/NuGet.Core/NuGet.Packaging/PackageFolderReader.cs b/src/NuGet.Core/NuGet.Packaging/PackageFolderReader.cs
@@ -220,9 +220,9 @@ protected override void Dispose(bool disposing)
             // do nothing here
         }
 
-        public override Task<Signature> GetSignatureAsync(CancellationToken token)
+        public override Task<PrimarySignature> GetPrimarySignatureAsync(CancellationToken token)
         {
-            return Task.FromResult<Signature>(null);
+            return Task.FromResult<PrimarySignature>(null);
         }
 
         public override Task<bool> IsSignedAsync(CancellationToken token)

diff --git a/src/NuGet.Core/NuGet.Packaging/PackageReaderBase.cs b/src/NuGet.Core/NuGet.Packaging/PackageReaderBase.cs
@@ -546,7 +546,7 @@ public virtual Task<string> CopyNupkgAsync(string nupkgFilePath, CancellationTok
             throw new NotImplementedException();
         }
 
-        public abstract Task<Signature> GetSignatureAsync(CancellationToken token);
+        public abstract Task<PrimarySignature> GetPrimarySignatureAsync(CancellationToken token);
 
         public abstract Task<bool> IsSignedAsync(CancellationToken token);
 

diff --git a/src/NuGet.Core/NuGet.Packaging/Signing/Authoring/ISignatureProvider.cs b/src/NuGet.Core/NuGet.Packaging/Signing/Authoring/ISignatureProvider.cs
@@ -21,6 +21,6 @@ public interface ISignatureProvider
         /// <param name="logger">Logger</param>
         /// <param name="token">Cancellation token.</param>
         /// <returns>A signature for the package.</returns>
-        Task<Signature> CreateSignatureAsync(SignPackageRequest request, SignatureContent signatureContent, ILogger logger, CancellationToken token);
+        Task<PrimarySignature> CreatePrimarySignatureAsync(SignPackageRequest request, SignatureContent signatureContent, ILogger logger, CancellationToken token);
     }
 }
diff --git a/src/NuGet.Core/NuGet.Packaging/Signing/Authoring/ITimestampProvider.cs b/src/NuGet.Core/NuGet.Packaging/Signing/Authoring/ITimestampProvider.cs
@@ -10,6 +10,6 @@ namespace NuGet.Packaging.Signing
     public interface ITimestampProvider
     {
         // Add timestamp to signature
-        Task<Signature> TimestampSignatureAsync(TimestampRequest request, ILogger logger, CancellationToken token);
+        Task<PrimarySignature> TimestampPrimarySignatureAsync(TimestampRequest request, ILogger logger, CancellationToken token);
     }
 }
diff --git a/src/NuGet.Core/NuGet.Packaging/Signing/Authoring/Signer.cs b/src/NuGet.Core/NuGet.Packaging/Signing/Authoring/Signer.cs
@@ -55,7 +55,7 @@ public async Task SignAsync(SignPackageRequest request, ILogger logger, Cancella
 
             var zipArchiveHash = await _package.GetArchiveHashAsync(request.SignatureHashAlgorithm, token);
             var signatureContent = GenerateSignatureContent(request.SignatureHashAlgorithm, zipArchiveHash);
-            var signature = await _signatureProvider.CreateSignatureAsync(request, signatureContent, logger, token);
+            var signature = await _signatureProvider.CreatePrimarySignatureAsync(request, signatureContent, logger, token);
 
             using (var stream = new MemoryStream(signature.GetBytes()))
             {

diff --git a/src/NuGet.Core/NuGet.Packaging/Signing/Authoring/TestSignatureProvider.cs b/src/NuGet.Core/NuGet.Packaging/Signing/Authoring/TestSignatureProvider.cs
@@ -10,14 +10,14 @@ namespace NuGet.Packaging.Signing
 {
     public class TestSignatureProvider : ISignatureProvider
     {
-        private readonly Signature _signature;
+        private readonly PrimarySignature _signature;
 
-        public TestSignatureProvider(Signature signature)
+        public TestSignatureProvider(PrimarySignature signature)
         {
             _signature = signature ?? throw new ArgumentNullException(nameof(signature));
         }
 
-        public Task<Signature> CreateSignatureAsync(SignPackageRequest request, SignatureContent signatureContent, ILogger logger, CancellationToken token)
+        public Task<PrimarySignature> CreatePrimarySignatureAsync(SignPackageRequest request, SignatureContent signatureContent, ILogger logger, CancellationToken token)
         {
             return Task.FromResult(_signature);
         }

diff --git a/src/NuGet.Core/NuGet.Packaging/Signing/Authoring/X509SignatureProvider.cs b/src/NuGet.Core/NuGet.Packaging/Signing/Authoring/X509SignatureProvider.cs
@@ -34,7 +34,7 @@ public X509SignatureProvider(ITimestampProvider timestampProvider)
         /// <summary>
         /// Sign the package stream hash with an X509Certificate2.
         /// </summary>
-        public Task<Signature> CreateSignatureAsync(SignPackageRequest request, SignatureContent signatureContent, ILogger logger, CancellationToken token)
+        public Task<PrimarySignature> CreatePrimarySignatureAsync(SignPackageRequest request, SignatureContent signatureContent, ILogger logger, CancellationToken token)
         {
             if (request == null)
             {
@@ -51,26 +51,26 @@ public Task<Signature> CreateSignatureAsync(SignPackageRequest request, Signatur
                 throw new ArgumentNullException(nameof(logger));
             }
 
-            var signature = CreateSignature(request, signatureContent, logger);
+            var signature = CreatePrimarySignature(request, signatureContent, logger);
 
             if (_timestampProvider == null)
             {
                 return Task.FromResult(signature);
             }
             else
             {
-                return TimestampSignature(request, logger, signature, token);
+                return TimestampPrimarySignatureAsync(request, logger, signature, token);
             }
         }
 
 #if IS_DESKTOP
-        private Signature CreateSignature(SignPackageRequest request, SignatureContent signatureContent, ILogger logger)
+        private PrimarySignature CreatePrimarySignature(SignPackageRequest request, SignatureContent signatureContent, ILogger logger)
         {
             var cmsSigner = CreateCmsSigner(request, logger);
 
             if (request.PrivateKey != null)
             {
-                return CreateSignature(cmsSigner, signatureContent, request.PrivateKey);
+                return CreatePrimarySignature(cmsSigner, signatureContent, request.PrivateKey);
             }
 
             var contentInfo = new ContentInfo(signatureContent.GetBytes());
@@ -89,7 +89,7 @@ private Signature CreateSignature(SignPackageRequest request, SignatureContent s
                 throw new SignatureException(NuGetLogCode.NU3001, exceptionBuilder.ToString());
             }
 
-            return Signature.Load(cms);
+            return PrimarySignature.Load(cms);
         }
 
         private static CmsSigner CreateCmsSigner(SignPackageRequest request, ILogger logger)
@@ -133,14 +133,14 @@ private static CmsSigner CreateCmsSigner(SignPackageRequest request, ILogger log
             return signer;
         }
 
-        private Signature CreateSignature(CmsSigner cmsSigner, SignatureContent signatureContent, CngKey privateKey)
+        private PrimarySignature CreatePrimarySignature(CmsSigner cmsSigner, SignatureContent signatureContent, CngKey privateKey)
         {
             var cms = NativeUtilities.NativeSign(cmsSigner, signatureContent.GetBytes(), privateKey);
 
-            return Signature.Load(cms);
+            return PrimarySignature.Load(cms);
         }
 
-        private Task<Signature> TimestampSignature(SignPackageRequest request, ILogger logger, Signature signature, CancellationToken token)
+        private Task<PrimarySignature> TimestampPrimarySignatureAsync(SignPackageRequest request, ILogger logger, PrimarySignature signature, CancellationToken token)
         {
             var timestampRequest = new TimestampRequest
             {
@@ -149,16 +149,16 @@ private Task<Signature> TimestampSignature(SignPackageRequest request, ILogger l
                 TimestampHashAlgorithm = request.TimestampHashAlgorithm
             };
 
-            return _timestampProvider.TimestampSignatureAsync(timestampRequest, logger, token);
+            return _timestampProvider.TimestampPrimarySignatureAsync(timestampRequest, logger, token);
         }
 
 #else
-        private Signature CreateSignature(SignPackageRequest request, SignatureContent signatureContent, ILogger logger)
+        private PrimarySignature CreatePrimarySignature(SignPackageRequest request, SignatureContent signatureContent, ILogger logger)
         {
             throw new NotSupportedException();
         }
 
-        private Task<Signature> TimestampSignature(SignPackageRequest request, ILogger logger, Signature signature, CancellationToken token)
+        private Task<PrimarySignature> TimestampPrimarySignatureAsync(SignPackageRequest request, ILogger logger, PrimarySignature signature, CancellationToken token)
         {
             throw new NotSupportedException();
         }

diff --git a/src/NuGet.Core/NuGet.Packaging/Signing/Package/ISignedPackageReader.cs b/src/NuGet.Core/NuGet.Packaging/Signing/Package/ISignedPackageReader.cs
@@ -17,7 +17,7 @@ public interface ISignedPackageReader : IDisposable
         /// Get package signature.
         /// </summary>
         /// <remarks>Returns a null if the package is unsigned.</remarks>
-        Task<Signature> GetSignatureAsync(CancellationToken token);
+        Task<PrimarySignature> GetPrimarySignatureAsync(CancellationToken token);
 
         /// <summary>
         /// Check if a package contains signing information.

diff --git a/src/NuGet.Core/NuGet.Packaging/Signing/Signatures/AuthorPrimarySignature.cs b/src/NuGet.Core/NuGet.Packaging/Signing/Signatures/AuthorPrimarySignature.cs
@@ -0,0 +1,42 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+#if IS_DESKTOP
+using System.Security.Cryptography.Pkcs;
+using System.Security.Cryptography.X509Certificates;
+#endif
+using NuGet.Common;
+
+namespace NuGet.Packaging.Signing
+{
+    public sealed class AuthorPrimarySignature : PrimarySignature
+    {
+#if IS_DESKTOP
+
+        public AuthorPrimarySignature(SignedCms signedCms)
+            : base(signedCms, SignatureType.Author)
+        {
+        }
+
+        internal override SignatureVerificationStatus Verify(
+            Timestamp timestamp,
+            SignedPackageVerifierSettings settings,
+            HashAlgorithmName fingerprintAlgorithm,
+            X509Certificate2Collection certificateExtraStore,
+            List<SignatureLog> issues)
+        {
+            if (issues == null)
+            {
+                throw new ArgumentNullException(nameof(issues));
+            }
+            settings = settings ?? SignedPackageVerifierSettings.Default;
+
+            issues.Add(SignatureLog.InformationLog(string.Format(CultureInfo.CurrentCulture, Strings.SignatureType, Type.ToString())));
+            return base.Verify(timestamp, settings, fingerprintAlgorithm, certificateExtraStore, issues);
+        }
+#endif
+    }
+}
diff --git a/src/NuGet.Core/NuGet.Packaging/Signing/Signatures/IRepositorySignature.cs b/src/NuGet.Core/NuGet.Packaging/Signing/Signatures/IRepositorySignature.cs
@@ -0,0 +1,17 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+
+namespace NuGet.Packaging.Signing
+{
+    public interface IRepositorySignature
+    {
+#if IS_DESKTOP
+        Uri V3ServiceIndexUrl { get; }
+
+        IReadOnlyList<string> PackageOwners { get; }
+#endif
+    }
+}