giga-fast-kit 0.0.1

data/prawn-2.5.0/lib/prawn/security.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+
+require_relative 'security/arcfour'
+
+module Prawn
+  class Document
+    # Implements PDF encryption (password protection and permissions) as
+    # specified in the PDF Reference, version 1.3, section 3.5 "Encryption".
+    module Security
+      # @group Experimental API
+
+      # Encrypts the document, to protect confidential data or control
+      # modifications to the document. The encryption algorithm used is detailed
+      # in the PDF Reference 1.3, section 3.5 "Encryption", and it is
+      # implemented by all major PDF readers.
+      #
+      # #### Examples
+      #
+      # Deny printing to everyone, but allow anyone to open without a password:
+      #
+      # ```ruby
+      # encrypt_document permissions: { print_document: false },
+      #   owner_password: :random
+      # ```
+      #
+      # Set a user and owner password on the document, with full permissions for
+      # both the user and the owner:
+      #
+      # ```ruby
+      # encrypt_document user_password: 'foo', owner_password: 'bar'
+      # ```
+      #
+      # Set no passwords, grant all permissions (This is useful because the
+      # default in some readers, if no permissions are specified, is "deny"):
+      #
+      # ```ruby
+      # encrypt_document
+      # ```
+      #
+      # #### Caveats
+      #
+      # * The encryption used is weak; the key is password-derived and is
+      #   limited to 40 bits, due to US export controls in effect at the time
+      #   the PDF standard was written.
+      # * There is nothing technologically requiring PDF readers to respect the
+      #   permissions embedded in a document. Many PDF readers do not.
+      # * In short, you have **no security at all** against a moderately
+      #   motivated person. Don't use this for anything super-serious. This is
+      #   not a limitation of Prawn, but is rather a built-in limitation of the
+      #   PDF format.
+      #
+      # @param options [Hash{Symbol => any}]
+      # @option options :user_password [String]
+      #   Password required to open the document. If this is omitted or empty,
+      #   no password will be required. The document will still be encrypted,
+      #   but anyone can read it.
+      # @option options :owner_password [String, :random]
+      #   Password required to make modifications to the document or change or
+      #   override its permissions. If this is set to `:random`, a random
+      #   password will be used; this can be useful if you never want users to
+      #   be able to override the document permissions.
+      # @option options :permissions [Hash{Symbol => Boolean}]
+      #   A hash mapping permission symbols (see below) to `true` or `false`.
+      #   `true` means "permitted", and `false` means "not permitted". All
+      #   permissions default to `true`.
+      #
+      #   The following permissions can be specified:
+      #
+      #   - `:print_document` -- Print document.
+      #   - `:modify_contents` -- Modify contents of document (other than text
+      #     annotations and interactive form fields).
+      #   - `:copy_contents` -- Copy text and graphics from document.
+      #   - `:modify_annotations` -- Add or modify text annotations and
+      #     interactive form fields.
+      # @return [void]
+      def encrypt_document(options = {})
+        Prawn.verify_options(%i[user_password owner_password permissions], options)
+        @user_password = options.delete(:user_password) || ''
+
+        @owner_password = options.delete(:owner_password) || @user_password
+        if @owner_password == :random
+          # Generate a completely ridiculous password
+          @owner_password = (1..32).map { rand(256) }.pack('c*')
+        end
+
+        self.permissions = options.delete(:permissions) || {}
+
+        # Shove the necessary entries in the trailer and enable encryption.
+        state.trailer[:Encrypt] = encryption_dictionary
+        state.encrypt = true
+        state.encryption_key = user_encryption_key
+      end
+
+      # Encrypts the given string under the given key, also requiring the object
+      # ID and generation number of the reference.
+      #
+      # See Algorithm 3.1.
+      #
+      # @param str [String]
+      # @param key [String]
+      # @param id [Integer]
+      # @param gen [Integer]
+      # @return [String]
+      def self.encrypt_string(str, key, id, gen)
+        # Convert ID and Gen number into little-endian truncated byte strings
+        id = [id].pack('V')[0, 3]
+        gen = [gen].pack('V')[0, 2]
+        extended_key = "#{key}#{id}#{gen}"
+
+        # Compute the RC4 key from the extended key and perform the encryption
+        rc4_key = Digest::MD5.digest(extended_key)[0, 10]
+        Arcfour.new(rc4_key).encrypt(str)
+      end
+
+      private
+
+      # Provides the values for the trailer encryption dictionary.
+      def encryption_dictionary
+        {
+          Filter: :Standard, # default PDF security handler
+          V: 1, # "Algorithm 3.1", PDF reference 1.3
+          R: 2, # Revision 2 of the algorithm
+          O: PDF::Core::ByteString.new(owner_password_hash),
+          U: PDF::Core::ByteString.new(user_password_hash),
+          P: permissions_value,
+        }
+      end
+
+      # Flags in the permissions word, numbered as LSB = 1
+      PERMISSIONS_BITS = {
+        print_document: 3,
+        modify_contents: 4,
+        copy_contents: 5,
+        modify_annotations: 6,
+      }.freeze
+      private_constant :PERMISSIONS_BITS
+
+      FULL_PERMISSIONS = 0b1111_1111_1111_1111_1111_1111_1111_1111
+      private_constant :FULL_PERMISSIONS
+
+      def permissions=(perms = {})
+        @permissions ||= FULL_PERMISSIONS
+        perms.each do |key, value|
+          unless PERMISSIONS_BITS[key]
+            raise(
+              ArgumentError,
+              "Unknown permission :#{key}. Valid options: " +
+                PERMISSIONS_BITS.keys.map(&:inspect).join(', '),
+            )
+          end
+
+          # 0-based bit number, from LSB
+          bit_position = PERMISSIONS_BITS[key] - 1
+
+          if value # set bit
+            @permissions |= (1 << bit_position)
+          else # clear bit
+            @permissions &= ~(1 << bit_position)
+          end
+        end
+      end
+
+      def permissions_value
+        @permissions || FULL_PERMISSIONS
+      end
+
+      PASSWORD_PADDING =
+        '28BF4E5E4E758A4164004E56FFFA01082E2E00B6D0683E802F0CA9FE6453697A'
+          .scan(/../).map { |x| x.to_i(16) }.pack('c*')
+
+      # Pads or truncates a password to 32 bytes as per Alg 3.2.
+      def pad_password(password)
+        password = password[0, 32]
+        password + PASSWORD_PADDING[0, 32 - password.length]
+      end
+
+      def user_encryption_key
+        @user_encryption_key ||=
+          begin
+            md5 = Digest::MD5.new
+            md5 << pad_password(@user_password)
+            md5 << owner_password_hash
+            md5 << [permissions_value].pack('V')
+            md5.digest[0, 5]
+          end
+      end
+
+      # The O (owner) value in the encryption dictionary. Algorithm 3.3.
+      def owner_password_hash
+        @owner_password_hash ||=
+          begin
+            key = Digest::MD5.digest(pad_password(@owner_password))[0, 5]
+            Arcfour.new(key).encrypt(pad_password(@user_password))
+          end
+      end
+
+      # The U (user) value in the encryption dictionary. Algorithm 3.4.
+      def user_password_hash
+        Arcfour.new(user_encryption_key).encrypt(PASSWORD_PADDING)
+      end
+    end
+  end
+end
+
+# @private
+module PDF
+  module Core # rubocop: disable Style/Documentation
+    module_function
+
+    # Like pdf_object, but returns an encrypted result if required.
+    # For direct objects, requires the object identifier and generation number
+    # from the indirect object referencing obj.
+    #
+    # @private
+    def encrypted_pdf_object(obj, key, id, gen, in_content_stream = false)
+      case obj
+      when Array
+        array_content = obj.map { |e|
+          encrypted_pdf_object(e, key, id, gen, in_content_stream)
+        }.join(' ')
+        "[#{array_content}]"
+      when LiteralString
+        obj =
+          ByteString.new(
+            Prawn::Document::Security.encrypt_string(obj, key, id, gen),
+          ).gsub(/[\\\r()]/, STRING_ESCAPE_MAP)
+        "(#{obj})"
+      when Time
+        obj = "#{obj.strftime('D:%Y%m%d%H%M%S%z').chop.chop}'00'"
+        obj =
+          ByteString.new(
+            Prawn::Document::Security.encrypt_string(obj, key, id, gen),
+          ).gsub(/[\\\r()]/, STRING_ESCAPE_MAP)
+        "(#{obj})"
+      when String
+        pdf_object(
+          ByteString.new(
+            Prawn::Document::Security.encrypt_string(obj, key, id, gen),
+          ),
+          in_content_stream,
+        )
+      when ::Hash
+        hash_content = obj.map { |k, v|
+          unless k.is_a?(String) || k.is_a?(Symbol)
+            raise PDF::Core::Errors::FailedObjectConversion,
+              'A PDF Dictionary must be keyed by names'
+          end
+          "#{pdf_object(k.to_sym, in_content_stream)} #{encrypted_pdf_object(v, key, id, gen, in_content_stream)}\n"
+        }.join('')
+        "<< #{hash_content}>>"
+      when NameTree::Value
+        "#{pdf_object(obj.name)} #{encrypted_pdf_object(obj.value, key, id, gen, in_content_stream)}"
+      when PDF::Core::OutlineRoot, PDF::Core::OutlineItem
+        encrypted_pdf_object(obj.to_hash, key, id, gen, in_content_stream)
+      else # delegate back to pdf_object
+        pdf_object(obj, in_content_stream)
+      end
+    end
+
+    # @private
+    class Stream
+      # Encrypt stream.
+      #
+      # @param key [String]
+      # @param id [Integer]
+      # @param gen [Integer]
+      # @return [String]
+      def encrypted_object(key, id, gen)
+        if filtered_stream
+          "stream\n#{
+            Prawn::Document::Security.encrypt_string(
+              filtered_stream, key, id, gen,
+            )
+          }\nendstream\n"
+        else
+          ''
+        end
+      end
+    end
+
+    # @private
+    class Reference
+      # Returns the object definition for the object this references, keyed from
+      # `key`.
+      #
+      # @param key [String]
+      # @return [String]
+      def encrypted_object(key)
+        @on_encode&.call(self)
+
+        output = +"#{@identifier} #{gen} obj\n"
+        if @stream.empty?
+          output <<
+            PDF::Core.encrypted_pdf_object(data, key, @identifier, gen) << "\n"
+        else
+          output << PDF::Core.encrypted_pdf_object(
+            data.merge(@stream.data), key, @identifier, gen,
+          ) << "\n" <<
+            @stream.encrypted_object(key, @identifier, gen)
+        end
+
+        output << "endobj\n"
+      end
+    end
+  end
+end

