CE235编程代写、代做python程序设计

日期：2024-12-10 09:18

Assignment 2: Blockchain and Mining with Proof-of-work for Bitcoin

CE235 Computer Security

2024-2025

University of Essex

1. Introduction

1.1 Bitcoin Mining

Bitcoin is a cryptocurrency. In the Bitcoin system Bitcoins are mined through proof-of-work mechanism.

Bitcoin miners are given technical puzzles to solve. There is only one puzzle at any time with a given difficulty

level, which is set by the system administrator. New puzzles are created after the current one is solved.

The first miner who solves the puzzle is awarded a specified number of bitcoins. The winner creates and sign a

new block with digital signature technology and broadcast to other Bitcoin users. The signed block is linked to

the previous signed blocks. These blocks form a chain of blocks (called blockchain) as shown in the following

figure. The new signed blocks are verified by others and could become mature after being confirmed by a given

number of miners, which is measured by length of blocks linked to the new blocks.

1.2 Technical puzzle

The puzzle set in the proof-of-work is to find a specific integer number (called nonce), which together with a

few other numbers (such as hash value of the previous block, the transactions to be included to the new block)

are hashed with SHA-256 algorithm and the hashed value satisfies a given condition.

The puzzle can be formulated as follows:

where preHash is the hash value of the previous block, Tx is transaction of bitcoins. levelHard is a given number,

usually controlled by requiring a consecutive number of most significant bits (MSB) being zeros, for example

the first 30 MSBs being zero. The more MSB zeros required on levelHard, the more difficult to solve the puzzle

(finding the nonce satisfying the condition). Below gives a binary number with the 15 MSB being zeros and 5

least significant bits (LSB).

(MSB) 00000000000000011100000101111110011010101100000 (LSB)

1.3 Signing and verifying a new block

The first miner solving the puzzle will create a new block, which includes a block header (storing the digital

signature of this new block, which will include the hash value of the block body) and a block body. The block

body includes the hash value of the previous block, the found nonce and transactions included in this block. The

digital signature is created by encrypting the hash value of this new block with private key. The block is linked

to the last block of the existing blockchain and broadcast. The new block will then be verified by others using

the winning miner’s public key and checking the hash values of this and previous blocks.

2. Specification

Block header (signature)

Prev Hash

Nonce

Tx1

Tx2

TxN

Block header (signature)

Prev Hash

Nonce

Tx1

Tx2

TxN

Block header (signature)

Prev Hash

Nonce

Tx1

Tx2

TxN

Block n-2 Block n-1 Block n

find nonce, subject to: hash(preHash, nonce, Tx) < levelHard This assignment takes 18% of the marks (18 marks) of this module. The aim of the assignment is to write a

Python program, which will implement a simplified version of Bitcoin mining and digital signature schemes as

