Chemaclass - security

The Cypherpunks

2024-12-11T00:00:00+00:00

In the early ’90s, with the internet on the rise, a group called the Cypherpunks emerged to defend digital privacy. They pushed for encryption and privacy, shaping our digital world with their vision.

Who were the Cypherpunks? #

The term “Cypherpunk” combines “cipher” (a reference to encryption) with “punk”, reflecting the group’s rebellious and anti-establishment spirit.

Far from being a formal organization, the Cypherpunks were a diverse assembly of visionaries, technologists, and activists bonded by shared principles. The movement started in 1992 when Eric Hughes, Timothy May, and John Gilmore founded the cypherpunks mailing list. Some key figures:

Eric Hughes who wrote “A Cypherpunk’s Manifesto,” laying out the philosophical foundation for the movement.
Timothy C. May authored “The Crypto Anarchist Manifesto,” which imagined a society where cryptography could foster a new anarchistic order.
John Gilmore, a co-founder of the Electronic Frontier Foundation (EFF), was pivotal in early internet privacy advocacy.
Julian Assange, later known for WikiLeaks, participated in these discussions.
Phil Zimmermann revolutionized email privacy with his creation of PGP.
Jude Milhon (St. Jude), a hacker and writer, coined the term “cypherpunk” together with Eric Hughes.
Nick Szabo contributed significantly to digital contracts and currencies, conceptualizing “bit gold” before Bitcoin.
Hal Finney, an early Bitcoin developer, worked on cryptographic software including PGP, influencing the privacy tech landscape.
Adam Back introduced Hashcash, which later inspired Bitcoin’s proof-of-work, while actively engaging in cypherpunk dialogues on privacy.
Wei Dai proposed “b-money,” an early idea for anonymous digital cash systems, which influenced Bitcoin’s development.
Zooko Wilcox-O’Hearn, with his work on Zcash, brought advanced privacy to cryptocurrencies, having roots in cypherpunk discussions.
David Chaum, often called the “godfather of cypherpunks”, pioneered digital cash with DigiCash (1989). His work on electronic privacy predates and inspired the movement.
Bram Cohen developed BitTorrent, showcasing the cypherpunk ethos of decentralization in file sharing.

Their work built on foundational cryptographic research by Whitfield Diffie and Martin Hellman, who invented public-key cryptography in 1976, making secure communication between strangers possible.

They gathered online on the cypherpunks mailing list, which at its peak had around 2000 subscribers exchanging 30+ messages per day. Their motto: “Cypherpunks write code.” They didn’t just talk about privacy. They built it.

Philosophy and goals #

The core philosophy of the Cypherpunks was centered around privacy, freedom of speech, and the potential of cryptography to protect these rights. Their main tenets included:

Privacy as a fundamental right: They believed that privacy was essential for personal freedom and that digital communication should be private.
Decentralization: Suspicious of centralized control over information, they pushed for decentralized systems where individuals could control their own data.
Cryptography as a tool: They saw encryption not just as a means of securing data but as a political tool against surveillance and oppressive regimes.

Their goals were #

To create and promote tools for encryption, anonymity, and digital cash.
To educate the public on the importance of cryptography.
To resist governmental and corporate efforts to control or monitor digital communications.

Impact nowadays #

Development of key technologies #

Cypherpunks built tools, not just theories:

PGP (1991): Email encryption for everyone
Tor (2002): Anonymous browsing through onion routing
BitTorrent (2001): Decentralized file sharing
Bitcoin (2009): Digital money without banks
Signal Protocol: The encryption behind Signal, WhatsApp, and other messengers

When you send an encrypted message today, you’re using cypherpunk technology.

Cultural shift #

They changed how society views privacy. Before them, encryption was mostly for governments or experts. Today, it’s a standard part of tools like messaging apps and web browsers. By promoting encryption and anonymity, they made privacy a priority and encouraged people to take control of their data.

