minor edits

Author: 0xbrayo

cachefile.dbm.dat

@@ -16,7 +16,7 @@ func generatePrimes(limit int)int{
 	primes:= prime(limit)
 	var choice []int
 	choice = append(choice, 1,7,11,13,17,19,23,29)
-	for{	
+	for{
 		k:=rand.Intn(int(limit/30))
 		i:=choice[rand.Intn(len(choice))]
 		c:=30*k+i
@@ -137,36 +137,38 @@ func toRune(slice []int)string{
 	}
 	return str
 }
-	
+
 
 func main(){
 	rand.Seed(time.Now().UTC().UnixNano())
-	bits:=15
-	
+	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)
+	fmt.Printf("asciiSlice : %v \n",asciiSlice)
 	encrypted := encryptRSA(asciiSlice,e,n)
-	fmt.Printf("encrypted :%v \n",encrypted)
+	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/RSAcipher.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"math/rand"
 )
+<<<<<<< HEAD
 
 func main() {
 	bit := 30
@@ -19,27 +20,57 @@ func main() {
 
 	p := 2 + rand.Intn(1<<bit)
 	g := 2 + rand.Intn(5)
+=======
+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)
+>>>>>>> 8e01f3d134dcddea9e8ab08b08e45ae06a476ede
 
 	//Both parties choose a secret key
 
 	AliceSecret := 1 + rand.Intn(1<<bit)
 	BobSecret := 1 + rand.Intn(1<<bit)
 
+<<<<<<< HEAD
 	fmt.Printf("Alice's secret key is: %v \n", AliceSecret)
 	fmt.Printf("Bob's secret key is: %v \n", BobSecret)
+=======
+	fmt.Printf("Alice's secret key is: %v\n",AliceSecret)
+	fmt.Printf("Bob's secret key is: %v\n",BobSecret)
+>>>>>>> 8e01f3d134dcddea9e8ab08b08e45ae06a476ede
 
 	//Both parties send ((g^secret_key)%p)
 	//It's not possible to determine the secretkey from the value sent
 
+<<<<<<< HEAD
 	AliceSends := modularExponentiation(g, AliceSecret, p)
 	BobSends := modularExponentiation(g, BobSecret, p)
 
 	fmt.Printf("Alice sends to Bob: %v \n", AliceSends)
 	fmt.Printf("Bob sends to Alice: %v \n", BobSends)
+=======
+	AliceSends :=modularExponentiation(g,AliceSecret,p)
+	BobSends :=modularExponentiation(g,BobSecret,p)
+
+	fmt.Printf("Alice sends to Bob: %v\n",AliceSends)
+	fmt.Printf("Bob sends to Alice: %v\n",BobSends)
+>>>>>>> 8e01f3d134dcddea9e8ab08b08e45ae06a476ede
 
 	//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
+<<<<<<< HEAD
 	AliceComputes := modularExponentiation(BobSends, AliceSecret, p)
 	BobComputes := modularExponentiation(AliceSends, BobSecret, p)
 
@@ -67,6 +98,38 @@ func modularExponentiation(b int, e int, mod int) int {
 		}
 		e = e >> 1
 		b = (b * b) % mod
+=======
+	AliceComputes :=modularExponentiation(BobSends,AliceSecret,p)
+	BobComputes := modularExponentiation(AliceSends,BobSecret,p)
+
+	fmt.Printf("Alice Computes the shared secret key as: %v\n",AliceComputes)
+	fmt.Printf("Bob Computes the shared secret key as: %v\n",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
+>>>>>>> 8e01f3d134dcddea9e8ab08b08e45ae06a476ede
 	}
 	return r
 }

ciphers/diffieHellmanKeyExchange.go

@@ -7,6 +7,7 @@
 // For example, the string "()()[()]" is properly nested but "[(()]" is not.
 // The function called isBalanced takes as input a string which is a sequence of brackets and
 // returns true if input is nested and false otherwise.
+//note that only an even number of brackets can be properly nested
 
 package main
 
@@ -18,7 +19,8 @@ import (
 )
 
 func isBalanced(input string) string {
-
+	if len(input)%2 == 0{
+		return input + "is not balanced."
 	if len(input) > 0 {
 		var stack []byte
 		for i := 0; i < len(input); i++ {

other/NestedBrackets.go

@@ -7,7 +7,7 @@ func binarySearch(array []int, target int, lowIndex int, highIndex int) int {
 	if highIndex < lowIndex {
 		return -1
 	}
-	mid := int((lowIndex + highIndex) / 2)
+	mid := int((lowIndex + (highIndex-lowIndex)/2))
 	if array[mid] > target {
 		return binarySearch(array, target, lowIndex, mid)
 	} else if array[mid] < target {
@@ -22,7 +22,7 @@ func iterBinarySearch(array []int, target int, lowIndex int, highIndex int) int
 	endIndex := highIndex
 	var mid int
 	for startIndex < endIndex {
-		mid = int((startIndex + endIndex) / 2)
+		mid = int((startIndex + (endIndex-startIndex)/2))
 		if array[mid] > target {
 			endIndex = mid
 		} else if array[mid] < target {