chore: implement signature storage, still need to load a key

Author: Emyrk

api/api.go

@@ -1,7 +1,9 @@
 package api
 
 import (
+	"context"
 	"encoding/json"
+	"io/fs"
 	"net/http"
 	"os"
 	"strconv"
@@ -112,7 +114,13 @@ func New(options *Options) *API {
 	r.Post("/api/extensionquery", api.extensionQuery)
 
 	// Endpoint for getting an extension's files or the extension zip.
-	r.Mount("/files", http.StripPrefix("/files", options.Storage.FileServer()))
+	r.Mount("/files", http.StripPrefix("/files", http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		// Convert the storage into a fs.FS, including the request context
+		http.FileServerFS(&contextFs{
+			ctx:  r.Context(),
+			open: options.Storage.Open,
+		}).ServeHTTP(rw, r)
+	})))
 
 	// VS Code can use the files in the response to get file paths but it will
 	// sometimes ignore that and use requests to /assets with hardcoded types to
@@ -256,3 +264,12 @@ func (api *API) assetRedirect(rw http.ResponseWriter, r *http.Request) {
 
 	http.Redirect(rw, r, url, http.StatusMovedPermanently)
 }
+
+type contextFs struct {
+	ctx  context.Context
+	open func(ctx context.Context, name string) (fs.File, error)
+}
+
+func (c *contextFs) Open(name string) (fs.File, error) {
+	return c.open(c.ctx, name)
+}

extensionsign/sigmanifest.go