Legal and policy influence: The Crypto Wars #

The 1990s saw a real battle between cypherpunks and governments, known as the “Crypto Wars.” The US classified strong encryption as a weapon and banned its export. When Phil Zimmermann released PGP, he was investigated for “exporting munitions” because the software spread globally via the internet.

The cypherpunks fought back creatively. They printed PGP source code in books, since books were protected speech. They wore t-shirts with encryption code. Eventually, they won. Export restrictions were relaxed in 2000. Today’s encrypted messaging exists because of that fight.

Challenges and Criticisms #

The Cypherpunks face these main criticisms:

Accessibility: Their tools are too complex for many people, so only tech-savvy individuals can use them, leaving others behind.
Misuse Risk: There’s concern that their encryption tech could be used by bad actors. While Cypherpunks believe privacy is a right for all, this view conflicts with security concerns from authorities who fear these tools could hide illegal acts.

This shows the ongoing struggle between promoting privacy and maintaining safety in the digital world.

Precursors to Bitcoin #

Bitcoin is the most well-known outcome of the cypherpunk philosophy, embodying their values of decentralization, privacy, and independence from government control over money. Created by the mysterious Satoshi Nakamoto, Bitcoin was first shared with the world through the cypherpunks’ mailing list in 2008.

However, it is the result of many trials of other technologies also created within this group of people. It uses ideas like proof-of-work from Hashcash, and concepts from b-money and bit gold, all reflecting the cypherpunks’ dream of a currency not controlled by any single entity.

DigiCash (eCash) #

Developed by David Chaum in the late 1980s and implemented in 1990, DigiCash was one of the earliest attempts at an electronic payment system. It used cryptography to ensure privacy in transactions but struggled with adoption and eventually failed due to issues like centralization and the double-spending problem.

B-Money #

Proposed by Wei Dai in 1998, B-Money was a conceptual framework for anonymous, distributed electronic cash. It aimed to solve issues like double-spending without a central authority but was never implemented. Its ideas influenced Bitcoin’s design.

Bit Gold #

Also conceptualized in 1998 by Nick Szabo, Bit Gold proposed a currency with properties similar to gold, using cryptographic proof-of-work. Like B-Money, it was never fully realized but contributed to Bitcoin’s development, particularly its proof-of-work system.

Hashcash #

Introduced by Adam Back in 1997, Hashcash was not a currency but a system to counter email spam using proof-of-work. This concept was later adopted by Bitcoin for mining.

These earlier projects and ideas, while not successful in creating a functional digital currency, were critical in laying the theoretical groundwork for Bitcoin. They tackled issues like double-spending, privacy, and decentralization, which were key problems Bitcoin aimed to solve.

Cypherpunk legacy #

Bitcoin has revolutionized our understanding of money, privacy, and security:

Decentralized Control: Bitcoin isn’t run by any bank or government, which fits perfectly with the cypherpunk’s skepticism of centralized power.
Privacy: While not completely anonymous, Bitcoin transactions use pseudonyms, offering some protection from financial oversight.
Immutable Transactions: Once a transaction is on the blockchain, it’s nearly unchangeable, fostering trust in digital dealings.

Bitcoin has brought cypherpunk ideals to life, sparking global discussions on financial privacy, money’s nature, and cryptography’s transformative power. With developments like the Lightning Network for faster, private transactions and Taproot for enhanced transaction privacy, Bitcoin continues to evolve.

What the cypherpunks left behind #

The cypherpunks proved that a small group of people who write code can change the world. Every encrypted message you send, every Bitcoin transaction, every anonymous browse: their legacy.

Privacy isn’t dead. They made sure of that.

Related links

Learn more: What is PGP encryption? A 3-minute tutorial for beginners
Wikipedia Article: wikipedia.org/Cypherpunk

Verified Git Commits

2024-11-17T00:00:00+00:00

