implementing with rsa library

serverIDsigner/keys.go

@@ -0,0 +1,104 @@
+package main
+
+import (
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/asn1"
+	"encoding/json"
+	"encoding/pem"
+	"io/ioutil"
+	"os"
+	"time"
+)
+
+type Key struct {
+	ID       string    `json:"id"`
+	PrivK    string    `json:"privK"` //path of the PrivK file
+	PubK     string    `json:"pubK"`  //path of the PubK file
+	Date     time.Time `json:"date"`
+	Verified bool      `json:"verified"`
+	Signed   string    `json:"signed"`
+}
+
+func savePEMKey(fileName string, key *rsa.PrivateKey) {
+	outFile, err := os.Create(fileName)
+	check(err)
+	defer outFile.Close()
+
+	var privateKey = &pem.Block{
+		Type:  "PRIVATE KEY",
+		Bytes: x509.MarshalPKCS1PrivateKey(key),
+	}
+
+	err = pem.Encode(outFile, privateKey)
+	check(err)
+}
+func savePublicPEMKey(fileName string, pubkey rsa.PublicKey) {
+	asn1Bytes, err := asn1.Marshal(pubkey)
+	check(err)
+
+	var pemkey = &pem.Block{
+		Type:  "PUBLIC KEY",
+		Bytes: asn1Bytes,
+	}
+
+	pemfile, err := os.Create(fileName)
+	check(err)
+	defer pemfile.Close()
+
+	err = pem.Encode(pemfile, pemkey)
+	check(err)
+}
+func openPEMKey(path string) (key rsa.PrivateKey) {
+	return
+}
+func openPublicPEMKey(path string) (key rsa.PublicKey) {
+	return
+}
+func readKeys() []Key {
+	path := keysDir + "/keys.json"
+	var keys []Key
+
+	file, err := ioutil.ReadFile(path)
+	check(err)
+	content := string(file)
+	json.Unmarshal([]byte(content), &keys)
+
+	return keys
+}
+
+func saveKeys(keys []Key) {
+	jsonKeys, err := json.Marshal(keys)
+	check(err)
+	err = ioutil.WriteFile(keysDir+"/keys.json", jsonKeys, 0644)
+	check(err)
+}
+func getKeyByKeyID(keyID string) (k Key) {
+	keys := readKeys()
+	for _, key := range keys {
+		if key.ID == keyID {
+			k = key
+		}
+	}
+	return k
+}
+
+/*
+func getServerPubK(url string) ownrsa.RSAPublicKey {
+	r, err := http.Get(url + "/")
+	check(err)
+	fmt.Println(r)
+
+	decoder := json.NewDecoder(r.Body)
+	//var sigmaString string
+	var pubK ownrsa.RSAPublicKey
+	err = decoder.Decode(&pubK)
+	if err != nil {
+		panic(err)
+	}
+	defer r.Body.Close()
+	color.Blue("received server pubK:")
+	fmt.Println(pubK)
+	return pubK
+}
+*/

serverIDsigner/keys/server_private.pem