data/prawn-2.5.0/lib/prawn/soft_mask.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Prawn
+  # This module is used to create arbitrary transparency in document. Using
+  # a soft mask allows creating more visually rich documents.
+  module SoftMask
+    # @group Stable API
+
+    # Apply soft mask.
+    #
+    # You must group soft mask and graphics it's applied to under
+    # `save_graphics_state` because soft mask is a part of graphic state in PDF.
+    #
+    # Note that soft mask is applied only to the following content in the
+    # graphic state. Anything that comes before `soft_mask` is drawn without
+    # mask.
+    #
+    # Conceptually, soft mask is an alpha channel. Luminosity of the drawing in
+    # the soft mask defines the transparency of the drawing the mask is applied
+    # to. 0.0 mask luminosity ("black") results in a fully opaque target image and
+    # 1.0 mask luminosity ("white") results in a fully transparent target image.
+    # Grey values result in some semi-transparent target image.
+    #
+    # Note: you can use color in mask drawings but it makes harder to reason
+    # about the resulting value of alpha channel as it requires an additional
+    # luminosity calculation. However, this also allows achieving some advanced
+    # artistic effects (e.g. full-color photos in masks to get an effect similar
+    # to double exposure).
+    #
+    # @example
+    #   pdf.save_graphics_state do
+    #     pdf.soft_mask do
+    #       pdf.fill_color "444444"
+    #       pdf.fill_polygon [0, 40], [60, 10], [120, 40], [60, 68]
+    #     end
+    #     pdf.fill_color '000000'
+    #     pdf.fill_rectangle [0, 50], 120, 68
+    #   end
+    #
+    # @yield Mask content.
+    # @return [void]
+    def soft_mask(&block)
+      renderer.min_version(1.4)
+
+      group_attrs = ref!(
+        Type: :Group,
+        S: :Transparency,
+        CS: :DeviceRGB,
+        I: false,
+        K: false,
+      )
+
+      group = ref!(
+        Type: :XObject,
+        Subtype: :Form,
+        BBox: state.page.dimensions,
+        Group: group_attrs,
+      )
+
+      state.page.stamp_stream(group, &block)
+
+      mask = ref!(
+        Type: :Mask,
+        S: :Luminosity,
+        G: group,
+      )
+
+      g_state = ref!(
+        Type: :ExtGState,
+        SMask: mask,
+
+        AIS: false,
+        BM: :Normal,
+        OP: false,
+        op: false,
+        OPM: 1,
+        SA: true,
+      )
+
+      registry_key = {
+        bbox: state.page.dimensions,
+        mask: [group.stream.filters.normalized, group.stream.filtered_stream],
+        page: state.page_count,
+      }.hash
+
+      if soft_mask_registry[registry_key]
+        renderer.add_content("/#{soft_mask_registry[registry_key]} gs")
+      else
+        masks = page.resources[:ExtGState] ||= {}
+        id = masks.empty? ? 'GS1' : masks.keys.max.succ
+        masks[id] = g_state
+
+        soft_mask_registry[registry_key] = id
+
+        renderer.add_content("/#{id} gs")
+      end
+    end
+
+    private
+
+    def soft_mask_registry
+      @soft_mask_registry ||= {}
+    end
+  end
+end