When it comes to software development, trust and security are very important. One easy way to level up both is by using verified commits.

Whether you’re working on an open-source project or in a private company, verified commits can make sure your contributions are legit. Let’s break down what they are, why they’re important, and how to start using them.

What are verified commits? #

A verified commit is basically a Git commit that is signed by the author using a digital signature. This signature proves that the commit actually came from the person who says they made it. Tools like GPG (GNU Privacy Guard) let you attach this signature to your commits.

If you’re using platforms like GitHub, you’ll notice a little “Verified” badge next to commits that are signed properly. It’s a quick way to show that the commit is authentic.

Why Are They Important? #

Signed commits help keep your contributions authentic and trustworthy. By adding a cryptographic signature to your commits, you prove that the changes came from you. This is especially important in collaborative environments, where maintaining trust and accountability is key.

Without signed commits, anyone could fake a commit using someone else’s email. For example, they could use your email, and platforms like GitHub would link it to your profile, making it look like you made the changes, even if you didn’t… not good!

By signing your commits, you show that the work is genuinely yours. It stops impersonation, builds trust in what you’ve done, and keeps everything transparent and accountable.

Note: For this demo, I used a public email address belonging to Linus Torvalds. After pushing the commit to this repository, GitHub recognized the email and linked it to his profile. This impersonation is purely for demo purposes to highlight potential risks. Always use your own email for commits.

How to get started with verified commits #

Set up a GPG key #

First, you’ll need a GPG key to start signing commits. Here’s how:

Generate a GPG key:

gpg --full-generate-key

Find your key ID:

gpg --list-secret-keys --keyid-format=long

Tell Git to use your key:

git config --global user.signingkey <your-key-id>

Make signing commits the default:

git config --global commit.gpgsign true

Add your key to GitHub/GitLab #

Export your public key:

gpg --armor --export <your-key-id>

Navigate to “Settings > SSH and GPG keys,” and paste your key.

Start signing commits #

From now on, Git will automatically sign your commits.

If you want to sign a commit manually, just use the -S flag:

git commit -S -m "Your commit message"

You can verify the commit signature with:

git log --show-signature

And also when clicking on the “Verified” badge on GitHub directly.

Verified commits might seem like a small step, but they make your code more trustworthy. It’s an easy way to add an extra layer of protection to your work, and it’s worth it. Give it a try!

Extra: Full setup in Spanish 🇪🇸 #

Related links

Learn more: What is PGP encryption? A 3-minute tutorial for beginners

Pretty Good Privacy

2024-07-13T00:00:00+00:00

PGP (Pretty Good Privacy) is an encryption program that ensures privacy and authentication for data communication. It is used for signing, encrypting, and decrypting texts, emails, files, directories, and whole disk partitions.

History #

PGP was developed by Phil Zimmermann out of concern for the lack of privacy in digital communications. He aimed to provide individuals with strong encryption tools. In 1991, PGP was released to the public for free, marking the beginning of a new era in digital security.

Legal Challenges #

In the early 1990s, strong encryption was classified as a weapon under U.S. export law. When PGP spread globally via the internet, Zimmermann faced a criminal investigation for “exporting munitions.”

His defense was clever: he published the PGP source code in a book. Books are protected speech. The case was dropped in 1996, and encryption export restrictions were eventually relaxed in 2000.

Key Features #

Encrypts and decrypts data to ensure secure communication
Provides authentication to verify the identity of senders and receivers
Generates public and private keys for secure key exchange
Supports various encryption algorithms and hash functions

Today, PGP lives on as OpenPGP (the standard) and GPG (GNU Privacy Guard, the free implementation). When you verify a software download or sign a git commit, you’re often using GPG.

How it works #

PGP uses a combination of public-key and symmetric-key to ensure secure data transmission. It generates a keypair consisting of a public key and a private key. The public key is shared with others, while the private key is kept secret. When data is encrypted, it is encrypted with the public key, and only the corresponding private key can decrypt it.

