Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Hacking

Hacking

The Art of Exploitation w/CD
Trace how small mistakes in code and network protocols become exploitable security failures.
by Jon Erickson 2003 264 pages
4.17
2k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat hacking as disciplined curiosity, not a synonym for crime.

Curiosity before labels. Erickson presents hacking as creative problem-solving: understand a system deeply, then use its rules in an unexpected way. The early MIT model railroad club put old telephone equipment to a new use, connecting operators to different sections of a track. Its members carried the same inventive approach into programming, valuing solutions that were not merely functional, but compact and elegant.

Knowledge cuts both ways. The Hacker Ethic in the book prizes learning, logic, and the free exchange of information. That tradition has contributed to technologies people rely on, while the same knowledge can also enable abuse. The central distinction is not whether knowledge is inherently good or bad, but how people apply it and whether they take responsibility for the consequences.

Analysis

What's compelling is the book's insistence that technical mastery begins with curiosity rather than tool collecting. That view fits a broader principle in science: understanding mechanisms makes it possible to improve them, not just operate them. Yet openness alone does not settle the ethical question. Security research affects real users, so responsible practice also requires authorization, careful disclosure, and attention to harm. The book's distinction between knowledge and its use is valuable precisely because it invites judgment instead of pretending that a label can do the moral work.

Programs follow literal inputs, so tiny boundary mistakes can become security failures.

Intent is not execution. A program does exactly what its instructions specify, even when that differs from what its programmer meant. Erickson illustrates this with an off-by-one error, the mistake of checking one boundary incorrectly. In the OpenSSH example, a comparison allowed an invalid channel index, helping turn an ordinary login into a path toward elevated access.

Conversions add hidden rules. A web server may check a path for forbidden characters, then decode an alternate character representation only afterward. The check and the later interpretation disagree, so a restriction can be bypassed. These examples show why software must be tested at boundaries and across transformations, not just with routine inputs. A small defect can have consequences far larger than the line of code that caused it.

Analysis

This is a precise account of a recurring engineering problem: components can each behave as designed while their interaction violates the system's intended policy. Formal methods address a related challenge by specifying invariants, such as which indices or paths must always be rejected. Such specifications help turn vague expectations into testable conditions. The harder work is ensuring that every layer interprets data consistently. A boundary check is only protective if it examines the same representation that the later operation will use.

Map memory before judging whether user data can redirect a program.

Data has an address. The book makes exploitation understandable by treating memory as numbered bytes and pointers as variables that hold addresses. It divides program memory into regions with different jobs: code, global data, heap allocations, and the stack. Function calls use stack frames to keep local variables, arguments, and the address where execution should resume.

Overflow changes neighbors. C does not automatically ensure that copied input fits the space reserved for it. If a program copies a long string into a short buffer, excess bytes can overwrite adjacent data. On the stack, that neighboring data can include a return address, which helps determine where execution continues. The same general flaw can affect heap data or function pointers. Understanding layout explains why a crash is only one possible consequence.

Analysis

The memory model is the book's strongest teaching device because it replaces a mysterious exploit with a physical account of data and control. This is also why memory-safe languages reduce entire classes of defects: they enforce boundaries that C leaves to the programmer. That protection is not absolute, since unsafe interfaces and logic errors remain, but it changes the default burden of proof. In lower-level code, reviewers must ask not only what a function intends to copy, but what its inputs can reach.

Never let user text double as the instructions for printing it.

Formatting is a language. A format string tells a printing function how to interpret later arguments. The common mistake is passing user-controlled text as the format itself rather than as ordinary text. If the input contains formatting directives, the function may interpret them and read values from memory it was not meant to inspect.

Some directives write. Erickson explains that a formatting instruction can also store the number of characters printed so far at an address supplied as an argument. When a program mishandles the format string, this behavior can turn a display bug into a way to inspect or alter memory, potentially changing program control. The defensive principle is straightforward: keep the format specification fixed, and pass user input only as data.

