Topic: [CHALLENGE] Merit Challenge Lokal Board Indonesia | RESMI & RUNNING - page 8. (Read 7028 times)

APPLICATION: COMMITMENTS

Now let’s look at an application of the hiding property. In particular, what we want to do is something called a commitment. A commitment is the digital analog of taking a value, sealing it in an envelope, and putting that envelope out on the table where everyone can see it. When you do that, you’ve committed yourself to what’s inside the envelope. But you haven’t opened it, so even though you’ve committed to a value, the value remains a secret from everyone else. Later, you can open the envelope and reveal the value that you committed to earlier.

Commitment scheme. A commitment scheme consists of two algorithms:
•  com := commit(msg, nonce) The commit function takes a message and secret random value, called a nonce, as input and returns a commitment.
•  verify(com, msg, nonce) The verify function takes a commitment, nonce, and message as input. It returns true if com == commit(msg, nonce) and false otherwise.
We require that the following two security properties hold:
•  Hiding: Given com, it is infeasible to find msg.
•  Binding: It is infeasible to find two pairs (msg, nonce) and (msg′, nonce′) such that msg ≠ msg′ and commit(msg, nonce) == commit(msg′, nonce′).

To use a commitment scheme, we first need to generate a random nonce. We then apply the commit function to this nonce together with msg, the value being committed to, and we publish the commitment com. This stage is analogous to putting the sealed envelope on the table. At a later point, if we want to reveal the value that we committed to earlier, we publish the random nonce that we used to create this commitment, and the message, msg. Now anybody can verify that msg was indeed the message committed to earlier. This stage is analogous to opening the envelope.

Every time you commit to a value, it is important that you choose a new random value nonce. In cryptography, the term nonce is used to refer to a value that can only be used once.

The two security properties dictate that the algorithms actually behave like sealing and opening an envelope. First, given com, the commitment, someone looking at the envelope can’t figure out what the message is. The second property is that it’s binding. This ensures that when you commit to what’s in the envelope, you can’t change your mind later. That is, it’s infeasible to find two different messages, such that you can commit to one message and then later claim that you committed to another.

So how do we know that these two properties hold? Before we can answer this, we need to discuss how we’re going to actually implement a commitment scheme. We can do so using a cryptographic hash function. Consider the following commitment scheme:
commit(msg, nonce) := H(nonce ‖ msg),
where nonce is a random 256-bit value

To commit to a message, we generate a random 256-bit nonce. Then we concatenate the nonce and the message and return the hash of this concatenated value as the commitment. To verify, someone will compute this same hash of the nonce they were given concatenated with the message. And they will check whether the result is equal to the commitment that they saw.

Take another look at the two properties required of our commitment schemes. If we substitute the instantiation of commit and verify as well as H(nonce ‖ msg) for com, then these properties become:
•  Hiding: Given H(nonce ‖ msg), it is infeasible to find msg.
•  Binding: It is infeasible to find two pairs (msg, nonce) and (msg′, nonce′) such that msg ≠ msg′ and H(nonce ‖ msg) == (nonce′ ‖ msg′).

The hiding property of commitments is exactly the hiding property that we required for our hash functions. If key was chosen as a random 256-bit value, then the hiding property says that if we hash the concatenation of key and the message, then it’s infeasible to recover the message from the hash output. And it turns out that the binding property is implied by the collision-resistant property of the underlying hash function. If the hash function is collision resistant, then it will be infeasible to find distinct values msg and msg′ such that H(nonce ‖ msg) = H(nonce′ ‖ msg′), since such values would indeed be a collision. (Note that the reverse implications do not hold. That is, it’s possible that you can find collisions, but none of them are of the form H(nonce ‖ msg) == H(nonce′ ‖ msg′). For example, if you can only find a collision in which two distinct nonces generate the same commitment for the same message, then the commitment scheme is still binding, but the underlying hash function is not collision resistant.)

Therefore, if H is a hash function that is both collisions resistant and hiding, this commitment scheme will work, in the sense that it will have the necessary security properties.

Property 3: Puzzle Friendliness
The third security property we’re going to need from hash functions is that they are puzzle friendly. This property is a bit complicated. We first explain what the technical requirements of this property are and then give an application that illustrates why this property is useful.
Puzzle friendliness. A hash function H is said to be puzzle friendly if for every possible n-bit output value y, if k is chosen from a distribution with high min-entropy, then it is infeasible to find x such that H(k ‖ x) = y in time significantly less than 2n.
Intuitively, if someone wants to target the hash function to have some particular output value y, and if part of the input has been chosen in a suitably randomized way, then it’s very difficult to find another value that hits exactly that target.

