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