stationery 0.2.0 → 0.3.0

data/lib/stationery/fonts/true_type.rb

@@ -3,9 +3,9 @@
 module Stationery
   module Fonts
     # Reads the sfnt tables of a static font needed to measure text and to
-    # embed it: TrueType outlines (.ttf) or CFF outlines (.otf). Variable CFF2
-    # fonts, font collections and web font wrappers are rejected with a named
-    # reason.
+    # embed it: TrueType outlines (.ttf) or CFF outlines (.otf), alone or as one
+    # face of a collection (.ttc), or unwrapped from a WOFF web font. Variable
+    # CFF2 fonts and WOFF2 are rejected with a named reason.
     class TrueType
       include SfntMetrics
 
@@ -13,10 +13,9 @@ module Stationery
       OUTLINE_TABLES = { "OTTO" => ["CFF "] }.freeze
       GLYF_TABLES = %w[loca glyf].freeze
       SFNT_VERSIONS = ["\x00\x01\x00\x00".b, "true", "OTTO"].freeze
+      COLLECTION = "ttcf"
       SIGNATURES = {
-        "ttcf" => "TrueType collections (.ttc) are not supported, use a single TrueType (.ttf) font",
-        "wOFF" => "WOFF web fonts are not supported, use the TrueType (.ttf) file",
-        "wOF2" => "WOFF2 web fonts are not supported, use the TrueType (.ttf) file"
+        "wOF2" => "WOFF2 needs Brotli; convert to .ttf or .woff"
       }.freeze
 
       attr_reader :data, :tables, :units_per_em, :bbox, :ascender, :descender, :line_gap, :num_glyphs,
@@ -24,9 +23,12 @@ module Stationery
                   :strikeout_position, :strikeout_size, :cap_height, :x_height, :weight, :postscript_name
 
       # A subset embedded in a PDF carries no cmap (the PDF maps glyphs itself),
-      # so reading one back passes `cmap: false`.
-      def initialize(data, cmap: true)
+      # so reading one back passes `cmap: false`. `index:` picks a face of a
+      # collection, face 0 by default.
+      def initialize(data, cmap: true, index: nil)
         @data = data.b
+        @data = WOFF.unpack(@data) if @data.start_with?(WOFF::SIGNATURE)
+        @sfnt = face_offset(index || 0)
         check_signature
         read_table_directory(cmap)
         parse_head
@@ -40,6 +42,12 @@ module Stationery
         @postscript_name = NameTable.postscript_name(self)
       end
 
+      def self.collection?(data) = data.byteslice(0, 4) == COLLECTION
+
+      def self.faces(data)
+        collection?(data) ? data.byteslice(8, 4).unpack1("N") : 1
+      end
+
       def inspect = "#<#{self.class} #{@postscript_name} glyphs=#{@num_glyphs}>"
 
       def glyph_id(codepoint)
@@ -68,6 +76,11 @@ module Stationery
         @kerning ||= Kerning.for(self)
       end
 
+      # Standard ligatures, read on first use and shared like #kerning.
+      def ligatures
+        @ligatures ||= Ligatures.for(self)
+      end
+
       def cff?
         @tables.key?("CFF ")
       end
@@ -106,8 +119,19 @@ module Stationery
 
       private
 
+      # Table offsets in a collection are already absolute, so a face is read
+      # from the shared data at its own table directory.
+      def face_offset(index)
+        count = self.class.faces(@data)
+        unless index.between?(0, count - 1)
+          raise ArgumentError, "font face #{index} is out of range (numFonts #{count})"
+        end
+
+        self.class.collection?(@data) ? u32(12 + (index * 4)) : 0
+      end
+
       def check_signature
-        signature = @data.byteslice(0, 4)
+        signature = @data.byteslice(@sfnt, 4)
         return if SFNT_VERSIONS.include?(signature)
 
         raise UnsupportedFont, SIGNATURES.fetch(signature, "not a TrueType font")
