tls13_enc.cc unsupported option '-G' for target 'arm64-apple-ios13.0'

Comment

0

post_install do |installer|
  installer.pods_project.targets.each do |target|
    if target.name == 'BoringSSL-GRPC'
      target.source_build_phase.files.each do |file|
        if file.settings && file.settings['COMPILER_FLAGS']
          flags = file.settings['COMPILER_FLAGS'].split
          flags.reject! { |flag| flag == '-GCC_WARN_INHIBIT_ALL_WARNINGS' }
          file.settings['COMPILER_FLAGS'] = flags.join(' ')
        end
      end
    end
  end
end

Popularity 1/10 Helpfulness 1/10 Language whatever

Source: stackoverflow.com

Tags: target whatever

Share

Link to this answer
Share Copy Link

Contributed on Sep 22 2024

Shadi Shakkour

0 Answers Avg Quality 2/10

golang crypto

Comment

0

	salt := rand.Reader

	headers := AsymmetricSignatureSnap{}
	headers.ClientKey = mandiriClientKey
	headers.TimeStamp = time.Now().Add(time.Duration(time.Second * 10)).Format(time.RFC3339)

	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		panic(fmt.Errorf("GenerateKey :%s", err.Error()))
	}

	cipherText := []byte(headers.ClientKey + ":" + headers.TimeStamp)
	// cipherTextHash256 := sha256.New()
	// cipherTextHash256.Write(cipherText)
	// cipherTextHash := cipherTextHash256.Sum(nil)

	secretKey := []byte(mandriPrivateKey)
	secretKeyHash256 := sha256.New()
	secretKeyHash256.Write(secretKey)
	secretKeyHash := secretKeyHash256.Sum(nil)

	// err = rsa.DecryptPKCS1v15SessionKey(salt, privateKey, secretKey, secretKeyHash)
	// if err != nil {
	// 	panic(fmt.Errorf("DecryptPKCS1v15SessionKey: %s", err.Error()))
	// }

	privateKeySign, err := privateKey.Sign(salt, secretKeyHash, crypto.SHA256)
	if err != nil {
		panic(fmt.Errorf("Sign: %s", err.Error()))
	}

	fmt.Println("Sign: ", base64.StdEncoding.EncodeToString(privateKeySign))

	// privateKeySign, err := rsa.SignPSS(salt, privateKey, crypto.SHA256, sha256Key, nil)
	// if err != nil {
	// 	panic(fmt.Errorf("SignPSS: %s", err.Error()))
	// }

	// err = rsa.VerifyPSS(&privateKey.PublicKey, crypto.SHA256, sha256Key, privateKeySign, nil)
	// if err != nil {
	// 	panic(fmt.Errorf("VerifyPSS: %s", err.Error()))
	// }

	// x509Config := x509.Certificate{}
	// x509Config.SerialNumber = big.NewInt(2096)
	// x509Config.PublicKeyAlgorithm = x509.PublicKeyAlgorithm(x509.PEMCipherAES256)
	// x509Config.SignatureAlgorithm = x509.SignatureAlgorithm(x509.SHA256WithRSA)

	// x509Res, err := x509.CreateCertificate(salt, &x509Config, &x509Config, privateKey.Public(), privateKey)
	// if err != nil {
	// 	panic(fmt.Errorf("CreateCertificate: %s", err.Error()))
	// }

	pemPrivateKeyOptions := &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)}
	pemPrivateKey := new(bytes.Buffer)

	if err := pem.Encode(pemPrivateKey, pemPrivateKeyOptions); err != nil {
		panic(fmt.Errorf("MarshalPKCS1PrivateKey: %s", err.Error()))
	}

	fmt.Printf("\n")
	fmt.Println("pemPrivateKey: ", base64.StdEncoding.EncodeToString(pemPrivateKey.Bytes()))

	pemPublicKeyOptions := &pem.Block{Type: "PUBLIC KEY", Bytes: x509.MarshalPKCS1PublicKey(&privateKey.PublicKey)}
	pemPublic := new(bytes.Buffer)

	if err := pem.Encode(pemPublic, pemPublicKeyOptions); err != nil {
		panic(fmt.Errorf("MarshalPKCS1PublicKey: %s", err.Error()))
	}

	fmt.Printf("\n")
	fmt.Println("pemPublic: ", base64.StdEncoding.EncodeToString(pemPublic.Bytes()))

	encryptOAEP, err := rsa.EncryptOAEP(crypto.Hash(x509.SHA256WithRSA).New(), salt, &privateKey.PublicKey, cipherText, nil)
	if err := pem.Encode(pemPublic, pemPublicKeyOptions); err != nil {
		panic(fmt.Errorf("EncryptOAEP: %s", err.Error()))
	}

	fmt.Printf("\n")
	fmt.Println("EncryptOAEP: ", base64.StdEncoding.EncodeToString(encryptOAEP))

	signPKCS1v15, err := rsa.SignPKCS1v15(salt, privateKey, crypto.Hash(x509.SHA256WithRSA), encryptOAEP)
	if err := pem.Encode(pemPublic, pemPublicKeyOptions); err != nil {
		panic(fmt.Errorf("SignPKCS1v15: %s", err.Error()))
	}

	fmt.Printf("\n")
	fmt.Println("SignPKCS1v15: ", base64.StdEncoding.EncodeToString(signPKCS1v15))

