Ecc 2

Name: Siddhant Kundlik Thaware
Class: TY-CS-D
Roll No:34
Date: 6/9/23
Prn No:12110937
Batch: 2
ASSIGNMENT-5:
ELLIPTIC CURVE CRYTOGRAPHY:
Code:
#include <assert.h>
#include <stdlib.h> //rand
#include <time.h> //for srand
#include <functional> //require c++11

#include <iostream>
using namespace std;
class G {
public:
G() {} // Default constructor
// Constructor with parameters to initialize the object

G(const int& x, const int& y, const int& p, const int& a) {
this->x = x, this->y = y, this->a = a, this->p = p;
}
// Overloaded '+' operator for adding two points on an

elliptic curve
G operator+(const G& g) const {
assert(this->a == g.a); // Ensure both points are on the
same curve
int t, xr, yr;

if (this->y == 0)
return G(g.x, g.y, this->p, this->a);
else if (g.y == 0)
return G(this->x, this->y, this->p, this->a);
else if (this->x == g.x && this->y == -g.y)
return G(this->x, 0, this->p, this->a);
else if (this->x == g.x && this->y == g.y)
t = mod(3 * this->x * this->x + this->a, this->p) *
inv(2 * this->y, this->p);
else
t = mod(g.y - this->y, this->p) * inv(mod(g.x - this-
>x, this->p), this->p);
t = mod(t, this->p);
xr = mod(t * t - this->x - g.x, this->p);
yr = t * (this->x - xr) - this->y;
yr = mod(yr, this->p);
return G(xr, yr, this->p, this->a);

}
// Overloaded '-' operator for subtracting two points on an

elliptic curve
G operator-(const G& g) const {
return *this + G(g.x, -g.y, this->p, g.a);
}
// Overloaded '*' operator for scalar multiplication of a

point on an elliptic curve
G operator*(const int& n) const {
G g = *this;
for (int i = 1; i < n; i++)
g = g + *this;
return g;
}
int x, y, p, a; // Public parameters of the point
private:
// Helper function to compute the modular inverse of a number
int inv(const int& num, const int& mod) const {
auto exgcd = [](const int& a, const int& b, int& g, int&
x, int& y) {
std::function<void(const int&, const int&, int&, int&,
int&)> exgcd;
exgcd = [&](const int& a, const int& b, int& g, int&
x, int& y) {
if (!b)
g = a, x = 1, y = 0;
else
exgcd(b, a % b, g, y, x), y -= x * (a / b);
};
return exgcd(a, b, g, x, y);
};
int g, x, y;
exgcd(num, mod, g, x, y);
return ((x % mod) + mod) % mod;
}
// Helper function to compute the modulo of a number

int mod(const int& num, const int& mod) const {
return (num % mod + mod) % mod;
}
};
// Overloaded '*' operator for scalar multiplication with the

scalar on the left-hand side
G operator*(const int& n, const G& g) {
return g * n;
}
class Elliptic_curve {
public:
// Constructor to initialize the elliptic curve parameters and
a base point
Elliptic_curve(const int& a, const int& b, const int& q, const
G& g) {
set(a, b, q, g);
}
// Setter function to update the curve parameters and base

point
void set(const int& a, const int& b, const int& q, const G& g)
{
this->a = a, this->b = b, this->q = q, this->g = g;
}
// Function to generate a random private key in the range [1,

q-1]
int getPrivateKey(const int& q) const {
return (rand() % (q - 1)) + 1; // Random number between 1
and q-1
}
// Function to compute the public key corresponding to a

private key
G getPublicKey(const int& privateKey, const G& g) const {
return privateKey * g; // Scalar multiplication of the
base point
}
// Function to encrypt a message given sender's private key,

receiver's public key, and message point
pair<G, G> getEncryptedMessage(const int& senderPrivateKey,
const G& receiverPublicKey, const G& message) const {
G c1 = senderPrivateKey * g; //
k*G
G c2 = message + senderPrivateKey * receiverPublicKey; //
Pm + k*Pb
return {c1, c2};
}
// Function to decrypt an encrypted message given the pair of
points and the receiver's private key
G getDecryptedMessage(const pair<G, G>& encryptedMessage,
const int& receiverPrivateKey) const {
return encryptedMessage.second - receiverPrivateKey *
encryptedMessage.first; // C2 - nb*C1
}
private:
int a, b, q;
G g; // Base point on the elliptic curve
};
int main() {
int q = 11, a = 1, b = 6;
G g(2, 7, q, a);
Elliptic_curve ec(a, b, q, g);
int nb = 7;
G pb = ec.getPublicKey(nb,g); // Compute the public key for
receiver nb
cout << "pb=" << pb.x << "," << pb.y << endl;
int na = 3;
G pm(10, 9, q, a); // Define the message point Pm
pair<G, G> cm = ec.getEncryptedMessage(na, pb, pm); //
Encrypt the message for receiver pb
cout << "cm1=" << cm.first.x << "," << cm.first.y << endl;
cout << "cm2=" << cm.second.x << "," << cm.second.y << endl;
G pm1 = ec.getDecryptedMessage(cm, nb); // Decrypt the

message using the receiver's private key
cout << "pm=" << pm1.x << "," << pm1.y << endl;
return 0;
}
Output:

Ecc 2

Uploaded by

Copyright:

Available Formats

Ecc 2

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ecc 2

Uploaded by

Copyright:

Available Formats

Name: Siddhant Kundlik Thaware

ELLIPTIC CURVE CRYTOGRAPHY:

#include <functional> //require c++11

// Constructor with parameters to initialize the object

// Overloaded '+' operator for adding two points on an

int t, xr, yr;

return G(xr, yr, this->p, this->a);

// Overloaded '-' operator for subtracting two points on an

// Overloaded '*' operator for scalar multiplication of a

int x, y, p, a; // Public parameters of the point

// Helper function to compute the modulo of a number

// Overloaded '*' operator for scalar multiplication with the

// Setter function to update the curve parameters and base

// Function to generate a random private key in the range [1,

// Function to compute the public key corresponding to a

// Function to encrypt a message given sender's private key,

G pm1 = ec.getDecryptedMessage(cm, nb); // Decrypt the

You might also like