@@ -115,13 +139,13 @@ module Stationery
 
       def read_table_directory(cmap)
         @tables = {}
-        u16(4).times do |i|
-          record = 12 + (i * 16)
+        u16(@sfnt + 4).times do |i|
+          record = @sfnt + 12 + (i * 16)
           @tables[@data.byteslice(record, 4)] = [u32(record + 8), u32(record + 12)]
         end
         raise UnsupportedFont, "variable CFF2 fonts are not supported" if @tables.key?("CFF2")
 
-        required = REQUIRED_TABLES + OUTLINE_TABLES.fetch(@data.byteslice(0, 4), GLYF_TABLES)
+        required = REQUIRED_TABLES + OUTLINE_TABLES.fetch(@data.byteslice(@sfnt, 4), GLYF_TABLES)
         required += ["cmap"] if cmap
         missing = required.reject { |tag| @tables.key?(tag) }
         raise UnsupportedFont, "font is missing the #{missing.map(&:strip).join(", ")} table" if missing.any?

data/lib/stationery/fonts/woff.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Stationery
+  module Fonts
+    # Unwraps a WOFF 1.0 web font into the sfnt it was made from: each table is
+    # inflated (or copied when stored) and laid out behind a fresh table
+    # directory, 4-byte aligned in directory order. Metadata and private data
+    # blocks are dropped.
+    module WOFF
+      SIGNATURE = "wOFF"
+      HEADER = 44
+      ENTRY = 20
+
+      module_function
+
+      def unpack(data)
+        data = data.b
+        flavor = data.byteslice(4, 4)
+        tables = Array.new(data.byteslice(12, 2).unpack1("n")) do |i|
+          tag, offset, compressed, length, checksum = data.byteslice(HEADER + (i * ENTRY), ENTRY).unpack("a4NNNN")
+          [tag, checksum, table(tag, data.byteslice(offset, compressed), length)]
+        end
+        assemble(flavor, tables)
+      end
+
+      def table(tag, bytes, length)
+        return bytes if bytes.bytesize >= length
+
+        Zlib::Inflate.inflate(bytes)
+      rescue Zlib::Error
+        raise UnsupportedFont, "corrupt WOFF table #{tag}"
+      end
+
+      def assemble(flavor, tables)
+        entry_selector = Math.log2(tables.size).floor
+        search_range = (2**entry_selector) * 16
+        directory = [flavor, tables.size, search_range, entry_selector, (tables.size * 16) - search_range]
+                    .pack("a4nnnn")
+        body = String.new(encoding: Encoding::BINARY)
+        offset = 12 + (tables.size * 16)
+
+        tables.each do |tag, checksum, bytes|
+          directory << [tag, checksum, offset + body.bytesize, bytes.bytesize].pack("a4NNN")
+          body << bytes << ("\0".b * (-bytes.bytesize % 4))
+        end
+        directory << body
+      end
+    end
+  end
+end

data/lib/stationery/layout/box.rb

@@ -8,16 +8,21 @@ module Stationery
     # `:avoid` never). A fragment's cut sides are `open`: `decoration: :slice`
     # drops their padding and border, `:clone` keeps the padding. A
     # fixed-height box can truncate or shrink text that does not fit
-    # (`overflow:`) and never splits.
+    # (`overflow:`) and never splits. `min_height:` is a floor that does split:
+    # the first fragment keeps as much of it as the page holds and the next
+    # one carries only what is left of it.
     class Box < Node
       BORDER = { width: 1, color: "#000000", sides: %i[top right bottom left] }.freeze
 
       attr_reader :content, :width_spec
 
       def initialize(content = Flow.new, padding: 0, background: nil, border: nil, radius: 0, width: nil,
-                     height: nil, overflow: :visible, valign: :top, opacity: nil, link: nil, outset: 0,
+                     height: nil, min_height: nil, overflow: :visible, valign: :top, opacity: nil, link: nil, outset: 0,
                      open: [], decoration: :slice)
