The following content is provided under a Creative
Commons license.
Your support will help MIT OpenCourseWare
continue to offer high-quality educational resources for free.
To make a donation or to view additional materials
from hundreds of MIT courses, visit MIT OpenCourseWare
at ocw.mit.edu.
NEHA NARULA: So to start, we're going
to recap what happened last class.
And last class we were talking about how traditional payment
systems work and some of the downsides
when you had a bank in the middle
even if you were using techniques like Chaumian e-cash
to try to manage what the bank was doing.
So just as a quick reminder, we had this kind of setup
where there was Alice and there was Bob.
In order to actually make transfers,
Alice had to interact with the bank.
And in the case of the traditional payment system,
we saw that the bank could basically just say no, right?
That it was always possible that a bank could decide
that it didn't like Alice and it didn't
want to process Alice's transactions.
We got a little better than this with Chaumian e-cash,
but even with Chaumian e-cash, the bank
was required to do something.
They were the ones minting the tokens,
and they were the ones redeeming the tokens.
So the banks still played an integral part in this system.
And that actually really does make a difference.
It's not just a theoretical problem.
There are many accounts of people with, for example,
PayPal accounts, who have their funds frozen,
so they can't access the money that they have in PayPal.
So this often happens to merchants, actually,
who end up accepting customers from different countries,
or things like this.
They can get flagged by people's algorithms
as being potentially fraudulent, and that
can put a hold on their funds.
In the case of Chaumian e-cash, you'll
notice that we're not all running around using
digital tokens issued by banks.
Chaumian e-cash didn't really work out.
And that was in part due to the fact
that banks weren't really interested in implementing
this technique.
So-- OK.
So this is where we ended last class, which
was we're in this situation where
the bank has a lot of control over payments
and how payments happen.
And something I want to emphasize here, as well,
is this isn't--
it's not just that we worry about this
because we want to do illegal activity.
Having an institution in the middle of payments
and being able to facilitate payments
can be a problem in other ways, as well, because it can just
simply make things slower.
It can make things-- it's harder to innovate.
It's harder to introduce new features.
There's a sign up process.
So there are reasons why we don't
want to have an institution in the middle,
even if we're totally honest actors.
So the question-- so where we ended up
was how do we build a decentralized digital token
transfer?
So we ended with Chaumian e-cash.
And now we're in this position where what we want to do
is we want to figure out how to make payments
without a bank in the middle.
So there's a few problems that we're
going to have to address in order to make this happen, OK?
So first of all, we really don't want
it to be possible for other users
to intercept a transfer of payment and steal funds.
If our system can't support this very basic thing,
then no one's going to use it.
No one's going to trust it.
No one's going to rely on it.
So it's very important that we have security, right?
Another aspect of security is that we
don't want to allow people to spend money
without authorization.
There has to be some mechanism by which we're
really sure it's Alice when Alice wants to make a payment.
Another problem that we want to avoid
is the double spend problem.
So what is the double spend problem?
Well-- oh, and an equivocation problem.
So what is a double spend problem?
Well, when you have digital tokens,
the problem with digital information
is that it can really easily be replicated, right?
So you actually need to think pretty carefully.
The naive solution of just having a unique string
that you blast around as your a digital token
doesn't really work.
You have to do something extra to think about how to ensure
that these--
once a token is spent, it cannot be spent again.
Now, what I mean by the equivocation problem
is you want to make sure that once a spend happens,
it can't be taken back very easily, right?
So if I'm being paid by Alice, I have some confidence
that once I actually receive the money I've received the money.
Alice can't renege on that promise, OK?
So these are some of the problems
that we want to solve with a decentralized digital payment
system.
And here are some of the features that we want to have,
which is kind of related to some of the problems.
So first of all, we want to make sure that anyone can use it.
That's what we mean by the word decentralized.
There's no single point of control.
There's no one metering access to this system.
If you want to make payments, if you want to join the system,
you can join the system.
So anyone can use it.
We need authoritative transfer so that we can be sure
that when Alice produces a transaction it's really her,
and we believe that.
And we want to make it so that you can't equivocate.
You can't undo spends.
So that translates into the following terminology
that we often use with these systems.
We want it to be permission-less.
It doesn't require permission to enter the system.
Anyone can join.
Authoritative transfer, no double
spends, and you can't undo.
We call that being tamper-proof.
So we don't want it to be the case that someone
could go back and undo a spend.
Another way to think about that is we
don't want people tampering with history.
Something that would be really useful here,
and something that the bank was keeping implicitly,
was a database of who is transferring money
to whom, right?
That was sort of the little thing in the corner which
said how much was in Alice's account
and how much was in Bob's account.
There are actually techniques out there
for maintaining a decentralized database
among a set of participants.
This problem of needing to agree on a value
amongst many different participants
is a problem known as distributed consensus.
So here's what distributed consensus means.
And if you've taken A24, then you've
probably seen this before.
But distributed consensus is the problem
of multiple computers agreeing on a value,
particularly in the presence of faults.
So some of these computers might fail or go away.
You can use this technique, distributed consensus,
to build a log of operations with something called state
machine replication, and essentially what you have
when you do this is a distributed database, which
is what we're trying to obtain here.
We need to keep track of accounts
and who's spending what, and what payments
have happened in the system.
And so distributed consensus is a tool that we might
be able to use to do this.
So the reason that we might be able to use distributed
consensus to do this is we could keep
a log of all of the transactions in the system.
So Alice pays Bob.
David pays Charlie.
And what this log provides is it provides ordering.
So if Alice tries to pay Carol the same thing that Alice pays
Bob, because we have this primitive, this log,
this globally ordered log, everyone
can see that this came after that one, right?
Everyone can see that Alice was trying to double spend.
Alice was trying to spend the same coin twice.
So this primitive is going to be really useful.
This idea of this globally-ordered log
of transactions is what fundamentally
underlies all of these things.
So we could say, if we were to see this log
and we were to see this transaction pop up,
we can decide that this doesn't really count.
That this is--
Alice already spent her coin.
A property that we want to maintain with these things
is that you can only spend a coin once.
So therefore, we're not really going to allow this to happen.
So as I said, the problem of distributed consensus
is that when you have a whole bunch of people
working on this log, you can tolerate faults.
So if some of the people go away,
if it's only up to a certain number, it's OK.
You still have a consistent, globally-ordered log.
So there's a lot of existing systems that
actually provide this property.
Some of them are Paxos, ZooKeeper, and Raft,
if you've ever heard of them.
So the way that these protocols work
is that all of these participants
are executing the protocol to agree on the log.
If a few fail, the protocol can still operate.
Usually they can tolerate up to a minority failing.
So these protocols, the ones that I just listed,
operate in something called the crash fault tolerance model,
meaning they can handle computers going away,
but not really much else.
And when we're operating in decentralized digital payment
land, we want to be able to tolerate more than crashes.
We want to be able to tolerate actively malicious behavior.
Because if you're going to create a digital payment
system, and it's money, then people
are going to try to steal that money.
So like I said, if people go away, if it's up to a minority,
you can still have the log.
So there's stuff from the literature
that actually supports something close to this.
There's something called Byzantine fault tolerance.
And Byzantine fault tolerance tolerates more than crashes.
It actually tolerates actively malicious participants.
It can tolerate a smaller number of actively
malicious participants, up to a third.
So here, nodes might not just fail.
They might actually try to subvert the protocol
to keep from landing on a single globally-ordered log.
And like I said, we have protocols
that can tolerate this.
Great.
However, and these protocols are very, very old, OK?
Like the Byzantine general's problem,
which was a basic formulation of what
led to Byzantium fault tolerance,
was formulated in 1982.
Paxos and view-stamped replication
also came about in the '80s.
Those were two distributed consensus program protocols.
Practical Byzantine fault tolerance,
so an actual, very practical protocol that you can implement
and that you can use to create a globally-ordered log, that
was in the '90s.
And ever since then we've had a lot of different protocols.
So-- And then in 2009, Bitcoin.
So this idea, this idea of a globally-ordered log
that can tolerate malicious participants, the thing I
want to impress upon you is that it's an old idea.
Decades old.
So what's new?
What happened with Bitcoin?
Well, a downside that all of these systems have
is that you need to know exactly who is participating
in the protocol.
So the way that these systems work
is that the protocol works based on identity.
So you have to know who is involved.
You need to know everybody in the system.
You know everybody in the system.
You can tell who's sending you messages
and who's not sending you messages,
and you can make decisions about what
everybody else thinks the globally-ordered log looks
like.
The thing that these protocols did not tolerate
was when you don't know everybody in the system.
And the problem when you don't know everybody in the system,
and you're not doing participation
based on identity, is that an attacker could create
a whole bunch of identities.
Well, there's nothing preventing an attacker
from creating identities.
And remember, we want a permission-less, decentralized
system.
We don't want to have some gatekeeper saying who can enter
into and out of the system.
And given that we don't want to have that gatekeeper,
we can't just let people join willy-nilly
and manufacture their own identities, because if they do,
all of these protocols, all of a sudden, no longer work.
This is what's known as a Sybil attack, OK?
When an attacker can create identities,
essentially for free, and can swarm the good guys
and take over the protocol.
So where I'm going to leave you is with this problem, which
is we want to figure out how to address the Sybil attack
problem when creating a globally-ordered log.
And one way of doing that is to think
about making identities costly.
So good guys can create new identities
and can join the system and can execute the protocol.
Bad guys could potentially create identities
and join the system and execute the protocol,
but because identities actually cost something,
there's a limit.
There's an inherent limit.
They don't come for free.
The bad guys can only create so many.
And that's where I want to end.
Are there any questions about that
as we transfer over to Tadge?
AUDIENCE: I have a question.
NEHA NARULA: Yeah?
AUDIENCE: Does that model you presented
to deal with distributed consensus assume you
have synchronicity in the system?
NEHA NARULA: Not necessarily.
So that problem is unsolvable in the case
where there is a totally asynchronous system.
But there's a lot of different ways
to create a model where, for example,
if you have random coins, then it
is solvable in an asynchronous system.
So this is something that-- you might have heard of something
called the CAP theorem.
This is sort of a predecessor to that,
which indicates that in a totally asynchronous system,
without random coins, consensus is actually impossible.
But that's-- there's different ways to get around that.
And oftentimes, people assume that the system
is semi-synchronous.
AUDIENCE: Awesome.
TADGE DRYJA: Neha.
AUDIENCE: I have one more question.
NEHA NARULA: What?
Oh, sorry.
Yeah.
AUDIENCE: So with Bitcoin, in the paper
they mentioned that they moved away from IP-based identity
to CPU [INAUDIBLE] identity.
Is that where the cost comes from?
NEHA NARULA: Exactly.
And that's what Tadge is going to talk about.
AUDIENCE: OK.
NEHA NARULA: Yeah.
TADGE DRYJA: Anything else?
Cool.
OK.
Hi, everyone.
I'm going to talk about proof of work, which
is, in my estimation, sort of the thing that started all
of this, that, you know, there's all sorts of cool cryptography
involved in Bitcoin and different cryptocurrencies,
but it was the proof of work consensus
that kicked all this off, and that was the big difference.
So we want a cost, Neha was mentioning.
We want some kind of cost to create identities or cost
to participate in the system.
How do we prevent Sybil attacks?
And this is a very hard problem, because it
tends to be an arms race in many ways,
where Twitter or Facebook or things like
that have tons of bots.
Because as soon as Twitter makes a cool new algorithm
to identify what's a bot and kick them off the system,
the various people who were trying
to make millions of Twitter bots start to figure it out.
They're like, hey, they banned all these bots.
Ah, well, I'll switch this around,
and make my bots more human-like and better.
I was actually kicked off of Twitter for being a bot,
and I am not.
I totally am not.
[LAUGHTER]
They said I exhibited automated activity.
So this is a hard problem, and this sort
of gets into like Turing test, CAPTCHA-kind of thing as well.
But Bitcoin's a fairly different solution.
And as Neha said, you don't want really anyone in charge.
You don't want a set identity list of people
who can participate.
So that rules out things that other system use, like let's
use social security numbers.
Let's use phone numbers.
Let's use CAPTCHAs.
Well, those don't really apply.
Like, what's a social security number?
What if I'm in Germany and I want to use it?
What if I'm in somewhere else, you know?
Phone numbers as well.
Phone numbers are just administrated
by a phone company who would then
become the de facto controller of the system.
And CAPTCHAs are kind of an interesting idea, but they--
you know, the identify the signs in this picture
or the cars in this picture or whatever.
But it doesn't really apply, because it's not
easy for people to verify, and not easy
for computers to verify, that the people were actually
doing it.
So those don't work.
So what does work is work.
So I don't know if--
I think some people have said they've--
some people said the first day, oh, I did problem set one.
I was, like, oh, OK.
Cool.
Some people have yet to start, which is fine as well.
But if you have started and looked into problem
set one, great.
I will talk about it a little bit in the next few minutes.
The problem set needs many attempts to forge a signature.
So if you've done it, you've--
I don't know what the fastest--
probably someone got it to work really fast.
When I completed it, I got it to run
on eight cores of a fairly fast machine,
and I got it to run in like three minutes.
And it took me something like 2 billion attempts.
Which it should, right?
2 billion is a run.
So this is because the hash functions have random output,
right?
I'm looking for a string where certain bits are set
and certain bits are free.
And since the hash functions have random output,
I have no shortcut to be like, well,
I want an output where these bits are ones
and these bits are zeros, and the rest I don't care.
I can't really specify that as the input to my hash function.
So I just have to keep trying different numbers, all right?
We know what we want, but the only way to get it is just
keep throwing in different numbers to this hash function,
getting the output, and checking if it matches our criteria.
So what do you want out of work in this case?
You want it to be time-consuming,
kind of like the homework.
But the example in the homework has some problems,
because it's this weird trusted setup, right?
In fact, it's-- so in the homework case,
you're trying to forge a signature where I have
the private key.
I've made four signatures, and you
want to forge a fifth signature without my private key.
The problem is it seems like I would
have an advantage in this work.
I actually don't, because you can verify that I
haven't revealed any new bits.
But it's a weird setup, right?
Where it's like, OK, well, there's
one certain actor that like sets up this whole work,
and we shouldn't have that kind of thing.
So you want it to be deterministic.
You also want it to be scalable.
And you want it to be memory-less,
where everyone gets a chance and you're not making progress.
Because if you are--
I'll get to that later, but if you're making progress,
it tends to be that the fastest person always wins, right?
If there's no randomness involved.
Like, if it's, you know, let's have
a race between a bicycle and someone running.
It's like, well, that's not really race.
The bicycle is always going to win.
Whereas in this case, if it's memory-less,
every attempt is a new shot at getting it,
and so someone who is 10% as fast
will still win 10% of the time.
OK.
So in the case of the homework.
So here's an example where five bits of eight are constrained.
So let's say these first two, you've
got the pre-images for both.
This is the zero row.
This is the one row.
And the signatures I've revealed--
OK, you get both bits here.
However, here, in this place, you only
have the one bit, the one pre-image.
Here you only have a zero.
Here you only have the one.
Here you've got both, and then you're also here, one, zero.
So the idea is these three bits are like x.
Like, don't care.
Either a one or a zero will work.
These five bits are constrained.
So it must match 101 and then 10.
So you're going to have to keep trying messages.
And since five bits are constrained,
you're going to have to try 2 to the 5 messages, which
is, what, 64?
I think?
Yeah.
Which is totally doable, right?
64 tries, and you'll probably get it.
So for example, you try once, and you
say, OK, I got, 11001100.
Doesn't work.
These are OK, because they're OK no matter what.
This one's wrong.
This one's OK.
This one's wrong.
Let me try again.
OK, I got it, right?
These can be anything.
I got a 0 and a 1.
Sure.
These all line up.
The red ones all line up, so I've found a valid solution.
And so that works as a proof of work, and in this case,
I found a solution, which was Tadge forge 1 154262107.
And that's a message that can be forged, given those four
signatures in the problem set.
And anyone can, you know, whatever homework solution
you have, you can probably copy and paste that string
and check that if you hash that, you'll
get a hash that matches up and can be signed with those four
signatures.
So then the question is, did I do 154 million tries
to get that?
Like did I start at zero?
Maybe I did more.
Maybe it was random.
Maybe I got lucky and I started counting at 150 million.
So it's not really a proof, is the thing.
Like, you're not exactly sure how many attempts someone did.
Not quite a proof, right?
There's a lot of chance.
However, over many proofs, it averages out
and you can be pretty sure that someone's doing all the work,
right?
So if-- you know, if someone gets lucky once, fine.
Like, maybe they tried a couple times
and got a valid proof of work, but eventually,
if they keep doing proof of work and they're iteratively
showing them, then you can be pretty sure
that they're not going to be lucky the whole time, right?
And so you have to estimate the collision difficulty.
The best way to estimate the difficulty and the amount
of work that people have done isn't to look at their proof,
isn't to look at their nonce, but to look
at the constraints of the system before they start, right?
So in the case of the homework, 31 bits are specified, right?
So with four signatures, you'd guess
that about 32 bits would be-- and in this case,
there's 1 bit difference.
So in the case of the homework, there's
31 bits that are specified, so that
means you're going to have to do about 2 billion hashes, right?
2 to the 31 is like 2.1 billion, or something.
And so that's the best estimate of how long it took,
regardless of what the nonce is, regardless
of what it looks like they did, you could say, well,
it's going to take on average 2 to 31 attempts.
Let's just-- and so if any valid solution they give me, I'm
going to credit that with 2 to the 31 work.
So actually, in the case of mine,
the one is the thread number, and there were eight threads,
so this Tadge forge 1 154 million.
So I had eight threads going in parallel,
and that happened to be thread one.
And so they all went about the same speed.
So it's really like, 154 million times
eight, which is about 1.2 billion.
And so that's actually kind of lucky, right?
Like, it should-- you would estimate
on average you would take 2 billion,
and I got it at 1.2 billion, so pretty good luck,
but within 2x of what you'd expect.
And since you can look at the probability distributions
of like--
that might be kind of interesting with the homework,
like OK, everyone's attempt, some people it takes 2 billion.
Some people get lucky and it takes 1 billion.
Some people get unlucky and it takes 5 billion.
And you're going to have this curve to see it.
But this is-- that's a kind of weird application
of this signature forging algorithm, all right?
It's not what it's made for.
We can have a simpler proof of work
that has a specific target that's reused forever,
and it's more universal in that it's not,
like, oh, here's this private key.
Here's this key pair and here are these four signatures.
Where are these things coming from?
That's weird.
We have to match these weird strings of bits and stuff.
That's kind of annoying.
So it's better to do something similar, but much simpler.
We'll just try to collide with a fixed string.
So there's some defined string of ones and zeros,
and we just say, OK, well let's try
to have a collision with this.
And the simplest is collide with zero,
or you could also collide with like FFFF.
But in the case of Bitcoin and the case
of many of these systems, we say, well,
let's just try to have a low number.
So let's interpret the hash output as an actual number.
In most cases-- do we have any hashes out here?
No.
You know, it's a 32 byte string, and we think of it as just,
like, here's a blob of bytes.
But you could cast that into an integer, right?
You could say, oh, let's interpret
these 32 bytes as a uint 256.
Right?
A 256-bit unsigned integer.
And let's look for really low ones.
And you can do that.
I think with some CPUs, they'll actually
let you do giant integers that way.
But even if not, you have some kind
of big int library in your computer, which just interprets
it that way and says, OK, let's try
to find collisions with zero.
Basically, let's try to find low numbers.
Yeah, OK.
So this idea-- there's a paper before hashcash,
but I don't think hashcash was the first software.
This idea is actually really old.
In 1997, Adam Back, who still works on this kind of stuff
now with Bitcoin, the idea was to stop email spam, which--
I don't if-- you know, in the late '90s,
was actually a huge problem.
They didn't have all the cool like different machine
learning stuff, and there's tons of spam.
And the idea was, OK, put a nonce.
And a nonce is this--
we call this a nonce, right, the random number
you're throwing in to keep changing things.
Put a nonce in your email header,
and you try to get a low hash output
when you hash the whole thing.
So within the UI for email, you don't necessarily
have to see, OK, what's this person's nonce?
The computer just does it all automatically for you.
But the idea is you need a partial collision with zero.
You need a low hash output for your email,
before your email, the receiving person, will display the email.
And since the header includes the destination address,
if you're a spammer and you want to spam
a million different people, you're
going to have to come up with a million different proofs
of work.
And that could take quite a while.
Like, let's say an average CPU can do it
in two or three seconds.
That means you're going to have to be waiting months
to spam all these emails.
However, for a normal person, if you're just
sending an email to your friend, takes a few seconds, right?
Takes two seconds for your CPU time, which is not a huge deal.
So this was a cool idea.
It never really got off the ground
just because, I don't know, Gmail happened,
Hotmail happened.
A lot of web mail things happened.
People don't really use--
AUDIENCE: I think there was a paper that the economics of it
doesn't work.
TADGE DRYJA: Yeah, I mean, spammers often have bot nets.
So, yeah, there's a lot of other issues, right?
Like there's-- it didn't take off for various reasons.
But yeah, also, spammers have botnets,
which also sort of hurts the whole idea of proof of work,
in some cases, which we'll talk about in a second.
OK.
So the simpler proof of work.
So for example, if you go onto your computers,
and you say, echo Tadge 4233964024, and pipe
that to sha256sum, you will get this output.
And that's eight zeros in the front, so that's 4 bytes.
I did 2 the 32 work, and it's-- you know, that's me, right?
And so that proves that I'm a hard worker,
and I'm going to put this nonce on my resume,
and everyone can see that I do work.
That is kind of silly, but it's a really easy universal way
to have a proof of work.
Anyone can put their name or any message, and any kind of nonce,
and we all just pipe it into the sha256 function
and see how low the output is.
In this case, it's actually 2 to 33, right?
Because the first digit is a 7, so that's 0111.
But this is what we use in Bitcoins.
It's what they use in a lot of these things.
I mean, it's really straightforward.
OK.
So partial collision work.
It has a lot of the properties that we're
looking for when we want this consensus system, right?
It increases the costs of equivocation
and helps with Sybil resistance, in that if I want to fool you,
I'm still going to have to do a lot of work.
And I need time to do that.
I need electricity to do that.
I need a bunch of computers to do that with.
Also scalable, because a ton of work
still takes the same amount of time and space
to verify as a little bit of work, right?
So I can do O of n work, right?
I can put as many zeros as I want,
and the nonce doesn't really get any bigger.
The nonce never has to get bigger than the hash output,
certainly.
And the time to verify is the same
no matter what, so that's really cool.
So why do we do work, in the case of Bitcoin?
The idea is you use a chained proof of work
as a distributed time stamping mechanism.
So it's to determine what happened first.
So in the case of a double spend, where someone is saying,
oh, transaction A happened first.
And someone else says, well, I think
transaction B happened first.
You can't just rely on what other people are telling you,
because who are these other people?
There's no real identities here.
So you look at what got into the chain of hashes first.
And you say, OK, well, that one--
this one, this data, has a hash of this data,
so it must have happened after it, right?
And the things that happened before
are pointed to by the things that happened after.
Because the idea is I can't include the hash of something
that I haven't seen yet, right?
It should be impossible to do that.
So the idea of the blockchain.
You've got some message m, some nonce.
Let's call it r, and some target, t.
And this actually changes, but we're not going
to talk about the changes yet.
So you tack the hash of your message and the nonce--
like I was doing with Tadge--
and the number, and you say, OK, that's h.
And h has to be less than some number t.
So in the case where I just said my nonce,
I had 2 to the 33 work.
So say the same thing here.
In the example, I'm going to only require
2 bytes for the target, so that target
needs to be fairly large.
And then the message for block n includes some data, and also
the hash of block m minus 1.
You refer to your previous block hash in your current block
data.
So for example, message number two
would be data 2 concatenated with the hash of data 1 and r--
well, there should be r1 there.
OK.
So I'll show you a little diagram this.
So the idea of a blockchain, which-- yeah?
AUDIENCE: You'll need to back up.
Could you explain why it's less than?
TADGE DRYJA: In this case, we want low numbers
as the hash outputs.
AUDIENCE: Does it have to be less than?
TADGE DRYJA: You could do greater than.
You could have, I want something that starts with a lot of Fs.
It would work the same, you know?
You could-- yeah?
AUDIENCE: The idea here is you want to constrain, right?
TADGE DRYJA: Yeah.
AUDIENCE: So you can do that with less than
or you can do that with greater than.
You could do that with a fixed sort of--
TADGE DRYJA: Yeah, you could--
AUDIENCE: Little bits have to be--
TADGE DRYJA: Well, there's something--
OK, so less than and greater than are actually
nicer than just fixed bit.
So you could say, I want it to start with the repeating
pattern 10101010.
That would work, too, but then you're
constrained in how fine tuned you
can turn the knob, in that you're
going to either have to add another bit of constraint
or remove a bit of constraint.
And so that, you know, you're going
to have to go in 2x jumps.
What's nice with this is you actually have very fine-grained
control over how much work you're requiring,
because you don't--
so in this example, I said, hey, I have this many zero bits.
But I can also say, well, I needed
to have a number less than 7f--
dah, dah, dah, dah, dah.
Like, less than 7f 000 here.
And this satisfies it, because hey, that's 7e.
That's less than 7f.
right?
So I can actually have a pretty specific thing,
not just in terms of number of bits specified.
So greater than or less than is kind of nice in that sense,
because you can have very small changes to the target.
Oh.
OK.
Any questions about all this crazy stuff?
Cool.
OK.
Yeah.
So you can you can specify.
So in the case of the homework, it's just number of bits,
right?
Because they're all scattered throughout the field,
whereas in this one, you can say,
well, it's the targets greater than or less than.
In this case, less than.
So I have fine-grained control.
Which, we're not going to--
we'll get into later.
But, yeah, in the actual case of Bitcoin,
the target can vary, right?
So when Bitcoin started, you needed 4 bytes of zeros, right?
You needed to do 2 to the 32 work.
Now you need to do way way, way more,
and there's an algorithm in Bitcoin that
adjusts what that target is.
And I'll show at the end of this--
like a current Bitcoin proof of work.
AUDIENCE: We've got to talk about that.
I was going to ask you, [INAUDIBLE] time?
How do you know [INAUDIBLE] solve?
TADGE DRYJA: Right.
Right.
So time is sort of a tricky, semi-ugly subject in Bitcoin.
It'd be really cool if they could get rid of it.
But time is used, and only to vary that target, right?
So when you mine a block, you say, I'm
going to put what time it is.
And you look at the last two--
when every two weeks, or so, every 2016 blocks,
you look at them, and say, OK, what's
the first timestamp of this 2016 period
and the current timestamp?
And if that took two weeks, cool,
we don't have to vary the target.
If it took less than two weeks, let's crank up the difficulty,
or lower the target.
And if it took too long, let's make it
easier by raising the target.
And so really, you're only comparing
the first and last thing.
During the process, when everyone's downloading stuff, I
think the general rule is if you see something that's off
by more than two hours, you reject it,
but it's very lax in terms of synchronization, right?
If someone's 10 minutes off, you're like, yeah, sure.
I'll take it.
Even if block eight says it happened before block seven,
refers to block seven, and yet has
a timestamp that's before it, you're still like, yeah, OK.
Fine.
Whatever.
People's clocks are off.
So that the time is fairly lax.
AUDIENCE: What happens if, like, the person
who has the last block--
who decides-- who timestamps it?
TADGE DRYJA: You just time-- the person who's
doing the work timestamps it.
AUDIENCE: Could an actor timestamp it wrong to like--
TADGE DRYJA: Yeah.
To screw around with the difficulty?
Yeah.
AUDIENCE: OK.
TADGE DRYJA: You're fairly constrained, right?
So it should be two weeks, and you can say, well,
I bet if I'm off by 20 minutes everyone will be OK with it.
But that's not a ton of control, right?
If you're the last one of this difficulty adjustment thing,
you could say, hey, I'm going to say it's--
I'm going to say--
what would you probably want to do?
I'm going to say it's 20 minutes in the future, because I want
the difficulty to not go up too much, because I'm
trying to get more blocks.
So you could try to push it to 20 minutes in the future
from what it actually is, and people,
all the rest of the nodes in the network
will probably accept it.
But you get 20 minutes difference
over a two week period, which is way less than a percent, so--
AUDIENCE: And you said two hours is--
like, it would not take a block that
says it's a week in the future?
TADGE DRYJA: Yeah.
Yeah.
So-- the thing is, it's hard to--
you don't really necessarily know everyone's consensus rules
in these systems.
But I think the default is two hours from your clock.
And every client I've seen will reject
something that seems to be more than two hours off.
Which is really lax, right?
For most types of distributed systems, two hours is crazy.
Most of the time they're going to be within a few seconds.
So in general, I don't think it ever
is a problem in terms of that.
So yeah.
But what people do--
OK.
So one of the things they do, which I can get to here.
Since there is a timestamp in the message being hashed,
some chips that are purpose-built for doing
this work, will actually flip bits in the timestamp,
flip the low order bits, because they're like, well,
no one cares what second it is, so I
have a bit here that I can just turn on and off
and use as a nonce.
So the last, the lowest few bits, they just randomize.
They're like, well, if I'm off by five seconds,
no one cares whether future, past,
so I'll just use this as nonce space.
OK.
So-- but I'll get into that a little more later.
So anyways, so a block.
Let's call this.
A block has a bunch of data, and then we hash it, right?
And in this case, it's got three things.
It's got a previous hash, so a pointer.
It specifies the thing it's building off of.
It's got a message so that you can
add your message that you're adding to the blockchain.
And it's got a nonce, so that you
can prove you're doing work.
And then these are the things, the actual data, but then
the block itself has a hash, right?
And this hash is not included anywhere in the block,
because it couldn't be, right?
This is the hash of this data.
And so we can compute it, but we can't we can't stick this 00db
thing here, because that would then change the data itself.
So the idea is, use these block hashes as identifiers.
And in most of these systems, in general, the hash of something
is its identifiers, its name, the way to point to it.
OK.
So the next block includes a hash of the last block, right?
So here you're saying, OK, the previous block is 00db.
You're pointing to it.
And then you're adding your own message, oh hi.
And you're adding your own nonce to make-- you know?
And so these two things you start out with.
You start out with the pointer to the previous block,
and then you say, OK, the message
I'm going to try to add here is oh hi.
And then you start grinding through these, right?
You start iterating or randomly attempting different nonces,
until you found one where it's low, right?
It's got a bunch of zeros.
And so this is the nonce you need to specify
to get a lot of zeros.
And in this case, there's four characters of nonce.
And you only need two characters of zero,
so it's way more nonce space than you need.
Yes?
AUDIENCE: How many possible nonces
are there that would result in this?
TADGE DRYJA: In this case there would
be, on average, 255 nonces that would work, right?
Because-- I'm, OK.
I haven't actually specified these things,
but assuming the target here is must be less than 00ff, right?
So you need eight zero bits in the front,
and all the rest can be Fs.
And you can have any nonce you want.
And this is an actual hash function, which is 2 byes long.
That means you've got 2 bytes here and only 1 byte specified,
so you've got two to the 16 nonce space,
and your output is constrained in 2 to the 8,
so you're going to have 2 to the 8 different nonces that
will work.
In the case of Bitcoin, there's nowhere near
enough nonce space, right?
Because your actual constraint on your proof of work
is a lot of bits, and you only have 4 bytes, or 32 bits,
of nonce space.
So what you actually end up doing
is using your message as further nonce space, right?
So the thing is, I could put oh hi 2,
and now I've changed my message, which will change my hash.
And so if I go through my entire nonce space
and don't find a valid proof of work, I can edit my message
and then go through it again.
So that-- it's a little ugly, right?
It'd be nicer if your nonce space was big enough that you'd
never had to do that.
In the case of Bitcoin, we don't know who designed it,
and whoever designed it didn't put enough nonce space,
and so it's kind of annoying.
But you can get around it.
In theory, you could just eliminate the nonce space
entirely and say, well, just put it in the message, right?
But it's nice-- it's much easier to think of when you're like,
here are these separate things.
Like, this is random.
It has no real meaning.
This is the thing that has meaning
that we're going to use.
Anyway.
So yeah.
The chain keeps building.
You add work each time, right, by finding
different nonces that match up with your message.
How are you?
Oh, I'm good.
OK.
And the idea is if you flip a bit
in any block that's come out.
So, for example, you change oh hi to oh hey,
and try to leave everything the same,
you're going to change the hash.
So most likely, the proof of work
will no longer be valid, right?
Oh, this starts with a 9 now.
No one's going to use it.
And more importantly, actually, these pointers
stop working, right?
Because this block was pointing to 002c.
That's not this.
That's this other one.
So basically, you flip any bit in the entire history
of this chain, and it breaks, right?
So you can't go back and edit things.
You can't change messages after the fact.
So it gives you the nice property of immutability
that once a message is included in the system.
So in the case of money, once a transaction
has moved funds from one place to another,
you can't go back and change it.
You can't undo something.
Unless.
Unless you fork the chain.
So the idea is everyone is running this system.
Sometimes inadvertently, or sometimes on purpose,
you can have two branches, right?
You can't have something point to two
different previous blocks, right?
There's one specified-- so in this case, when
I say previous block, it's a single, specific hash
that I'm pointing to.
And since we're pretty sure we can't find collisions,
that means if I'm pointing to 00db, it's only this one,
which has the message hi.
I should not be able to find two different blocks which hash
to 00db, because then it's ambiguous, and like, wait,
which am I pointing to?
So I shouldn't be able to do that.
However, it's easy to have two blocks
here that both point to the same ancestor,
that both-- we call this a parent, call this a child,
call this a branch.
So this is easy to do, right?
Two different people can just come up with their own messages
and own nonces and point to the same ancestor.
They could do this inadvertently,
because they're not aware of each other's work, right?
Or maybe these two things happened at the same time,
and they're like, oh, well we both found the answers
at about the same time.
Or they could do it, maliciously,
where I saw that you made this block,
and I saw that you made this block,
and I'm going to make these two, to try to confuse things.
So this can happen.
And the rule in Bitcoin, and most all of these systems,
is OK, well, the highest blockchain wins.
The most work wins.
So that's just our metric for what we all determine
as the state of the system.
So everyone uses the chain with the most work.
And that can change, right?
Let's say we started off with the 008a being the chain tip.
That's what we call the current state of the system.
And then someone came along and said,
well, I'm want to get rid of this thing.
Something happened in 94 that I want to rewrite.
I want to get rid of the how ru message,
and I'm going to replace it with my own message.
And so the way I do it is I branch off from 002c,
make this one, make this one, and now, I've made another one.
So now, this branch here has the most work.
And everyone's going to use it.
And they sort of forget about these two things.
They're like, yeah, that was the tip.
That was the most work state of the system, but now this is.
So now we have to go back.
We have to erase these two messages,
and add these three messages, and now everyone
agrees that that's the next state the system.
And this is called a reorg, a reorganization of the block.
This is sort of bad, but yeah.
Yeah?
AUDIENCE: How does the whole process of--
so no one realizes they're in the wrong chain, [INAUDIBLE],,
right?
TADGE DRYJA: Mm-hmm.
AUDIENCE: How do they say, OK, I need all the information
to build the actual chain?
TADGE DRYJA: Yeah.
They request it, or basically, someone says, hey,
I have these three.
And you're like, really?
What are those three?
And they give them to you.
And you're like, OK.
Yep.
That works.
So the actual network--
I think in a few weeks we're going into the actual network
messages that are used in Bitcoin, but they're not like--
you--
actually, if you wrote it yourself,
you'd probably write something more sensible and better.
It's a little weird.
But basically, you sort of--
nodes in this network are all connected to each other,
and they report on what they have.
And they say, hey, I have 0061.
And you're like, really?
I don't have 0061.
And you think, maybe 0061 builds off here.
You request 0061 and you're like, oh,
it builds off of here.
And then they're like, I have f2.
I have a3.
And so they build these--
you know, they request them all and build them.
And then they actually keep these in memory
for a little while, and then--
but I don't think they save them on disc.
So you can have multiple different branches,
concurrently, in your software, and you just use this
and show this to the UI.
Yeah?
AUDIENCE: Who specifically do you ask for the chain?
Because if it needs only one, then you could just sort of--
TADGE DRYJA: Needs only--
AUDIENCE: If only one person had a longer chain,
and then everyone starts replicating it,
then the network starts believing it, right?
TADGE DRYJA: Yep.
Yep.
So it's a gossip network.
So basically, there's no real identity
for all the different nodes of computers.
You also will report all the--
you basically do it by IP address, right?
So when I connect to a node, I don't think I ask.
I think they just tell me, like, hey,
here's a thousand IP addresses that I know of,
that I've connected to, that are running this software.
And you're like, OK.
I'll add that into my list.
And then you just randomly connect to people.
I think the default is randomly connect to seven peers.
And then when you--
when anything comes in, you're like, hey, I got a new--
you know, I got a new block message.
You will tell all seven of your peers.
Hey, I got 00a3.
And if they request what the data is,
you'll give it to them.
So in practice, things get propagated pretty well.
But yeah, partition attacks.
If you can isolate--
so like, if you can isolate this off the network,
you may be able to prevent this kind of thing from happening.
So if someone built these three blocks
but isn't able to broadcast it to the network,
then people will still think that this is the most work
and build off of this.
So yeah, those are attacks that can happen.
Yeah?
AUDIENCE: What happens if you reorg transactions,
for instance?
Like if the messages were transactions?
TADGE DRYJA: Yeah.
They stop being-- they get undone.
So this is a very real risk.
If you have a--
Alice is sending Bob 5 bitcoins in this block.
And in this block, you have a conflicting transaction,
Alice is sending Carol 5 bitcoins, the same 5 bitcoins,
Bob could think at this point, hey, I got some money.
I have some money.
Oh, shoot.
I, whoops, don't have the money anymore when
this gets reorged out.
So that's-- that is an attack, right?
And you have to be aware of that in using Bitcoin, or any
of these kinds of systems.
They're not-- you have consensus,
but I think it's like eventually consensus.
So generally, the rule of thumb people use is wait six blocks.
I think that's in the original Bitcoin white paper.
Which is fairly arbitrary.
Like, you know?
The longer you wait, the more certain it is.
The more difficult it will be to perform this kind of attack,
because you're going to have to do more work, right?
And the idea is everyone's building off of the one
that they think is the tip.
So everyone's going to--
you have to get pretty lucky or outrun everyone else to perform
this kind of attack.
So.
OK.
Yeah?
AUDIENCE: Are those known as uncles?
TADGE DRYJA: Oh.
So like, in Ethereum and some other systems
they have uncles where you can point
to multiple ancestors, which is weird,
because your uncle is not really your ancestor, but anyway.
[LAUGHTER]
So that would let--
for example, that would let 00f2 to point to both 0061 and 0094.
NEHA NARULA: The answer is no.
These are not uncles.
TADGE DRYJA: Yes.
So yes.
NEHA NARULA: [LAUGHS]
TADGE DRYJA: Sorry.
Uncles is a separate thing.
This is not uncles, but related, right?
You could draw, like-- you could draw an arrow there, and--
I don't know.
OK.
So I'll talk about pros and cons, and some of this
gets into not as objective and somewhat subjective ideas.
But it's an interesting thing to talk about, especially
in context of money.
OK.
So pros.
Anonymous, member lists, scalable, non-interactive.
I'll go through all of these.
Tied to the real world.
Cons.
Pretty much all nonces fail.
It uses watts.
It uses chips.
There's 51% attacks.
And people hate it.
[LAUGHTER]
So the pros.
They're quite good.
It is anonymous, right?
You can mine without any kind of identity.
Even after you've mined, you don't really
have to say who you are.
There's no pre-known keys.
There's actually no signatures involved, right?
There's no public key system at all.
You're just trying different nonces.
Anyone can go for it.
Every attempt is equally likely to succeed, since it's random,
and it's not limited to humans.
So you could have--
you don't need a social security number.
Bots are welcome.
Anything can mine.
And everyone doesn't really care who mined it.
It's not about who.
It's just oh, there's a nonce.
There's work.
OK, this is valid.
So that's really cool.
It's memory-less.
This is important, and a little counter-intuitive in some ways.
There's no progress.
So if you have 10 trillion failed nonces,
your next nonce is just as likely to fail,
which is extremely likely.
So that makes it a Poisson process, right?
Which is-- you know, it's a certain probability
distribution, kind of thing.
You will always expect the next block in 10 minutes from now.
So, hey, it's been 20 minutes since the last block came out.
When's the next one coming out?
Probably 10 minutes.
And there's no-- it's sort of like--
you know, there's no progress being made.
You always have no memory of what
the last few minutes have had.
So the fact that it's been 10 minutes,
the fact that it's-- or it's been two seconds,
you still think it's going to take about 10 minutes.
Which is nice, because it means there's
a linear trade off between how many attempts you're making
and what your chances of finding the next block are.
So if you attempt twice as many, you
have twice as good a chance of finding the next block.
Which is good, because if there is progress, right,
if you had some kind of function where the probability was not
just linear number of chances, but if it
was super linear, exponential or something like that, you--
the fastest person would always win, right?
So if it's like, OK, I need to compute this thing,
and it takes a couple trillion computations.
And so for some computers, it takes five minutes.
For some computers, it only takes two minutes.
The computers that can do it in two minutes
are just always going to win, because the people who
take five minutes to finish it, well, they just
did it in two minutes, and I can't keep up with them.
So this is really nice, and it makes it competitive.
Otherwise, it would end up being like whoever
is fastest just consistently can perform the work.
Any questions about memory lists?
It's kind of-- this--
I mean, you guys actually know computers, and stuff, and math.
You know, MIT.
But this is a fairly common misconception in Bitcoin
and other systems like this, where people get mad.
Like, it's been an hour and no block's come out.
It's like well, yeah, you know?
Poisson process.
On average, every day and a half there will be a one hour gap.
And then people have been, like, well,
the last three blocks came out in like, two minutes.
So there's going to be a awhile before the next block.
It's like no, no.
There's--
[LAUGHTER]
There's no memory.
So there's a lot of misconceptions
when it's a purely random system, that people are not
used to this kind of thing.
But it's counter-intuitive, right?
Even I think, like, oh, well--
no, no.
Memory-less.
Got to remember that.
Got to remember that it's memory-less.
OK.
So scalability is actually amazing.
So this is a block hash from this morning,
or late last night, that actually happened in Bitcoin,
and there's a lot of zeros.
There's 18 of them, and 9 bytes, and actually more,
because it starts with a three instead of an f or something.
So what's really cool about this is it takes just as long
to verify this work as it did with the one with my name,
right?
Which only had 4 bytes of work, you know?
And the one with my name, it took my computer,
I don't know, 20 minutes or whatever to do.
This took computer-- you know, this one
took 10 minutes, right?
But it took the network 10 minutes,
because everyone's participating at the same time.
So yeah.
And it's a trillion times more work,
and takes no more time to verify.
That's really cool, and it is kind of amazing,
because this is almost a mole of attempts.
Like, Avogadro's number.
So you're getting into numbers that like,
you never deal with these scales of numbers in--
I mean, you do in chemistry, but, like, whoa.
So that's a nice property.
Also, it's non-interactive, and that helps as well.
So you never have to report your failed attempts, right?
So you can have a thousand different computers all
trying one nonce with different messages,
or one chip trying a thousand times,
and you don't need any communication between them.
So the only communication between in the network
is when a block is actually found.
So there's no real setup needed.
So it's a very simple message protocol where you say hey,
here's a block.
Everyone just broadcasts.
That's really cool, too.
So these are all really useful properties
for our network and our consensus system.
Oh, also.
It uses real world resources.
So when you want to go back and rewrite history,
even if a majority of participants want to do that,
there's still going to be a cost.
So that's pretty unique compared to many different says
consensus systems.
In many systems, say, OK, well, we have unanimous agreement.
All participants in the system are going to rewrite history.
We're going to go back, pretend that never happened,
and branch off and create a new history.
Even if everyone in Bitcoin, every participant,
tries to do that, they're still going
to have to spend that energy and that work.
And so that really discourages reorging
and trying to rewrite history, even when everyone wants to.
So that's cool in that you're tied down
not just by the other participants in the system,
but by physics itself and the way the world works.
We are going to have to do work to rewrite this.
So that's-- and also, it shows that people are sort
of invested, and they've done work.
So that's cool, too.
OK.
So any questions about all these pros?
Or if you want to say some of these pros
are actually cons before I get to the cons?
OK.
We can go to cons.
And this-- it's always more fun to complain about stuff.
So we can go into cons, and I'm sure people
can jump in with other things that, oh, yeah, this is bad.
So one problem is that it's inefficient.
Almost every attempt fails.
So that's no fun, right?
So the proof of work from a few hours
ago, this is 10 to the 22 attempts.
And all-- you know, there's 10 to 22 failed attempts that
were required, that happened, in order to get that one.
So that's extremely inefficient, you know?
I don't know how to express that as a percentage,
but the actual things moving the system
are some incredibly small percentage
of the actual things happening.
It's also a problem because you're not
going to be able to get a valid block, right?
If you have to 2 to the 72 attempts,
you're just not going to do it.
Like, ever.
You can run your laptop for your entire life
and you will not be able to do two to the 72 work, which
is kind of depressing.
Even if you buy specialized hardware, yeah,
you're not going to--
you're not going to find a block.
It consolidates into-- you need a factory.
You need a warehouse full of equipment, basically,
in order to do this now.
So that's kind of annoying, right?
It's not as fun.
Like, the small players have been pushed out of the game
because you need to do so much work in order
to have-- you can't get, hey, I came close.
Can I get partial credit?
Can I-- you know, I did 2 to the 50 work.
Can I get anything for that?
The system doesn't recognize partial work.
OK.
Other cons.
It uses watts and chips, uses lots of electricity.
You could use that electricity to charge your car
or do something cool.
It uses fabs to make microchips, which could make more CPUs
or make cool phones or something.
Once it gets big enough, it actually
starts affecting markets.
So I don't know if--
I just know in Micro Center, down there, many times--
because I live near there.
And you go around, and there's the GPU section,
and everyone complains about Bitcoin
in Micro Center near the GPUs.
It's a Bitcoin.
It's usually Ethereum and other coins that use GPUs for mining,
but that has had a really big effect on the market for GPUs.
A lot of people-- because you can make money with them.
So people are like, yeah, I'll buy
one of these things for $500, because I'll
make back my $500 in a year.
And then I'll still have the GPU,
and maybe I can sell it used, and get a couple
hundred dollars back, and then I profited.
So these things affect--
it's big enough that it affects markets.
Initially it didn't, because it was just
a couple of nerds running Bitcoin,
and so like, who cares?
You know, a couple of people buying GPUs.
But now it's big enough.
These are like billion dollar markets,
and it's getting to be the same sort of scale as the gamer
market-- or gamer, or whatever--
CUDA, or whatever people use GPUs for.
But you know, mining is significant,
and so it affects the market.
Who knows?
Someday you could start to affect electricity prices
if you get big enough, where a significant portion of all
the electrical usage in the world or the country
is going into doing this sha256.
And so that makes electricity prices go up.
And then everyone starts complaining like,
man, electricity is twice as much
as it used to be because all these people mining Bitcoins.
And it's possible if it gets big enough, instead of just people
complaining about GPUs.
So that's sort of a con, right?
That's-- it starts affecting the real world in big ways.
The corollary of it being a memory-less process
is that it's irregular.
It's a Poisson process, which means
sometimes you get in a few seconds,
and sometimes it takes an hour.
And people don't like that, right?
I can see how you'd rather have something come out regularly.
A lot of people think, yeah, blocks come out
every 10 minutes.
Well, on average, every 10 minutes, but it can be hours.
It can be seconds.
And so that's hard.
In some cases, you can't really use it.
Like, hey, I want a regular clock,
or I want messages that come out in some kind of--
I want some assurance, right?
If I make a transaction, I want it
to be included in the system.
I want some assurance it will be included in the next 20
minutes.
You don't get that assurance, right?
It can be 30 minutes before anything gets included.
And in fact, we'll get into it later,
but there's even worse assurance properties,
in that just because five blocks came out
doesn't mean your transaction got into any of them.
It might have been ignored.
It might-- there's all sorts of reasons.
So you can deal with this, but it is annoying,
and it precludes some use cases.
And other consensus systems do not have this problem.
Other consensus systems can have much more regular clocks.
So this is kind of annoying as well.
Any questions about the irregularity aspects?
OK.
OK, big con.
It's like 51% attacks.
OK.
Part of the problem with anonymity
is you have no idea who's doing this stuff, right?
Even if they say who-- even if they claim--
so one of the interesting parts of anonymity,
despite this being designed as a really cool hacker-y, cyber
punk, anonymous system, one of the first things people
did was put their name in it, right?
So if you mine a block, you've got space
where you can put 32 bytes or so that are undefined,
and people would start putting the names of their mining pools
or the names of their cat or whatever.
They just put their names in it.
So it's kind of like they're showing who they are, and you
can look at distribution of who are
the different miners, and stuff like that,
even though it's supposed to be anonymous.
So they claim-- but they can claim a name,
and they can claim this block was mined by F2Pool,
or this block was mined by BTC.com,
you're not 100% sure, right?
It's all-- I could also mine a block
and claim that it's from F2Pool.
And it's hard to disprove.
So you don't really know who's mining,
and an attacker with 51% of the total network power
can write a chain faster than everyone else combined.
So that means they can rewrite history, right?
So like in the example before, where hey, I made this
three blocks longer than these two blocks,
I had to either get lucky or everyone else stopped mining
for a second, but that's not really possible,
long term, if I have a minority of the hash power, right?
Because everyone's just going to start--
you know, if the majority is honest and playing
by the right rules, they're just going
to see what the most, the longest
worked-- the most worked, the longest chain
is, and start throwing blocks on top of that.
And if I go back and try to make a branch,
the main branch will grow faster than my sub branch,
and so I'll never overtake the main branch,
and so I'll never be able to reorg out a transaction.
However, if I am faster than everyone else put together,
it's assured that I will eventually
catch up and overtake the rest of the network,
and then everyone will have to reorg out onto mine.
So here's the main chain, and then I branch off here,
and I'm faster, so I overtake them and then, that's sort of--
everyone's stuck, right?
Even if they want to keep mining,
I can just reorg them out every time, because I'm bigger.
This is called a 51% attack.
It's pretty bad.
An attacker can rewrite history, can undo transactions.
They can't forge transactions, right?
So they can't necessarily reorg out a message
and replace it with a message of their choosing.
All they can do is, you know, if they--
but they can do that with their own messages.
So you need to have this as part of an attack
where they reorg their own messages out.
By default, when a reorg occurs, so like--
I can-- go here.
So by default, when a reorg occurs,
like say, these two blocks of messages have been invalidated,
software will attempt to include all the transactions
in these blocks into the next blocks, right?
It's not-- just because this got reorged out,
doesn't mean it was invalid.
It just means it didn't get into a block.
And so we can try to include this message later, as
long as nothing in here conflicts with it.
So just doing a 51% attack to reorg on its own
doesn't actually do very much damage.
However, it's not too hard to combine that with other attacks
where whoever's doing this mining
says, oh, I'll pay someone here, and then pay myself here.
And then undo the payment that they made to someone.
So that's a big, big con.
51% attacks.
Not only is it very disruptive to the system,
it's very hard to predict when it will happen,
since it's anonymous.
It could be the case that all the people mining Bitcoin now
are friends and they're a 51% group,
and they could just get together and say, hey, let's
reorg out these things.
That said, there is a cost to do so.
Yeah?
AUDIENCE: There seems to be some requirement of momentum
of messages to not able to trick the system.
So if you're setting up a new currency,
it must be much, much easier to work the chain.
TADGE DRYJA: Yeah.
I mean, if there's very little work being done in the system,
it's probably pretty cheap to get a bunch of hardware
and be 51% of that system.
True.
So like-- and in the case of Bitcoin,
if you have to 2 the 72 work, well, every 10 minutes,
that means if I want to be 51%, I have to do 2 to the 71 work
every 10 minutes, which--
that's a lot of work.
And so you're going to need enormous amounts of resources
to become a 51% attacker.
There's two ways this attack can happen.
Either some attacker comes out of nowhere
and says, OK, I'm just going to build up
an enormous amount of attack power,
or the existing actors in the system
go bad, which seems more likely, where they're like,
OK, we're already--
you know, I'm 5%.
He's 10%.
And she's 20%.
And they all get together and try to do an attack.
So both of those different ways are possible.
Yes?
AUDIENCE: But [INAUDIBLE] mining downsides?
Like, we join some other pool?
TADGE DRYJA: Wait.
Wait.
Sorry.
Who does?
AUDIENCE: Like, small players.
TADGE DRYJA: Yes.
AUDIENCE: So like, [INAUDIBLE] of [INAUDIBLE]..
If the miner pool rollback-- like for example,
I'm in a miner [INAUDIBLE],, and the software is malicious,
so one of the players can roll back simultaneously?
TADGE DRYJA: Yeah.
So pools, we haven't mentioned pools, but the idea--
part of the con of you're never going to find a valid proof
of work, is the way they mitigate that,
is people get together in pools and they will prove partial
work to each other, and there's one entity that's then--
controls a lot of different miners
and gives out partial rewards.
So OK, there's a thousand different people mining,
and one of them found the block, but I'll distribute that reward
to all the thousand people for all the work they've done.
And so that does concentrate power
in that mining pool, whoever's running it.
So that can also be a big problem.
Yeah.
Because if you're doing it solo now.
So solo mining is saying, I'm just mining on my own.
I'm going to try to find a valid proof of work.
That's very difficult, because of the amount of work needed.
So many people pool together.
So yeah, that's another issue.
Yeah?
AUDIENCE: So [INAUDIBLE].
TADGE DRYJA: Yeah.
There's also protocols, one called P2Pool,
where you can have another layer of block chain-y kind
of messages, which allows you to pool together resources
without having a single entity responsible for getting
the rewards and distributing them back up.
I mean, I haven't really talked about the rewards.
The Bitcoin-specific stuff will be in next week, probably.
But yeah.
There's all sorts of--
this gets really complicated and crazy.
And like, pools, there's so many attacks on pools,
and it's a mess.
OK.
Last con.
People hate it.
And this is not a quantitative, objective reason,
but it is a problem.
And people don't like proof of work.
Some people are fine with it, but a lot of--
especially in academia.
I've talked to a lot of people.
They're just like, ah, this this is horrible.
The whole point of sha256 is you can't find collisions,
and you've designed an entire system where all we're doing is
trying to find collisions in this non-collidable system,
and you've got giant warehouses full--
uses so much electricity, and you've
got giant warehouses full of chips that are just
doing this pointless thing.
And it's-- you know, it offends the sensibilities of many
people.
And it probably is getting worse,
because it keeps getting bigger, and so a lot of people
don't like it.
And I can understand that.
When I first read about this stuff,
I was like, that's kind of cool.
That's kind of stupid.
And then I was like, oh, man what if this really takes off?
There's just going to be so much power usage and so many chips
dedicated to kind of a pointless thing.
I would say that I acknowledge this as a big problem,
and I think the best analogy is something like gold or silver,
precious metal mining where you could
make very similar arguments, that all these you know
Spanish or Portuguese people sailed over
to South America 500 years ago, and it
was sort of-- it was horrible and all these people were
working in these mines, and it's a mess,
just to get silver or gold or whatever.
And it's like, why?
Why are you doing this, right?
Just to get some gold?
So similarly, the bitcoin and the proof of work in general
has a lot of people who don't like it.
And so that's why there's a lot of research in, OK,
can we have the same kind of system, but without the work?
Or alternatively, can we have some kind of proof of work
that's also useful for other things?
So can we have some kind of proof of work
that cures cancer?
And it's like, well, I mean-- there's actually, right,
papers about protein folding proof of work.
And I haven't seen a ton-- there's
one where you like find sequences of prime numbers,
and it sort of worked.
It sort of has most of the properties you want.
And it's like, OK, but it's like, well.
You found five prime numbers in a row.
Like, eh.
Yeah?
AUDIENCE: The fundamental problem with those [INAUDIBLE]
that's different from this is generally
the same amount of time to verify as they do to generate,
whereas the advantage of this is it takes ages to generate,
but it's really quick to verify.
TADGE DRYJA: Yeah.
So that's another-- yeah.
People want useful proof work.
A lot of times with useful proofs of work,
it's hard to tell that it's a valid proof,
or there's not as much of a gap.
Like, the gap in Bitcoin is enormous, right?
O of n takes O of 1 to verify, which is perfect.
Yeah, you can't get better than that.
So yeah, it's hard to verify.
There's also-- that also applies to many different proofs
of work.
So one of the things with 51% attacks
is if, like you were saying, if you
want to build your own coin, if you use the same proof of work
algorithm as Bitcoin, you are in a very risky situation,
because you've started your own new coin that--
your own new message network that very few people are using,
and there's very little work being done in this network.
And then there's this huge Bitcoin network.
And as soon as they see your network,
they could easily overpower it, right?
One actor, one person who's mining,
could become more than 51% of your network, just
with the flip of a--
pressing of a button.
And so it's very dangerous to be running
a very small network that shares a proof of work
with the larger network.
And so most of the different coins, when people say, hey,
I'm going to make my own derivative of Bitcoin
or my own new coin, I'm going to have a different proof of work.
And so there's all sorts of different hash.
Maybe I'll use sha3 instead of sha256.
OK.
Or I'll use some other hash function, or some other usually
iterative hash function, like for password hashing,
where you actually end up hashing several million times.
And the disadvantage there, as well, is it
can take quite a while to verify the work.
Not too much, but noticeable, where
if you're running different clients like Lightcoin,
for example, it uses a proof of work
which takes thousands of times longer to verify.
Still fast enough, but some of them are pretty heavy.
So those are all the different-- you know, it gets pretty messy,
and I'm--
ask-- probably James and some other people
are much more familiar with all the horrible intricacies
of proof of work.
AUDIENCE: [INAUDIBLE] if you back
to the part about [INAUDIBLE],, like back when
Bitcoin was first made, it just spawned the longest chain,
by absolute number or blocks.
TADGE DRYJA: Oh, yeah.
Well, yeah.
AUDIENCE: [INAUDIBLE]
TADGE DRYJA: Yeah.
So there's one-- wait.
So I said the longest--
so if you say the longest chain is the valid one,
I think I mostly said most work, right?
They're not necessarily the same, right?
In this case, where we have a fixed target, a fixed
amount of work per block, they are the same.
But in the case of Bitcoin and most of these networks,
the target and the amount of work required for a block
can change with that 2016 period.
And so there are attacks where you can say,
well, I'm going to make something that's
longer, but actually has less work,
because I've forged all these--
You know, I go back in time.
I pretend it took me a long time,
and I changed the timestamps so it
looks like it took a long time and the difficulty decreased,
but I actually have more blocks, but less total work.
And then I can have some weird attacks
where I reorg out things.
So in the case of Bitcoin, I think-- yeah.
Pretty early.
AUDIENCE: Like, version one point--
TADGE DRYJA: Version one point--
Version 0.1, it actually just looked
at number of blocks, because it's so much easier
in the code to just do number of blocks.
Otherwise, you have to treat all the hashes as big ints
and figure out how much work was done
on each one, and this annoying stuff.
But that attack was thought of.
I don't think the attack ever happened,
but whoever designed it was like, oh, wait.
Yeah.
Longest is not quite right.
Has to be most work.
And so they changed the code.
OK.
So proof of work.
People hate it.
Yeah, but the thing is, it does work.
It's been working for nine years.
The blocks keep on coming.
Not regularly, but over the course of a day,
about 144 will come out.
In practice, it's infeasible to write old messages, right?
There are all these known attacks,
but they're very costly, and either you
have to do an enormous amount of work
and get all these resources, or you
have to have a lot of collusion between the different actors.
One nice part is that in these systems,
people are very adversarial, and so they don't want to collude,
and they always are attacking each other and hate each other.
So that keeps the system working.
In practice, with Bitcoin, there are very few block reorgs.
This happens-- I don't know.
When's the last time an actual reorg happened, instead
of just two?
Like, years.
This just never happens.
Most, one or two blocks.
So you can have a one block where two blocks come out
at the same time and point to the same parent,
but that's not a reorg, right?
Because then your software sees it,
and it's like, well, which is going to be right?
And then one of them pulls ahead.
So that happens every couple days.
It used to be more frequently, but now it's fairly infrequent.
And like, two blocks reorg sometimes.
It has happened, but it's very rare now.
So you can build on these things.
OK I'm almost done.
We'll do one last fun fact, and then questions.
OK, so fun facts.
How to estimate the total work done throughout history
of the network.
Well, you just look at the lowest hash.
This is kind of counter-intuitive, like whoa,
kind of thing.
You can prove all the work ever done
in the history of the system with just one hash, the lowest.
Because probabilistically, well, I've
been doing work the whole time.
Probabilistically, I guess the way
this works is that whether we were all
trying for the same block or whether we're
trying for all these different blocks,
it doesn't matter, right?
We're still doing attempts.
And the best attempts will have the most zeros in front of it.
And that holds true for whatever configuration,
graph configuration, whether there's forks,
whether there's a single chain, whether we all just work
on the same thing and never make any progress
and just admit the best hash.
So that's kind of cool.
You can just look at a single hash
and see all the work that's ever been done in the system.
Kind of cool.
With pretty crummy accuracy, of course,
but actually not too bad.
And so there's a paper that's pretty interesting.
If you're interested in it this and want to look into the math,
there's a paper called HyperLogLog
that uses this fact for something completely different,
to count set cardinalities and stuff,
and it's kind of a cool math paper.
But I think the Bitcoin software does do that,
and it'll say best hash.
And it's in there, and you can say, like, well,
this is how much work we all have done.
There's also some papers in Bitcoin
where you can try to use these facts,
like the lucky blocks that happen
to have much more work than they needed,
and you can look back through history
and give an abridged version of history that
still took as much-- that would still take about as
much work to rewrite, without providing
all of the different blocks and stuff.
You can also prove close calls.
So with pools and mining, one way you can do it is you
can prove that you were trying but didn't quite make it.
So if the requirement is you need 2 to the 40 leading zeros,
and you get 2 to the 39, you can show.
Like, hey.
I got 2 to the 39 and I didn't quite make it, but I tried.
And then people can verify that work as well,
and credit you for it.
So the way a mining pool works will
be you give what's called shares, which
is like close calls that were not sufficient to meet
the proof of work, but you keep giving them every few seconds,
or every few minutes.
And then the central pool operator
says, OK, well, this person did this many shares.
This person did this many shares.
I have-- the central operator has a very good estimation
of how much work different people are doing,
and so credits them.
And said, OK, well, he's doing this much work.
She's doing this much work.
And then when someone actually finds the block,
distributes the rewards from the block proportionately
to how much work everyone's been doing.
So that's trusted, and not great.
And there's also a bunch of attacks.
The sort of sneakiest of which is keep submitting
shares, submitting close calls.
But when you actually do find a valid proof work,
immediately forget about it.
Drop it, and never tell anyone.
The reason that's a good attack is fairly counter-intuitive,
but it's a good attack, even though it seems like, well, you
just found the block.
Tell everyone.
You get this reward.
You get--
It's like no.
No, I found a block.
Throw it away.
But oh, I got a close call.
OK, keep telling the central operator.
What that does is that really screws
over the central operator, who now thinks you're
doing a lot of work, but you never find an actual block.
And eventually, the central operator will be like,
this person is really unlucky, huh?
He's found so many close calls, but never
seems to actually get over the line
and find a valid proof work.
And so maybe they can kick you off, eventually,
but it's not something you can prove.
You're like, well, I got unlucky.
So there's all sorts of things.
There's all sorts of fun things you
can do with the proof of work and just these hash functions.