Popularity 6/10 Helpfulness 2/10 Language go

Source: Grepper

Tags: go

Share

Link to this answer
Share Copy Link

Contributed on Apr 20 2023

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

golang crypto

Comment

0

golang crypto

package helpers

import (
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"crypto/x509"
	"encoding/base64"
	"encoding/pem"
	"errors"
	"os"
	"strings"
)

func (h *rsaCrypto) Asymmetric(req *Asymmetric, password string) error {
	salt := rand.Reader
	rsaPrivateKey := new(rsa.PrivateKey)

	internalClientID := os.Getenv("INTERNAL_CLIENT_ID")
	internalClientKey := os.Getenv("INTERNAL_CLIENT_KEY")
	internalPrivateKey := os.Getenv("INTERNAL_PRIVATE_KEY")
	internalPublicKey := os.Getenv("INTERNAL_PUBLIC_KEY")

	headers := Asymmetric{}
	headers.ClientID = strings.TrimSpace(req.ClientID)
	headers.ClientKey = strings.TrimSpace(req.ClientKey)
	headers.PrivateKey = strings.TrimSpace(req.PrivateKey)

	cipherBody := []byte(headers.ClientID + ":" + headers.ClientKey + ":" + headers.PrivateKey)
	cipherBodyHash256 := sha256.New()
	cipherBodyHash256.Write(cipherBody)
	cipherBodyHash := cipherBodyHash256.Sum(nil)

	if headers.PrivateKey == "" {
		return errors.New("PEM PrivateKey certificate must be a base64 format")
	} else if headers.ClientID != internalClientID {
		return errors.New("Invalid ClientId")
	} else if headers.ClientKey != internalClientKey {
		return errors.New("Invalid ClientKey")
	} else if strings.Compare(headers.PrivateKey, internalPrivateKey) != 0 {
		return errors.New("Invalid PrivateKey")
	}

	decodedPrivateKey, err := base64.StdEncoding.DecodeString(headers.PrivateKey)
	if err != nil {
		return err
	}

	headers.PrivateKey = string(decodedPrivateKey)
	pemDecode, _ := pem.Decode([]byte(headers.PrivateKey))

	if pemDecode == nil {
		return errors.New("Invalid PEM PrivateKey certificate")
	}

	switch pemDecode.Type {
	case PRIVPKCS1:
		if password != "" && x509.IsEncryptedPEMBlock(pemDecode) {
			pemBlockDecrypt, err := x509.DecryptPEMBlock(pemDecode, []byte(strings.TrimSpace(password)))
			if err != nil {
				return err
			}

			parsePrivateKey, err := x509.ParsePKCS1PrivateKey(pemBlockDecrypt)
			if err != nil {
				return err
			}

			rsaPrivateKey = parsePrivateKey
		}

		parsePrivateKey, err := x509.ParsePKCS1PrivateKey(pemDecode.Bytes)
		if err != nil {
			return err
		}

		rsaPrivateKey = parsePrivateKey

		break

	case PRIVPKCS8:
		if password != "" && x509.IsEncryptedPEMBlock(pemDecode) {
			pemBlockDecrypt, err := x509.DecryptPEMBlock(pemDecode, []byte(strings.TrimSpace(password)))
			if err != nil {
				return err
			}

			parsePrivateKey, err := x509.ParsePKCS8PrivateKey(pemBlockDecrypt)
			if err != nil {
				return err
			}

			rsaPrivateKey = parsePrivateKey.(*rsa.PrivateKey)
		}

		parsePrivateKey, err := x509.ParsePKCS8PrivateKey(pemDecode.Bytes)
		if err != nil {
			return err
		}

		rsaPrivateKey = parsePrivateKey.(*rsa.PrivateKey)

		break

	default:
		return errors.New("Invalid PEM PrivateKey certificate")
	}

	if err := rsaPrivateKey.Validate(); err != nil {
		return err
	}

	signature, err := rsa.SignPKCS1v15(salt, rsaPrivateKey, crypto.SHA256, cipherBodyHash)
	if err != nil {
		return err
	}

	rsaPublicKeyRaw, err := h.PublicKey(internalPublicKey, true)
	if err != nil {
		return err
	}

	rsaPublicKey, err := x509.ParsePKIXPublicKey(rsaPublicKeyRaw)
	if err != nil {
		return err
	}

	if err := rsa.VerifyPKCS1v15(rsaPublicKey.(*rsa.PublicKey), crypto.SHA256, cipherBodyHash, signature); err != nil {
		return err
	}

	return nil
}

