First commit

.gitignore

@@ -0,0 +1,3 @@
+cert.pem
+key.pem
+os-proxy

README.md

@@ -0,0 +1,22 @@
+# os-proxy
+
+Proxies calls to the OpenStack API with a self-signed certificate.
+
+All URLs in the OpenStack catalog are rewritten to point to the proxy itself, which will properly reverse proxy them to the original URL.
+
+**Required configuration:**
+* **-a**: URL of the remote OpenStack Keystone.
+* **-u**: URL the proxy will be reachable at.
+* **-f**: Flavor of the proxy Nova instance.
+* **-i**: Image of the proxy Nova instance.
+* **-u**: Name or ID of the public network where to create the floating IP.
+
+**Example:**
+```
+./proxy.sh \
+	-a 'https://keystone.example.com:13000' \
+	-u 'https://proxy.example.com:5443'     \
+	-f 'm1.s2.medium'                       \
+	-i 'rhcos'                              \
+	-n 'external'
+```

generate_cert.go

@@ -0,0 +1,167 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Generate a self-signed X.509 certificate for a TLS server. Outputs to
+// 'cert.pem' and 'key.pem' and will overwrite existing files.
+
+package main
+
+import (
+	"crypto/ecdsa"
+	"crypto/ed25519"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"flag"
+	"fmt"
+	"math/big"
+	"net"
+	"os"
+	"strings"
+	"time"
+)
+
+var (
+	validFrom  = flag.String("start-date", "", "Creation date formatted as Jan 1 15:04:05 2011")
+	validFor   = flag.Duration("duration", 5*time.Hour, "Duration that certificate is valid for")
+	isCA       = flag.Bool("ca", false, "whether this cert should be its own Certificate Authority")
+	rsaBits    = flag.Int("rsa-bits", 2048, "Size of RSA key to generate. Ignored if --ecdsa-curve is set")
+	ecdsaCurve = flag.String("ecdsa-curve", "", "ECDSA curve to use to generate a key. Valid values are P224, P256 (recommended), P384, P521")
+	ed25519Key = flag.Bool("ed25519", false, "Generate an Ed25519 key")
+)
+
+func publicKey(priv interface{}) interface{} {
+	switch k := priv.(type) {
+	case *rsa.PrivateKey:
+		return &k.PublicKey
+	case *ecdsa.PrivateKey:
+		return &k.PublicKey
+	case ed25519.PrivateKey:
+		return k.Public().(ed25519.PublicKey)
+	default:
+		return nil
+	}
+}
+
+func generateCertificate(host string) error {
+	if len(host) == 0 {
+		return fmt.Errorf("Missing required --host parameter")
+	}
+
+	var priv interface{}
+	var err error
+	switch *ecdsaCurve {
+	case "":
+		if *ed25519Key {
+			_, priv, err = ed25519.GenerateKey(rand.Reader)
+		} else {
+			priv, err = rsa.GenerateKey(rand.Reader, *rsaBits)
+		}
+	case "P224":
+		priv, err = ecdsa.GenerateKey(elliptic.P224(), rand.Reader)
+	case "P256":
+		priv, err = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	case "P384":
+		priv, err = ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
+	case "P521":
+		priv, err = ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
+	default:
+		return fmt.Errorf("Unrecognized elliptic curve: %q", *ecdsaCurve)
+	}
+	if err != nil {
+		return fmt.Errorf("Failed to generate private key: %v", err)
+	}
+
+	// ECDSA, ED25519 and RSA subject keys should have the DigitalSignature
+	// KeyUsage bits set in the x509.Certificate template
+	keyUsage := x509.KeyUsageDigitalSignature
+	// Only RSA subject keys should have the KeyEncipherment KeyUsage bits set. In
+	// the context of TLS this KeyUsage is particular to RSA key exchange and
+	// authentication.
+	if _, isRSA := priv.(*rsa.PrivateKey); isRSA {
+		keyUsage |= x509.KeyUsageKeyEncipherment
+	}
+
+	var notBefore time.Time
+	if len(*validFrom) == 0 {
+		notBefore = time.Now()
+	} else {
+		notBefore, err = time.Parse("Jan 2 15:04:05 2006", *validFrom)
+		if err != nil {
+			return fmt.Errorf("Failed to parse creation date: %v", err)
+		}
+	}
+
+	notAfter := notBefore.Add(*validFor)
+
+	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
+	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
+	if err != nil {
+		return fmt.Errorf("Failed to generate serial number: %v", err)
+	}
+
+	template := x509.Certificate{
+		SerialNumber: serialNumber,
+		Subject: pkix.Name{
+			Organization: []string{"Red Hat Inc."},
+		},
+		NotBefore: notBefore,
+		NotAfter:  notAfter,
+
+		KeyUsage:              keyUsage,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+		BasicConstraintsValid: true,
+	}
+
+	hosts := strings.Split(host, ",")
+	for _, h := range hosts {
+		if ip := net.ParseIP(h); ip != nil {
+			template.IPAddresses = append(template.IPAddresses, ip)
+		} else {
+			template.DNSNames = append(template.DNSNames, h)
+		}
+	}
+
+	if *isCA {
+		template.IsCA = true
+		template.KeyUsage |= x509.KeyUsageCertSign
+	}
+
+	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey(priv), priv)
+	if err != nil {
+		return fmt.Errorf("Failed to create certificate: %v", err)
+	}
+
+	certOut, err := os.Create("cert.pem")
+	if err != nil {
+		return fmt.Errorf("Failed to open cert.pem for writing: %v", err)
+	}
+	if err := pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
+		return fmt.Errorf("Failed to write data to cert.pem: %v", err)
+	}
+	if err := certOut.Close(); err != nil {
+		return fmt.Errorf("Error closing cert.pem: %v", err)
+	}
+	// log.Print("wrote cert.pem\n")
+
+	keyOut, err := os.OpenFile("key.pem", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	if err != nil {
+		return fmt.Errorf("Failed to open key.pem for writing: %v", err)
+	}
+	privBytes, err := x509.MarshalPKCS8PrivateKey(priv)
+	if err != nil {
+		return fmt.Errorf("Unable to marshal private key: %v", err)
+	}
+	if err := pem.Encode(keyOut, &pem.Block{Type: "PRIVATE KEY", Bytes: privBytes}); err != nil {
+		return fmt.Errorf("Failed to write data to key.pem: %v", err)
+	}
+	if err := keyOut.Close(); err != nil {
+		return fmt.Errorf("Error closing key.pem: %v", err)
+	}
+	// log.Print("wrote key.pem\n")
+	return nil
+}

