Merge pull request #129 from brayo-pip/master

Created Xor cipher

Author: StepfenShawn

ciphers/RSAcipher.go

@@ -0,0 +1,174 @@
+package main
+
+import (
+	//"math/big"
+	"math/rand"
+	"math"
+	"time"
+	"fmt"
+)
+func generatePrimes(limit int)int{
+	/*
+	generate primes by factoring
+	relies on the 30k+i, though better formulae exist
+	where k >=0 and i = (1,7,11,13,17,13,19,23,29)
+	*/
+	primes:= prime(limit)
+	var choice []int
+	choice = append(choice, 1,7,11,13,17,19,23,29)
+	for{
+		k:=rand.Intn(int(limit/30))
+		i:=choice[rand.Intn(len(choice))]
+		c:=30*k+i
+		found := true
+		for _,v:= range primes{
+			if c%v==0{
+				found = false
+				break
+			}
+		}
+		if found{
+			return c
+		}
+	}
+}
+func prime(limit int)(primes []int){
+	sqrtLimit:=int(math.Ceil(math.Sqrt(float64(limit))))
+	exit:= false
+	primes = append(primes,2,3,5)
+	lastIndex :=2
+	for ;primes[lastIndex]<sqrtLimit;{
+		if exit == true{
+			break
+		}
+		for i:=primes[lastIndex]+2;i<primes[lastIndex]*primes[lastIndex];i+=2{
+			found:= true
+			for _,v:= range primes {
+				if i%v==0{
+					found= false
+					break
+				}
+			}
+			if found{
+				primes = append(primes,i)
+				lastIndex++
+				if i >=sqrtLimit{
+					exit = true
+					break
+				}
+			}
+
+		}
+	}
+	return
+}
+func lcm (a int, b int)int{
+	//complexity depende
+	return int((a*b)/gcd(a,b))
+
+}
+func gcd (a int, b int) int{
+	//complexity not clear
+	for b != 0{
+		t:=b
+		b = a % b
+		a = t
+	}
+	return a
+}
+func modularMultiplicativeInverse(e int, delta int)int{
+	//runs in O(n) where n = delta
+	e= e % delta
+	for i:=1;i<delta;i++{
+		if (i*e)%delta==1{
+			return i
+		}
+	}
+	return 0
+}
+
+func modularExponentiation(b int, e int, mod int)int{
+	//runs in O(log(n)) where n = e
+	if mod == 1{
+		return 0
+	}
+	r:=1
+	b = b % mod
+	for ;e>0;{
+		if e%2==1{
+			r=(r*b)%mod
+		}
+		e =e>>1
+		b = (b*b)%mod
+	}
+	return r
+}
+
+func encryptRSA(message []int,e int,n int)[]int{
+	//runs in O(k*log(n)) where k = len(message) and n = e
+	var ciphertext []int
+	for _,v := range message{
+		ciphertext = append(ciphertext, modularExponentiation(v,e,n))
+	}
+	return ciphertext
+}
+func decryptRSA(ciphertext []int, d int, n int )[]int{
+	//runs in O(k*log(n)) where k = len(ciphertext) and n = d
+	var message []int
+	for _,v := range ciphertext {
+		message = append(message, modularExponentiation(v,d,n))
+	}
+	return message
+}
+func toASCII(slice []rune)[]int{
+	//runs in O(n) where n = len(slice)
+	var converted []int
+	for _,v:= range slice{
+		converted = append(converted, int(v))
+	}
+	return converted
+}
+
+func toRune(slice []int)string{
+	//runs in O(n) where n = len(slice)
+	var str string
+	for _,v:= range slice{
+		str += string(v)
+	}
+	return str
+}
+
+
+func main(){
+	rand.Seed(time.Now().UTC().UnixNano())
+	bits:=17
+
+	p:= generatePrimes(1<<bits)
+	q:= generatePrimes(1<<bits)
+	for p==q{
+		q = generatePrimes(1<<bits)
+	}
+
+	n:= p*q
+
+	delta:=lcm(p-1,q-1)
+
+	e:=generatePrimes(delta)
+	d:=modularMultiplicativeInverse(e,delta)
+
+	fmt.Printf("%v \n%v \n%v \n%v\n",p,q,e,d)
+
+
+	str:="I think RSA is really great"
+	message := []rune(str)
+	asciiSlice :=toASCII(message)
+
+	fmt.Printf("asciiSlice : %v \n",asciiSlice)
+	encrypted := encryptRSA(asciiSlice,e,n)
+	fmt.Printf("encrypted : %v \n",encrypted)
+	decrypted := decryptRSA(encrypted,d,n)
+	fmt.Printf("decrypted : %v \n",decrypted)
+	fmt.Printf("cleartext : %v \n",toRune(decrypted))
+	//switched to atom
+
+}