Symmetric Key Encryption: PGP generates a unique, one-time-use session key to encrypt the message. This method is fast and efficient but requires the sender and recipient to share the same key securely.
Asymmetric Key Encryption: PGP solves the key exchange problem with asymmetric encryption. Each user has a public key and a private key. The session key is encrypted with the recipient’s public key and can only be decrypted by the recipient’s private key.
Digital Signatures: PGP provides authentication through digital signatures. The sender signs the message with their private key, allowing the recipient to verify the sender’s identity using the sender’s public key, ensuring the message has not been tampered with.

My public key #

Fingerprint #

56D5 D60B 0934 0999 199C 3750 E51B 5BF4 5F85 D160

Import directly #

curl https://chemaclass.com/pgp.asc | gpg --import

Download the .asc file #

Download public PGP key

Programmable Money

2024-07-06T00:00:00+00:00

Bitcoin is often referred to as “programmable money” because it allows for the execution of programmable transactions through its scripting language.

Understanding Programmable Money #

Programmable money is the ability to embed logic and conditions into financial transactions. This programmability allows transactions to be executed automatically based on predefined rules without intermediaries or manual intervention. It transforms money from a static medium of exchange into a dynamic tool capable of executing complex agreements and automating financial operations.

The Script Language #

Bitcoin’s programmability is powered by its built-in scripting language, Script. Unlike traditional programming languages, Script is a stack-based, Forth-like language explicitly designed for Bitcoin transactions.

It supports multi-signature, time-locked, and other conditional transfers that can be programmed into Bitcoin transactions. It is intentionally not Turing-complete, without loops.

This video includes examples of the most commonly used locking/unlocking scripts.

Key Features of Bitcoin’s Script #

Stack-Based Execution #

Script operates on a stack-based execution model where commands and data are pushed onto a stack and processed in a Last-In-First-Out (LIFO) manner.

Conditional Spending #

A transaction that can only be spent if certain data is provided or specific criteria are met. This can be used for:

escrow services
atomic swaps
and other complex financial arrangements

Multisignature #

Transactions can be set up to require multiple signatures from different private keys before they can be spent. Useful for:

joint accounts
corporate funds
and enhancing security, as no single party can unilaterally spend the funds

Timelocking #

Transactions can include time-based conditions that prevent them from being spent until a certain time or block height is reached. This feature is useful for various purposes:

delayed payments
smart contracts
and ensuring that funds are not spent prematurely (eg: with Lightning Network)

Operation Codes #

Bitcoin’s Script performs specific operations within transactions with its OP_Codes. Here are some of them:

OP_DUP: Duplicates the top stack item.
OP_HASH160: Hashes the top stack item twice (SHA-256 followed by RIPEMD-160).
OP_EQUALVERIFY: Verifies that the top two items are equal and removes them.
OP_CHECKSIG: Verifies a signature against a public key.
OP_RETURN: Marks the transaction output as invalid, often used to store data.

Common Bitcoin address types #

In Bitcoin, different address types correspond to various ways to script transactions. Here, we’ll explore examples of Bitcoin Script for each major address type. Each address type has its own specific script format.

P2PK: Earliest legacy transactions using full public keys directly.
P2PKH: Begins with 1. Legacy transactions using public key hashes.
P2SH: Begins with 3. Legacy, encapsulates complex scripts like multisig.
P2MS: It is typically a type of P2SH or P2WSH address.
P2WPKH: Begins with bc1. Native SegWit, more efficient transactions.
P2WSH: Begins with bc1. SegWit for complex scripts.
P2TR: Begins with bc1p. SegWit Taproot addresses, improving privacy and efficiency for complex transactions.

Using native SegWit (P2WPKH and P2WSH) is preferable when possible, as it maximizes the benefits of the SegWit upgrade, but P2SH-SegWit can be useful for compatibility with older systems.