Analysis

This bug is a vivid example of a general security boundary: data becomes dangerous when a system mistakes it for instructions. The same conceptual error appears in database queries, command construction, and markup rendering. Escaping and parameterization work by preserving the distinction between a program's structure and the values it processes. The important nuance is that validation alone is often brittle, especially when many valid inputs are possible. Designing interfaces that maintain this separation is a more durable safeguard.

When one defense closes a route, inspect the other places control can travel.

Blocking execution changes the route. Injected code can take advantage of an overflow when a program is allowed to execute instructions from writable memory. Marking the stack non-executable blocks that particular path, but it does not make corrupted control data harmless. The book describes returning into existing library functions as an alternative: the program is redirected to code that is already present rather than to newly supplied instructions.

Every mitigation has a scope. Other examples target writable function pointers or tables that guide calls to shared library functions. These techniques depend on the binary and operating environment, but they demonstrate a durable lesson: a defense aimed at one mechanism may leave other control-flow mechanisms exposed. Layered protections, careful bounds checks, and limiting privileged programs reduce the impact of a single failure.

Analysis

The section illustrates an arms race familiar from safety engineering: countermeasures reshape the failure landscape, but rarely erase every failure mode. That does not make defenses futile. It means evaluations should state what a control prevents, what assumptions it relies on, and what risks remain. The strongest designs combine prevention with containment, so a defect does not automatically grant broad authority. The book's old platform examples are historically specific, but the habit of threat-modeling beyond a single mitigation remains useful.

Network security fails when one layer trusts another layer's unverified claims.

Communication is layered. The OSI model separates network work into layers, from physical transmission to application behavior. Each layer handles a limited task and wraps its information in headers for the next. This organization makes complex communication manageable, but it also means a device may trust information supplied by another layer without confirming its origin.

Local trust can be abused. On an unswitched network, devices may receive traffic not addressed to them, making passive packet capture possible. Switched networks limit that exposure, but address resolution still relies on machines accepting claims that connect an IP address to a hardware address. Forged replies can corrupt those associations and redirect traffic through an intermediary. Unencrypted services then expose the contents of that traffic, including credentials.

Analysis

Layering is both a source of clarity and a source of blind spots. Network engineers can reason locally about routing, while attackers look for mismatches between local assumptions. The book's examples make a broader security idea concrete: a trustworthy component can be misled by untrusted context. Encryption reduces the value of intercepted traffic, and authenticated network mechanisms can reduce false address claims, but neither replaces sound network segmentation. Security improves when trust boundaries are explicit rather than inherited silently.

Audit TCP bookkeeping and scan responses as security assumptions.

Reliability requires state. TCP tracks sequence and acknowledgment numbers so that data can be reordered, retransmitted, and delivered reliably. That state also creates opportunities for an attacker who can observe or imitate a connection's traffic. Erickson describes how forged packets can desynchronize a connection, disrupt it, or make an intermediary appear to be a legitimate participant.

Visibility leaks through replies. Port scans infer whether services are listening by observing how a system responds to unusual or incomplete connection attempts. Denial-of-service attacks exploit other protocol limits, such as queues that hold unfinished connections. The book's Shroud example tries to confuse scans by generating misleading responses. Defenders should treat protocol behavior as information, and test how both ordinary and abnormal traffic is handled.

Analysis

Protocols gain resilience by keeping state, but state also creates finite resources and observable behavior. This is a useful connection between security and distributed-systems design: every timeout, queue, and retry policy embodies assumptions about load and failure. A deceptive response can frustrate simplistic reconnaissance, but it may also complicate legitimate diagnosis. More reliable defense usually combines sensible resource limits, monitoring, and clear response policies rather than depending on obscurity alone.

Encryption protects content only when identity and key exchange hold.