ciphers/diffieHellmanKeyExchange.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+)
+func main(){
+	bit:=30
+	/*
+	p and g are pre-agreed constants
+	that can be communicated over an insecure channel
+	p should ideally be a large prime number but any integer works
+	g should be a small integer, 2,3 works fine
+
+	PS: Note that the secret keys are never send over
+	the network
+	*/
+
+	p:=2+rand.Intn(1<<bit)
+	g:=2+rand.Intn(5)
+	
+	//Both parties choose a secret key
+	
+	AliceSecret := 1 + rand.Intn(1<<bit)
+	BobSecret := 1 + rand.Intn(1<<bit)
+	
+	fmt.Printf("Alice's secret key is: %v",AliceSecret)
+	fmt.Printf("Bob's secret key is: %v",BobSecret)
+	
+	//Both parties send ((g^secret_key)%p) 
+	//It's not possible to determine the secretkey from the value sent
+	
+	AliceSends :=modularExponentiation(g,AliceSecret,p)
+	BobSends :=modularExponentiation(g,BobSecret,p)
+
+	fmt.Printf("Alice sends to Bob: %v",AliceSends)
+	fmt.Printf("Bob sends to Alice: %v",BobSends)
+
+	//Both parties calculate the shared secret key from the value send
+	//(value_sent^secret_key)%p
+	//Both calculations end up with same value despite the different inputs
+	AliceComputes :=modularExponentiation(BobSends,AliceSecret,p)
+	BobComputes := modularExponentiation(AliceSends,BobSecret,p)
+
+	fmt.Printf("Alice Computes the shared secret key as: %v",AliceComputes)
+	fmt.Printf("Bob Computes the shared secret key as: %v",BobComputes)
+	
+	// simply confirms that the values are equal
+	if AliceComputes == BobComputes{
+		sharedKey:=AliceComputes
+		fmt.Println(" Voila, shared key is",sharedKey)
+	}
+
+	
+
+	
+}
+func modularExponentiation(b int, e int, mod int)int{
+	//runs in O(log(n)) where n = e
+	//uses exponentiation by squaring to speed up the process
+	if mod == 1{
+		return 0
+	}
+	r:=1
+	b = b % mod
+	for ;e>0;{
+		if e%2==1{
+			r=(r*b)%mod
+		}
+		e =e>>1
+		b = (b*b)%mod
+	}
+	return r
+}

ciphers/xorCipher.go