Popularity 2/10 Helpfulness 1/10 Language go

Source: Grepper

Tags: go

Share

Link to this answer
Share Copy Link

Contributed on Sep 22 2024

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

golang crypto

Comment

0

golang crypto

const (
	PRIVPKCS1 = "RSA PRIVATE KEY"
	PRIVPKCS8 = "PRIVATE KEY"

	PUBPKCS1    = "RSA PUBLIC KEY"
	PUBPKCS8    = "PUBLIC KEY"
	CERTIFICATE = "CERTIFICATE"
)

type (
	IRsaCrypto interface {
		PrivateKey(value string) error
		PublicKey(value string, raw bool) ([]byte, error)
		Asymmetric(req *Asymmetric, password string) error
	}

	Asymmetric struct {
		ClientID   string `json:"clientId"`
		ClientKey  string `json:"clientKey"`
		PrivateKey string `json:"privateKey"`
	}

	rsaCrypto struct{}
)

func NewRsa() IRsaCrypto {
	return &rsaCrypto{}
}

func (h *rsaCrypto) PrivateKey(value string) error {
	var privateKey string

	decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(value))
	if err != nil {
		return err
	}

	pemDecoded, _ := pem.Decode([]byte(decoded))
	if pemDecoded == nil {
		return errors.New("Invalid PEM PrivateKey certificate")
	}

	if pemDecoded.Type == PRIVPKCS1 {
		privateKey = string(pem.EncodeToMemory(pemDecoded))
	} else if pemDecoded.Type == PRIVPKCS8 {
		privateKey = string(pem.EncodeToMemory(pemDecoded))
	} else if pemDecoded.Type == CERTIFICATE {
		privateKey = string(pem.EncodeToMemory(pemDecoded))
	} else {
		return errors.New("Invalid PEM PrivateKey certificate")
	}

	if privateKey == "" {
		return errors.New("Invalid PEM PrivateKey certificate")
	}

	return nil
}

func (h *rsaCrypto) PublicKey(value string, rawPem bool) ([]byte, error) {
	var publicKey []byte

	externalPublicKey, err := base64.StdEncoding.DecodeString(strings.TrimSpace(value))
	if err != nil {
		return nil, err
	}

	pemDecoded, _ := pem.Decode([]byte(externalPublicKey))
	if pemDecoded == nil {
		return nil, errors.New("Invalid PEM PublicKey certificate")
	}

	if !rawPem && pemDecoded.Type == PUBPKCS1 {
		publicKey = pem.EncodeToMemory(pemDecoded)
	} else if !rawPem && pemDecoded.Type == PUBPKCS8 {
		publicKey = pem.EncodeToMemory(pemDecoded)
	} else if !rawPem && pemDecoded.Type == CERTIFICATE {
		publicKey = pem.EncodeToMemory(pemDecoded)
	} else {
		publicKey = pemDecoded.Bytes
	}

	return publicKey, nil
}

// NEXT CODE IN BELOW

Popularity 1/10 Helpfulness 1/10 Language go

Source: Grepper

Tags: go

Share

Link to this answer
Share Copy Link

Contributed on Sep 22 2024

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

tls13_enc.cc unsupported option '-G' for target 'arm64-apple-ios13.0'

Contents

More Related Answers