Skip to content

This Repository is a collection of different ethical hacking tools and malware's for penetration testing and research purpose written in python, ruby, rust, c++, go and c.

Create ECDSA Algorithm.md

Abdul Wahab Junaid011ec3679324
diff --git a/Cryptography/Cryptography Course/Course/ECDSA Algorithm.md b/Cryptography/Cryptography Course/Course/ECDSA Algorithm.md
new file mode 100644
index 0000000..51984f4
--- /dev/null
+++ b/Cryptography/Cryptography Course/Course/ECDSA Algorithm.md
@@ -0,0 +1,137 @@
+### **ECDSA (Elliptic Curve Digital Signature Algorithm)**
+
+The **Elliptic Curve Digital Signature Algorithm (ECDSA)** is a cryptographic algorithm used for **digital signatures** and is based on the mathematics of elliptic curves. It is widely used for securing communications and is part of many security protocols such as **TLS** (Transport Layer Security), **SSL** (Secure Sockets Layer), and **Bitcoin** transactions.
+
+ECDSA is an elliptic curve analog of the **Digital Signature Algorithm (DSA)**, which is based on modular arithmetic and the discrete logarithm problem. ECDSA offers the same security as DSA but with smaller key sizes, making it more efficient and suitable for environments with limited resources, such as mobile devices and IoT devices.
+
+### **Elliptic Curves in Cryptography**
+
+Elliptic curves are defined by equations of the form:
+
+$\[
+y^2 = x^3 + ax + b
+\]$
+
+Where \( a \) and \( b \) are constants, and the equation describes a curve over a finite field (typically a field of prime numbers). The difficulty of solving the **Elliptic Curve Discrete Logarithm Problem (ECDLP)** is the basis for the security of elliptic curve cryptography (ECC), including ECDSA.
+
+### **How ECDSA Works**
+
+ECDSA operates in three steps: **key generation**, **signature generation**, and **signature verification**.
+
+#### **1. Key Generation**
+
+1. **Choose an elliptic curve** \( E \) over a finite field $\( F_p \)$.
+2. Select a base point \( G \) on the curve (a predefined point known to both the signer and verifier).
+3. **Generate a private key** \( d \), which is a randomly selected integer from \( 1 \) to $\( n-1 \)$, where \( n \) is the order of the base point \( G \).
+4. **Generate the public key** $\( Q = d \times G \)$, where \( \times \) denotes scalar multiplication of the point \( G \) by the private key \( d \).
+
+The public key \( Q \) is used for signature verification, and the private key \( d \) is kept secret by the signer.
+
+#### **2. Signature Generation**
+
+To sign a message \( M \), the signer generates a **digital signature** in the following steps:
+
+1. **Hash the message**: Compute the hash of the message \( M \) using a cryptographic hash function $\( H(M) \)$. The hash function must be collision-resistant (e.g., SHA-256).
+
+2. **Generate a random integer** \( k \): Randomly choose an integer \( k \) from \( 1 \) to \( n-1 \), where \( n \) is the order of the base point \( G \). This random number must be kept secret.
+
+3. **Calculate the elliptic curve point**: Compute the elliptic curve point $\( P = k \times G \)$, where \( G \) is the base point and \( k \) is the random integer.
+
+4. **Calculate the signature components**:
+ - $\( r = x_P \mod n \)$, where $\( x_P \)$ is the x-coordinate of the point \( P \).
+ - $\( s = k^{-1} (H(M) + r \times d) \mod n \)$, where $\( k^{-1} \)$ is the modular inverse of \( k \) modulo \( n \).
+
+The **signature** is the pair \( (r, s) \).
+
+#### **3. Signature Verification**
+
+To verify the signature \( (r, s) \) for the message \( M \) and the public key \( Q \), the verifier follows these steps:
+
+1. **Check validity**: Ensure that both \( r \) and \( s \) are integers in the range $\( 1 \leq r, s \leq n-1 \)$. If not, the signature is invalid.
+
+2. **Hash the message**: Compute the hash of the message $\( H(M) \)$.
+
+3. **Compute the elliptic curve points**:
+ - Compute $\( w = s^{-1} \mod n \)$.
+ - Compute $\( u_1 = H(M) \times w \mod n \)$.
+ - Compute $\( u_2 = r \times w \mod n \)$.
+ - Compute the elliptic curve point $\( P = u_1 \times G + u_2 \times Q \)$.
+
+4. **Verify the signature**: The signature is valid if $\( r \equiv x_P \mod n \)$, where $\( x_P \)$ is the x-coordinate of the point \( P \). If the condition is true, the signature is valid, otherwise, it is invalid.
+
+### **Security of ECDSA**
+
+The security of ECDSA relies on the **Elliptic Curve Discrete Logarithm Problem (ECDLP)**, which states that it is computationally infeasible to determine the private key \( d \) from the public key \( Q = d \times G \) for large enough curves and key sizes. Since elliptic curve operations are more efficient than traditional integer-based methods (such as RSA and DSA), ECDSA can provide comparable levels of security with smaller key sizes, reducing computational overhead.
+
+### **Advantages of ECDSA**
+
+1. **Efficiency**: ECDSA requires much smaller key sizes than RSA or DSA to achieve the same level of security. For example, a 256-bit key in ECDSA offers roughly the same security as a 3072-bit key in RSA.
+
+2. **Faster Computations**: Due to the smaller key sizes, operations such as signing and verifying messages are faster and less resource-intensive. This is especially important in environments with limited resources, such as embedded systems, mobile devices, and blockchain applications.
+
+3. **Scalability**: ECDSA is scalable, meaning that you can use larger key sizes (e.g., 384-bit or 521-bit) to provide higher security levels if needed, while still maintaining reasonable performance.
+
+4. **Widely Adopted**: ECDSA is widely used in various security protocols, including **TLS**, **SSL**, **SSH**, **Bitcoin**, and other cryptocurrency protocols.
+
+### **Example of ECDSA in Python**
+
+To implement ECDSA in Python, we can use the **`ecdsa`** library. Here's an example demonstrating how to sign and verify messages using ECDSA.
+
+#### **Installation**:
+
+First, install the `ecdsa` library using pip:
+
+```bash
+pip install ecdsa
+```
+
+#### **ECDSA Example Code**:
+
+```python
+from ecdsa import SigningKey, NIST384p
+from ecdsa.util import string_to_number
+from hashlib import sha256
+
+# Generate private and public keys
+sk = SigningKey.generate(curve=NIST384p) # private key
+vk = sk.get_verifying_key() # public key
+
+# Message to sign
+message = b"Hello, this is a test message."
+
+# Hash the message using SHA-256
+hashed_msg = sha256(message).digest()
+
+# Sign the message with the private key
+signature = sk.sign(hashed_msg)
+
+print("Original Message:", message)
+print("Signature:", signature)
+
+# Verify the signature using the public key
+is_valid = vk.verify(signature, hashed_msg)
+
+if is_valid:
+ print("The signature is valid.")
+else:
+ print("The signature is invalid.")
+```
+
+#### **Explanation**:
+
+1. We generate a **private key** (`sk`) and a corresponding **public key** (`vk`) using the **NIST384p** curve.
+2. The message is hashed using **SHA-256**.
+3. The message is signed using the private key (`sk.sign()`).
+4. The **public key** is used to verify the signature.
+
+#### **Output**:
+
+```text
+Original Message: b'Hello, this is a test message.'
+Signature: <signature_bytes>
+The signature is valid.
+```
+
+### **Conclusion**
+
+ECDSA is a widely used and efficient cryptographic algorithm for generating digital signatures. By leveraging elliptic curves, it provides high levels of security with smaller key sizes compared to traditional algorithms like RSA and DSA. ECDSA's efficiency makes it particularly suited for resource-constrained environments, such as IoT, mobile devices, and blockchain technologies.