1package ownrsa
  2
  3import (
  4	"errors"
  5	"fmt"
  6	"math/big"
  7	"math/rand"
  8	"strconv"
  9	"strings"
 10	"time"
 11)
 12
 13type RSAPublicKey struct {
 14	E *big.Int `json:"e"`
 15	N *big.Int `json:"n"`
 16}
 17type RSAPublicKeyString struct {
 18	E string `json:"e"`
 19	N string `json:"n"`
 20}
 21type RSAPrivateKey struct {
 22	D *big.Int `json:"d"`
 23	N *big.Int `json:"n"`
 24}
 25
 26type RSA struct {
 27	PubK  RSAPublicKey
 28	PrivK RSAPrivateKey
 29}
 30
 31type PackRSA struct {
 32	PubK       string    `json:"pubK"`
 33	PrivK      string    `json:"privK"`
 34	Date       time.Time `json:"date"`
 35	PubKSigned string    `json:"pubKSigned"`
 36	Verified   bool      `json:"verified"`
 37}
 38
 39const maxPrime = 500
 40const minPrime = 100
 41
 42func GenerateKeyPair() RSA {
 43
 44	rand.Seed(time.Now().Unix())
 45	p := randPrime(minPrime, maxPrime)
 46	q := randPrime(minPrime, maxPrime)
 47	fmt.Print("p:")
 48	fmt.Println(p)
 49	fmt.Print("q:")
 50	fmt.Println(q)
 51
 52	n := p * q
 53	phi := (p - 1) * (q - 1)
 54	e := 65537
 55	var pubK RSAPublicKey
 56	pubK.E = big.NewInt(int64(e))
 57	pubK.N = big.NewInt(int64(n))
 58
 59	d := new(big.Int).ModInverse(big.NewInt(int64(e)), big.NewInt(int64(phi)))
 60
 61	var privK RSAPrivateKey
 62	privK.D = d
 63	privK.N = big.NewInt(int64(n))
 64
 65	var rsa RSA
 66	rsa.PubK = pubK
 67	rsa.PrivK = privK
 68	return rsa
 69}
 70func Encrypt(m string, pubK RSAPublicKey) []int {
 71	var c []int
 72	mBytes := []byte(m)
 73	for _, byte := range mBytes {
 74		c = append(c, EncryptInt(int(byte), pubK))
 75	}
 76	return c
 77}
 78func Decrypt(c []int, privK RSAPrivateKey) string {
 79	var m string
 80	var mBytes []byte
 81	for _, indC := range c {
 82		mBytes = append(mBytes, byte(DecryptInt(indC, privK)))
 83	}
 84	m = string(mBytes)
 85	return m
 86}
 87
 88func EncryptBigInt(bigint *big.Int, pubK RSAPublicKey) *big.Int {
 89	Me := new(big.Int).Exp(bigint, pubK.E, nil)
 90	c := new(big.Int).Mod(Me, pubK.N)
 91	return c
 92}
 93func DecryptBigInt(bigint *big.Int, privK RSAPrivateKey) *big.Int {
 94	Cd := new(big.Int).Exp(bigint, privK.D, nil)
 95	m := new(big.Int).Mod(Cd, privK.N)
 96	return m
 97}
 98
 99func EncryptInt(char int, pubK RSAPublicKey) int {
100	charBig := big.NewInt(int64(char))
101	Me := charBig.Exp(charBig, pubK.E, nil)
102	c := Me.Mod(Me, pubK.N)
103	return int(c.Int64())
104}
105func DecryptInt(val int, privK RSAPrivateKey) int {
106	valBig := big.NewInt(int64(val))
107	Cd := valBig.Exp(valBig, privK.D, nil)
108	m := Cd.Mod(Cd, privK.N)
109	return int(m.Int64())
110}
111
112func Blind(m []int, r int, pubK RSAPublicKey) []int {
113	var mBlinded []int
114	rBigInt := big.NewInt(int64(r))
115	for i := 0; i < len(m); i++ {
116		mBigInt := big.NewInt(int64(m[i]))
117		rE := new(big.Int).Exp(rBigInt, pubK.E, nil)
118		mrE := new(big.Int).Mul(mBigInt, rE)
119		mrEmodN := new(big.Int).Mod(mrE, pubK.N)
120		mBlinded = append(mBlinded, int(mrEmodN.Int64()))
121	}
122	return mBlinded
123}
124
125func BlindSign(m []int, privK RSAPrivateKey) []int {
126	var r []int
127	for i := 0; i < len(m); i++ {
128		mBigInt := big.NewInt(int64(m[i]))
129		sigma := new(big.Int).Exp(mBigInt, privK.D, privK.N)
130		r = append(r, int(sigma.Int64()))
131	}
132	return r
133}
134func Unblind(blindsigned []int, r int, pubK RSAPublicKey) []int {
135	var mSigned []int
136	rBigInt := big.NewInt(int64(r))
137	for i := 0; i < len(blindsigned); i++ {
138		bsBigInt := big.NewInt(int64(blindsigned[i]))
139		//r1 := new(big.Int).Exp(rBigInt, big.NewInt(int64(-1)), nil)
140		r1 := new(big.Int).ModInverse(rBigInt, pubK.N)
141		bsr := new(big.Int).Mul(bsBigInt, r1)
142		sig := new(big.Int).Mod(bsr, pubK.N)
143		mSigned = append(mSigned, int(sig.Int64()))
144	}
145	return mSigned
146}
147func Verify(msg []int, mSigned []int, pubK RSAPublicKey) bool {
148	if len(msg) != len(mSigned) {
149		return false
150	}
151	var mSignedDecrypted []int
152	for _, ms := range mSigned {
153		msBig := big.NewInt(int64(ms))
154		//decrypt the mSigned with pubK
155		Cd := new(big.Int).Exp(msBig, pubK.E, nil)
156		m := new(big.Int).Mod(Cd, pubK.N)
157		mSignedDecrypted = append(mSignedDecrypted, int(m.Int64()))
158	}
159	fmt.Print("msg signed decrypted: ")
160	fmt.Println(mSignedDecrypted)
161	r := true
162	//check if the mSignedDecrypted == msg
163	for i := 0; i < len(msg); i++ {
164		if msg[i] != mSignedDecrypted[i] {
165			r = false
166		}
167	}
168	return r
169}
170
171func HomomorphicMultiplication(c1 int, c2 int, pubK RSAPublicKey) int {
172	c1BigInt := big.NewInt(int64(c1))
173	c2BigInt := big.NewInt(int64(c2))
174	c1c2 := new(big.Int).Mul(c1BigInt, c2BigInt)
175	n2 := new(big.Int).Mul(pubK.N, pubK.N)
176	d := new(big.Int).Mod(c1c2, n2)
177	r := int(d.Int64())
178	return r
179}
180
181func PubKStringToBigInt(kS RSAPublicKeyString) (RSAPublicKey, error) {
182	var k RSAPublicKey
183	var ok bool
184	k.E, ok = new(big.Int).SetString(kS.E, 10)
185	if !ok {
186		return k, errors.New("error parsing big int E")
187	}
188	k.N, ok = new(big.Int).SetString(kS.N, 10)
189	if !ok {
190		return k, errors.New("error parsing big int N")
191	}
192	return k, nil
193}
194
195func PackKey(k RSA) PackRSA {
196	var p PackRSA
197	p.PubK = k.PubK.E.String() + "," + k.PubK.N.String()
198	p.PrivK = k.PrivK.D.String() + "," + k.PrivK.N.String()
199	return p
200}
201
202func UnpackKey(p PackRSA) RSA {
203	var k RSA
204	var ok bool
205	k.PubK.E, ok = new(big.Int).SetString(strings.Split(p.PubK, ",")[0], 10)
206	k.PubK.N, ok = new(big.Int).SetString(strings.Split(p.PubK, ",")[1], 10)
207	k.PrivK.D, ok = new(big.Int).SetString(strings.Split(p.PrivK, ",")[0], 10)
208	k.PrivK.N, ok = new(big.Int).SetString(strings.Split(p.PrivK, ",")[1], 10)
209	if !ok {
210		fmt.Println("error on Unpacking Keys")
211	}
212	return k
213}
214
215func ArrayIntToString(a []int, delim string) string {
216	return strings.Trim(strings.Replace(fmt.Sprint(a), " ", delim, -1), "[]")
217}
218func StringToArrayInt(s string, delim string) []int {
219	var a []int
220	arrayString := strings.Split(s, delim)
221	for _, s := range arrayString {
222		i, err := strconv.Atoi(s)
223		if err != nil {
224			fmt.Println(err)
225		}
226		a = append(a, i)
227	}
228	return a
229}