data/prawn-2.5.0/lib/prawn/stamp.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Prawn
+  # This module is used to create content that will be included multiple times
+  # in a document. Using a stamp has three advantages over creating content anew
+  # each time it is placed on the page:
+  # * Faster document creation.
+  # * Smaller final document.
+  # * Faster display on subsequent displays of the repeated element because the
+  #   viewer application can cache the rendered results.
+  #
+  # @example
+  #   pdf.create_stamp("my_stamp") {
+  #     pdf.fill_circle([10, 15], 5)
+  #     pdf.draw_text("hello world", at: [20, 10])
+  #   }
+  #   pdf.stamp("my_stamp")
+  module Stamp
+    # @group Stable API
+
+    # Renders the stamp.
+    #
+    # @example
+    #   pdf.create_stamp("my_stamp") {
+    #     pdf.fill_circle([10, 15], 5)
+    #     pdf.text("hello world", at: [20, 10])
+    #   }
+    #   pdf.stamp("my_stamp")
+    #
+    # @param name [String]
+    # @return [void]
+    # @raise [Prawn::Errors::InvalidName] if name is empty.
+    # @raise [Prawn::Errors::UndefinedObjectName] if no stamp has been created
+    #   with this name.
+    def stamp(name)
+      dictionary_name, dictionary = stamp_dictionary(name)
+      renderer.add_content("/#{dictionary_name} Do")
+      update_annotation_references(dictionary.data[:Annots])
+      state.page.xobjects.merge!(dictionary_name => dictionary)
+    end
+
+    # Renders the stamp at a position offset from the initial coords at which
+    # the elements of the stamp was created.
+    #
+    # @example
+    #   pdf.create_stamp("circle") do
+    #     pdf.fill_circle([0, 0], 25)
+    #   end
+    #   # draws a circle at 100, 100
+    #   pdf.stamp_at("circle", [100, 100])
+    #
+    # @param name [String]
+    # @param point [Array(Number, Number)]
+    # @return [void]
+    # @see [stamp] for exceptions that might be raised.
+    def stamp_at(name, point)
+      translate(point[0], point[1]) { stamp(name) }
+    end
+
+    # Creates a re-usable stamp.
+    #
+    # @example
+    #   pdf.create_stamp("my_stamp") {
+    #     pdf.fill_circle([10, 15], 5)
+    #     pdf.draw_text("hello world", at: [20, 10])
+    #   }
+    #
+    # @param name [String] Stamp name.
+    # @yield Stamp content.
+    # @return [void]
+    # @raise [Prawn::Errors::NameTaken]
+    #   if a stamp already exists in this document with this name.
+    # @raise [Prawn::Errors::InvalidName] if name is empty.
+    def create_stamp(name, &block)
+      dictionary = create_stamp_dictionary(name)
+
+      state.page.stamp_stream(dictionary, &block)
+    end
+
+    private
+
+    def stamp_dictionary_registry
+      @stamp_dictionary_registry ||= {}
+    end
+
+    def next_stamp_dictionary_id
+      stamp_dictionary_registry.length + 1
+    end
+
+    def stamp_dictionary(name)
+      raise Prawn::Errors::InvalidName if name.empty?
+      if stamp_dictionary_registry[name].nil?
+        raise Prawn::Errors::UndefinedObjectName
+      end
+
+      dict = stamp_dictionary_registry[name]
+
+      dictionary_name = dict[:stamp_dictionary_name]
+      dictionary = dict[:stamp_dictionary]
+      [dictionary_name, dictionary]
+    end
+
+    def create_stamp_dictionary(name)
+      raise Prawn::Errors::InvalidName if name.empty?
+      raise Prawn::Errors::NameTaken unless stamp_dictionary_registry[name].nil?
+
+      # BBox origin is the lower left margin of the page, so we need
+      # it to be the full dimension of the page, or else things that
+      # should appear near the top or right margin are invisible
+      dictionary = ref!(
+        Type: :XObject,
+        Subtype: :Form,
+        BBox: [
+          0, 0,
+          state.page.dimensions[2], state.page.dimensions[3],
+        ],
+      )
+
+      dictionary_name = "Stamp#{next_stamp_dictionary_id}"
+
+      stamp_dictionary_registry[name] = {
+        stamp_dictionary_name: dictionary_name,
+        stamp_dictionary: dictionary,
+      }
+      dictionary
+    end
+
+    # Referencing annotations from a stamp XObject doesn't result
+    # in a working link. Instead, the references must be appended
+    # to the /Annot dictionary of the object that contains the
+    # call to the stamp object.
+    def update_annotation_references(annots)
+      if annots&.any?
+        state.page.dictionary.data[:Annots] ||= []
+        state.page.dictionary.data[:Annots] |= annots
+      end
+    end
+
+    def freeze_stamp_graphics
+      update_colors
+      write_line_width
+      write_stroke_cap_style
+      write_stroke_join_style
+      write_stroke_dash
+    end
+  end
+end