A cipher is one part of security. Symmetric encryption uses the same secret key to encrypt and decrypt, while asymmetric encryption uses a public and private key pair. Hybrid systems use asymmetric methods to establish a shared secret, then faster symmetric encryption for the conversation. The book contrasts practical security, where breaking a system is infeasible with available resources, with a one-time pad, which is theoretically unbreakable when its random key is truly secret, at least as long as the message, and used only once.

Identity still matters. A man-in-the-middle attack places an intermediary between two parties, each of whom believes the other is on the line. Host keys and certificates are meant to expose this substitution. Weak user verification, unfamiliar hosts, or visually similar fingerprints can erode that protection.

Analysis

The key insight is that confidentiality and authentication solve different problems. Encryption can hide a conversation from outsiders while leaving a user connected to the wrong endpoint. This distinction is central to secure system design, where identity binding is as important as secrecy. The book's fuzzy-fingerprint example also highlights a human-factors limit: a warning is useful only if people can interpret it reliably. Strong cryptographic mechanisms need clear verification practices, not merely mathematically strong algorithms.

Judge password strength by search cost, not by how strange it looks.

Hashes hide, but do not erase, guesses. Password systems store one-way hashes rather than the original text. A salt changes the hash computation so identical passwords do not produce the same stored result, and it makes large precomputed lookup tables less useful. But an attacker with a stolen hash can still test candidate passwords by hashing each guess and comparing the result.

Length changes the workload. Dictionary attacks try likely words and variations; exhaustive attacks try every combination. The number of possibilities grows exponentially with password length, making longer passwords far more costly to search. Erickson also presents a Password Probability Matrix, a precomputed structure that narrows the candidates for four-character passwords. It illustrates the trade between storage and computation, not a replacement for choosing a larger search space.

Analysis

This section turns password advice into a model of adversarial cost. Human intuitions about complexity are unreliable: an unusual-looking but short password may still sit in a small search space, while length can expand that space sharply. Salting improves resistance to shared precomputation, but it cannot make weak guesses expensive enough by itself. The underlying lesson is to evaluate both the attacker's candidate strategy and the system's hashing cost, rather than treating a visual checklist of character types as a complete measure.

WEP's 24-bit IV turns ordinary traffic into a growing cryptographic liability.

Packets reused the same secret. WEP combined a shared key with a 24-bit initialization vector, or IV, to seed RC4 separately for each packet. The IV was sent openly. Because it was short, reuse became increasingly likely as traffic accumulated. The book uses the birthday paradox to explain why collisions can arise much sooner than a simple count of all possible IVs suggests, estimating about a 52.5 percent collision chance after 5,000 randomly chosen packets.

The design leaked more than intended. Reusing a keystream can expose relationships between messages, while weaknesses in RC4 key scheduling let the FMS attack draw information from certain IVs. WEP's integrity check also relied on a checksum that could be manipulated. The lesson is that combining familiar parts does not guarantee a secure protocol.

Analysis

WEP is a useful case study in how several modest design flaws compound. A short nonce, repeated key use, predictable message structure, and a malleable integrity check each weaken a different guarantee; together, they make traffic collection progressively more valuable. This is why cryptographic protocols require analysis as complete systems rather than as a cipher plus a key length. The account is historical, but the design principle endures: randomness, integrity, and key management must be treated as core requirements.

Turn discovered weaknesses into fixes before attackers make them operational.

Discovery can improve security. The book describes a continuing contest between people finding weaknesses and people building defenses. Research teams can identify flaws and notify vendors, who can then patch vulnerable software. Improvements in detection systems and defenses prompt new attempts to evade them, pushing both sides to refine their methods.

Patching changes the target. A published technique may be useful for understanding a class of failure, but systems that apply the relevant fixes should not remain exposed to that same known flaw. The greater risk comes from assumptions left unexamined, especially in new features or overlooked interactions. Erickson's practical invitation is to keep studying how systems actually work, experiment in a controlled setting, and use discoveries to improve security rather than merely demonstrate access.

Analysis