+        raise ArgumentError, "pass height: or min_height:, not both" if height && min_height
+
         super()
+        @min_height = min_height
         @open = open
         @decoration = decoration
         @link = link
@@ -58,17 +63,20 @@ module Stationery
         available = height - vertical(cut)
         head, tail = @content.split(inner_width(width), available, fresh:)
         return [nil, self] unless head
-        return [with_content(head), nil] unless tail
+        return [with_content(head), nil] unless tail || @min_height.to_f > height + EPSILON
 
-        [with_content(head, cut).tap { |part| part.keep_with_next = nil }, with_content(tail, @open | [:top])]
+        fragments(width, height, head, tail || Flow.new, cut)
       end
 
+      # An empty continuation: open at the top, without a floor.
+      def continued = fragment(Flow.new, @open | [:top], nil)
+
       # A copy holding other content and open sides, every option kept.
       def with_content(content, open = @open) = dup.reopen(content, open)
       def with_open(*sides) = with_content(@content, @open | sides)
 
       def measure(width)
-        @height || memoize_by_width(width) { @content.measure(inner_width(width)) + vertical }
+        @height || memoize_by_width(width) { [@content.measure(inner_width(width)) + vertical, @min_height || 0].max }
       end
 
       def paint(canvas, x, y, width, height = nil, valign: nil, debug_kind: :box, **)
@@ -82,14 +90,23 @@ module Stationery
 
       protected
 
-      def reopen(content, open)
+      def reopen(content, open, min_height = @min_height)
         @content = content
         @open = open
+        @min_height = min_height
         self
       end
 
       private
 
+      def fragment(content, open, min_height) = dup.reopen(content, open, min_height)
+
+      def fragments(width, height, head, tail, cut)
+        first = fragment(head, cut, @min_height && [@min_height, height].min).tap { |part| part.keep_with_next = nil }
+        rest = @min_height.to_f - first.measure(width)
+        [first, fragment(tail, @open | [:top], rest.positive? ? rest : nil)]
+      end
+
       def insets(open = @open)
         border = @border ? @border[:width] : 0
         sides = @border ? @border[:sides] - open : []

data/lib/stationery/layout/row.rb

@@ -36,7 +36,7 @@ module Stationery
         return [nil, self] if parts.any? { |head, _| head.nil? }
 
         heads = parts.map { |head, _| head.with_open(:bottom) }
-        tails = parts.zip(@columns).map { |(_, tail), column| tail || column.with_content(Flow.new).with_open(:top) }
+        tails = parts.zip(@columns).map { |(_, tail), column| tail || column.continued }
         [with_columns(heads).tap { |row| row.keep_with_next = nil }, with_columns(tails)]
       end
 

data/lib/stationery/layout/svg.rb

@@ -5,9 +5,11 @@ module Stationery
     # A vector drawing at a fixed size: `width:` and/or `height:` (the other
     # follows the viewBox's aspect ratio), never wider than the space given.
     class Svg < Node
-      def initialize(document, width: nil, height: nil, color: "#000000")
+      # `context` gives SVG text its font book and default family.
+      def initialize(document, width: nil, height: nil, color: "#000000", context: nil)
         super()
         @document = document
+        @context = context
         @width = width
         @height = height
         @color = color
@@ -26,7 +28,8 @@ module Stationery
 
       def paint(canvas, x, y, width, _height = nil, **)
         w, h = size(width)
-        @document.draw(canvas, x:, y:, width: w, height: h, color: @color)
+        @document.draw(canvas, x:, y:, width: w, height: h, color: @color, book: @context&.book,
+                               family: @context&.style&.family)
         canvas.debug_rect(x, y, w, h, :image)
       end
 

data/lib/stationery/layout/text.rb

@@ -42,7 +42,8 @@ module Stationery
           style = run.style
           font = @context.book.resolve(style).first
           run.text.split(/[ \t\n]+/).map do |word|
