Types & classes — github.com/Godspower-Eze/learn-cryptography-and-zk

CodeHub MCPcopy Create free account

hub / github.com/Godspower-Eze/learn-cryptography-and-zk / types & classes

Types & classes37 in github.com/Godspower-Eze/learn-cryptography-and-zk

⨍ Functions 275◇ Types & classes 37

↓ 37 callersClassField

A generic implementation of a finite field

with_python/utils/fields.py:4

↓ 16 callersClassFp

A generic implementation of a finite field over the modulus of the bandersnatch curve

with_python/utils/ecc/bandersnatch/fields.py:19

↓ 10 callersClassFr

A generic implementation of a finite field over the order of the bandersnatch curve

with_python/utils/ecc/bandersnatch/fields.py:76

↓ 4 callersClassBandersnatchAffinePoint

An implementation of the bandersnatch curve point in affine coordinate. The bandersnatch curve is a twisted-edwards curve Bandersnatch

with_python/utils/ecc/bandersnatch/curve.py:19

↓ 4 callersClassHMAC

Steps: 1. Pick your hashing algorithm 2. Get the block_size of the hash algorithm. Check https://en.wikipedia.org/wiki/HMAC#Defi

with_python/mac/hmac.py:20

↓ 2 callersClassBandersnatchExtendedPoint

with_python/utils/ecc/bandersnatch/curve.py:270

↓ 1 callersClassDHKE

Steps: 1. Choose a large prime `n`. The modulus 2. Choose a generator g 3. Share publicly 4. The sender generates

with_python/key_exchange/diffie_hellman.py:14

↓ 1 callersClassECC

Steps: 1. Choose an elliptic curve. E.g secp256k1, curve25519 2. Alice generates key pair and shares the public key with Bob

with_python/utils/ecc.py:44

↓ 1 callersClassECDSA

Steps: To Sign: 1. Choose a random integer between k, 1 <= k <= n - 1. Recall that `n` is order of the generator point `G`. S

with_python/signatures/ecdsa.py:21

↓ 1 callersClassPed_ECC

Steps: Verifier: Setup: 1. Get the order of the curve `q` 2. Get the generator of the curve `

with_python/commitments/pedcomm_ecc.py:13

↓ 1 callersClassPed_Mod

Steps: Verifier: Setup: 1. Generate a large prime `q` 2. Pick a generator `g` (a number in [1

with_python/commitments/pedcomm_mod.py:32

↓ 1 callersClassPolyComm_ECC

with_python/commitments/polynomials/basic_polynomial_comm_using_ecc.py:15

↓ 1 callersClassPolyComm_Mod

with_python/commitments/polynomials/basic_polynomial_comm_using_mod.py:142

↓ 1 callersClassRSA

Steps 1. Generate two large primes `p` and `q` using a good random number generator 2. Compute `n` where `n = p * q` 3. C

with_python/rsa.py:5

↓ 1 callersClassSHA_1

Steps: 1. Set some constants: - rounds (80) - number of iterations in the compression grouped into sets of 20. that is, the we have

with_python/commitments/hashing/sha1.py:18

↓ 1 callersClassSHA_224

with_python/commitments/hashing/sha2/sha224.py:4

↓ 1 callersClassSHA_256

Overview: This implementation is similar to the SHA_1 implementation with the following modifications: - Uses a different initializatio

with_python/commitments/hashing/sha2/sha256.py:8

↓ 1 callersClassSHA_384

with_python/commitments/hashing/sha2/sha384.py:7

↓ 1 callersClassSHA_512

with_python/commitments/hashing/sha2/sha512.py:9

↓ 1 callersClassTrustedSetup_ECC

with_python/commitments/polynomials/basic_trusted_setup_ecc.py:13

↓ 1 callersClassTrustedSetup_Mod

with_python/commitments/polynomials/basic_trusted_setup_mod.py:63

ClassCaesarCipher

STEPS: 1. Choose a secret number from 1 to 26 2. Shift every letter of the word by that secret number to get a cipher text 3. R

with_python/ciphers/caesar_cipher.py:14

with_rust/ff/src/lib.rs:25

with_rust/ff/src/lib.rs:31

with_rust/ff/src/lib.rs:7

ClassOne_Time_Pad

STEPS: 1. Generate a list of random numbers the length of the word to be encrypted. 2. Shift every letter of the word by the numb

with_python/ciphers/one_time_pad.py:19

ClassPolyAlphabetic_Cipher

STEPS: 1. Choose a secret word and get it's equivalent in numbers. E.g Love -> 12 15 22 5 2. Repeat this sequence of numbers acro

with_python/ciphers/polyaphabetic_cipher.py:10

InterfacePolynomial

with_rust/poly/src/lib.rs:5

with_rust/sss/src/lib.rs:12

with_rust/ff/src/lib.rs:148

with_rust/ff/src/lib.rs:418

with_rust/ff/src/lib.rs:156

ClassSimpleSubstitution_Cipher

Steps 1. Generate a random sequence of letters whereby each letter occurs once 2. Map this sequence to an ordered sequence of let

with_python/ciphers/simple_substitution.py:12

ClassTestFields

with_python/test/utils/test_fields.py:6

with_rust/poly/src/lib.rs:31

InterfaceUnivariatePolynomial

with_rust/poly/src/lib.rs:19

ClassXOR_One_Time_Pad

STEPS: 1. Generate a list of random numbers the length of the word to be encrypted. 2. Convert every letter of the word to be enc

with_python/ciphers/xor_and_one_time_pad.py:14