@@ -0,0 +1,27 @@
+-----BEGIN PRIVATE KEY-----
+MIIEpQIBAAKCAQEA061q3ahXEG9rHf/uekmIk4fSvtG8p7OwkjP3PlafFjxeA4BS
+8dkjPUEboXMftQCFrzWc5nLyQR4Ig5xMzjaEbQv/JBdpP/E1nl+fC6ca45Rov0OE
+7OQrDyEPb1qNJ3uQmh+N9ZvTLNndT3bBxtBfmIRyMq+78mMumzNvFbx6zfNpwv9T
+HDgBnfZoAZ7gpIZeKn/yFasQmzFwpy9hfqZ21SCL7GmiU+nAz2TxtyFkUttMeIxD
+gSSKLYxzt6mKdElNv0K97tBU1eRaXz4hpq/I0dtmcidrS/45MtXij6wO1agIvnH+
+pygSI5QF3rE+lVYaDuKJZ6QBvnNEF9/cu7j/ZQIDAQABAoIBAQDAP+apPnUkpi0B
+aCqtwg9a/qb3TAItxdN+VdgeNAn05gr03x12LiIFRhbUQXzwpXLFOMoxuwAvCBnv
+fot7VqRbbePiYajjvC1Yk7wdlz2iqG2iGK6ngGtjKEGefv1oeJ9Se4oxIb9gItcP
+jupbqXDJUrFtO5JViKMRrlsbwL1AQkWafiBJyfaeO9f6fikrv9dWJCE/wDN6F4XB
+cVZj30GzBVpLfq6cuP1I7o1txNdRivPza4S6zufy53CfkFqsyjehFfvmlMCK+6/p
+6EDd1pag3tfr/+1k1BGKwSgQyOBUYWS3FwW9J6wMm6bkUFmhAgJhl/cQmOPTas1/
+5OQxmaqZAoGBANthrMTPuMefYypKxbb+AxURpe09W+AVxm3PjtaOWkGKYIKFZD/+
+q4t9Jgc6H8vj92XMC7fsE8W9hJa5btTvvHzhLp+5lxxpO9idh2E7whFf7JpVs4aZ
+8WhITZKiOja5sMXe0u8/L2zLN8ANmHo4Yh87pKd+DvNYaANYTQxtxvLfAoGBAPcC
+iiwQ4FtlBXba305NqOwwPg126+Jl1hZ1gECHAPpnB05cIq584dDPEW2Crqs3zYEG
+JyvXmAdB+GqVgY2OpRJDCB05kIzevDFSiu4wE7WA2/tMHcP4hNGtnG/iOUyiHPMq
+pdxWDCq7pyvZELl8CHsL1PZ1uVZKqVnn4VBbt7o7AoGBAMRZ4slwZaD9rkLvE5Ea
+PmYAGrOAxJeGxcgJCn5MgMnCcWjAvR5t8NnzFDNJuaXCju5kt2RRfszwOBizNViO
+jfRzk0hQUsiSA4d4TvAfDS6B3YGxDPJ/HEtK02tXmaTbhDVFnyOVOPw10tspD/zs
+NB5iQpfKwtTYnpfH04Y5RuSfAoGAMVzfkgjZXUpl+iepYrOgY3sMm5I9d6QUUa6v
+r7WLG3+FdUJyZ95rHliTSghIsczYE8XQBDH0ntavN1Wja0+ra2fb8kMzwQMuJskx
+HIKdHbOfwqumcyhyGpkQX0edXdQz5uCJ/utvSQbxVJDvh7Hi2/w0VgCWxkjraR0u
+6Ok7YUsCgYEAjiJng9gj3GGZ6noBZ+lcK2VU839yExkJzj68lBzviMeD0kuyVN7R
+fNpUOtjgR1a2paJLyXFq2a2AyhakA6r87GGGAGW3o6TCEw3jTXcc2L3CX113Ee5N
+DbXbE9rXB8OT0q/x1ugoel+nFQMW+wwAigMl50DcENczyStJNQoXP9I=
+-----END PRIVATE KEY-----

serverIDsigner/keys/server_public.pem

@@ -0,0 +1,8 @@
+-----BEGIN PUBLIC KEY-----
+MIIBCgKCAQEA061q3ahXEG9rHf/uekmIk4fSvtG8p7OwkjP3PlafFjxeA4BS8dkj
+PUEboXMftQCFrzWc5nLyQR4Ig5xMzjaEbQv/JBdpP/E1nl+fC6ca45Rov0OE7OQr
+DyEPb1qNJ3uQmh+N9ZvTLNndT3bBxtBfmIRyMq+78mMumzNvFbx6zfNpwv9THDgB
+nfZoAZ7gpIZeKn/yFasQmzFwpy9hfqZ21SCL7GmiU+nAz2TxtyFkUttMeIxDgSSK
+LYxzt6mKdElNv0K97tBU1eRaXz4hpq/I0dtmcidrS/45MtXij6wO1agIvnH+pygS
+I5QF3rE+lVYaDuKJZ6QBvnNEF9/cu7j/ZQIDAQAB
+-----END PUBLIC KEY-----

serverIDsigner/main.go

@@ -1,21 +1,25 @@
 package main
 
 import (
-	"fmt"
+	"crypto/rand"
+	"crypto/rsa"
 	"log"
 	"net/http"
+	"os"
 
 	mgo "gopkg.in/mgo.v2"
 
 	"github.com/fatih/color"
 	"github.com/gorilla/handlers"
-
-	ownrsa "./ownrsa"
 )
 
+const keysDir = "keys"
+const keysize = 2048
+const hashize = 1536
+
 var userCollection *mgo.Collection
 