-            font.width_of(word, style.render_size, letter_spacing: style.letter_spacing, kerning: style.kerning)
+            font.width_of(word, style.render_size, letter_spacing: style.letter_spacing, kerning: style.kerning,
+                                                   ligatures: style.ligatures)
           end
         end.max || 0
       end

data/lib/stationery/pdf/assembler.rb

@@ -4,15 +4,16 @@ module Stationery
   module PDF
     # Writes finished pages, their shared resources and document info as PDF.
     class Assembler
-      def initialize(pages:, resources:, info: {}, outline: [])
+      def initialize(pages:, resources:, info: {}, outline: [], encryption: nil)
         @pages = pages
         @resources = resources
         @info = info
         @outline = outline
+        @encryption = encryption
       end
 
       def render
-        writer = Writer.new
+        writer = Writer.new(encryption: @encryption)
         tree = writer.reserve
         refs = @resources.build(writer)
         kids = @kids = @pages.map { writer.reserve }

data/lib/stationery/pdf/encryption/aes.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Stationery
+  module PDF
+    module Encryption
+      # AES as PDF uses it: object data is CBC with a random IV in front and
+      # PKCS#5 padding; key material (UE, OE, Perms) is unpadded.
+      module AES
+        ZERO_IV = ("\0" * 16).b
+
+        module_function
+
+        def encrypt(key, data)
+          iv = OpenSSL::Random.random_bytes(16)
+          iv + run(cipher(key, "CBC", iv), data)
+        end
+
+        def raw(key, data, iv: ZERO_IV, mode: "CBC")
+          aes = cipher(key, mode, mode == "ECB" ? nil : iv)
+          aes.padding = 0
+          run(aes, data)
+        end
+
+        def cipher(key, mode, iv)
+          aes = OpenSSL::Cipher.new("AES-#{key.bytesize * 8}-#{mode}").encrypt
+          aes.key = key
+          aes.iv = iv if iv
+          aes
+        end
+
+        def run(aes, data) = aes.update(data.b) + aes.final
+      end
+    end
+  end
+end

data/lib/stationery/pdf/encryption/rc4.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Stationery
+  module PDF
+    module Encryption
+      # RC4 in Ruby: OpenSSL 3 builds drop it from the default provider.
+      module RC4
+        module_function
+
+        def crypt(key, data)
+          state = schedule(key.b.bytes)
+          i = j = 0
+          data.b.bytes.map do |byte|
+            i = (i + 1) & 0xFF
+            j = (j + state[i]) & 0xFF
+            state[i], state[j] = state[j], state[i]
+            byte ^ state[(state[i] + state[j]) & 0xFF]
+          end.pack("C*")
+        end
+
+        def schedule(key)
+          state = (0..255).to_a
+          j = 0
+          256.times do |i|
+            j = (j + state[i] + key[i % key.size]) & 0xFF
+            state[i], state[j] = state[j], state[i]
+          end
+          state
+        end
+      end
+    end
+  end
+end

data/lib/stationery/pdf/encryption/revision4.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+
+module Stationery
+  module PDF
+    module Encryption
+      # The MD5 key derivation of security handler revisions 3 and 4
+      # (ISO 32000-1 algorithms 1-5) with a 128-bit key. Each object is
+      # encrypted with its own key: RC4 for R3, AES-128 (AESV2) for R4.
+      class Revision4
+        PADDING = ["28BF4E5E4E758A4164004E56FFFA01082E2E00B6D0683E802F0CA9FE6453697A"].pack("H*").freeze
+
+        def initialize(user:, owner:, permissions:, file_id:, aes:)
+          @aes = aes
+          user = pad(user)
+          @owner_key = rounds(stretch(Digest::MD5.digest(pad(owner))), user)
+          @key = stretch(Digest::MD5.digest(user + @owner_key + [permissions].pack("l<") + file_id))
+          @user_key = rounds(@key, Digest::MD5.digest(PADDING + file_id)) + PADDING.byteslice(0, 16)
+        end
+
+        def entries = { O: HexString.new(@owner_key), U: HexString.new(@user_key) }
+
+        def encrypt(data, number, generation)
+          key = object_key(number, generation)
+          @aes ? AES.encrypt(key, data) : RC4.crypt(key, data)
+        end
+
+        private
+
+        def pad(password) = (password.b + PADDING).byteslice(0, 32)
+
+        def stretch(digest) = 50.times.reduce(digest) { |previous, _| Digest::MD5.digest(previous) }
+
+        def rounds(key, data)
+          20.times.reduce(data) { |previous, round| RC4.crypt(xor(key, round), previous) }
+        end
+
+        def xor(key, value) = key.bytes.map { |byte| byte ^ value }.pack("C*")
+
+        def object_key(number, generation)
+          seed = @key + [number].pack("V").byteslice(0, 3) + [generation].pack("v")
+          Digest::MD5.digest(@aes ? "#{seed}sAlT" : seed)
+        end
+      end
+    end
+  end
+end