This feedback-loop view is strongest when research is connected to a functioning process for remediation. Finding a flaw is not the same as reducing risk; maintainers need enough detail to reproduce it, prioritize it, and distribute a fix. Incentives and coordination can therefore matter as much as technical insight. The book's optimism about security progress is persuasive, though progress is uneven: legacy systems and delayed updates can preserve known weaknesses long after a patch exists.

Analysis

Jon Erickson's book is a technical tutorial organized around a larger claim: exploitation becomes understandable once a reader learns the rules beneath a system's visible behavior. The progression from C programs and memory to network protocols and cryptography is deliberate. Each domain rewards the same habit of mind: identify assumptions, inspect how representations change, and ask what happens at boundaries that ordinary use does not exercise.

The most valuable teaching move is the connection between high-level intention and low-level consequence. A programmer sees a string copy or a path check; the machine sees bytes, addresses, and branch conditions. A network designer sees a simple address-resolution exchange; the receiving host may accept an unauthenticated assertion. A user sees a familiar encryption warning; an attacker may exploit uncertainty about identity. These are not separate curiosities. They are variations on the gap between what a system means to do and what its rules permit.

The book also presents security as adversarial learning. Defenses are not static barriers, and attacks are not magic tricks. Each is an attempt to model the other side's assumptions. That makes the material useful beyond its specific examples, especially for developers and defenders learning to reason about failure modes rather than memorize tools.

Its limitations are substantial but manageable. The text dates to 2003 and uses a particular Linux and x86 environment, so its exploit demonstrations, software versions, and defensive details should be read as historical instruction, not current operational guidance. Some arguments also lean toward the idea that open information reliably improves security. In practice, publication helps only when defenders can respond and users can adopt fixes. The lasting value is therefore not the old payloads, but the method: understand mechanisms, test assumptions safely, and connect technical discovery to repair.

Summary in 30 Seconds
Programs obey their instructions literally, so boundary errors and mismatched input checks can expose memory or redirect execution. Network layers can accept forged claims, while TCP behavior and scan responses reveal assumptions. Encryption depends on reliable identity checks and key exchange, not just strong ciphers. Longer passwords raise guessing costs. WEP’s 24-bit initialization vector faces a 52.5 percent collision chance after about 5,000 random packets.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.17 out of 5
Average of 2k+ ratings from Goodreads and Amazon.

Hacking: The Art of Exploitation is highly praised for its in-depth technical explanations of hacking techniques, covering topics like buffer overflows, networking, and cryptography. Readers appreciate the hands-on approach with the included LiveCD, allowing practical experimentation. While some find it challenging and potentially outdated, many consider it an essential resource for understanding low-level exploits and improving programming skills. The book is recommended for those interested in cybersecurity, though it may be too advanced for beginners and focuses primarily on C programming and Linux systems.

Your rating:
4.57
547 ratings
Want to read the full book?

Glossary

Hacker Ethic

Learning-driven technical values

The book's name for a subculture that values logic, technical mastery, curiosity, and the free exchange of information. Erickson traces it to early computer enthusiasts who treated programming as both a science and an art. The ethic describes motivations and ideals, not a guarantee that every person using hacking techniques acts responsibly.

buffer overflow

Writing beyond allocated memory

A memory error that occurs when a program stores more data in a buffer than the space reserved for it. The excess data can overwrite neighboring memory. Depending on what is overwritten, the result may be a crash, altered program state, or changed execution flow. C makes this class of error possible when programmers do not check input lengths.

format-string vulnerability

User input interpreted as formatting

A programming flaw in which user-controlled text is passed to a formatting function as its instructions rather than as ordinary content. Formatting directives can cause the function to interpret values from memory, and some directives can write data. The book shows how an unsafe printing pattern can therefore expose or modify program memory.

returning into libc

Reusing existing library code

A technique discussed as an alternative when a system prevents execution of code from the stack. Instead of redirecting execution to newly injected instructions, the program is made to continue at a function already present in the C library. The technique demonstrates that blocking one execution path does not automatically protect every control-flow target.