go.mod

@@ -0,0 +1,9 @@
+module github.com/shiftstack/os-proxy
+
+go 1.14
+
+require (
+	github.com/BurntSushi/xdg v0.0.0-20130804141135-e80d3446fea1
+	github.com/gofrs/uuid v3.3.0+incompatible
+	gopkg.in/yaml.v2 v2.3.0
+)

go.sum

@@ -0,0 +1,8 @@
+github.com/BurntSushi/xdg v0.0.0-20130804141135-e80d3446fea1 h1:wm6oM17JoxfyN6IuKH8r3bU7Q2DjYRADJWgSHNfUXiY=
+github.com/BurntSushi/xdg v0.0.0-20130804141135-e80d3446fea1/go.mod h1:GTqQ4bvL7tTmcOwcZ3VVzwjWulHgjD2uamy76yuySp0=
+github.com/gofrs/uuid v3.3.0+incompatible h1:8K4tyRfvU1CYPgJsveYFQMhpFd/wXNM7iK6rR7UHz84=
+github.com/gofrs/uuid v3.3.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

main.go

@@ -0,0 +1,117 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+
+	"github.com/BurntSushi/xdg"
+	"github.com/shiftstack/os-proxy/proxy"
+	"gopkg.in/yaml.v2"
+)
+
+const (
+	defaultPort = "5443"
+)
+
+var (
+	proxyURL  = flag.String("proxyurl", "", "The host this proxy will be reachable")
+	osAuthURL = flag.String("authurl", "", "OpenStack entrypoint (OS_AUTH_URL)")
+)
+
+func getAuthURL(cloudName string) (string, error) {
+	cloudsPath, err := xdg.Paths{XDGSuffix: "openstack"}.ConfigFile("clouds.yaml")
+	if err != nil {
+		return "", err
+	}
+
+	cloudsFile, err := os.Open(cloudsPath)
+	if err != nil {
+		return "", err
+	}
+	defer cloudsFile.Close()
+
+	var clouds struct {
+		Clouds map[string]struct {
+			Auth struct {
+				URL string `yaml:"auth_url"`
+			} `yaml:"auth"`
+		} `yaml:"clouds"`
+	}
+
+	cloudsContent, err := ioutil.ReadAll(cloudsFile)
+	if err != nil {
+		return "", err
+	}
+
+	if err := yaml.Unmarshal(cloudsContent, &clouds); err != nil {
+		return "", err
+
+	}
+
+	if _, ok := clouds.Clouds[cloudName]; !ok {
+		return "", fmt.Errorf("cloud %q not found", cloudName)
+	}
+
+	return clouds.Clouds[cloudName].Auth.URL, nil
+}
+
+func main() {
+	flag.Parse()
+
+	if *proxyURL == "" {
+		log.Fatal("Missing required --proxyurl parameter")
+	}
+
+	if *osAuthURL == "" {
+		if osCloud := os.Getenv("OS_CLOUD"); osCloud != "" {
+			log.Print("Missing --authurl parameter; parsing from clouds.yaml")
+			var err error
+			*osAuthURL, err = getAuthURL(osCloud)
+			if err != nil {
+				log.Fatalf("Error parsing auth_url from cloud %q: %v", osCloud, err)
+			}
+		} else {
+			log.Fatal("Missing --authurl parameter. Set it or set the relative OS_CLOUD environment to enable parsing it from clouds.yaml.")
+		}
+	}
+
+	var proxyHost, proxyPort string
+	{
+		u, err := url.Parse(*proxyURL)
+		if err != nil {
+			log.Fatal(err)
+		}
+		proxyHost = u.Host
+		proxyPort = u.Port()
+		if proxyPort == "" {
+			proxyPort = defaultPort
+		}
+	}
+
+	p, err := proxy.NewOpenstackProxy(*proxyURL, *osAuthURL)
+	if err != nil {
+		panic(err)
+	}
+
+	log.Printf("Rewriting URLs to %q", proxyHost)
+	log.Printf("Proxying %q", *osAuthURL)
+
+	{
+		proxyDomain := strings.SplitN(proxyHost, ":", 2)[0]
+		if err := generateCertificate(proxyDomain); err != nil {
+			log.Fatal(err)
+		}
+		log.Printf("Certificate correctly generated for %q", proxyDomain)
+	}
+
+	log.Printf("Starting the server on %q...", proxyPort)
+	log.Fatal(
+		http.ListenAndServeTLS(":"+proxyPort, "cert.pem", "key.pem", p),
+	)
+}