data/lib/stationery/pdf/encryption/revision6.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "digest/sha2"
+require "openssl"
+
+module Stationery
+  module PDF
+    module Encryption
+      # Security handler revision 6 (ISO 32000-2, AES-256): a random file key
+      # wrapped once per password, with salted SHA-2 hashes that run through
+      # the hash iteration of algorithm 2.B. Every object uses the file key.
+      class Revision6
+        DIGESTS = [Digest::SHA256, Digest::SHA384, Digest::SHA512].freeze
+
+        def initialize(user:, owner:, permissions:)
+          @key = random(32)
+          user = password(user)
+          owner = password(owner)
+          validation = random(8)
+          key_salt = random(8)
+          @user_key = hash(user, validation) + validation + key_salt
+          @user_wrapped = AES.raw(hash(user, key_salt), @key)
+          validation = random(8)
+          key_salt = random(8)
+          @owner_key = hash(owner, validation, @user_key) + validation + key_salt
+          @owner_wrapped = AES.raw(hash(owner, key_salt, @user_key), @key)
+          @perms = AES.raw(@key, "#{[permissions, 0xFFFFFFFF].pack("l<V")}Tadb#{random(4)}", mode: "ECB")
+        end
+
+        def entries
+          { O: @owner_key, U: @user_key, OE: @owner_wrapped, UE: @user_wrapped, Perms: @perms }
+            .transform_values { |bytes| HexString.new(bytes) }
+        end
+
+        def encrypt(data, _number, _generation) = AES.encrypt(@key, data)
+
+        private
+
+        def random(size) = OpenSSL::Random.random_bytes(size)
+
+        def password(value) = value.encode(Encoding::UTF_8).b.byteslice(0, 127)
+
+        def hash(password, salt, user_key = "".b)
+          key = Digest::SHA256.digest(password + salt + user_key)
+          round = 0
+          loop do
+            block = AES.raw(key.byteslice(0, 16), (password + key + user_key) * 64, iv: key.byteslice(16, 16))
+            key = DIGESTS[block.byteslice(0, 16).bytes.sum % 3].digest(block)
+            round += 1
+            return key.byteslice(0, 32) if round >= 64 && block.getbyte(-1) <= round - 32
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stationery/pdf/encryption/standard_security.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Stationery
+  module PDF
+    module Encryption
+      # The standard security handler: passwords, permissions and the
+      # /Encrypt dictionary, plus the per-object encryption the writer applies
+      # to every string and stream.
+      #
+      #   StandardSecurity.new(owner_password: "s3cret", permissions: %i[print copy])
+      class StandardSecurity
+        PERMISSIONS = { print: 3, modify: 4, copy: 5, annotate: 6, fill_forms: 9, extract_accessible: 10,
+                        assemble: 11, print_high: 12 }.freeze
+        ALGORITHMS = {
+          aes_256: { V: 5, R: 6, Length: 256, CFM: :AESV3, key: 32 },
+          aes_128: { V: 4, R: 4, Length: 128, CFM: :AESV2, key: 16 },
+          rc4_128: { V: 2, R: 3, Length: 128 }
+        }.freeze
+
+        # Checks and normalizes the options without deriving any keys.
+        def self.options(owner_password:, user_password: "", permissions: PERMISSIONS.keys, algorithm: :aes_256)
+          raise ArgumentError, "encryption needs an owner_password" if owner_password.to_s.empty?
+
+          permissions = Array(permissions).map(&:to_sym)
+          unknown = permissions - PERMISSIONS.keys
+          raise ArgumentError, "unknown permission #{unknown.first.inspect}" if unknown.any?
+          raise ArgumentError, "unknown algorithm #{algorithm.inspect}" unless ALGORITHMS.key?(algorithm)
+
+          { owner_password: owner_password.to_s, user_password: user_password.to_s, permissions:, algorithm: }
+        end
+
+        # The signed 32-bit /P value: granted bits set, bits 1-2 clear, the rest set.
+        def self.permission_bits(permissions)
+          masks = PERMISSIONS.transform_values { |bit| 1 << (bit - 1) }
+          bits = 0xFFFFFFFC & ~masks.values.sum
+          bits |= permissions.sum { |name| masks.fetch(name) }
+          [bits].pack("L").unpack1("l")
+        end
+
+        attr_reader :file_id
+
+        def initialize(**)
+          options = self.class.options(**)
+          @algorithm = ALGORITHMS.fetch(options[:algorithm])
+          @permissions = self.class.permission_bits(options[:permissions])
+          @file_id = OpenSSL::Random.random_bytes(16)
+          @handler = handler(options[:user_password], options[:owner_password], options[:algorithm])
+        end
+
+        def dictionary
+          { Filter: :Standard, **@algorithm.slice(:V, :R, :Length), P: @permissions, **@handler.entries,
+            **crypt_filters }
+        end
+
+        def encrypt(data, number, generation = 0) = @handler.encrypt(data, number, generation)
+
+        private
+
+        def handler(user, owner, algorithm)
+          if algorithm == :aes_256
+            Revision6.new(user:, owner:, permissions: @permissions)
+          else
+            Revision4.new(user:, owner:, permissions: @permissions, file_id: @file_id, aes: algorithm == :aes_128)
+          end
+        end
+
+        def crypt_filters
+          return {} unless @algorithm[:CFM]
+
+          filter = { CFM: @algorithm[:CFM], AuthEvent: :DocOpen, Length: @algorithm[:key] }
+          { CF: { StdCF: filter }, StmF: :StdCF, StrF: :StdCF }
+        end
+      end
+    end
+  end
+end

