freeCodeCamp · scissorsneedfoodtoo · Jul 19, 2019 · Jun 15, 2019 · Jun 17, 2019 · Jun 17, 2019
diff --git a/index51.js b/index51.js
diff --git a/rsa-cryptosystem-signature/index.html b/rsa-cryptosystem-signature/index.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
+    <title>RSA Digital Signature System</title>
+  </head>
+  <body>
+    <script src="index.js"></script>
+  </body>
+</html>
diff --git a/rsa-cryptosystem-signature/index.js b/rsa-cryptosystem-signature/index.js
@@ -0,0 +1,72 @@
+const firstPrime = 2;
+const secondPrime = 5;
+const N = firstPrime * secondPrime;
+const phiOfN = (firstPrime - 1) * (secondPrime - 1);
+let publicKey = 0;
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; ++i) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue % N;
+}
+
+function isCoPrime(smallerNum, largerNum) {
+  for (let i = 2; i <= smallerNum; ++i) {
+    if (smallerNum % i === 0 && largerNum % i === 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function generatePrivateKey() {
+  for (let privateKey = 2; privateKey < phiOfN; ++privateKey) {
+    if (isCoPrime(privateKey, N) && isCoPrime(privateKey, phiOfN)) {
+      return privateKey;
+    }
+  }
+
+  console.log("Private key can't be generated.");
+  return 0;
+}
+
+function generatePublicKey(privateKey) {
+  while (privateKey) {
+    if ((publicKey * privateKey) % phiOfN === 1 && privateKey !== publicKey) {
+      return;
+    }
+    ++publicKey;
+  }
+
+  console.log("Public key can't be generated.");
+}
+
+function generateSignature(hashValue, privateKey) {
+  return Math.pow(hashValue, privateKey) % N;
+}
+
+function decryptSignature(digitalSignature) {
+  return Math.pow(digitalSignature, publicKey) % N;
+}
+
+function sendMsgToBob(message) {
+  const privateKey = generatePrivateKey();
+  generatePublicKey(privateKey);
+  const hashValue = hashTheMessage(message);
+  const generatedSignature = generateSignature(hashValue, privateKey);
+  sendAndVerify(generatedSignature, message);
+}
+
+function sendAndVerify(digitalSignature, message) {
+  const hashValue = hashTheMessage(message);
+  const decryptedSignature = decryptSignature(digitalSignature);
+  if (hashValue === decryptedSignature) {
+    console.log("Success! Data is intact and signature is verified.");
+  } else {
+    console.log("Failure! There's something wrong with data or signature.");
+  }
+}
+
+sendMsgToBob("Hey Bob, I'm Alice here. Bob, Buy 300 shares of TSLA!");
diff --git a/rsa-cryptosystem-signature/index01.js b/rsa-cryptosystem-signature/index01.js
@@ -0,0 +1,9 @@
+/*
+Cryptography is a mathematical art of protecting information from an unauthorized access.
+
+Digital signature is a way to verify the authenticity and integrity of documents and messages.
+
+First, we hash our message, which is a method to transform a document into a fixed-size value.
+
+Create a function `hashTheMessage()` with `message` as a parameter. Functions which hash the data are called hash functions.
+*/
diff --git a/rsa-cryptosystem-signature/index02.js b/rsa-cryptosystem-signature/index02.js
@@ -0,0 +1,6 @@
+/*
+The fixed-size value is also known as a hash value.
+Create a variable `hashValue` and set it to 0.
+*/
+
+function hashTheMessage(message) {}
diff --git a/rsa-cryptosystem-signature/index03.js b/rsa-cryptosystem-signature/index03.js
@@ -0,0 +1,9 @@
+/* 
+Hash functions ideally use all of the data for hashing.
+
+Create a `for` loop to iterate over all the characters of `message`.
+*/
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+}
diff --git a/rsa-cryptosystem-signature/index04.js b/rsa-cryptosystem-signature/index04.js
@@ -0,0 +1,11 @@
+/*
+The hash value should not let users know the original data. So, we will represent our message as an integer. 
+
+Add the ASCII value of characters to `hashValue`.
+Use `charCodeAt(index)` to find the ASCII value of each character in `message`.
+*/
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; i++) {}
+}
diff --git a/rsa-cryptosystem-signature/index05.js b/rsa-cryptosystem-signature/index05.js
@@ -0,0 +1,11 @@
+/*
+Hash functions should always return the same hash value when same message is passed.
+Return `hashValue`.
+*/
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; i++) {
+    hashValue += message.charCodeAt(i);
+  }
+}
diff --git a/rsa-cryptosystem-signature/index06.js b/rsa-cryptosystem-signature/index06.js
@@ -0,0 +1,15 @@
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; i++) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue;
+}
+
+/*
+In `ROT13`, the values of letters were shifted by 13 places. The number 13 is called a key. It was used for both encryption and decryption. This is known as Symmetric key cryptography.
+
+In Asymmetric key cryptography, each user has two different keys - public and private. The public key can be shared with everyone.
+
+Create an empty function `generatePublicKey()`.
+*/
diff --git a/rsa-cryptosystem-signature/index07.js b/rsa-cryptosystem-signature/index07.js
@@ -0,0 +1,15 @@
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; i++) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue;
+}
+
+function generatePublicKey() {}
+
+/*
+The private key is only known to the user. It must be kept as a secret.
+
+Create an empty function `generatePrivateKey()`.
+*/
diff --git a/rsa-cryptosystem-signature/index08.js b/rsa-cryptosystem-signature/index08.js
@@ -0,0 +1,17 @@
+/*
+If `publicKey` is used for encryption then only the `privateKey` can decrypt it. Keep in mind that the vice-versa is also true. Therefore, they are referred to as key pairs. 
+
+Create a variable `publicKey` and set it to 0.
+*/
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; ++i) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue;
+}
+
+function generatePrivateKey() {}
+
+function generatePublicKey() {}
diff --git a/rsa-cryptosystem-signature/index09.js b/rsa-cryptosystem-signature/index09.js
@@ -0,0 +1,21 @@
+let publicKey = 0;
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; ++i) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue;
+}
+
+function generatePrivateKey() {}
+
+function generatePublicKey() {}
+
+/*
+Suppose Alice sends an encrypted message to Bob using a symmetric key. There's no way for Bob to verify if the sender is Alice. Since anyone with access to that key can send Bob the message and claim to be Alice.
+
+Digital signature is the solution. Alice encrypts the hash value of data with his private key which we call signature.
+
+Create an empty function `generateSignature()`.
+*/
diff --git a/rsa-cryptosystem-signature/index10.js b/rsa-cryptosystem-signature/index10.js
@@ -0,0 +1,24 @@
+let publicKey = 0;
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; ++i) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue;
+}
+
+function generatePrivateKey() {}
+
+function generatePublicKey() {}
+
+function generateSignature() {}
+
+/* 
+Alice sends the signature along with the original data to Bob. Bob decrypts the received signature with Alice's public key and hashes the received data.
+
+If the hash value of the received data and the decrypted signature match then the signature is authentic and data is intact.
+
+Create an empty function `decryptSignature()`.
+Tip: Go back to previous challenge, read it once more and come back. You'll get the idea. 
+*/
diff --git a/rsa-cryptosystem-signature/index11.js b/rsa-cryptosystem-signature/index11.js
@@ -0,0 +1,25 @@
+let publicKey = 0;
+
+/*
+We'll use the RSA asymmetric cryptographic algorithm to generate key pairs, to encrypt and decrypt data.
+
+RSA is based on the fact that finding prime factors of a large number is difficult.
+
+Create a constant `firstPrime` and set it to 2.
+*/
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; ++i) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue;
+}
+
+function generatePrivateKey() {}
+
+function generatePublicKey() {}
+
+function generateSignature() {}
+
+function decryptSignature() {}
diff --git a/rsa-cryptosystem-signature/index12.js b/rsa-cryptosystem-signature/index12.js
@@ -0,0 +1,25 @@
+const firstPrime = 2;
+let publicKey = 0;
+
+/*
+Remember, prime numbers are only divisible by 1 and by the number itself.
+E.g. 2, 3, 5, 7, 11, etc.
+
+Create a constant `secondPrime` and set it to 5.
+*/
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; ++i) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue;
+}
+
+function generatePrivateKey() {}
+
+function generatePublicKey() {}
+
+function generateSignature() {}
+
+function decryptSignature() {}
diff --git a/rsa-cryptosystem-signature/index13.js b/rsa-cryptosystem-signature/index13.js
@@ -0,0 +1,25 @@
+const firstPrime = 2;
+const secondPrime = 5;
+let publicKey = 0;
+
+/*
+Create a constant `N` and set it as `firstPrime * secondPrime`. `N` will be a part of both private and public key. Here, `N = 10`. So, it's easy to find the prime factors 2 and 5. 
+
+But in real world usage `N` is around 600 digits long which makes prime factorization almost impossible. Our implementation is insecure. It is just to teach you about the fundamentals of asymmetric cryptography.
+*/
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; ++i) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue;
+}
+
+function generatePrivateKey() {}
+
+function generatePublicKey() {}
+
+function generateSignature() {}
+
+function decryptSignature() {}
diff --git a/rsa-cryptosystem-signature/index14.js b/rsa-cryptosystem-signature/index14.js
@@ -0,0 +1,28 @@
+const firstPrime = 3;
+const secondPrime = 5;
+const N = firstPrime * secondPrime;
+let publicKey = 0;
+
+/*
+Private key must be between 1 and `Φ(N)` i.e. 1 < privateKey < `Φ(N)`.
+
+`Φ(N)` pronounced as phi of N is called Euler's totient function. It outputs number of integers upto `N` that are coprime with `N`.
+
+Create a constant `phiOfN` and set it to 0.
+*/
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; ++i) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue;
+}
+
+function generatePrivateKey() {}
+
+function generatePublicKey() {}
+
+function generateSignature() {}
+
+function decryptSignature() {}
diff --git a/rsa-cryptosystem-signature/index15.js b/rsa-cryptosystem-signature/index15.js
@@ -0,0 +1,30 @@
+const firstPrime = 2;
+const secondPrime = 5;
+const N = firstPrime * secondPrime;
+const phiOfN = 0;
+let publicKey = 0;
+
+function hashTheMessage(message) {
+  let hashValue = 0;
+  for (let i = 0, msgLength = message.length; i < msgLength; ++i) {
+    hashValue += message.charCodeAt(i);
+  }
+  return hashValue;
+}
+
+/*
+Two integers are coprime if the only positive integer that divides both of them simultaneously is 1.
+
+E.g. 10 and 7 are coprime.
+2 and 5 divides 10 but not 7. Hence, they both are only divisible by 1.
+
+Create an empty function `isCoPrime` with two integer parameters.
+*/
+
+function generatePrivateKey() {}
+
+function generatePublicKey() {}
+
+function generateSignature() {}
+
+function decryptSignature() {}