P2PK (Pay-to-PubKey) - Earliest Legacy Address up #

Begins with "1" (e.g., 1A1zP1eP5QGefi2DMPTf...v7DivfNa)

Before P2PKH and P2SH became standard, Bitcoin addresses were not as flexible or feature-rich. Here are some considerations:

Addresses starting with 1 but without hashing the public key.
Not common in modern practice due to lack of privacy and efficiency.
The P2PK format is largely obsolete in favor of (at very least) P2PKH.

P2PKH (Pay-to-PubKey-Hash) - Legacy Address up #

Begins with "1" (e.g., 1A1zP1eP5QGefi2DMPTf...v7DivfNa)

A typical P2PKH script consists of two main parts:

ScriptPubKey: The locking script (also known as the output script) that specifies how funds can be spent.
ScriptSig: The unlocking script (also known as the input script) that provides the necessary data to unlock the funds.

ScriptPubKey (Locking Script) #

OP_DUP OP_HASH160 <PubKHash> OP_EQUALVERIFY OP_CHECKSIG

OP_DUP: Duplicates the top stack item (the public key).
OP_HASH160: Hashes the public key with SHA-256 followed by RIPEMD-160.
<PubKHash>: The hashed public key (a 20-byte value).
OP_EQUALVERIFY: Checks if the hashed public key matches the hash in the script.
OP_CHECKSIG: Verifies the provided signature against the public key.

ScriptSig (Unlocking Script) #

<sig> <PubK>

<sig>: The digital signature generated by the private key.
<PubK>: The public key corresponding to the address.

Execution Flow #

The ScriptSig (unlocking script) is pushed onto the stack.
The ScriptPubKey (locking script) is executed.

P2SH (Pay-to-Script-Hash) up #

Begins with "3" (e.g., 3J2BtwzN2GEr6FCP.....81T2eiX8PVHh)

P2SH scripts are used for more complex scripts. The primary feature is that the address itself encodes a hash of a script, which will be used in the transaction.

ScriptPubKey (Locking Script) #

OP_HASH160 <ScriptHash> OP_EQUAL

OP_HASH160: Hashes the script with SHA-256 followed by RIPEMD-160.
<ScriptHash>: The hashed script (a 20-byte value).
OP_EQUAL: Checks if the hash matches the provided script hash.

ScriptSig (Unlocking Script) #

<sig> <PubK> ... <ScriptSig>

<sig>: The digital signature.
<PubK>: The public key.
<ScriptSig>: The actual script that matches the script hash, which itself will be executed by the Bitcoin network.

P2MS (Pay-to-Multisig) up #

Script Format #

OP_M <M> <PubK1> <PubK2> ... <PubKN> OP_N OP_CHECKMULTISIG

OP_M: The minimum number of signatures required.
<PubK1>, <PubK2>, ..., <PubKN>: The public keys involved in the multisignature scheme.
OP_N: The total number of public keys provided.
OP_CHECKMULTISIG: The opcode that verifies the signatures against the provided public keys.

ScriptPubKey (Locking Script) #

OP_2 <PubK1> <PubK2> <PubK3> OP_3 OP_CHECKMULTISIG

This script means that any 2 out of 3 provided public keys are required to sign the transaction for it to be valid.

ScriptSig (Unlocking Script) #

<sig1> <sig2> ... <sigN> <SerializedScript>

<sig1>, <sig2>, ..., <sigN>: The public keys.
<SerializedScript>: The serialized script (the same as the locking script but without the OP_M and OP_N).

NOTE: There is an oddity in CHECKMULTISIG execution. See note at the bottom.

P2WPKH (Pay-to-Witness-Public-Key-Hash) - Segwit up #

Begins with "bc1q" (e.g., bc1qf0r2m0ck4psv6yrk9w.....kw8v5rj7ph3)