data/lib/stationery/pdf/serializer.rb

@@ -7,6 +7,9 @@ module Stationery
     # A plain String is always written as a literal byte string `( … )` — never
     # re-encoded — so a URI stays the 7-bit ASCII the spec requires. Use
     # TextString for human-readable text that may need UTF-16.
+    #
+    # `crypt`, when given, receives every string's bytes (the writer binds it
+    # to the object being written) and the result is written as hex.
     module Serializer
       NAME_ESCAPE = %r{[^\x21-\x7E]|[#%()/<>\[\]{}]}n
       LITERAL_ESCAPE = /[\\()\r]/n
@@ -14,15 +17,15 @@ module Stationery
 
       module_function
 
-      def dump(value)
+      def dump(value, crypt = nil)
         case value
         when Reference then "#{value.id} 0 R"
         when Symbol then name(value)
-        when Hash then "<<#{value.map { |k, v| "#{name(k)} #{dump(v)}" }.join(" ")}>>"
-        when Array then "[#{value.map { |v| dump(v) }.join(" ")}]"
-        when HexString then "<#{value.bytes.unpack1("H*").upcase}>"
-        when TextString then text(value.value)
-        when String then literal(value)
+        when Hash then "<<#{value.map { |k, v| "#{name(k)} #{dump(v, crypt)}" }.join(" ")}>>"
+        when Array then "[#{value.map { |v| dump(v, crypt) }.join(" ")}]"
+        when HexString then hex(value.bytes, crypt)
+        when TextString then text(value.value, crypt)
+        when String then crypt ? hex(value, crypt) : literal(value)
         when Integer, true, false then value.to_s
         when Float then number(value)
         when nil then "null"
@@ -38,6 +41,11 @@ module Stationery
         "(#{value.b.gsub(LITERAL_ESCAPE) { |c| c == "\r" ? "\\r" : "\\#{c}" }})"
       end
 
+      def hex(bytes, crypt = nil)
+        bytes = crypt.call(bytes.b) if crypt
+        "<#{bytes.unpack1("H*").upcase}>"
+      end
+
       def number(value)
         return value.to_s if value.is_a?(Integer)
 
@@ -49,11 +57,11 @@ module Stationery
         str == "-0" ? "0" : str
       end
 
-      def text(value)
+      def text(value, crypt = nil)
         value = value.to_s
-        return literal(value) if value.ascii_only?
+        return dump(value, crypt) if value.ascii_only?
 
-        dump(HexString.new(UTF16_BOM + value.encode(Encoding::UTF_16BE).b))
+        hex(UTF16_BOM + value.encode(Encoding::UTF_16BE).b, crypt)
       end
     end
   end

data/lib/stationery/pdf/writer.rb

@@ -9,8 +9,11 @@ module Stationery
     class Writer
       HEADER = "%PDF-1.7\n%\xE2\xE3\xCF\xD3\n".b
 
-      def initialize
+      # `encryption` (an Encryption::StandardSecurity) encrypts every string
+      # and stream except those of its own /Encrypt dictionary.
+      def initialize(encryption: nil)
         @objects = []
+        @encryption = encryption
       end
 
       # Hands out a reference now and lets the object be set later, so a page
@@ -34,30 +37,46 @@ module Stationery
           raise Error, "object #{missing + 1} reserved but never set"
         end
 
+        @encrypt = @encryption && add(@encryption.dictionary)
         out = HEADER.dup
         offsets = @objects.each_with_index.map { |object, index| write_object(out, index + 1, object) }
         xref = out.bytesize
-        id = HexString.new(Digest::MD5.digest(out))
+        id = HexString.new(@encryption ? @encryption.file_id : Digest::MD5.digest(out))
 
         out << "xref\n0 #{@objects.size + 1}\n0000000000 65535 f \n"
         offsets.each { |offset| out << format("%010d 00000 n \n", offset) }
-        out << "trailer\n" << Serializer.dump({ Size: @objects.size + 1, Root: root, Info: info, ID: [id, id] })
+        out << "trailer\n" << Serializer.dump(trailer(root, info, id))
         out << "\nstartxref\n#{xref}\n%%EOF\n"
       end
 
       private
 
+      def trailer(root, info, id)
+        trailer = { Size: @objects.size + 1, Root: root, Info: info, ID: [id, id] }
+        @encrypt ? trailer.merge(Encrypt: @encrypt) : trailer
+      end
+
       def write_object(out, number, object)
         offset = out.bytesize
+        crypt = crypt_for(number)
         out << "#{number} 0 obj\n"
         if object.is_a?(Stream)
-          out << Serializer.dump(object.dictionary) << "\nstream\n" << object.data << "\nendstream"
+          data = crypt ? crypt.call(object.data) : object.data
+          out << Serializer.dump(object.dictionary.merge(Length: data.bytesize), crypt)
+          out << "\nstream\n" << data << "\nendstream"
         else
-          out << Serializer.dump(object)
+          out << Serializer.dump(object, crypt)
         end
         out << "\nendobj\n"
         offset
       end
+
+      # The Serializer hook: encrypts a string or stream with this object's key.
+      def crypt_for(number)
+        return unless @encrypt && number != @encrypt.id
+
+        ->(bytes) { @encryption.encrypt(bytes, number) }
+      end
     end
   end
 end