Hasty Briefsbeta

All tags

#cryptography

130 stories total

Bilingual

Moving Beyond the NPM Elliptic Package
5 months ago
- The elliptic JavaScript package has unfixed cryptographic vulnerabilities.
- The maintainer of elliptic is unresponsive to security issues.
- Over 3000 NPM packages depend on elliptic, posing a security risk.
- A shim package, elliptic-to-noble, is introduced to replace elliptic with noble-curves.
- The shim allows quick migration without breaking changes or pressuring the elliptic maintainer.
- Users are encouraged to migrate to noble-curves for better security.
Constant-time support coming to LLVM: Protecting cryptographic code
5 months ago
- Trail of Bits introduces constant-time coding support for LLVM 21 to protect cryptographic code from timing attacks.
- New __builtin_ct_select intrinsics ensure constant-time properties are preserved during compilation, preventing optimization-induced vulnerabilities.
- Compilers often break constant-time guarantees by optimizing cryptographic code into vulnerable, branch-dependent versions.
- The solution works across architectures (x86-64, ARM, etc.), using platform-specific instructions like cmov or CSEL for constant-time execution.
- Community engagement includes feedback from cryptographic libraries and compiler developers, with plans for Rust and Swift adoption.
- Benchmarking shows minimal performance overhead while maintaining 100% constant-time property preservation.
- Future roadmap includes additional intrinsics for arithmetic and string operations, and broader language support.
BebboSSH: SSH2 implementation for Amiga systems (68000, GPLv3)
5 months ago
- BebboSSH is an SSH2 implementation for Amiga systems (68000+).
- It includes tools like bebboSSH (client), bebboSSHd (server), bebboSCP (file transfer), and bebboSSHkeygen (key generation).
- Supports modern cryptographic algorithms such as curve25519-sha256, ssh-ed25519, and [email protected].
- Performance varies by CPU: slower on unaccelerated Amiga (~1 min connection time), faster on 68020+ CPUs.
- Includes libraries (libcryptossh.library) optimized for different CPU architectures.
- License: Mostly GPLv3+, with some components in the Public Domain (e.g., Ed25519 math routines).
- No warranty or liability; use at your own risk.
- Recent updates (v1.39) include speed improvements and consolidated crypto with BebboGet.
- Tips for troubleshooting: xterm-amiga terminfo, LANG settings, and public key authentication fixes.
- Tested by contributors like Patrik Axelsson and Javier de las Rivas.
How stealth addresses work in Monero
5 months ago
- Alice runs a confidential restaurant and accepts Monero for payments.
- Bob uses Alice's public view key (A) and spend key (S) to generate a stealth address (P) for the transaction.
- Bob's software computes a shared secret (k) using elliptic curve Diffie-Hellman (ECDH) with Alice's view key.
- Alice can derive the same shared secret (k) using her private view key (a) and the point R provided by Bob.
- Alice scans the blockchain for payments to the stealth address (P = kG + S), which only she can spend using her private spend key (s).
- Monero's ring signatures ensure privacy by making it difficult to link transactions to specific individuals.
A brief history of NSA backdoors. (2013)
5 months ago
- The British and US governments sold compromised Enigma machines post-WW2 to allies and former colonies, enabling espionage for decades.
- The 'Boris Project' involved weakening Crypto AG ciphers for NSA access to NATO communications, continuing possibly to the present.
- DES was altered by the NSA to reduce key size, making brute force attacks feasible.
- The Clipper Chip, proposed in 1993, was a publicly acknowledged backdoor for voice communications, but was never widely adopted.
- Lotus Notes was weakened at the NSA's request, compromising documents and emails globally.
- Actel ProASIC3 FPGAs were found to contain a deliberate backdoor, used in critical US systems.
- Dual_EC_DRBG, a random number generator, was backdoored by the NSA and promoted as a standard.
- The NSA's SIGINT project aimed to backdoor encryption chips, with Cavium CPUs identified as compromised.
- Trusted Computing Platforms were targeted by the NSA for exploitation, raising concerns in Germany.
- The NSA intercepted and implanted backdoors in computer equipment during transit, targeting airgapped networks.
Zero Knowlege Proof of Compositeness
5 months ago
- A zero knowledge proof (ZKP) answers a question without revealing anything more than the answer.
- Example: Proving a drawn card is a spade without revealing which card by showing all other suits remain in the deck.
- Fermat’s primality test can act as a ZKP to show a number is composite without revealing its factors.
- Fermat’s little theorem states that if n is prime and b is not a multiple of n, then b^(n−1) ≡ 1 mod n.
- A base b where b^(n−1) ≠ 1 mod n proves n is composite.
- Fermat’s little theorem cannot prove a number is prime, only that it is probably prime.
- ZKPs can be applied beyond mathematics, such as in cryptocurrencies to verify transaction constraints without revealing details.
- Non-constructive proofs, like the intermediate value theorem, can be viewed as ZKPs as they prove existence without specifics.
Plinko PIR Tutorial
5 months ago
- Private Information Retrieval (PIR) allows clients to query a database without revealing what they are reading.
- Plinko is a PIR protocol that reduces communication and server-side compute overhead from O(N) to O(√N).
- Classic two-server PIR involves XOR operations on subsets of data, requiring trust in at least one server.
- Plinko uses a setup phase where clients generate hints and a query phase that leverages invertible PRFs for efficiency.
- Backup hints in Plinko ensure privacy by preventing hint reuse and allowing updates to the dataset.
- Concrete efficiency examples show Plinko's application in large datasets like Ethereum's state tree.
- TreePIR is an alternative to Plinko, using puncturable PRFs for logarithmic communication complexity.
- Lower bounds for PIR protocols suggest potential for further optimization, especially in server-side computation.
Zenroom – No-code cryptographic virtual machine
5 months ago
- Zenroom is a no-code cryptographic virtual machine that is secure, open source, and runs on any platform.
- Supports multiple cryptographic functions including signatures, hash, zero-knowledge proofs (ZKP), homomorphic encryption, and post-quantum cryptography.
- Features deterministic execution, fully isolated environment (no access to filesystem, network, or time), and low resource usage (~1MB executable).
- Supports multiple elliptic curves like SECP256K1, BLS 12-381, ED25519, and post-quantum options like Dilithium and Kyber.
- Programmable in Zencode, a no-code English-like language, making it accessible to non-programmers.
- Offers blockchain interoperability, document signing, and W3C-DID implementation.
- Available under AGPL3 and commercial licensing, with professional support for enterprise integration.
- Includes developer resources like documentation, sandbox, and bindings for various languages.
- Part of the DECODE, Sovrin, OW2, and Cosmos communities, with EU funding from Horizon 2020.
Understanding ECDSA
5 months ago
- ECDSA (Elliptic Curve Digital Signature Algorithm) is used by the Ethereum blockchain for signing messages.
- The article explains ECDSA with a focus on security, including the signature malleability attack.
- Prerequisites include basic knowledge of Public Key Cryptography and basic math, without requiring abstract algebra.
- The article is written in a constructive, insightful, and naive style, encouraging critical thinking and engagement.
- Modular arithmetic is fundamental to ECDSA, with operations like addition and multiplication mod p being key.
- The extended Euclidean algorithm (EEA) is used to compute multiplicative inverses mod p efficiently.
- Fibonacci numbers are connected to the time complexity of the EEA, growing exponentially with the golden ratio.
- secp256k1 is the elliptic curve used by Ethereum, defined by y² = x³ + 7 mod p, where p is a large prime.
- A group is defined over the points on the elliptic curve, with addition operations that include a point at infinity.
- The article details how to add points on the elliptic curve, both in continuous and modular (mod p) cases.
- Projective space is introduced to handle the point at infinity and simplify computations.
- ECDSA private keys are numbers in ℤₙ, and public keys are derived by multiplying the private key by the generator point G.
- Signing a message involves generating a nonce k, computing R = kG, and deriving the signature components r and s.
- Signature verification involves recovering R from the signature and checking it against the message hash and public key.
- The signature malleability attack allows an attacker to create a valid signature (r, n-s, 1-v) from (r, s, v), bypassing blacklists.
Yawning abyss of the decimal labyrinth
5 months ago
- Kant's Critique of Pure Reason explores time as the infrastructure connecting thought and sensation, with schemata linking intellectual categories to pure intuition (time and space).
- The Numogram is a decimal-based diagram mapping dynamics through operations like addition, subtraction, and digital roots, structured into zones, syzygies, currents, and gates.
- Natural numbers reveal hidden structures, especially primes, which are fundamental in cryptography due to the asymmetry between factorization and multiplication.
- Gödel's work shows arithmetic cannot be both complete and self-certifying, transforming Kant's synthetic a priori into an open-ended process where number becomes a medium for thinking time.
- Gematria and numerical reduction practices generate hypertextuality, creating subterranean connections between words and phrases, disciplining literacy through numeracy.
- Tic Xenotation (TX) is a non-standard numeral notation based on prime factorization, representing numbers uniquely but excluding 0 and 1 without special encoding.
- Alphanumeric Qabbala (Base-36) assigns numerical values to English words and phrases by summing letter values, enabling gematric analysis.
- The provided C code implements tools for Numogrammatics, including digital roots, prime factorization, Base-36 conversion, and Tic Xenotation encoding/decoding.
Show HN: PVAC FHE over hypergraphs with LPN security
5 months ago
- PVAC-HFHE is a proof of concept implementation based on binary parity for learning with noise and arithmetic on a 127-bit prime field.
- It uses a syndrome graph from a dense random k-uniform hypergraph, with parameters based on MIPT's research on threshold behavior and fractional colorability.
- This is the first implementation of its kind in early 2024.
- Requirements include C++17 or later, GCC 9+/Clang 10+/MSVC 2019+, and an x86-64 CPU with PCLMUL support.
- The implementation supports homomorphic operations like addition, subtraction, and multiplication on encrypted values.
- Example usage includes key generation, encryption, homomorphic operations, and decryption of results.
Go Proposal: Secret Mode
5 months ago
- Go 1.26 introduces the experimental `runtime/secret` package to automatically erase memory used by sensitive functions.
- `secret.Do(func() {...})` ensures registers, stack, and heap allocations are zeroed out after function execution to prevent secret leaks.
- Primarily aimed at cryptographic library developers to enhance forward secrecy by securely erasing session keys and sensitive data.
- Limitations include platform support (linux/amd64, linux/arm64), no protection for global variables, and restrictions on goroutines within `secret.Do`.
- Example usage demonstrates encrypting data with an ephemeral key, where all intermediate sensitive states are automatically erased.
Is P=NP?
5 months ago
- Complexity theory classifies problems based on computational resources like time and space.
- Big-O notation categorizes algorithms by their growth rates (e.g., O(1), O(n), O(n²), O(2ⁿ)).
- P (Polynomial Time) problems are solvable quickly, while NP (Nondeterministic Polynomial Time) problems have verifiable solutions but may be hard to solve.
- NP-Complete problems are universal hard problems; solving one could solve all NP problems.
- NP-Hard problems are at least as hard as NP-Complete but may not be verifiable quickly.
- P=NP would collapse cryptography and revolutionize AI by making optimization problems trivial.
- Modern cryptography relies on one-way functions, which would become obsolete if P=NP.
- The author had a dream about P=NP, leading to existential reflections on digital security.
Nature's many attempts to evolve a Nostr
5 months ago
- Centralized server architecture grants servers total control over users, including data and cryptographic keys.
- Federation allows users to choose their server, enabling communication across different servers, but leads to oligopolies at scale.
- Peer-to-peer (P2P) networks enable direct connections but face challenges like unreliable peers and the emergence of superpeers.
- Nostr protocol introduces a relay-based architecture, combining simplicity, scalability, and user ownership of keys.
What Is an Elliptic Curve?
5 months ago
- Elliptic curves are studied in both pure and applied mathematics, with significant applications in cryptography.
- They are defined by simple equations but require abstract mathematics for deeper study.
- A preliminary definition involves the equation y² = x³ + ax + b, with specific conditions on coefficients.
- Elliptic curves' properties vary depending on the field (real numbers, finite fields, complex numbers) they are defined over.
- They are not ellipses; the name relates to integrals used to calculate ellipse arc lengths.
- The full definition includes being smooth, projective, algebraic, of genus one, and having a specified point O.
- In cryptography, elliptic curves require a base point for subgroup generation, crucial for security protocols.
- The post also shares personal stories of individuals pursuing advanced studies or career changes related to mathematics and cybersecurity.
Optimization Countermeasures
5 months ago
- Silicon designers often fail at creating secure hardware, necessitating 'constant-time' programming to protect key material from timing attacks.
- Constant-time programming is a threat model designed to prevent side-channel attacks like Spectre by ensuring operations do not leak key material through CPU microarchitecture.
- Compilers can undermine constant-time protections, but specific compiler directives, known as 'value barriers', can enforce correct behavior.
- The 'value barrier' is a technique to prevent compilers from optimizing code in ways that could leak sensitive information, effectively acting as a dataflow barrier.
- A practical example of constant-time programming is the implementation of a secure comparison function (ct_memeq) that compares every byte without branching to prevent timing attacks.
- The 'value barrier' is crucial for cryptography libraries, ensuring that operations like conditional selection (ct_select) do not introduce branches that could leak information.
- Despite its effectiveness, the 'value barrier' can hinder performance optimizations like vectorization, presenting a trade-off between security and efficiency.
- The 'value barrier' is implicitly a part of C++ as implemented by GCC and Clang, due to its critical role in widely-used cryptography libraries like BoringSSL.
- Future compiler improvements, such as the proposed __builtin_ct_select intrinsic, aim to provide better support for constant-time operations without relying on workarounds.
- The article highlights the ongoing challenges in balancing security, performance, and compiler optimizations in the context of constant-time programming.
Great Ideas in Theoretical Computer Science
5 months ago
- CS251 at CMU focuses on the rigorous study of computation, exploring central results and questions about the nature of computation.
- The course begins with deterministic finite automata (DFA) as a stepping stone to understanding general algorithms and computational models.
- Turing machines are introduced as the standard mathematical model for computation, with implications for both technology and the universe's computational limits.
- The course covers undecidable problems, using diagonalization and reductions as key techniques.
- Connections between theoretical computer science and the foundations of mathematics are explored, highlighting the role of computation in mathematical reasoning.
- Computational complexity is discussed, focusing on time complexity and practical computability.
- Graphs are emphasized for their fundamental role in abstracting computational problems and their wide-ranging applications.
- The complexity class NP and the P vs NP problem are introduced, with discussions on their implications for mathematics, AI, and cryptography.
- Randomness in computer science is explored, including randomized algorithms and their efficiency compared to deterministic algorithms.
- The module concludes with cryptographic protocols, leveraging computational hardness for secure communication.
Building a Transparent Keyserver
5 months ago
- Building a transparent keyserver for age public keys using transparency log technology.
- Using Tessera and Torchwood to integrate transparency in less than 500 lines of code.
- Implementing Verifiable Random Functions (VRFs) to protect user privacy by hiding email addresses in the log.
- Adding anti-poisoning measures to prevent malicious entries in the log.
- Incorporating witness cosigning to ensure non-equivocation and prevent split-view attacks.
- Deploying the final transparent, privacy-preserving keyserver at keyserver.geomys.org.
- Future work includes efficient monitoring and revocation using Verifiable Indexes.
More on whether useful quantum computing is "imminent"
4 months ago
- The author has reversed their stance on the imminence of scalable quantum computing, now believing it to be plausible due to recent experimental milestones.
- Keynote talk 'Why I Think Quantum Computing Works' highlighted optimism, focusing on experimental achievements rather than broadening quantum speedups.
- Q2B conference provided insights into the current state of quantum computing, with notable talks from Ryan Babbush and John Preskill.
- Quantinuum showcased recent successes, while the author participated in a podcast discussing the proximity to fault-tolerant quantum computing.
- Two main approaches showing promise are trapped ions (Quantinuum, Oxford Ionics) and superconducting qubits (Google, IBM), with neutral atoms (QuEra, Infleqtion, Atom Computing) also making strides.
- The author maintains confidence in the principles of quantum computing theory but remains uncertain about the timeline and leading hardware approach.
- 2025 exceeded expectations in hardware progress, with multiple platforms achieving >99.9% fidelity two-qubit gates, nearing the threshold for fault-tolerance.
- Main applications of quantum computing remain quantum physics simulation, cryptography breaking, and modest benefits for optimization and machine learning.
- A warning was issued about the eventual cessation of public estimates on qubit and gate requirements for breaking cryptosystems, urging migration to post-quantum cryptosystems.
- The author faced backlash from a Twitter user for criticizing IonQ and other quantum companies, accused of having ulterior motives.
Cleartext Signatures Considered Harmful
4 months ago
- Cleartext signatures in PGP allow text to be readable without special tools but verification is complex.
- Terminal escape codes can mislead users about what was actually signed, requiring PGP tools for accurate verification.
- Commands like `gpg --verify -o signed.txt message.asc` are necessary to properly verify cleartext signatures.
- Cleartext signatures are prone to attacks, such as fake armor lines and misleading comment lines.
- Detached signatures or PGP/MIME are recommended over cleartext signatures for better security.
- Historical context: Cleartext signatures were designed for early Internet and BBS systems, now largely outdated.
- Common pitfalls include altered armor lines, misleading comment lines, and hidden terminal control characters.
- Conclusion: Avoid cleartext signatures; use detached signatures and verify with trusted tools.

first prev4next

About|Login

#cryptography

Moving Beyond the NPM Elliptic Package

Constant-time support coming to LLVM: Protecting cryptographic code

BebboSSH: SSH2 implementation for Amiga systems (68000, GPLv3)

How stealth addresses work in Monero

A brief history of NSA backdoors. (2013)

Zero Knowlege Proof of Compositeness

Plinko PIR Tutorial

Zenroom – No-code cryptographic virtual machine

Understanding ECDSA

Yawning abyss of the decimal labyrinth

Show HN: PVAC FHE over hypergraphs with LPN security

Go Proposal: Secret Mode

Is P=NP?

Nature's many attempts to evolve a Nostr

What Is an Elliptic Curve?

Optimization Countermeasures

Great Ideas in Theoretical Computer Science

Building a Transparent Keyserver

More on whether useful quantum computing is "imminent"

Cleartext Signatures Considered Harmful