Luatex allows manipulating fonts in the define_font callback.
Luaotfload facilitates this even more with an extra hook it installs
right after the font loader has finished its job: the
luaotfload.patch_font callback.
Normally it is used for serious and constructive tasks like setting a
couple font dimensions or ensuring backward compatibility in the data
structures.
Of course, it can also be abused for dirty hacks like disabling copy
and paste.

At the point where the patch_font callback is applied, the font is
already defined and ready to use.
All necessary tables are created and put in a place where Luatex
expects them.
Among these is the characters table that holds preprocessed
information about the glyphs.
In the below code we modify the tounicode field of each glyph so
that it maps to some random location within the printable ASCII range.
Note that this does not affect the shape and metrics of the glyph since
those are unrelated to the actual codepoint.
As a consequence, the PDF will contain legible text that cannot be
copied.

Package file obfuscate.lua:

packagedata = packagedata or { }



local mathrandom    = math.random

local stringformat  = string.format



--- this is the callback by means of which we will obfuscate

--- the tounicode values so they map to random characters of

--- the printable ascii range (between 0x21 / 33 and 0x7e / 126)



local obfuscate = function (tfmdata, _specification)

  if not tfmdata or type (tfmdata) ~= "table" then

    return

  end



  local characters = tfmdata.characters

  if characters then

    for codepoint, char in next, characters do

      char.tounicode = stringformat ([[%0.4X]], mathrandom (0x21, 0x7e))

    end

  end

end



--- we also need some functions to toggle the callback activation so

--- we can obfuscate fonts selectively



local active = false



packagedata.obfuscate_begin = function ()

  if not active then

    luatexbase.add_to_callback ("luaotfload.patch_font", obfuscate,

                                "user.obfuscate_font", 1)

    active = true

  end

end



packagedata.obfuscate_end = function ()

  if active then

    luatexbase.remove_from_callback ("luaotfload.patch_font",

                                     "user.obfuscate_font")

    active = false

  end

end

Usage demonstration:

%% we will need these packages

input luatexbase.sty

input luaotfload.sty



%% for inspecting the pdf with an ordinary editor

pdfcompresslevel0

pdfobjcompresslevel0



%% load obfuscation code

RequireLuaModule {obfuscate}



%% convenience macro

def packagecmd #1{directlua {packagedata.#1}}



%% the obfuscate environment, mapping to Lua functions that enable and

%% disable tounicode obfuscation

def beginobfuscate {packagecmd {obfuscate_begin ()}}

def endobfuscate   {packagecmd {obfuscate_end   ()}}



%%···································································%%

%% Demo

%%···································································%%



%% firstly, load some fonts. within the “obfuscate” environment all

%% fonts will get their cmaps scrambled ...



beginobfuscate



  font mainfont   = "file:Iwona-Regular.otf:mode=base"

  font italicfont = "file:Iwona-Italic.otf:mode=base"



endobfuscate



%% ... while fonts defined outside will have the mapping intact



font boldfont       = "file:Iwona-Bold.otf:mode=base"

font bolditalicfont = "file:Iwona-BoldItalic.otf:mode=base"



%% now we can use them in our document like any ordinary font



mainfont

obfuscated text before {italicfont     obfuscated too} and after par

obfuscated text before {boldfont       not obfuscated} and after par

obfuscated text before {bolditalicfont not obfuscated} and after par



bye

Result in PDF viewer:

Contrast this with the output of pdftotext:

rf2yC'I_J I_dI r_f{_ 9;H`bp<<L& <99 '5J 'fI_{

rf2yC'I_J I_dI r_f{_ not obfuscated '5J 'fI_{

rf2yC'I_J I_dI r_f{_ not obfuscated '5J 'fI_{

But please forget about all this immediately and never obfuscate a
production text -- don’t be mean to your readers!

EDIT
Because the generous karma donor specifically asked for a Context
solution, I’ll throw that one in as a bonus.
It is a good deal more elegant since it relies on the font goodies
mechanism that allows applying postprocessors to specific fonts which
can afterwards be used just like common font features.

startluacode



local mathrandom    = math.random

local stringformat  = string.format



--- create a postprocessor



local obfuscate = function (tfmdata)

  fonts.goodies.registerpostprocessor (tfmdata, function (tfmdata)

    if not tfmdata or type (tfmdata) ~= "table" then

      return

    end



    local characters = tfmdata.characters

    if characters then

      for codepoint, char in next, characters do

        char.tounicode = stringformat ([[%0.4X]], mathrandom (0x21, 0x7e))

      end

    end

  end)

end



--- now register as a font feature