ARP cache poisoning

Corrupting address associations

An attack on Address Resolution Protocol behavior that supplies false associations between network addresses and hardware addresses. If a device accepts and stores the false information, it may send traffic to an unintended machine. Erickson describes how this can route communications through an intermediary, where traffic may be observed or forwarded.

TCP/IP hijacking

Taking over a live connection

A network attack that exploits the tracking of TCP sequence and acknowledgment numbers. An attacker who can observe a connection may send traffic that appears to come from one participant, disrupting the original exchange and attempting to continue the conversation. The book emphasizes the importance of being positioned on the same network as the victim.

computational security

Practical resistance to attack

A security standard based on whether the best-known method for breaking a cryptosystem would require unreasonable time or computational resources. Unlike unconditional security, it does not claim that breaking the system is mathematically impossible. Its assessment depends on current knowledge, available resources, and the value or lifetime of the protected information.

one-time pad

Single-use random encryption key

A cipher that combines a message with a truly random key at least as long as the message, using the same operation to reverse the process. When the key remains secret and is used only once, the system is unconditionally secure in the book's account. Securely distributing and protecting such long keys makes the method impractical for many everyday uses.

Password Probability Matrix

Precomputed password candidate filter

A technique Erickson presents for reducing the search needed to recover a short password from its hash. Instead of storing every password and hash pair directly, the method stores compressed relationships between pieces of plaintext and pieces of ciphertext. A hash query yields likely character pairs, which are then checked. It trades precomputation and storage for faster candidate search.

Fluhrer, Mantin, and Shamir (FMS) attack

RC4 key recovery from weak IVs

A method for attacking WEP that uses weaknesses in RC4's key-scheduling behavior and selected initialization vectors. Because packet structure can reveal the first byte of the keystream, observations from enough weak-IV packets can statistically suggest bytes of the secret key. The attack proceeds byte by byte and illustrates how protocol-level key use can undermine a cipher.

Wired Equivalent Privacy (WEP)

Legacy wireless encryption protocol

The wireless security scheme examined in the book for 802.11b networks. WEP combined a shared key with a short initialization vector to generate RC4 keystreams, and used a CRC32 checksum for integrity. Weaknesses in IV reuse, key scheduling, and checksum handling made the overall protocol vulnerable despite its use of encryption.

FAQ

What's Hacking: The Art of Exploitation about?

  • Introduction to Hacking: The book introduces hacking as a form of creative problem-solving, focusing on finding unconventional solutions.
  • Technical Foundation: It provides a comprehensive technical foundation, covering essential hacking techniques often missing in other literature.
  • Core Techniques: Readers learn about exploiting buffer overflows, writing shellcode, and understanding networking and cryptology.

Why should I read Hacking: The Art of Exploitation?

  • Comprehensive Learning: Ideal for those serious about ethical hacking or understanding system vulnerabilities.
  • Hands-On Approach: Encourages experimentation with code examples on a Linux system for practical understanding.
  • Mindset Development: Helps develop a hacker mindset, fostering creative problem-solving and security awareness.

What are the key takeaways of Hacking: The Art of Exploitation?

  • Understanding Exploits: Gain insights into how exploits work and how to defend against them, including buffer overflows and format string vulnerabilities.
  • Hacker Ethic: Discusses the Hacker Ethic, promoting the free flow of information and knowledge pursuit.
  • Practical Skills: Equips readers with skills to write hacks and understand security vulnerabilities.

How does Hacking: The Art of Exploitation define hacking?

  • Creative Problem Solving: Describes hacking as creating problem-solving methods through unconventional means.
  • Beyond Criminality: Emphasizes that hacking is not inherently criminal but a means of innovation and exploration.
  • Historical Context: Traces hacking origins to early computer enthusiasts who creatively manipulated systems.

