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 3/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

toast react

Comment

0

// toast in react
// create toast.js component

import { toast } from 'react-toastify';
import 'react-toastify/dist/ReactToastify.css';

toast.configure()

const options = {
  autoClose: 2000,
  className: '',
  position: toast.POSITION.TOP_RIGHT,
};

export const toastSuccess = message => {
  console.log("Hello0 success toast")
  toast.success(message, options);
}

export const toastError = message => {
  toast.error(message, options);
}

export const toastWarning = message => {
  toast.warn(message, options);
}

export const toastInformation = message => {
  toast.info(message, options);
}

export const toastDark = message => {
  toast.dark(message, options);
}

export const toastDefault = message => {
  toast(message, options);
}

// wherever in need that toast use like this 

import { toastError, toastSuccess } from "./Toast";
toastSuccess("User successfully registered");
toastError("User is not created try again");

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: javascript j

Share

Link to this answer
Share Copy Link

Contributed on Jan 15 2023

Abhishek

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

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

golang crypto

Contents

More Related Answers

golang crypto

Closely Related Answers

toast react

golang crypto

golang crypto

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.