shown in the following figure, with additional task of protecting the confidentiality of the signed message (from

by encrypting/decrypting the signed message (such as with an extra RSA key pair for the validator).

2.1 Task1: Create a RSA public/private key pair with 1024 bits key length [1 mark]

o The RSA key pairs will be used in Task3 and Task4 of this assignment.

o The created RSA public {n,e} and private keys {n,d} need to be displayed with the following

format:

2.2 Task2: Find a nonce with hash algorithm SHA-256, which is a hash value satisfying requirement

of the 6 least significant bits (LSB) being zero [4 marks]. Produce a figure (or a table) which shows

the computation time (denoted by T) used to find a valid nonce by your own computer against the

number of required LSB being zero (denoted by N) changing from 1 to 8 [3 marks].

o Hint: you can extend Example 4 in the provided sample program to complete this task. Example 4

generates only one nonce and check if the nonce is valid.

o You should try many random integers as nonce (with a loop) until you successfully find a nonce

that meets the requirement. The only output from this task is the nonce, which needs to be displayed

with the following format (suppose the found nonce is 12345):

o You can use your program to produce the figure/table automatically, or you can record the

computation times and create the figure/table using other software, then present it to the teaching

staff members during your demonstration. Not to submit the figure/table to Faser.

2.3 Task3: Digitally sign the nonce and your student number with the RSA private key [3 marks]

o The message to be signed is a string consisting of the nonce (found with 6 LSB being zero) and

your student number, which are separated by a space. For example, if the found nonce is 12345 and

your student number is 54321, then the message to be signed needs to be a string “12345 54321”

o You need to sign the message with RSA key pair generated in Task 1.

o The outputs of this Task3 include the hashed value of the message and the signature, which need to

be displayed with the following format.

Find a valid

nonce

Sign message

(nonce, student #)

Verify the digital

signature

Generate RSA

keys

Measure

computation time

Required # of

LSB zeros

Valid

nonce

Encrypted message

& signature

Validation

outcome

Table or figure Keys

Keys

Public key:

(n=0x995361030caa5bf308e272fe07f3466c0727b5ac0c41107142fd97dd75ec4a197250c038

8b8711b210b2beb300980321913e9eb21b22f72c3fe8b62adda13491c6efbf3f4e6c6c60738da

c790af2ca0b8067f4550fae82c8ea85d3fc0667f1de7a193f23a1d30e8e7f2894f07ce26b5d94

85df5a29fc265fc217dbbb91065b35, e=0x10001)

Private key:

(n=0x995361030caa5bf308e272fe07f3466c0727b5ac0c41107142fd97dd75ec4a197250c038

8b8711b210b2beb300980321913e9eb21b22f72c3fe8b62adda13491c6efbf3f4e6c6c60738da

c790af2ca0b8067f4550fae82c8ea85d3fc0667f1de7a193f23a1d30e8e7f2894f07ce26b5d94

85df5a29fc265fc217dbbb91065b35,

d=0x24cf1913a7d74042dce7ac6ea30efae19568299bb7c769009ff20ca2ec9c010011eb23f28

f40aa7562bfdebb4f91aef2c091557cf1b9d7b82651a2663115f1ee0c416b1fec516a83657558

068f1eebffae9f11b2801830acf2b0af4367fcd26ffe4672c5c5165afaeb5eeb81e6497a04192

133476e124b4ce2a869a16fc998e1)

Valid Nonce: 12345  

2.4 Task4: Verify the signature [3 marks]

o The signature verification is to be achieved by decrypting the digital signature with public key

{n,e} generated in Task 1 to get the hash value from the signature and compare it to the one

obtained from hashing the signed message.

o The process of signature verification needs to output yes or no depending on the verification

outcome.

2.5 Task5: Protect the confidentiality of the signed message from Task 3 by encrypting/decrypting

the signed message [4 marks]

o You should generate another RSA key pair for the validator.

o The signed message should be encrypted with a key of the validator by the user who signs the

message.

o The encrypted signed message should be decrypted with another key of the validator before the

signature validation by the validator.

3. Sample Program

We provide a sample python program miningBitcoin_sample.py, which includes most of the needed

RSA encryption and digital signature functions to complete the above tasks. It can be run from integrated

development environments (IDLE). It can also be run from the command line like this:

python mingingBitcoin_sample.py

You should modify the sample python program to complete the tasks. Your own program should have a name

like cs_bitcoin_registrationnumber.py (replace registrationnumber by your own registration number). For

example, if your registration number is 1234567, your filename will be:

cs_bitcoin_1234567.py

Your program must run from the command line like this:

python cs_bitcoin_1234567.py

The outputs of your program are required to be displayed, following the specified format for marking purposes.

4. How to submit

Submit your python .py file to Faser by the submission deadline Friday, 13/12/2024.

5. Marking Scheme

You will be asked by the Professor He or teaching assistants at NWU to demonstrate your work and answer questions

to ensure it is your own work. Your marks for this assignment will be dependent on the complement and output

results of your program, and your answers to the questions asked by the teachers. If you are asked to but you don’t

demonstrate your work, no mark will be given to your assignment work.

Apart from demonstration of your work to the teaching staff members, it is mandatory for you to submit your program

file to Faser on time. Otherwise, you may not get any mark for your work on the assignment.

Your submitted program may be checked and tested by Professor He. If problems such as plagiarism are found from

the testing, your marks will be reduced.

Plagiarism

You should work individually on this project. Anything you submit is assumed to be entirely your own work.

The usual Essex policy on plagiarism applies: http://www.essex.ac.uk/plagiarism/.

Message: 12345 54321

Hash value of message:

32547436749427615422843012801191259465058592439985110545719463144077305232244

Signature:

0x3ee3934a23e2d55c7377a125e052e5f305d82fbf0643713acb00cf1cb0c968eb65f56de35d0

37aac5d0d3ae7489d4067e9c38ceee2f4f602ebf90d8a070606c27808f22bd537a42e066c86c3

6d5e5efa786be09e0753f82a847a05d0bdcd0418624a3f3c8a203524f97f56528ffca1e633d29

bd8cfa80fb80bc3b4a53e2d51b5 Appendix A. Sample Python Program for Bitcoin Mining

### First first time use, you need to install module pycryptodome

### using the following commands (without #) in terminal:

# pip uninstall crypto

# pip install pycryptodome

# import necessary modules

from Crypto.PublicKey import RSA

from hashlib import sha512, sha256

import random

#The following function generateRSAKeys creates the RSA public/private key pair.

def generateRSAKeys(numBits):

keyPair = RSA.generate(numBits)

return keyPair

### Example 1: generating RSA public/private keys.

numBits = 1024

keyPair = generateRSAKeys(numBits)

print("Public key: n={", hex(keyPair.n), "}, e={", hex(keyPair.e), "})")

print(' ')

print("Private key: n={", hex(keyPair.n), "}, d={", hex(keyPair.d), "})")

print(' ')

#The following function digitalSignRSA digitally sign a message of type "bytes"

# with RSA private key of keyPair

#- input: msg and keyPairRSA

#- output: signature (type: int)

def digitalSignRSA(msg, keyPairRSA):

### RSA sign the message

# msg = bytes('A message for signing', 'utf-8')

# compute the hash value of the message to be signed with hash algorithm SHA-256

hashValue = int.from_bytes(sha256(msg).digest(), byteorder='big')

#sign (encrypt) the hash value of the message with RSA priviate key

# only the person with RSA private key can perform the operation

signature = pow(hashValue, keyPair.d, keyPair.n)

return(hashValue, signature)

### Example 2: calling function digitalSignRSA to sign a given message

msg = bytes('A message for signing', 'utf-8')

(hashValue, signature) = digitalSignRSA(msg, keyPair)

print("Hash value of message:", hashValue)

print("Signature:", hex(signature))

print(' ')

#The following function digitalVerifyRSA verify the signature of a message of type "bytes"

# with RSA public key of keyPair

#- input: msg, keyPairRSA and signature #- output: validity (type: boolean)

def digitalVerifyRSA(msg, keyPairRSA, signature):

### Verify the digital signature

# compute the hash value of the message to be signed with hash algorithm SHA-256

hashValue = int.from_bytes(sha256(msg).digest(), byteorder='big')

# decrypt the signature of the message to obtain the hash value with RSA public key

# everyone with RSA public key can perform the operation

hashFromSignature = pow(signature, keyPair.e, keyPair.n)

validity = (hashValue == hashFromSignature)

return(validity)

### Example 3: verifying a message signature using function digitalVerifyRSA

# Verify the true digital signature with the original message

msg = bytes('A message for signing', 'utf-8')

validity = digitalVerifyRSA(msg, keyPair, signature)

print("Signature validity:", validity)

print(' ')

# Verify the true digital signature with a tampered message

msgTampered = bytes('A message for signing (tampered)', 'utf-8')

validity = digitalVerifyRSA(msgTampered, keyPair, signature)

print("Signature validity:", validity)

print(' ')

#The following function checkOneNonce will check if one nonce can solve the puzzle

#This function can be used to implement the proof-of-work

#- input: numZerosNeeded (type: int), required number of least significant bits to be zero.

# nonce (type: int), a random number to be checked

#- output: validity (type: boolean), true or false on the validity of this nonce.

def checkOneNonce(numZerosNeeded, nonce):

# Note that hash function sha256 accepts input of type byte.

# so we convert random number nonce to a byte array nByte

#convert the random integer to a byte array

nByte = bytes(str(nonce), 'utf-8')

# compute the hash of the nonce

hash = int.from_bytes(sha256(nByte).digest(), byteorder='big')

# convert the hash value to binary number and extract the needed LSBs.

hashBin = bin(hash)

hashLSB = int(hashBin[-numZerosNeeded:])

# check if the LSBs are all zero

if hashLSB == 0:

print('nRand:', nonce, '; hash_lsb:', hashLSB)

validity = (hashLSB == 0)

return (validity)

# Example 4: generating a random number as a nonce, checking only one nonce with function checkOneNonce,

# the nonce may be valid or may be invalid.

numZerosNeeded = 5

# generate a nonce (a random integer in a specified range)

nonce = random.randint(0,1000000)  

Example Output after running the sample program:

validity = checkOneNonce(numZerosNeeded, nonce)

print('The validity of this nonce ', nonce, ' is:', validity)

print('================================================================ ')

### Task 1: Create a RSA public/private key pair with 1024 bits key length [1%]

### Task 2 [7%]: Using hash algorithm SHA-256 to find a nonce, and produce a figure or a table showing the

computation time to find valid naunce against the number of required LSB being zero (1 to 8).

### Task3: Digitally sign the nonce and your student number with the RSA private key [3%]

### Task4: Digitally verify the signature with the RSA public key [3%]

# you should produce and display the output of either “yes” or “no” according to the verification result.

### Task5: Protect the confidentiality of the signed message [4%]

# you should produce and display the output of either “yes” or “no” according to the verification result.