APPLICATION: SEARCH PUZZLE
Let’s consider an application that illustrates the usefulness of this property. In this application, we’re going to build a search puzzle, a mathematical problem that requires searching a very large space to find the solution. In particular, a search puzzle has no shortcuts. That is, there’s no way to find a valid solution other than searching that large space.
Search puzzle. A search puzzle consists of
•  a hash function, H,
•  a value, id (which we call the puzzle-ID), chosen from a high min-entropy distribution, and
•  a target set Y.
A solution to this puzzle is a value, x, such that

The intuition is this: if H has an n-bit output, then it can take any of 2n values. Solving the puzzle requires finding an input such that the output falls within the set Y, which is typically much smaller than the set of all outputs. The size of Y determines how hard the puzzle is. If Y is the set of all n-bit strings, then the puzzle is trivial, whereas if Y has only one element, then the puzzle is maximally hard. That the puzzle ID has high min-entropy ensures that there are no shortcuts. On the contrary, if a particular value of the ID were likely, then someone could cheat, say, by precomputing a solution to the puzzle with that ID.

If a hash function is puzzle friendly, then there’s no solving strategy for this puzzle that is much better than just trying random values of x. And so, if we want to pose a puzzle that’s difficult to solve, we can do it this way as long as we can generate puzzle-IDs in a suitably random way. We’re going to use this idea later, when we talk about Bitcoin mining, starting in Chapter 2—mining is a sort of computational puzzle.


We’ve discussed three properties of hash functions and one application of each of these properties. Now let’s discuss a particular hash function that we’re going to use a lot in this book. Many hash functions exist, but this is the one Bitcoin uses primarily, and it’s a pretty good one to use. It’s called SHA-256.

Recall that we require that our hash functions work on inputs of arbitrary length. Luckily, as long as we can build a hash function that works on fixed-length inputs, there’s a generic method to convert it into a hash function that works on arbitrary-length inputs. It’s called the Merkle-Damgård transform. SHA-256 is one of a number of commonly used hash functions that make use of this method. In common terminology, the underlying fixed-length collision-resistant hash function is called the compression function. It has been proven that if the underlying compression function is collision resistant, then the overall hash function is collision resistant as well.

The Merkle-Damgård transform is quite simple. Suppose that the compression function takes inputs of length m and produces an output of a smaller length n. The input to the hash function, which can be of any size, is divided into blocks of length m – n. The construction works as follows: pass each block together with the output of the previous block into the compression function. Notice that input length will then be (m – n) + n = m, which is the input length to the compression function. For the first block, to which there is no previous block output, we instead use an initialization vector (IV in Figure 1.3). This number is reused for every call to the hash function, and in practice you can just look it up in a standards document. The last block’s output is the result that you return.


FIGURE 1.3. SHA-256 hash function (simplified). SHA-256 uses the Merkle-Damgård transform to turn a fixed-length collision-resistant compression function into a hash function that accepts arbitrary-length inputs. The input is padded, so that its length is a multiple of 512 bits. IV stands for initialization vector.

---

Modeling Hash Functions
Hash functions are the Swiss Army knife of cryptography: they find a place in a spectacular variety of applications. The flip side to this versatility is that different applications require slightly different properties of hash functions to ensure security. It has proven notoriously hard to pin down a list of hash function properties that would result in provable security across the board.
In this text, we’ve selected three properties that are crucial to the way that hash functions are used in Bitcoin and other cryptocurrencies. Even in this space, not all of these properties are necessary for every use of hash functions. For example, puzzle friendliness is only important in Bitcoin mining, as we’ll see.
Designers of secure systems often throw in the towel and model hash functions as functions that output an independent random value for every possible input. The use of this “random oracle model” for proving security remains controversial in cryptography. Regardless of one’s position on this debate, reasoning about how to reduce the security properties that we want in our applications to fundamental properties of the underlying primitives is a valuable intellectual exercise for building secure systems. Our presentation in this chapter is designed to help you learn this skill.

---

SHA-256 uses a compression function that takes 768-bit input and produces 256-bit outputs. The block size is 512 bits. See Figure 1.3 for a graphical depiction of how SHA-256 works.

We’ve talked about hash functions, cryptographic hash functions with special properties, applications of those properties, and a specific hash function that we use in Bitcoin. In the next section, we discuss ways of using hash functions to build more complicated data structures that are used in distributed systems like Bitcoin.

Post foto artis paling cantik yang kemarin baru saja menikah dengan duda muda

List bonti potensial April 2018 apa saja? Sertakan alasannya!

Saya punya ANN, silakan posting di sana sebanyak 10 kali, satu kali agan dapat merit!

Buatkanlah infografis yang unik dan menarik serta informatif untuk membantu member baru di Bitcointalk (khususnya sub Indo) memahami seluk beluk rules dengan lebih cepat.