@@ -2,12 +2,12 @@ package extensionsign
 
 import (
 	"bytes"
+	"crypto/sha256"
 	"encoding/base64"
 	"errors"
 	"fmt"
 	"io"
 
-	"github.com/cloudflare/cfssl/scan/crypto/sha256"
 	"golang.org/x/xerrors"
 
 	"github.com/coder/code-marketplace/storage/easyzip"

extensionsign/sigzip.go

@@ -3,7 +3,8 @@ package extensionsign
 import (
 	"archive/zip"
 	"bytes"
-	"crypto/ed25519"
+	"crypto"
+	"crypto/rand"
 	"encoding/json"
 
 	"golang.org/x/xerrors"
@@ -26,18 +27,9 @@ func ExtractSignatureManifest(zip []byte) (SignatureManifest, error) {
 	return manifest, nil
 }
 
-func SignAndZipVSIX(key ed25519.PrivateKey, vsix []byte) ([]byte, error) {
-	manifest, err := GenerateSignatureManifest(vsix)
-	if err != nil {
-		return nil, xerrors.Errorf("generate manifest: %w", err)
-	}
-	return SignAndZipManifest(key, manifest)
-}
-
-// SignAndZip signs a manifest and zips it up
-// Should be a PCKS8 key
-// TODO: Support other key types
-func SignAndZipManifest(key ed25519.PrivateKey, manifest SignatureManifest) ([]byte, error) {
+// SignAndZipManifest signs a manifest and zips it up
+// Sign
+func SignAndZipManifest(secret crypto.Signer, manifest json.RawMessage) ([]byte, error) {
 	var buf bytes.Buffer
 	w := zip.NewWriter(&buf)
 
@@ -46,12 +38,7 @@ func SignAndZipManifest(key ed25519.PrivateKey, manifest SignatureManifest) ([]b
 		return nil, xerrors.Errorf("create manifest: %w", err)
 	}
 
-	manifestData, err := json.Marshal(manifest)
-	if err != nil {
-		return nil, xerrors.Errorf("encode manifest: %w", err)
-	}
-
-	_, err = manFile.Write(manifestData)
+	_, err = manFile.Write(manifest)
 	if err != nil {
 		return nil, xerrors.Errorf("write manifest: %w", err)
 	}
@@ -68,12 +55,10 @@ func SignAndZipManifest(key ed25519.PrivateKey, manifest SignatureManifest) ([]b
 		return nil, xerrors.Errorf("create signature: %w", err)
 	}
 
-	signature := ed25519.Sign(key, manifestData)
-
-	//signature, err := key.Sign(rand.Reader, manifestData, crypto.SHA512)
-	//if err != nil {
-	//	return nil, xerrors.Errorf("sign: %w", err)
-	//}
+	signature, err := secret.Sign(rand.Reader, manifest, nil)
+	if err != nil {
+		return nil, xerrors.Errorf("sign: %w", err)
+	}
 
 	_, err = sigFile.Write(signature)
 	if err != nil {

storage/artifactory.go

@@ -7,9 +7,11 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 	"net/http"
 	"os"
 	"path"
+	"path/filepath"
 	"sort"
 	"strings"
 	"sync"
@@ -276,25 +278,32 @@ func (s *Artifactory) AddExtension(ctx context.Context, manifest *VSIXManifest,
 	return s.uri + dir, nil
 }
 
-func (s *Artifactory) FileServer() http.Handler {
-	// TODO: Since we only extract a subset of files perhaps if the file does not
-	// exist we should download the vsix and extract the requested file as a
-	// fallback.  Obviously this seems like quite a bit of overhead so we would
-	// then emit a warning so we can notice that VS Code has added new asset types
-	// that we should be extracting to avoid that overhead.  Other solutions could
-	// be implemented though like extracting the VSIX to disk locally and only
-	// going to Artifactory for the VSIX when it is missing on disk (basically
-	// using the disk as a cache).
-	return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
-		reader, code, err := s.read(r.Context(), r.URL.Path)
-		if err != nil {
-			http.Error(rw, err.Error(), code)
-			return
+// Open returns a file from Artifactory.
+// TODO: Since we only extract a subset of files perhaps if the file does not
+// exist we should download the vsix and extract the requested file as a
+// fallback.  Obviously this seems like quite a bit of overhead so we would
+// then emit a warning so we can notice that VS Code has added new asset types
+// that we should be extracting to avoid that overhead.  Other solutions could
+// be implemented though like extracting the VSIX to disk locally and only
+// going to Artifactory for the VSIX when it is missing on disk (basically
+// using the disk as a cache).
+func (s *Artifactory) Open(ctx context.Context, fp string) (fs.File, error) {
+	resp, code, err := s.request(ctx, http.MethodGet, path.Join(s.repo, fp), nil)
+	if err != nil {
+		switch code {
+		case http.StatusNotFound:
+			return nil, fs.ErrNotExist
+		case http.StatusForbidden:
+			return nil, fs.ErrPermission
+		default:
+			return nil, err
 		}
-		defer reader.Close()
-		rw.WriteHeader(http.StatusOK)
-		_, _ = io.Copy(rw, reader)
-	})
+	}
+
+	return artifactoryFile{
+		Response: resp,
+		path:     fp,
+	}, nil
 }
 
 func (s *Artifactory) Manifest(ctx context.Context, publisher, name string, version Version) (*VSIXManifest, error) {
@@ -443,3 +452,30 @@ func (s *Artifactory) Versions(ctx context.Context, publisher, name string) ([]V
 	sort.Sort(ByVersion(versions))
 	return versions, nil
 }
+
+type contextFs struct {
+	ctx  context.Context
+	open func(ctx context.Context, name string) (fs.File, error)
+}
+
+func (c *contextFs) Open(name string) (fs.File, error) {
+	return c.open(c.ctx, name)
+}
+
+var _ fs.File = (*artifactoryFile)(nil)
+var _ fs.FileInfo = (*artifactoryFile)(nil)
+
+type artifactoryFile struct {
+	*http.Response
+	path string
+}
+
+func (a artifactoryFile) Name() string               { return filepath.Base(a.path) }
+func (a artifactoryFile) Size() int64                { return a.Response.ContentLength }
+func (a artifactoryFile) Mode() fs.FileMode          { return fs.FileMode(0) } // ?
+func (a artifactoryFile) ModTime() time.Time         { return time.Now() }
+func (a artifactoryFile) IsDir() bool                { return false }
+func (a artifactoryFile) Sys() any                   { return nil }
+func (a artifactoryFile) Stat() (fs.FileInfo, error) { return a, nil }
+func (a artifactoryFile) Read(i []byte) (int, error) { return a.Response.Body.Read(i) }
+func (a artifactoryFile) Close() error               { return a.Response.Body.Close() }

storage/local.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"io/fs"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -141,8 +142,8 @@ func (s *Local) AddExtension(ctx context.Context, manifest *VSIXManifest, vsix [
 	return dir, nil
 }
 
-func (s *Local) FileServer() http.Handler {
-	return http.FileServer(http.Dir(s.extdir))
+func (s *Local) Open(_ context.Context, fp string) (fs.File, error) {
+	return http.Dir(s.extdir).Open(fp)
 }
 
 func (s *Local) Manifest(ctx context.Context, publisher, name string, version Version) (*VSIXManifest, error) {

storage/signature.go

@@ -1,8 +1,13 @@
 package storage
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
+	"io"
+	"io/fs"
+	"path/filepath"
+	"time"
 
 	"golang.org/x/xerrors"
 
@@ -11,6 +16,11 @@ import (
 
 var _ Storage = (*Signature)(nil)
 
+const (
+	sigzipFilename  = "extension.sigzip"
+	sigManifestName = ".signature.manifest"
+)
+
 type Signature struct {
 	// SignDesignExtensions is a flag that determines if the signature should
 	// include the extension payloads.
@@ -40,7 +50,7 @@ func (s *Signature) AddExtension(ctx context.Context, manifest *VSIXManifest, vs
 	}
 
 	return s.Storage.AddExtension(ctx, manifest, vsix, append(extra, File{
-		RelativePath: ".signature.manifest",
+		RelativePath: sigManifestName,
 		Content:      data,
 	})...)
 }
@@ -54,10 +64,50 @@ func (s *Signature) Manifest(ctx context.Context, publisher, name string, versio
 	if s.signExtensions {
 		manifest.Assets.Asset = append(manifest.Assets.Asset, VSIXAsset{
 			Type:        VSIXSignatureType,
-			Path:        "extension.sigzip",
+			Path:        sigzipFilename,
 			Addressable: "true",
 		})
 	}
 
 	return manifest, nil
 }
+
+func (s *Signature) Open(ctx context.Context, fp string) (fs.File, error) {
+	if s.signExtensions && filepath.Base(fp) == sigzipFilename {
+		// hijack this request, sign the sig manifest
+		manifest, err := s.Storage.Open(ctx, sigManifestName)
+		if err != nil {
+			return nil, err
+		}
+		defer manifest.Close()
+
+		key, _ := extensionsign.GenerateKey()
+		manifestData, err := io.ReadAll(manifest)
+		if err != nil {
+			return nil, xerrors.Errorf("read signature manifest: %w", err)
+		}
+
+		signed, err := extensionsign.SignAndZipManifest(key, manifestData)
+		if err != nil {
+			return nil, xerrors.Errorf("sign and zip manifest: %w", err)
+		}
+		return memFile{data: bytes.NewBuffer(signed), name: sigzipFilename}, nil
+	}
+
+	return s.Storage.Open(ctx, fp)
+}
+
+type memFile struct {
+	data *bytes.Buffer
+	name string
+}
+
+func (a memFile) Name() string               { return a.name }
+func (a memFile) Size() int64                { return int64(a.data.Len()) }
+func (a memFile) Mode() fs.FileMode          { return fs.FileMode(0) } // ?
+func (a memFile) ModTime() time.Time         { return time.Now() }
+func (a memFile) IsDir() bool                { return false }
+func (a memFile) Sys() any                   { return nil }
+func (a memFile) Stat() (fs.FileInfo, error) { return a, nil }
+func (a memFile) Read(i []byte) (int, error) { return a.data.Read(i) }
+func (a memFile) Close() error               { return nil }

storage/storage.go

@@ -6,6 +6,7 @@ import (
 	"encoding/xml"
 	"fmt"
 	"io"
+	"io/fs"
 	"net/http"
 	"os"
 	"regexp"
@@ -212,7 +213,8 @@ type Storage interface {
 	AddExtension(ctx context.Context, manifest *VSIXManifest, vsix []byte, extra ...File) (string, error)
 	// FileServer provides a handler for fetching extension repository files from
 	// a client.
-	FileServer() http.Handler
+	//FileServer() fs.FS
+	Open(ctx context.Context, name string) (fs.File, error)
 	// Manifest returns the manifest bytes for the provided extension.  The
 	// extension asset itself (the VSIX) will be included on the manifest even if
 	// it does not exist on the manifest on disk.