fonts.handlers.otf.features.register {

  name         = "obfuscate",

  description  = "treat the reader like a piece of garbage",

  default      = false,

  initializers = {

    base     = obfuscate,

    node     = obfuscate,

  }

}



stopluacode



%%···································································%%

%% demonstration

%%···································································%%



%% we can now treat the obfuscation postprocessor like any other

%% font feature



definefontfeature [obfuscate] [obfuscate=yes]



definefont [mainfont]   [file:Iwona-Regular.otf*obfuscate]

definefont [italicfont] [file:Iwona-Italic.otf*obfuscate]



definefont [boldfont]       [file:Iwona-Bold.otf]

definefont [bolditalicfont] [file:Iwona-BoldItalic.otf]





starttext



  mainfont

  obfuscated text before {italicfont     obfuscated too} and after par

  obfuscated text before {boldfont       not obfuscated} and after par

  obfuscated text before {bolditalicfont not obfuscated} and after par



stoptext

You can disable the copying of text with the help of PDF encryption. With it you can also disable other things like printing.

You need to use an external PDF tool like pdftk or of course the full version of Adobe Acrobat to encrypt the PDF.

Remarks

I use a little script, which converts all my fonts to paths. The script uses the first parameter as input of a .pdf-file and writes the output to a file with the same name and the extension-rst.pdf

You need Ghostscript for my script to run.

Implementation

Runs on bash

#!/bin/sh



GS=/usr/bin/gs



$GS -sDEVICE=pswrite        -dNOCACHE -sOutputFile=-        -q -dBATCH -dNOPAUSE "$1"       -c quit | ps2pdf - > "${1%%.*}-rst.pdf"

if [ $? -eq 0 ]; then

    echo "Output written to ${1%%.*}-rst.pdf"

else

    echo "There were errors. See the output."

fi

use ps2write (in stead of pswrite) these days as seen here.

Result

If content can be viewed, it can be copied.
No matter what encryption and restrictions are used, at some point the content must be put out in plain view in order for it to be of any use.
This is probably true of all digital content and most physical content larger than the nanoscale...

For example, a PDF:

• Rasterisation: Printscreen => OCR


• Any protection: Re-type it out


• Content protection: Modified build of an open-source reader

Web content:

• Right-click popup: Opera=>Prevent page receiving content menu events


• Right-click popup: "Menu" button on any modern keyboard


• Flash: Download the SWF file, decompile it using free software


• View page source, use Chrome/Opera/Firefox debugger to get URL of desired content

Audio (e.g. HDCP):

• Headphones socket on TV => line-in socket on PC


• Solder to tap into preamplifier => line-in socket on PC

Video (e.g. HDCP):

• Many, many options... A quick google search will show you.

Encrypted content on someone's laptop/pendrive:

• Digital brute force: brute-force cracking of the encryption key


• Physical brute force: http://imgs.xkcd.com/comics/security.png
  

The answer is: Yes.
There is a way described here: http://spivey.oriel.ox.ac.uk/corner/Obfuscated_PDF

But it looks tedious and doesn't use pdflatex. The method, however, is described as being portable to PDF. It involves changing glyphs of a font and other dirty things that get you bad dreams.

I didn't find a method described for directly PDF let alone something automated for pdflatex. I'll happily buy you a beverage of your choice if you implement it :-)

I am using gswin32 only make a pdf after change the format to ps:

"C:Program Files (x86)gsgs9.09bingswin32.exe" -sDEVICE=ps2write -r9000 

-dNOPAUSE -sOutputFile=OUTPUT.ps input_insecure.pdf

Now translate to pdf with secure mode 4 (only read and print):

"C:Program Files (x86)gsgs9.09bingswin32.exe" -sDEVICE=pdfwrite -r9000 

-dNOPAUSE -sPAPERSIZE=a4 -dPDFSETTINGS=/prepress -dMaxSubsetPct=100 

-dSubsetFonts=true -dEmbedAllFonts=true -sOwnerPassword=null -dEncryptionR=3 

-dKeyLength=40 -dPermissions=4 -sOutputFile=OUTPUT_secure.pdf output.ps

On a unix-based system, you can probably type gswin32 instead of "C:Program Files (x86)gsgs9.09bingswin32.exe".

Use XeTeX to at least get some "nonsense characters", see here and here.

Though this would obviously be just a nuisance for most cases/users (which can be avoided using LuaLaTeX instead), depending on what you are trying to achieve compiling with XeTeX may prove to add at least some value to your solution...

You can use ImageMagick to convert the pdf to an image pdf.
Running

convert file1.pdf file2.pdf

will create a pdf called file2.pdf which is about the same size as the input pdf but since its an image, the text cannot be selected. There is a notable decrease in quality though