What is the Hacker Ethic mentioned in Hacking: The Art of Exploitation?

  • Free Information: Promotes the belief that information should be free and accessible to all.
  • Learning and Mastery: Values continuous learning and mastery over technology, encouraging boundary-pushing and innovation.
  • Community and Collaboration: Fosters a sense of community among hackers, where knowledge sharing and collaboration are encouraged.

What are some core techniques covered in Hacking: The Art of Exploitation?

  • Buffer Overflows: Explains exploiting programs using buffer overflows, a common software vulnerability.
  • Shellcode Writing: Teaches writing and injecting shellcode, essential for executing arbitrary code on target systems.
  • Network Traffic Manipulation: Covers techniques to redirect network traffic and hijack TCP connections, enhancing network security understanding.

How does Jon Erickson explain buffer overflows in Hacking: The Art of Exploitation?

  • Detailed Explanation: Provides a thorough explanation of buffer overflows, including their occurrence and implications.
  • Practical Examples: Includes practical examples and code snippets to illustrate buffer overflow exploitation.
  • Mitigation Strategies: Discusses strategies for mitigating buffer overflow vulnerabilities, emphasizing secure coding practices.

What is the significance of shellcode in hacking as explained in Hacking: The Art of Exploitation?

  • Execution of Arbitrary Code: Shellcode is crucial for executing arbitrary code on a target system, a key component of many exploits.
  • Crafting Shellcode: Teaches writing shellcode that is small, efficient, and free of null bytes for successful exploitation.
  • Polymorphic Shellcode: Discusses creating polymorphic shellcode to evade detection by security systems.

What are some specific methods discussed in Hacking: The Art of Exploitation?

  • Buffer Overflow Exploits: Details how buffer overflows can be exploited to execute arbitrary code by manipulating stack memory.
  • Format String Vulnerabilities: Explains exploiting format string vulnerabilities to read or write arbitrary memory locations.
  • Network Attacks: Covers network attacks like ARP spoofing and TCP/IP hijacking, demonstrating traffic interception and manipulation.

How does Hacking: The Art of Exploitation approach the topic of network security?

  • Comprehensive Coverage: Covers various aspects of network security, including common attacks and vulnerabilities.
  • Practical Techniques: Includes techniques for securing networks, such as implementing firewalls and intrusion detection systems.
  • Real-World Examples: Uses real-world examples to illustrate the impact of network vulnerabilities, emphasizing the importance of security.

What are the best quotes from Hacking: The Art of Exploitation and what do they mean?

  • "Hacking is about understanding the rules of the system.": Emphasizes understanding systems to identify vulnerabilities, highlighting the hacker mindset.
  • "The best way to learn is by doing.": Reflects the book's hands-on approach, encouraging practical exercises and real-world application.
  • "Vulnerabilities exist in every system.": Reminds readers that no system is completely secure, underscoring the need for continuous security improvement.

How can I apply the knowledge from Hacking: The Art of Exploitation in real life?

  • Ethical Hacking: Techniques can be applied in ethical hacking and penetration testing to identify and mitigate system vulnerabilities.
  • Improving Security Practices: Understanding hacking techniques helps developers and IT professionals enhance security practices.
  • Continuous Learning: Encourages a mindset of continuous learning and curiosity, staying updated on the latest hacking techniques and security measures.

About the Author

Jon Erickson is the author of "Hacking: The Art of Exploitation," a widely acclaimed book in the field of computer security. Known for his ability to explain complex technical concepts in an accessible manner, Erickson has contributed significantly to the understanding of hacking techniques and software vulnerabilities. His work focuses on teaching readers not just how to use existing exploits, but how to develop their own and understand the underlying principles. Erickson's approach emphasizes the importance of creative problem-solving in hacking, encouraging readers to think critically about computer systems and their potential weaknesses. His book has become a valuable resource for both aspiring security professionals and experienced programmers looking to deepen their understanding of cybersecurity.

Download PDF

To save this Hacking summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.30 MB     Pages: 22

Download EPUB

To read this Hacking summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.43 MB     Pages: 27
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
600,000+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...