Buatkanlah tutorial untuk membuat signature message disertai dengan gambar dan juga video untuk memudahkan member lain melakukan sign message, khususnya yang masih newbie.

Jawablah pertanyaan ini:
Dari mana miner Bitcoin mendapatkan reward, apabila jumlah koin yang ditambang sudah mencapai jumlah maksimal?

Buatkan musik dong, yang enak didenger waktu lagi ke WC

Buatkan saya wallet di cryptobakpia

Buatkanlah infografis yang unik dan menarik serta informatif untuk membantu member baru di Bitcointalk (khususnya sub Indo) memahami seluk beluk rules dengan lebih cepat.

Buatkanlah tutorial untuk membuat signature message disertai dengan gambar dan juga video untuk memudahkan member lain melakukan sign message, khususnya yang masih newbie.

Jawablah pertanyaan di bawah ini:
Challenge for newbie yang baru mengenal Bitcoin!
Kadang kala dalam suatu transaksi kita mengalami stuck karena fee yang terlalu rendah. Salah satu teknik yang sering dipakai untuk mengatasi masalah itu adalah dengan melakukan child-for-parent payment. Jelaskan bagaimana child-for-parent payment bekerja dan mengapa hal itu bisa dilakukan?

Buatkan infografis thread om pandu sampai april
yang paling bagus yang menang

Buatkanlah infografis thread statistik om pandu sampai dengan bulan April, dengan ketentuan:
- Gambarkan siapa member yang paling banyak mereview dan diminta review.
- Gambarkan member mana yang paling banyak mendapatkan merit dari thread tersebut.
- Rank mana saja yang paling banyak meminta review dan mereview selama bulan April.
- Gunakan font yang 'enak' dilihat mata, seperti Legato, Sans, Comic Sans dst.
- Jangan gunakan warna yang kontras sehingga 'tidak sedap' dipandang mata.
- Gunakan bentuk chart/infografis yang sesuai dengan informasi yang ingin disampaikan. Misal: jangan menggunakan box plot untuk menggambarkan distribusi merit. Baca lebih lanjut fungsi" chart di sini: xxx.
- Jangan copas chart orang!
- Challenge hanya untuk rank member ke bawah, atau yang memiliki merit kurang dari 50.
- Challenge berlaku sampai 1 minggu setelah challenge ini diterima.
- Kriteria penilaian (karena bersifat infografis, bisa jadi ada segi subjektif estetika yang masuk):
a. Keunikan
b. Keenakan dilihat
c. Ketepatan pengambilan data (kalau perlu agan bisa rekap statistik sendiri, ga perlu pake statistik kasar yang ada)
d. Kecepatan pembuatan infografis

#Saran Challenge

Nama akun : joniboini
Challenge : Kontribusi di Thread Edukasi Bitcoin
Deskripsi challenge:

Semua peserta challenge boleh membantu memperkaya isi thread edukasi Bitcoin dengan bahan-bahan yang akan disediakan. Setiap bahan berasal dari bahasa Inggris, sehingga yang perlu dikerjakan adalah melakukan penerjemahan atas bahan tersebut ke dalam bahasa Indonesia. Akan tetapi, para peserta juga bisa menambahkan isi materi terjemahan thread tersebut dengan sumber lain yang dianggap kredibel: buku, jurnal, dokumentasi mengenai topik terkait yang dibahas, dst.

Kriteria peserta :

- Rank Member ke bawah.
- Jumlah merit saat mengikuti challenge harus dibawah 30.
- Kualitas post relatif baik, dalam arti tidak melakukan banyak spamming (post one-liner, dst), post OOT dst.
- Jumlah maksimal peserta 6 orang.

Batas waktu :

Satu minggu dari penerimaan challenge.

Kriteria pemenang :

- Terjemahan memiliki kualitas yang baik, dalam arti maksud pesan asli bahasa Inggris tidak terdistorsi (atau sangat sedikit terdistorsi).
- Tidak banyak tipo.
- Paling sesuai penulisannya dengan mengikuti penulisan kaidah EYD.
- Paling banyak menambahkan sumber lain untuk membantu memahamkan maksud gagasan tertentu melalui catatan kaki yang diisi dengan penjelasan lanjutan.

Reward :

- 1^st : 10 merit
- 2^nd : 5 merit
- 3^rd : 3 merit
- The rest: 1 merit (selama penerjemahan masih bisa dipahami).

Larangan :

- No copas.
- No plagiasi.

Misc :

- None.

#Partisipasi Challenge

Nama akun: joniboini
Challenge yang diikuti: Kontribusi di Thread Edukasi Bitcoin
Jawaban:
[isi terjemahan]