working commit

pkg/auxx509/x509cert.go

@@ -0,0 +1,63 @@
+package auxx509
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"fmt"
+	"math/big"
+	"time"
+)
+
+func CreateSelfSignedCert(subject string, dnsNames ...string) ([]byte, []byte, error) {
+	var err error
+	certPem := make([]byte, 0)
+	keyPem := make([]byte, 0)
+
+	now := time.Now()
+
+	const yearsAfter int = 10
+	const keySize int = 2048
+
+	key, err := rsa.GenerateKey(rand.Reader, keySize)
+	if err != nil {
+		err := fmt.Errorf("Can't create a private key: %v", err)
+		return certPem, keyPem, err
+
+	}
+	keyPemBlock := pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: x509.MarshalPKCS1PrivateKey(key),
+	}
+	keyPem = pem.EncodeToMemory(&keyPemBlock)
+
+	names := make([]string, 0)
+	names = append(names, subject)
+	names = append(names, dnsNames...)
+	tml := x509.Certificate{
+		SerialNumber: big.NewInt(now.Unix()),
+		NotBefore:    now,
+		NotAfter:     now.AddDate(yearsAfter, 0, 0),
+		Subject: pkix.Name{
+			CommonName: subject,
+		},
+		DNSNames:              names,
+		BasicConstraintsValid: true,
+	}
+	certBytes, err := x509.CreateCertificate(rand.Reader, &tml, &tml, &key.PublicKey, key)
+	if err != nil {
+		return certPem, keyPem, fmt.Errorf("Can't create a certificate: %v", err)
+
+	}
+	certPemBlock := pem.Block{
+		Type:  "CERTIFICATE",
+		Bytes: certBytes,
+	}
+	certPem = pem.EncodeToMemory(&certPemBlock)
+	if err != nil {
+		return certPem, keyPem, err
+	}
+	return certPem, keyPem, err
+}

pkg/auxx509/x509cert_test.go

@@ -0,0 +1,15 @@
+package auxx509
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestCert(t *testing.T) {
+	caCert, caKey, err := CreateSelfSignedCert("test1")
+	require.NoError(t, err)
+	fmt.Println(string(caCert))
+	fmt.Println(string(caKey))
+}

pkg/client/client.go

@@ -3,6 +3,7 @@ package client
 import (
 	"context"
 	"crypto/tls"
+	"encoding/base64"
 	"fmt"
 	"io"
 	"net/http"
@@ -13,22 +14,28 @@ import (
 	"strings"
 )
 
+const fileAPI = "/v3/api/file/"
+
 type Client struct{}
 
 func NewClient() *Client {
 	return &Client{}
 }
 
-func (cli *Client) FileExists(ctx context.Context, reference string) (bool, error) {
+func (cli *Client) FileExists(ctx context.Context, ref string) (bool, error) {
 	var res bool
 	var err error
 
-	reqpath := fmt.Sprintf("/v3/api/file/%s", reference)
-
-	req, err := http.NewRequestWithContext(ctx, "HEAD", reqpath, nil)
+	ref, err = convertFileLink(ref)
 	if err != nil {
 		return res, err
 	}
+	req, err := http.NewRequestWithContext(ctx, "HEAD", ref, nil)
+	if err != nil {
+		return res, err
+	}
+	authValue := createBasicAuthPair
+
 	transport := &http.Transport{
 		TLSClientConfig: &tls.Config{
 			InsecureSkipVerify: true,
@@ -48,21 +55,33 @@ func (cli *Client) FileExists(ctx context.Context, reference string) (bool, erro
 	return res, err
 }
 
-func (cli *Client) GetFile(ctx context.Context, ref, filename string) error {
+func createBasicAuthPair(username, password string) string {
+	auth := username + ":" + password
+	return "Basic " + base64.StdEncoding.EncodeToString([]byte(auth))
+}
+
+func convertFileLink(ref string) (string, error) {
 	var err error
-
-	const api = "/v3/api/file/"
-
+	var res string
 	if !strings.Contains(ref, "://") {
 		ref = "https://" + ref
 	}
 	url, err := url.Parse(ref)
+	if err != nil {
+		return res, err
+	}
+	url.Path = path.Join(fileAPI, url.Path)
+	url.User = nil
+	res = url.String()
+	return res, err
+}
+
+func (cli *Client) GetFile(ctx context.Context, ref, filename string) error {
+	var err error
+	ref, err = convertFileLink(ref)
 	if err != nil {
 		return err
 	}
-	url.Path = path.Join(api, url.Path)
-	url.User = nil
-	ref = url.String()
 
 	req, err := http.NewRequestWithContext(ctx, "GET", ref, nil)
 	if err != nil {
@@ -81,6 +100,7 @@ func (cli *Client) GetFile(ctx context.Context, ref, filename string) error {
 		return err
 	}
 	defer resp.Body.Close()
+
 	if resp.StatusCode != http.StatusOK {
 		err := fmt.Errorf("Received wrong status code: %s", resp.StatusCode)
 		return err