juneja-codebase 4.1.0__tar.gz → 4.1.1__tar.gz

juneja_codebase-4.1.1/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include juneja_codebase/templates *

{juneja_codebase-4.1.0 → juneja_codebase-4.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: juneja_codebase
-Version: 4.1.0
+Version: 4.1.1
 Summary: CLI tool to generate academic practical code files for Compiler Design, Data Structures, OS, and DBMS
 Home-page: UNKNOWN
 Author: AJ

{juneja_codebase-4.1.0 → juneja_codebase-4.1.1}/juneja_codebase/__init__.py

@@ -2,5 +2,5 @@
 juneja-codebase: A CLI tool to generate academic practical code files
 """
 
-__version__ = "4.1.0"
+__version__ = "4.1.1"
 __author__ = "AJ"

{juneja_codebase-4.1.0 → juneja_codebase-4.1.1}/juneja_codebase/main.py

@@ -175,7 +175,7 @@ Examples:
     parser.add_argument(
         '--version', '-v',
         action='version',
-        version='%(prog)s 4.0.0'
+        version='%(prog)s 4.1.1'
     )
     
     args = parser.parse_args()

juneja_codebase-4.1.1/juneja_codebase/templates/Blockchain Codes/.vscode/tasks.json

@@ -0,0 +1,28 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: gcc build active file",
+            "command": "/usr/bin/gcc",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}/${fileBasenameNoExtension}"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "Task generated by Debugger."
+        }
+    ],
+    "version": "2.0.0"
+}

juneja_codebase-4.1.1/juneja_codebase/templates/Blockchain Codes/pythonic version/q10_hyperledger_chaincode.js

@@ -0,0 +1,273 @@
+'use strict';
+
+/**
+ * Q10. Create a simple permissioned blockchain using Hyperledger Fabric
+ *
+ * This is a Chaincode (Smart Contract) for Hyperledger Fabric written in JavaScript.
+ * It implements an Asset Management system on a permissioned blockchain.
+ *
+ * Features demonstrated:
+ *  - Permissioned access (only authorized organizations can perform actions)
+ *  - Create, Read, Update, Delete (CRUD) operations on assets
+ *  - Asset transfer between owners
+ *  - Transaction history retrieval
+ *  - World State ledger interaction
+ *
+ * ── Setup & Run Instructions ───────────────────────────────────────────────
+ *
+ * Prerequisites:
+ *   - Docker & Docker Compose installed
+ *   - Node.js >= 14.x installed
+ *   - Hyperledger Fabric binaries and samples installed:
+ *       curl -sSL https://bit.ly/2ysbOFE | bash -s
+ *
+ * Step 1: Navigate to the Fabric test network
+ *   cd fabric-samples/test-network
+ *
+ * Step 2: Start the network with a channel
+ *   ./network.sh up createChannel -c mychannel -ca
+ *
+ * Step 3: Deploy this chaincode
+ *   ./network.sh deployCC -ccn assetcc -ccp ../chaincode/asset -ccl javascript
+ *
+ * Step 4: Set environment variables for Org1 (peer admin)
+ *   export PATH=${PWD}/../bin:$PATH
+ *   export FABRIC_CFG_PATH=$PWD/../config/
+ *   export CORE_PEER_TLS_ENABLED=true
+ *   export CORE_PEER_LOCALMSPID="Org1MSP"
+ *   export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt
+ *   export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp
+ *   export CORE_PEER_ADDRESS=localhost:7051
+ *
+ * Step 5: Invoke chaincode functions
+ *
+ *   Initialize ledger:
+ *     peer chaincode invoke ... -c '{"function":"InitLedger","Args":[]}'
+ *
+ *   Create an asset:
+ *     peer chaincode invoke ... -c '{"function":"CreateAsset","Args":["ASSET1","Laptop","Alice","5000"]}'
+ *
+ *   Read an asset:
+ *     peer chaincode query  ... -c '{"function":"ReadAsset","Args":["ASSET1"]}'
+ *
+ *   Update an asset:
+ *     peer chaincode invoke ... -c '{"function":"UpdateAsset","Args":["ASSET1","Desktop","Alice","4000"]}'
+ *
+ *   Transfer an asset:
+ *     peer chaincode invoke ... -c '{"function":"TransferAsset","Args":["ASSET1","Bob"]}'
+ *
+ *   Get all assets:
+ *     peer chaincode query  ... -c '{"function":"GetAllAssets","Args":[]}'
+ *
+ *   Get transaction history:
+ *     peer chaincode query  ... -c '{"function":"GetAssetHistory","Args":["ASSET1"]}'
+ *
+ *   Delete an asset:
+ *     peer chaincode invoke ... -c '{"function":"DeleteAsset","Args":["ASSET1"]}'
+ *
+ * Step 6: Shut down the network
+ *   ./network.sh down
+ *
+ * ──────────────────────────────────────────────────────────────────────────
+ */
+
+const { Contract } = require('fabric-contract-api');
+
+class AssetContract extends Contract {
+
+    // ── Helper: Check if an asset exists ──────────────────────
+
+    async AssetExists(ctx, assetId) {
+        const assetJSON = await ctx.stub.getState(assetId);
+        return assetJSON && assetJSON.length > 0;
+    }
+
+    // ── Helper: Get caller's MSP ID (Organization) ────────────
+
+    getCallerMSP(ctx) {
+        return ctx.clientIdentity.getMSPID();
+    }
+
+    // ── Helper: Permissioned access check ────────────────────
+    // Only Org1MSP and Org2MSP members are allowed to transact
+
+    checkPermission(ctx) {
+        const mspID = this.getCallerMSP(ctx);
+        const allowedOrgs = ['Org1MSP', 'Org2MSP'];
+        if (!allowedOrgs.includes(mspID)) {
+            throw new Error(`Permission denied: Organization '${mspID}' is not authorized.`);
+        }
+    }
+
+    // ── 1. Initialize the ledger with sample assets ───────────
+
+    async InitLedger(ctx) {
+        this.checkPermission(ctx);
+
+        const assets = [
+            { assetId: 'ASSET001', name: 'Laptop',     owner: 'Alice', value: 5000 },
+            { assetId: 'ASSET002', name: 'Smartphone', owner: 'Bob',   value: 1500 },
+            { assetId: 'ASSET003', name: 'Tablet',     owner: 'Carol', value: 800  },
+        ];
+
+        for (const asset of assets) {
+            asset.docType = 'asset';
+            await ctx.stub.putState(asset.assetId, Buffer.from(JSON.stringify(asset)));
+            console.log(`Asset ${asset.assetId} initialized on ledger.`);
+        }
+
+        console.log('Ledger initialized successfully.');
+    }
+
+    // ── 2. Create a new asset ─────────────────────────────────
+
+    async CreateAsset(ctx, assetId, name, owner, value) {
+        this.checkPermission(ctx);
+
+        const exists = await this.AssetExists(ctx, assetId);
+        if (exists) {
+            throw new Error(`Asset '${assetId}' already exists.`);
+        }
+
+        const asset = {
+            docType  : 'asset',
+            assetId  : assetId,
+            name     : name,
+            owner    : owner,
+            value    : parseInt(value),
+            createdBy: this.getCallerMSP(ctx),
+            createdAt: new Date().toISOString(),
+        };
+
+        await ctx.stub.putState(assetId, Buffer.from(JSON.stringify(asset)));
+        console.log(`Asset ${assetId} created by ${asset.createdBy}`);
+        return JSON.stringify(asset);
+    }
+
+    // ── 3. Read an asset ──────────────────────────────────────
+
+    async ReadAsset(ctx, assetId) {
+        this.checkPermission(ctx);
+
+        const assetJSON = await ctx.stub.getState(assetId);
+        if (!assetJSON || assetJSON.length === 0) {
+            throw new Error(`Asset '${assetId}' does not exist.`);
+        }
+
+        console.log(`Asset ${assetId} retrieved.`);
+        return assetJSON.toString();
+    }
+
+    // ── 4. Update an existing asset ───────────────────────────
+
+    async UpdateAsset(ctx, assetId, name, owner, value) {
+        this.checkPermission(ctx);
+
+        const exists = await this.AssetExists(ctx, assetId);
+        if (!exists) {
+            throw new Error(`Asset '${assetId}' does not exist.`);
+        }
+
+        const updatedAsset = {
+            docType    : 'asset',
+            assetId    : assetId,
+            name       : name,
+            owner      : owner,
+            value      : parseInt(value),
+            updatedBy  : this.getCallerMSP(ctx),
+            updatedAt  : new Date().toISOString(),
+        };
+
+        await ctx.stub.putState(assetId, Buffer.from(JSON.stringify(updatedAsset)));
+        console.log(`Asset ${assetId} updated by ${updatedAsset.updatedBy}`);
+        return JSON.stringify(updatedAsset);
+    }
+
+    // ── 5. Transfer an asset to a new owner ───────────────────
+
+    async TransferAsset(ctx, assetId, newOwner) {
+        this.checkPermission(ctx);
+
+        const assetJSON = await ctx.stub.getState(assetId);
+        if (!assetJSON || assetJSON.length === 0) {
+            throw new Error(`Asset '${assetId}' does not exist.`);
+        }
+
+        const asset       = JSON.parse(assetJSON.toString());
+        const oldOwner    = asset.owner;
+        asset.owner       = newOwner;
+        asset.transferredBy = this.getCallerMSP(ctx);
+        asset.transferredAt = new Date().toISOString();
+
+        await ctx.stub.putState(assetId, Buffer.from(JSON.stringify(asset)));
+        console.log(`Asset ${assetId} transferred from '${oldOwner}' to '${newOwner}'`);
+        return `Asset '${assetId}' transferred from '${oldOwner}' to '${newOwner}'.`;
+    }
+
+    // ── 6. Delete an asset ────────────────────────────────────
+
+    async DeleteAsset(ctx, assetId) {
+        this.checkPermission(ctx);
+
+        const exists = await this.AssetExists(ctx, assetId);
+        if (!exists) {
+            throw new Error(`Asset '${assetId}' does not exist.`);
+        }
+
+        await ctx.stub.deleteState(assetId);
+        console.log(`Asset ${assetId} deleted by ${this.getCallerMSP(ctx)}`);
+        return `Asset '${assetId}' deleted successfully.`;
+    }
+
+    // ── 7. Get all assets from the ledger ─────────────────────
+
+    async GetAllAssets(ctx) {
+        this.checkPermission(ctx);
+
+        const allResults = [];
+        // Range query with empty start/end key retrieves all assets
+        const iterator = await ctx.stub.getStateByRange('', '');
+
+        let result = await iterator.next();
+        while (!result.done) {
+            const strValue = Buffer.from(result.value.value.toString()).toString('utf8');
+            let record;
+            try {
+                record = JSON.parse(strValue);
+            } catch (err) {
+                record = strValue;
+            }
+            allResults.push(record);
+            result = await iterator.next();
+        }
+
+        console.log(`Retrieved ${allResults.length} asset(s) from ledger.`);
+        return JSON.stringify(allResults);
+    }
+
+    // ── 8. Get full transaction history of an asset ───────────
+
+    async GetAssetHistory(ctx, assetId) {
+        this.checkPermission(ctx);
+
+        const historyIterator = await ctx.stub.getHistoryForKey(assetId);
+        const history         = [];
+
+        let result = await historyIterator.next();
+        while (!result.done) {
+            const record = {
+                txId      : result.value.txId,
+                timestamp : result.value.timestamp,
+                isDelete  : result.value.isDelete,
+                value     : result.value.value.toString('utf8'),
+            };
+            history.push(record);
+            result = await historyIterator.next();
+        }
+
+        console.log(`History for asset '${assetId}': ${history.length} transaction(s).`);
+        return JSON.stringify(history);
+    }
+}
+
+module.exports = AssetContract;

juneja_codebase-4.1.1/juneja_codebase/templates/Blockchain Codes/pythonic version/q1_sha256_digest.py

@@ -0,0 +1,16 @@
+"""
+Q1. Using SHA-256, obtain the message digest of string "Blockchain Developer"
+"""
+
+import hashlib
+
+message = "Blockchain Developer"
+
+# Encode the string and compute SHA-256 digest
+sha256_hash = hashlib.sha256(message.encode())
+
+# Get the message digest in hexadecimal
+message_digest = sha256_hash.hexdigest()
+
+print("Message         :", message)
+print("SHA-256 Digest  :", message_digest)

juneja_codebase-4.1.1/juneja_codebase/templates/Blockchain Codes/pythonic version/q2_sha256_encrypt_decrypt.py

@@ -0,0 +1,40 @@
+"""
+Q2. Write a program to encrypt and decrypt the message "Hello World" using SHA256.
+
+Note: SHA-256 is a cryptographic hash function, not a symmetric cipher.
+It is used here to derive an encryption key (via XOR stream cipher),
+which is a standard academic approach to demonstrate SHA-256 in encryption.
+"""
+
+import hashlib
+
+def encrypt(message, key):
+    # Generate SHA-256 hash of the key
+    key_hash = hashlib.sha256(key.encode()).digest()  # 32 bytes
+    message_bytes = message.encode()
+    # XOR each byte of the message with the key hash (cyclic)
+    encrypted = bytes([message_bytes[i] ^ key_hash[i % len(key_hash)]
+                       for i in range(len(message_bytes))])
+    return encrypted
+
+def decrypt(encrypted_bytes, key):
+    # Generate SHA-256 hash of the key
+    key_hash = hashlib.sha256(key.encode()).digest()  # 32 bytes
+    # XOR again with same key to reverse encryption
+    decrypted = bytes([encrypted_bytes[i] ^ key_hash[i % len(key_hash)]
+                       for i in range(len(encrypted_bytes))])
+    return decrypted.decode()
+
+# ── Main ──────────────────────────────────────────────────────
+message = "Hello World"
+key     = "secretkey"
+
+print("Original Message   :", message)
+
+# Encrypt
+encrypted = encrypt(message, key)
+print("Encrypted (hex)    :", encrypted.hex())
+
+# Decrypt
+decrypted = decrypt(encrypted, key)
+print("Decrypted Message  :", decrypted)

juneja_codebase-4.1.1/juneja_codebase/templates/Blockchain Codes/pythonic version/q3_rsa.py

@@ -0,0 +1,103 @@
+"""
+Q3. Implement RSA Cryptographic Algorithm
+"""
+
+# # RSA Implementation from scratch (no external crypto libraries)
+
+# def gcd(a, b):
+#     while b:
+#         a, b = b, a % b
+#     return a
+
+# def mod_inverse(e, phi):
+#     # Extended Euclidean Algorithm to find modular inverse
+#     original_phi = phi
+#     x0, x1 = 0, 1
+#     if phi == 1:
+#         return 0
+#     while e > 1:
+#         q = e // phi
+#         phi, e = e % phi, phi
+#         x0, x1 = x1 - q * x0, x0
+#     if x1 < 0:
+#         x1 += original_phi
+#     return x1
+
+# def is_prime(n):
+#     if n < 2:
+#         return False
+#     for i in range(2, int(n**0.5) + 1):
+#         if n % i == 0:
+#             return False
+#     return True
+
+# def generate_keys():
+#     # Two prime numbers p and q
+#     p = 61
+#     q = 53
+
+#     n = p * q                  # n = 3233
+#     phi = (p - 1) * (q - 1)   # phi = 3120
+
+#     # Choose e such that 1 < e < phi and gcd(e, phi) = 1
+#     e = 17
+#     while gcd(e, phi) != 1:
+#         e += 2
+
+#     # Compute d such that d*e ≡ 1 (mod phi)
+#     d = mod_inverse(e, phi)
+
+#     public_key  = (e, n)
+#     private_key = (d, n)
+#     return public_key, private_key
+
+# def encrypt(message, public_key):
+#     e, n = public_key
+#     # Convert each character to its ASCII value, then apply RSA: c = m^e mod n
+#     encrypted = [pow(ord(char), e, n) for char in message]
+#     return encrypted
+
+# def decrypt(encrypted, private_key):
+#     d, n = private_key
+#     # Reverse RSA: m = c^d mod n, then convert back to character
+#     decrypted = ''.join([chr(pow(char, d, n)) for char in encrypted])
+#     return decrypted
+
+# # ── Main ──────────────────────────────────────────────────────
+# public_key, private_key = generate_keys()
+
+# print("RSA Key Generation")
+# print("  Public Key  (e, n) :", public_key)
+# print("  Private Key (d, n) :", private_key)
+# print()
+
+# message = "Hello World"
+# print("Original Message   :", message)
+
+# # Encrypt
+# encrypted = encrypt(message, public_key)
+# print("Encrypted          :", encrypted)
+
+# # Decrypt
+# decrypted = decrypt(encrypted, private_key)
+# print("Decrypted Message  :", decrypted)
+
+from Crypto.PublicKey import RSA
+from Crypto.Cipher import PKCS1_OAEP
+
+# Generate keys
+key = RSA.generate(2048)
+public_key = key.publickey()
+
+# Encrypt
+message = "Hello RSA"
+cipher = PKCS1_OAEP.new(public_key)
+encrypted = cipher.encrypt(message.encode())
+
+print("Encrypted:", encrypted)
+
+# Decrypt
+cipher_dec = PKCS1_OAEP.new(key)
+decrypted = cipher_dec.decrypt(encrypted)
+
+print("Decrypted:", decrypted.decode())

juneja_codebase-4.1.1/juneja_codebase/templates/Blockchain Codes/pythonic version/q4_pow_blockchain.py

@@ -0,0 +1,69 @@
+"""
+Q4. Create a simple blockchain using Proof of Work (PoW)
+"""
+
+import hashlib
+import time
+
+class Block:
+    def __init__(self, index, data, previous_hash):
+        self.index         = index
+        self.timestamp     = time.time()
+        self.data          = data
+        self.previous_hash = previous_hash
+        self.nonce         = 0
+        self.hash          = self.proof_of_work()
+
+    def compute_hash(self):
+        block_string = f"{self.index}{self.timestamp}{self.data}{self.previous_hash}{self.nonce}"
+        return hashlib.sha256(block_string.encode()).hexdigest()
+
+    def proof_of_work(self, difficulty=4):
+        # Keep hashing until hash starts with required number of zeros
+        target = "0" * difficulty
+        while True:
+            self.hash = self.compute_hash()
+            if self.hash.startswith(target):
+                return self.hash
+            self.nonce += 1
+
+
+class Blockchain:
+    def __init__(self):
+        self.chain = []
+        self.create_genesis_block()
+
+    def create_genesis_block(self):
+        genesis_block = Block(0, "Genesis Block", "0")
+        self.chain.append(genesis_block)
+
+    def get_last_block(self):
+        return self.chain[-1]
+
+    def add_block(self, data):
+        last_block = self.get_last_block()
+        new_block  = Block(len(self.chain), data, last_block.hash)
+        self.chain.append(new_block)
+
+    def display_chain(self):
+        for block in self.chain:
+            print(f"\nBlock Index    : {block.index}")
+            print(f"Timestamp      : {block.timestamp}")
+            print(f"Data           : {block.data}")
+            print(f"Nonce          : {block.nonce}")
+            print(f"Previous Hash  : {block.previous_hash}")
+            print(f"Hash           : {block.hash}")
+            print("-" * 64)
+
+
+# ── Main ──────────────────────────────────────────────────────
+blockchain = Blockchain()
+
+blockchain.add_block("Transaction: Alice pays Bob 10 BTC")
+blockchain.add_block("Transaction: Bob pays Carol 5 BTC")
+blockchain.add_block("Transaction: Carol pays Dave 2 BTC")
+
+print("=" * 64)
+print("        Simple Blockchain with Proof of Work (PoW)")
+print("=" * 64)
+blockchain.display_chain()

juneja_codebase-4.1.1/juneja_codebase/templates/Blockchain Codes/pythonic version/q5_digital_signature.py

@@ -0,0 +1,104 @@
+"""
+Q5. Demonstrate sending of a digitally signed document
+"""
+
+import hashlib
+
+# ── RSA helper functions (from scratch) ───────────────────────
+
+def gcd(a, b):
+    while b:
+        a, b = b, a % b
+    return a
+
+def mod_inverse(e, phi):
+    original_phi = phi
+    x0, x1 = 0, 1
+    if phi == 1:
+        return 0
+    while e > 1:
+        q = e // phi
+        phi, e = e % phi, phi
+        x0, x1 = x1 - q * x0, x0
+    if x1 < 0:
+        x1 += original_phi
+    return x1
+
+def generate_rsa_keys():
+    p, q  = 61, 53
+    n     = p * q
+    phi   = (p - 1) * (q - 1)
+    e     = 17
+    d     = mod_inverse(e, phi)
+    return (e, n), (d, n)   # public_key, private_key
+
+# ── Digital Signature functions ───────────────────────────────
+
+def hash_document(document):
+    """Compute SHA-256 digest of the document and return as integer."""
+    digest_hex = hashlib.sha256(document.encode()).hexdigest()
+    # Use only first 8 hex chars (32-bit int) to keep within RSA key space
+    return int(digest_hex[:8], 16)
+
+def sign_document(document, private_key):
+    """Sender signs the document hash using private key."""
+    d, n = private_key
+    doc_hash = hash_document(document)
+    doc_hash_mod = doc_hash % n          # ensure hash fits within key space
+    signature = pow(doc_hash_mod, d, n)  # signature = hash^d mod n
+    return signature
+
+def verify_signature(document, signature, public_key):
+    """Receiver verifies the document using the sender's public key."""
+    e, n = public_key
+    doc_hash = hash_document(document)
+    doc_hash_mod = doc_hash % n
+    # Decrypt signature using public key
+    decrypted_hash = pow(signature, e, n)
+    return decrypted_hash == doc_hash_mod
+
+# ── Main ──────────────────────────────────────────────────────
+
+public_key, private_key = generate_rsa_keys()
+
+document = "This is a digitally signed document sent from Alice to Bob."
+
+print("=" * 60)
+print("         Digitally Signed Document Demo")
+print("=" * 60)
+print()
+print("[ SENDER - Alice ]")
+print(f"  Document        : {document}")
+print(f"  Public Key      : {public_key}")
+print(f"  Private Key     : {private_key}")
+
+# Alice signs the document
+signature = sign_document(document, private_key)
+print(f"  Signature       : {signature}")
+print()
+print("  Alice sends the document + signature to Bob.")
+
+print()
+print("[ RECEIVER - Bob ]")
+print(f"  Document        : {document}")
+print(f"  Signature       : {signature}")
+
+# Bob verifies using Alice's public key
+is_valid = verify_signature(document, signature, public_key)
+
+if is_valid:
+    print("  Verification    : SUCCESS - Document is authentic and untampered.")
+else:
+    print("  Verification    : FAILED  - Document may be tampered!")
+
+# ── Demonstrate tampering ─────────────────────────────────────
+print()
+print("[ TAMPERING DEMO ]")
+tampered_document = "This is a TAMPERED document."
+print(f"  Tampered Doc    : {tampered_document}")
+is_valid_tampered = verify_signature(tampered_document, signature, public_key)
+
+if is_valid_tampered:
+    print("  Verification    : SUCCESS")
+else:
+    print("  Verification    : FAILED  - Tampering detected! Signature is invalid.")