-var serverRSA ownrsa.RSA
+var serverKey *rsa.PrivateKey
 
 func main() {
 	color.Blue("Starting serverIDsigner")
@@ -23,14 +27,20 @@ func main() {
 	//read configuration file
 	readConfig("config.json")
 
+	//create models directory
+	_ = os.Mkdir(keysDir, os.ModePerm)
+
 	initializeToken()
 
 	//initialize RSA
-	serverRSA = ownrsa.GenerateKeyPair()
-	color.Blue("Public Key:")
-	fmt.Println(serverRSA.PubK)
-	color.Green("Private Key:")
-	fmt.Println(serverRSA.PrivK)
+	//generate RSA keys pair
+	reader := rand.Reader
+	k, err := rsa.GenerateKey(reader, keysize)
+	check(err)
+	serverKey = k
+
+	savePEMKey(keysDir+"/server_private.pem", k)
+	savePublicPEMKey(keysDir+"/server_public.pem", k.PublicKey)
 
 	//mongodb
 	session, err := getSession()

serverIDsigner/userRESTFunctions.go

@@ -1,16 +1,15 @@
 package main
 
 import (
+	"crypto/rsa"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"strconv"
 	"strings"
 
-	"github.com/fatih/color"
+	"github.com/cryptoballot/rsablind"
 	"gopkg.in/mgo.v2/bson"
-
-	ownrsa "./ownrsa"
 )
 
 type User struct {
@@ -23,7 +22,7 @@ type User struct {
 func Index(w http.ResponseWriter, r *http.Request) {
 	//TODO return the public key, to allow others verifign signed strings by this server
 
-	jResp, err := json.Marshal(serverRSA.PubK)
+	jResp, err := json.Marshal("a")
 	if err != nil {
 		panic(err)
 	}
@@ -103,9 +102,11 @@ type Sign struct {
 }
 
 type AskBlindSign struct {
-	/*PubKString ownrsa.RSAPublicKeyString `json:"pubKstring"`
-	PubK       ownrsa.RSAPublicKey       `json:"pubK"`*/
-	M string `json:"m"`
+	M []byte `json:"m"`
+}
+type SignResponse struct {
+	Sig  []byte        `json:"sig"`
+	PubK rsa.PublicKey `json:"pubK"`
 }
 
 func BlindSign(w http.ResponseWriter, r *http.Request) {
@@ -116,38 +117,25 @@ func BlindSign(w http.ResponseWriter, r *http.Request) {
 		panic(err)
 	}
 	defer r.Body.Close()
-	color.Red(askBlindSign.M)
 	fmt.Println(askBlindSign)
+	blinded := askBlindSign.M
 
-	/*fmt.Println(askBlindSign)
-	askBlindSign.PubK, err = ownrsa.PubKStringToBigInt(askBlindSign.PubKString)
-	if err != nil {
-		fmt.Fprintln(w, "error")
-		return
-	}*/
+	/*privK := openPEMKey(keysDir + "/server_private.pem")
+	pubK := openPublicPEMKey(keysDir + "/server_public.pem")*/
+	sig, err := rsablind.BlindSign(serverKey, blinded)
+	check(err)
+	var signResponse SignResponse
+	signResponse.Sig = sig
+	signResponse.PubK = serverKey.PublicKey
 
-	//convert msg to []int
-	/*var m []int
-	mBytes := []byte(askBlindSign.M)
-	for _, byte := range mBytes {
-		m = append(m, int(byte))
-	}*/
-
-	m := ownrsa.StringToArrayInt(askBlindSign.M, "_")
-
-	sigma := ownrsa.BlindSign(m, serverRSA.PrivK) //here the privK will be the CA privK, not the m emmiter's one. The pubK is the user's one
-	fmt.Print("Sigma': ")
-	fmt.Println(sigma)
-	sigmaString := ownrsa.ArrayIntToString(sigma, "_")
-	askBlindSign.M = sigmaString
-
-	jResp, err := json.Marshal(askBlindSign)
+	jResp, err := json.Marshal(signResponse)
 	if err != nil {
 		panic(err)
 	}
 	fmt.Fprintln(w, string(jResp))
 }
 
+//TODO verifysign will not be necessary in this server
 type PetitionVerifySign struct {
 	M       string `json:"m"`
 	MSigned string `json:"mSigned"`
@@ -180,7 +168,7 @@ func VerifySign(w http.ResponseWriter, r *http.Request) {
 		mSignedInts = append(mSignedInts, i)
 	}
 
-	verified := ownrsa.Verify(mOriginal, mSignedInts, serverRSA.PubK)
-
+	//verified := ownrsa.Verify(mOriginal, mSignedInts, serverRSA.PubK)
+	verified := false
 	fmt.Fprintln(w, verified)
 }