@@ -0,0 +1,44 @@
+package main
+
+import "fmt"
+func encrypt(key int, plaintext []int)(ciphertext []int){
+	for _,char:= range plaintext {
+		ciphertext = append(ciphertext,xor(char,key))
+	}
+	return
+}
+func xor(char int,key int)int{
+	return (char^key)
+}
+
+func decrypt(key int, ciphertext []int)(plaintext []int){
+	for _,char:= range ciphertext {
+		plaintext = append(plaintext , xor(char,key))
+	}
+	return
+}
+
+func decodeToString(slice []int)(str string){
+	for _,v:= range slice{
+		str+=string(v)
+	}
+	return
+}
+func toASCII(slice []rune)[]int{
+	var converted []int
+	for _,v:= range slice{
+		converted = append(converted, int(v))
+	}
+	return converted
+}
+func main(){
+	str := "hello world"
+	key :=97
+	temp:= []rune(str)
+	message:=toASCII(temp)
+	encrypted:=encrypt(key,message)
+	decrypted:=decrypt(key,encrypted)
+	plaintext:=decodeToString(decrypted)
+	fmt.Println(plaintext)
+}
+

sorts/heap_sort.go

@@ -1,20 +1,20 @@
 //Package sorts a package for demonstrating sorting algorithms in Go
 package sorts
 
-type MaxHeap struct {
+type maxHeap struct {
 	slice    []int
 	heapSize int
 }
 
-func BuildMaxHeap(slice []int) MaxHeap {
-	h := MaxHeap{slice: slice, heapSize: len(slice)}
+func buildMaxHeap(slice []int) maxHeap {
+	h := maxHeap{slice: slice, heapSize: len(slice)}
 	for i := len(slice) / 2; i >= 0; i-- {
 		h.MaxHeapify(i)
 	}
 	return h
 }
 
-func (h MaxHeap) MaxHeapify(i int) {
+func (h maxHeap) MaxHeapify(i int) {
 	l, r := 2*i+1, 2*i+2
 	max := i
 
@@ -31,10 +31,10 @@ func (h MaxHeap) MaxHeapify(i int) {
 	}
 }
 
-func (h MaxHeap) size() int { return h.heapSize } // ???
+func (h maxHeap) size() int { return h.heapSize } // ???
 
 func heapSort(slice []int) []int {
-	h := BuildMaxHeap(slice)
+	h := buildMaxHeap(slice)
 	//log.Println(slice)
 	for i := len(h.slice) - 1; i >= 1; i-- {
 		h.slice[0], h.slice[i] = h.slice[i], h.slice[0]

sorts/quick_sort.go

@@ -13,26 +13,26 @@ func quickSort(arr []int) []int {
 
 	median := arr[rand.Intn(len(arr))]
 
-	low_part := make([]int, 0, len(arr))
-	high_part := make([]int, 0, len(arr))
-	middle_part := make([]int, 0, len(arr))
+	lowPart := make([]int, 0, len(arr))
+	highPart := make([]int, 0, len(arr))
+	middlePart := make([]int, 0, len(arr))
 
 	for _, item := range arr {
 		switch {
 		case item < median:
-			low_part = append(low_part, item)
+			lowPart = append(lowPart, item)
 		case item == median:
-			middle_part = append(middle_part, item)
+			middlePart = append(middlePart, item)
 		case item > median:
-			high_part = append(high_part, item)
+			highPart = append(highPart, item)
 		}
 	}
 
-	low_part = quickSort(low_part)
-	high_part = quickSort(high_part)
+	lowPart = quickSort(lowPart)
+	highPart = quickSort(highPart)
 
-	low_part = append(low_part, middle_part...)
-	low_part = append(low_part, high_part...)
+	lowPart = append(lowPart, middlePart...)
+	lowPart = append(lowPart, highPart...)
 
-	return low_part
+	return lowPart
 }

strings/naiveStringSearch.go

@@ -16,14 +16,14 @@ import (
 
 func naivePatternSearch(text string, pattern string) []int { 
     var positions []int 
-    for i := 0; i < len(text); i++ {
+    for i := 0; i < len(text)-len(pattern); i++ {
         var match bool = true
-        for j := 0; j < len(pattern); j++ {
-            if text[i+j] != pattern[j] {
+        j := i +(len(pattern))
+        if text[i+j] != pattern[j] {
                 match = false
                 break
             }
-        }
+        
         if match {
             positions = append(positions, i)
         }