P2WPKH is a Segregated Witness (SegWit) address type that uses a different scripting format compared to legacy and P2SH addresses. Simplifies transactions by reducing data size and fees compared to legacy formats.

ScriptPubKey (Locking Script) #

OP_0 OP_PUSHBYTES_20 <PubKHash>

OP_0: A single byte (0x00) indicating the version of the script.
OP_PUSHBYTES_20: Pushes 20 bytes (the public key hash) onto the stack.
<PubKHash>: The 20-byte hash of the public key.

Witness Data #

For P2WPKH, the unlocking script is not required in the traditional sense (i.e., inside the unlocking script explicitly included in the transaction input). Instead, the unlocking information is provided as part of the witness data in the SegWit transaction format.

<sig> <PubK>

<sig>: Digital signature for the transaction.
<PubK>: Public key used to generate the public key hash.

P2WSH (Pay-to-Witness-Script-Hash) - Segwit up #

Begins with bc1q (e.g.: bc1q4a3h5sdg4cfkhftgd24tj9g2sg...yj57jmfckhkrw5gslr9g59)

ScriptPubKey (Locking Script) #

OP_0 OP_PUSHBYTES_32 <ScriptHash>

OP_0: Indicates a witness version 0 (SegWit).
OP_PUSHBYTES_32: Pushes the next 32 bytes (the script hash) onto the stack.
<ScriptHash>: 32-byte hash of the redeem script.

Witness Data #

<sig1> <sig2> ... <RedeemScript>

<sig1>, <sig2>: Signatures required to unlock the transaction.
<RedeemScript>: The actual script that matches the script hash. This script will be executed as part of the witness data.

P2TR (Pay-to-Taproot) - Taproot up #

Begins with bc1p (e.g.: bc1pl9dfv7kvj4hj9s3a8l.....gjstmrpjl09g8ks3ukds70q4r2j5h)

Taproot combines Schnorr signatures with MAST, enabling private, efficient spending conditions and making complex transactions appear standard unless conditions are revealed. It allows the efficient execution of complex transactions while hiding their details.

ScriptPubKey (Locking Script) #

OP_1 <x-only PubK>

OP_1: Indicates a witness version 1 (Taproot).
<x-only PubK>: A 32-byte Schnorr public key (without the y-coordinate).

Witness Data #

<sig>

<sig>: A Schnorr signature proving possession of the private key corresponding to the x-only pubkey.

*There is an oddity in CHECKMULTISIG execution up #

The implementation of OP_CHECKMULTISIG pops one more item than it should. The extra item is disregarded when checking the signatures, so it has no direct effect on the OP itself. It must be present because if OP_CHECKMULTISIG attempts to pop on an empty stack, it will cause a stack error and script failure.

OP_0 <sig2> <sig3> 2 <PubK1> <PubK2> <PubK3> 3 OP_CHECKMULTISIG

The input script in this multisig is not <sig2> <sig3> but OP_0 <sig2> <sig3>.

It became the custom early on to use OP_0, which later became a relay policy rule and eventually a consensus rule (BIP147).

It is possible that the original developer added the extra element in the original version of Bitcoin, so they could add a feature for allowing a map to be passed in a later soft fork (for performance reasons). However, that feature was never implemented, and the BIP147 update to the consensus rules in 2017 makes it impossible to add that feature in the future.

Only Bitcoin’s original developer could tell whether the dummy stack element was the result of a bug or a plan for a future upgrade. From now on, if you see a multisig script, you should expect to see an extra OP_O in the beginning, whose only purpose is as a workaround to an oddity in the consensus rules.

Follow-ups #

Official docs of Script in the Bitcoin Wiki.
Bitcoin IDE is an online Bitcoin Script visual emulator. Great for learning purposes.
Script Editor is product-driven research on Bitcoin scalability and usability.
Miniscript is a language for writing (a subset of) Bitcoin Scripts in a structured way, enabling analysis, composition, generic signing, and more.