1package main
  2
  3import (
  4	"crypto/rsa"
  5	"crypto/x509"
  6	"encoding/asn1"
  7	"encoding/json"
  8	"encoding/pem"
  9	"errors"
 10	"fmt"
 11	"io/ioutil"
 12	"os"
 13	"time"
 14
 15	"github.com/fatih/color"
 16)
 17
 18type Key struct {
 19	ID             string         `json:"id"`
 20	PrivK          string         `json:"privK"` //path of the PrivK file
 21	PubK           string         `json:"pubK"`  //path of the PubK file
 22	Date           time.Time      `json:"date"`
 23	Hashed         []byte         `json:"hashed"`
 24	UnblindedSig   []byte         `json:"unblindedsig"`
 25	Verified       bool           `json:"verified"`
 26	ServerVerifier *rsa.PublicKey `json:"serververifier"`
 27	SignerID       string         `json:"signerid"`
 28	BlockchainRef  string         `json:"blockchainref"`
 29}
 30
 31func ExportRsaPrivateKeyAsPemStr(privkey *rsa.PrivateKey) string {
 32	privkey_bytes := x509.MarshalPKCS1PrivateKey(privkey)
 33	privkey_pem := pem.EncodeToMemory(
 34		&pem.Block{
 35			Type:  "RSA PRIVATE KEY",
 36			Bytes: privkey_bytes,
 37		},
 38	)
 39	return string(privkey_pem)
 40}
 41
 42func ParseRsaPrivateKeyFromPemStr(privPEM string) (*rsa.PrivateKey, error) {
 43	block, _ := pem.Decode([]byte(privPEM))
 44	if block == nil {
 45		return nil, errors.New("failed to parse PEM block containing the key")
 46	}
 47	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
 48	if err != nil {
 49		return nil, err
 50	}
 51	return priv, nil
 52}
 53
 54func ExportRsaPublicKeyAsPemStr(pubkey rsa.PublicKey) (string, error) {
 55	asn1Bytes, err := asn1.Marshal(pubkey)
 56	check(err)
 57	pubkey_pem := pem.EncodeToMemory(
 58		&pem.Block{
 59			Type:  "PUBLIC KEY",
 60			Bytes: asn1Bytes,
 61		},
 62	)
 63	color.Red("pubkey_pem")
 64	fmt.Println(pubkey_pem)
 65	return string(pubkey_pem), nil
 66}
 67
 68func ParseRsaPublicKeyFromPemStr(pubPEM string) (pub rsa.PublicKey, err error) {
 69	pemBlock, _ := pem.Decode([]byte(pubPEM))
 70	_, err = asn1.Unmarshal(pemBlock.Bytes, &pub)
 71	return
 72}
 73
 74func savePEMKey(fileName string, key *rsa.PrivateKey) {
 75	outFile, err := os.Create(fileName)
 76	check(err)
 77	defer outFile.Close()
 78
 79	var privateKey = &pem.Block{
 80		Type:  "PRIVATE KEY",
 81		Bytes: x509.MarshalPKCS1PrivateKey(key),
 82	}
 83
 84	err = pem.Encode(outFile, privateKey)
 85	check(err)
 86}
 87func savePublicPEMKey(fileName string, pubkey rsa.PublicKey) {
 88	asn1Bytes, err := asn1.Marshal(pubkey)
 89	check(err)
 90
 91	var pemkey = &pem.Block{
 92		Type:  "PUBLIC KEY",
 93		Bytes: asn1Bytes,
 94	}
 95
 96	pemfile, err := os.Create(fileName)
 97	check(err)
 98	defer pemfile.Close()
 99
100	err = pem.Encode(pemfile, pemkey)
101	check(err)
102}
103func openPEMKey(path string) (key *rsa.PrivateKey, err error) {
104	b, err := ioutil.ReadFile(path)
105	if err != nil {
106		fmt.Print(err)
107	}
108	key, err = ParseRsaPrivateKeyFromPemStr(string(b))
109	return
110}
111func openPublicPEMKey(path string) (key rsa.PublicKey, err error) {
112	b, err := ioutil.ReadFile(path)
113	if err != nil {
114		fmt.Print(err)
115	}
116	key, err = ParseRsaPublicKeyFromPemStr(string(b))
117	return
118}
119func readKeys() []Key {
120	path := keysDir + "/keys.json"
121	var keys []Key
122
123	file, err := ioutil.ReadFile(path)
124	check(err)
125	content := string(file)
126	json.Unmarshal([]byte(content), &keys)
127
128	return keys
129}
130
131func saveKeys(keys []Key) {
132	jsonKeys, err := json.Marshal(keys)
133	check(err)
134	err = ioutil.WriteFile(keysDir+"/keys.json", jsonKeys, 0644)
135	check(err)
136}
137func saveKey(k Key) {
138	fmt.Println(k)
139	keys := readKeys()
140	for i, key := range keys {
141		if key.ID == k.ID {
142			keys[i] = k
143		}
144	}
145	saveKeys(keys)
146}
147func getKeyByKeyID(keyID string) (k Key) {
148	keys := readKeys()
149	for _, key := range keys {
150		if key.ID == keyID {
151			k = key
152		}
153	}
154	return k
155}
156func removeKey(keyID string, originalKeys []Key) (keys []Key) {
157	for _, key := range originalKeys {
158		if key.ID != keyID {
159			keys = append(keys, key)
160		}
161	}
162	return
163}
164
165/*
166func getServerPubK(url string) ownrsa.RSAPublicKey {
167	r, err := http.Get(url + "/")
168	check(err)
169	fmt.Println(r)
170
171	decoder := json.NewDecoder(r.Body)
172	//var sigmaString string
173	var pubK ownrsa.RSAPublicKey
174	err = decoder.Decode(&pubK)
175	if err != nil {
176		panic(err)
177	}
178	defer r.Body.Close()
179	color.Blue("received server pubK:")
180	fmt.Println(pubK)
181	return pubK
182}
183*/