SU vs TERMINAL

Sun, 3 Aug 2008 21:34:55 -0600

There are questions raised on the Internet that never get a straight answer. One of them is: "How can I get around this error? : su: must be run from a terminal.” This question triggers 2500 hits in Google and I’ve yet to find one straight answer. The question is an orphan.

Now to be fair, those that shun it do so for good reasons: there are serious security concerns when su is called from a non-terminal, like from a file or pipe. When the input isn’t a tty, then the root password persists outside the security environment of the root login. The su programmers are trying hard to discourage this, but as I’ll argue later, there are good reasons to allow su from non-terminals.

Speaking of terminals, some implementations of su complain differently: “su: standard in must be a tty”. In either case the point is the same.

Here is what I mean by being an orphan question. Notice how all the responses avoid giving a direct answer? Its certainly not because a direct answer doesn’t exist. My criteria for being an orphan question is “does Experts-Exchange.com offer to answer it for $.” If they do, you can be sure there is a lot of confusion amongst the free postings. In this case the answer is yes (on Experts-Exchange.com) and the confusion resides there as well since the right answer isn’t there either.

• http://forums.fedoraforum.org/showthread.php?t=178464
• http://www.experts-exchange.com/Programming/Languages/CPP/Q_21104620.html

Now in the case of su vs terminal, there are five typical non-answers. Here is they are:

I have made a script with the su command:  echo -ne "password\n"|su - root  But it complains:  su : must be run from a terminal  Help!
Reply1> Works for me - OSX user
Reply2> I have the same problem - redhat, debian, vmware esx user
Reply3> Using su from a script is unsafe, use sudo
Reply4> Using su from a script is unsafe, use cron
Reply5> Using su from a script is unsafe, use a setuid program

First, I have to scope the problem. I'm going to answer a common variation:
. "I want to manage a machine using an ssh script, but I can't because it needs to be root and 'su: must be run from a terminal"

This appears often because, as a best practice, direct login using ssh is disabled for root. This is even a Vmware guideline.
. The usual solution for an interactive user is to login using ssh to account fred, then su -.
. But if you try this from a script, say on Debian, it won't work: echo password | ssh -l fred 'su -'

So inevitable the poor soul will post a question to some forum and get one of these run-around answers:
. Works for me - OSX user
. I have the same problem - Debian, Redhat, Solaris, HP/UX
. Don't do that, its unsafe. Use sudo!
. Don't do that, its unsafe. Use cron.
. Don't do that, its unsafe. Use a setuid program.

The first two answers show the inconsistency of su between *nix implementations. Usually a machine running a packaging of Linux will generate the su error. Not all other Unix variations will. OSX will accept the su just fine over a terminal.
. XXX I need to try Solaris
. XXX AIX
. XXX HP/UX

So, what exactly is the problem?
. The problem is that Linux su is performing a safety check that the root password is originating from a user instead of a script.
. If a script were accepted, that means the root password is persistently stored in a lower security ring than root, which is a problem.

How about those solutions?
. Obviously the first two aren't helping; we can't all be running OSX.
. The next two answers are textbook. Unfortunately, they don't really solve the problem the user is having. Oh yes, they do solve the problem of loggin in using ssh and su'ing on an a _recurring_ basis, but the user here is often trying to set the configuration. Sometimes the user is setting the configuration of sudo itself. Obviously depending on an existing sudo config to create the sudo config is circular. This is why this question shows up in Experts Exchange.
. Actually, the final answer, use a setuid program highlights the situation nicely. How did the setuid program get there and get configured in the first place? Recall that sudo and cron are setuid programs that require configuration.

So all the solutions are wanting. Now what?
. Well, I'm not going to make you wait any longer:
echo password | ssh -t -t -l username 'su -'
. If that's all you wanted to know, you can skip my explanation that follows.

To understand why this works, I need to explain something about ssh.
. Ssh is a client program that connects to a server program called sshd on *nix.
. When you ssh to a remote host, ssh runs on your client and sshd runs on the remote - the host to which you are shelling.
. Invoking ssh -c 'su -' results in ssh running on your client, sshd on the remote, and su as a subprocess of sshd.
. The ssh reads characters from its standard input, send them to sshd through an encrypted tunnel, and sshd forwards them to su through a pipe.
. Of course, what su is reading is a password and some commands.

Try these examples:
echo password | ssh -t -t -l username 'ps'
. Here you can see that in addition to ps running, sshd is also and is the parent of ps.

Now the pipe from sshd to whatever command is running remotely is not a terminal. You can test this using the tty program.
. Try running tty at your local host. It should return something like this:

. Now try this:
echo password | ssh -c tty
echo password | ssh -t -c tty
echo password | ssh -t -t -c tty
. Here the tty was run at the remote. Here you can see that in the first two cases tty was able to detect that the pipe was not a terminal.
. But look at the third case, the double -t fooled sshd. What is going on?

Figure 1 ..

Ssh commands (using -t) the remote sshd to establish a 'pseudo-terminal' pipe to the worker process when -t is given.
. ssh does this as long as its stdin is a terminal.
. But if ssh's stdin is a non-terminal, ssh won't direct sshd to establish a pseudo-terminal unless TWO -t's are given:
echo password | ssh -t -t -l username remote_host
. So with -t -t (from ssh) sshd sets up a pseudo-terminal to the client process.
. The client, whether it be 'tty' or 'su' cannot tell it is connected to a ficticious terminal:
echo dummystr | ssh -t -t -l username host.com -c ''tty'
echo password | ssh -t -t -l username host.com -c 'su -'

So there is the answer. Use double -t if you are 'su root'ing' on a linux box through an interactive client ssh like the one from OpenBSD.
One more time, here are some examples:
. echo password | ssh -t -t -l username -c 'su -'
. echo password | ssh -t -t -l username -c 'su - \; id'
. (echo password, cat file.sh) | ssh -t -t -l username

And hopefully that answers one question that was sorely needing a direct answer.

Correlation Graphs

Thu, 27 Dec 2007 22:05:13 -0700

Download CorrelationGraph.nb

In a previous posting titled Visual Solution Search, I described how to use domain coloring to scan for a solution to a system of equations or formulas. Essential to that technique was the coloring of the domain of a multidimensional function as a two dimensional plane. Since the goal was to discern solutions, the coloring worked by finding the best value of all the N dimensional points sharing each 2-D component and coloring the 2-D point the respective color. Here best means the value closest to the solution using an arbitrary metric.

But into which two dimensions should the domain be projected?

Into all of them.

A correlation graph is a graphical device that places every possible 2-D view of a multidimensional object side-by-side organized in a matrix. In fact, another name for a correlation graph is a correlation matrix.

Given a domain (x,y,z,t) there is one row and one column labelled each of x,y,z,t. At position (y,t) for example, appears the domain coloring of the multidimensional function projected into the (y,t)-plane. For a ten variable function, the matrix will be a 10 x 10 grid. The graphs on the diagonal is always empty as there is no point in plotting any variable y against itself.

We can use a correlation graph to visually search for system solutions. Take the system’s domain as the multidimensional object. The set of all 2-D projections comprise the views.

For example, reconsider this 4-D system:

Glimpsing Hammurabi’s Code (When Programs phone home)

Wed, 28 Nov 2007 06:53:19 -0700

By now, many of us are aware that our programs are sending unauthorized information back to the software manufacturer via the Internet. What is surprising is how pervasive this problem is becoming and how even legitimate software manufacturers are collecting personal information that they are neither validating, authenticating, or protecting against theft into perpetuity.

What exactly are programs saying when they phone home? Here is one way to find out if you use Mac OS X. You will need a free tool called Little Snitch along with a quick command line that invokes tcpdump.

Little Snitch is an Mac OS X program that tattles every time a program attempts a covert network connection. Snitch blocks the connection and gives you the opportunity to approve or disapprove the process. You can see which program is phoning ‘home’ and where it is calling. Unfortunately, Little Snitch doesn’t show you what the program is trying to say. For that you will need tcpdump.

While Little Snitch is waiting for you to approve the covert network connection, the subject program is waiting and unaware that the delay is being caused by Little Snitch asking for your approval verses vanilla network latency. This time gives you the opportunity to take some action: start a tcpdump.

Tcpdump is a command line program that prints network packets. It has options for filtering packets by source and destination, as well as providing hex and ASCII dumps, and other options. When Little Snitch suspends a program, it gives you just enough information to target an instance of tcpdump against the particular network connection.

Here is an example tcpdump command you can use:

sudo tcpdump -s 1024 -i en1 -t -X port 80

I’m going to leave it to you to read the tcpdump man page to explain the command line switches. The point is that you invoke tcpdump after the Little Snitch warning, but before you ‘Allow’ the network connection. Use the ‘port’ in the Little Snitch warning dialog to filter the tcpdump as done above - you can also filter by the host.

Now for an example of what you will see. This was captured from the network while I was reading some Mathematica documentation. The packet was sending my IP address, license, and mathid to Wolfram.com (Mathematica’s vendor) as well as what I was reading and a bonus timestamp. (I have anonimized these identifiers in the dump below). Take note that I wasn’t asking for any service from Wolfram.com and all this was happening quietly in the background.

Worse, there is no way for Wolfram to authenticate or validate this information. Anyone can be submitting these requests using my license.

These datagrams have probably been taking place for some time and by now Wolfram is aware that I’m a closet Homeomorphologist.

$ sudo tcpdump -s 1024 -t -X -i en1

IP 123.45.67.890.23456 > search.wolfram.com.http: P 1:193(192) ack 1 win 12345 <nop,nop,timestamp 91234567 123456789>
...
0x0030: 0ba6 aec9 4745 5420 2f6c 7563 656e 652f ....GET./lucene/
0x0040: 6e75 6d62 6572 6f66 6869 7473 2e6a 7370 numberofhits.jsp
0x0050: 3f71 7565 7279 3d48 6f6d 656f 6d6f 7068 ?query=Homeomorp
0x0060: 6f6c 6f67 7974 2663 6f6c 6c65 6374 696f hology&collectio
0x0070: 6e3d 7472 796f 6e61 6c6c 266d 6174 6869 n=tryonall&mathi
0x0080: 643d 3131 3131 2d32 3232 3232 2d33 3333 d=1111-22222-333
0x0090: 3434 266c 6963 656e 7365 3d4c 3131 3131 44&license=L1111
0x00a0: 2d32 3232 3220 4854 5450 2f31 2e31 0d0a -2222.HTTP/1.1..
0x00b0: 5573 6572 2d61 6765 6e74 3a20 4d61 7468 User-agent:.Math
0x00c0: 656d 6174 6963 612f 362e 302e 3120 504d ematica/6.0.1.PM
0x00d0: 2f31 2e30 2e32 0d0a 486f 7374 3a20 7365 /1.0.2..Host:.se
0x00e0: 6172 6368 2e77 6f6c 6672 616d 2e63 6f6d arch.wolfram.com
0x00f0: 0d0a 0d0a ....

Greg Frascadore @ Serranos, Monument CO, Nov 2007. Updated Dec 2007.

Visual Solution Search

Sat, 20 Oct 2007 20:15:27 -0600

Download NetMethod.nb

Solving a system of equations is a common problem in game-theory and many other domains that use mathematical models. Computer mathematics systems like Maple and Mathematica can easily digest cryptic arrays of equations and put forth solutions or warnings of un-solvability, but I want to tell you about a visual way to detect a system solution.

What motivated me to write about this was solving a problem in game theory after remembering a description of how World War II British cryptographers searched for keys to the German Enigma cipher visually. The British used perforated Zygalski sheets. Briefly, the method superimposed a stack of sheets, each containing a set of holes aligned on a grid, and overlaid the sheets while shining a light behind the stack. This eliminates a large number of non-solutions and flags a solution when light can shine through an aligned aperture in every sheet.

This technique is called the Net Method. You can read more about Zygalski sheets and the Net Method at:

http://www.google.com/search?q=site:wikipedia.org+zygalski+perforated

My variation of the technique has a bias towards Mathematica, but it should be obvious how to apply the technique using Maple or other systems for doing mathematics by computer. I don’t consider it an anachronism to use a computer to enhance a technique developed prior to the Age of Information.

Background

A system of equations is a set of equations that share variables. A solution is a set of variable values that satisfy all the equations simultaneously. For this reason, a system of equations is sometimes called a set of simultaneous equations. Here is an a small homework example, we’ll solve some realistic ones shortly:

The general rule is that if we have N such equations in N unknown variables, then we can solve the system using substitution or matrix algebra - if the equations are linear and linearly independent. This is the old N equations in N unknowns rule.

Of course, real-life systems are often not so pretty. They may be quadratic instead of linear; there might be linearly dependent equations in the mix; the system might be over-determined; the system might be be an inequality instead of an equation. All of these difficulties are well-treated in the mathematics literature and I can’t improve upon them here. Instead, lets work on an oft-overlooked difficulty: solving simultaneous systems is boring, tedious, error-prone, work.

Contour Plotting

During World War II, British cryptographers at Bletchley Park were searching for keys to German Enigma-encoded messages. At its core, the problem was also a simultaneous system. It was also very big, tedious, full of noisy data, error-prone, and boring. The technique the British used to overcome these hurdles was invented by a Polish cryptographer Henryk Zygalski. The idea has general application.

The idea is this, create a domain map of each equation in a system of equations. Overlay the maps in a way that visually highlights a simultaneous solution.

To apply this technique, we define a metric that measures a result’s closeness to the solution, and assign colors to distances. The Bletchley Park ‘colors’ were simply transparent at a solution and black otherwise, however lets use a spectrum where solutions are colored black and brighter colors indicate distance - in other words a contour map where sea-level is our goal.

Now we interpret the domain values as coordinates of a point in a plane (or hyperplane if there are more than 2 domain variables), and color the domain point corresponding to the result’s distance from the solution. If a point in the domain maps to a solution, we color the point black. If it maps to a non-solution, we use the spectrum color proportional to the distance from the solution. In a system having two equations and two unknowns, there will be two 2-dimensional maps: one map per equation, one dimension per unknown. Here again is our homework example and its two maps:

Now a key step: we overlay the maps and use the maximum (lighter) color wherever different colors overlap. This means black occurs in the overlay only in the vicinity of a solution. The overlay of the above two maps produces this bat-like image:

Higher Dimensions
There is another detail that needs explaining: what happens if the system has more than two variables? Such a system’s domain cannot immediately be drawn as a two dimensional map.

The answer is to realize that since a system’s solution occurs at simultaneous minima, we can flatten any N-dimensional domain into two dimensions by maximizing.

Realistic Example
Here is an real application. Suppose we are seeking the solution of the following system of four equations in four unknowns. This problem was posted to USENET (from http://tolstoy.newcastle.edu.au/R/help/04/11/7134.html):

So we proceed as follows:
- Assign colors to the measures that vary from black as the values stray further from solution
- Flatten each domain into a plane by picking the maximum result from all those that project into the same plane point
- Overlay the domain planes by picking the minimum color from all those that project into the same final-plane point
- Color the resulting plane as a contour map to visualize the vicinity of solutions

Here is the result of flatting the four dimensional domain (λ, σ, δ, τ) into the plane (λ, σ) and then overlaying the four planes:

Here are two examples. The first is contrived to demonstrate several concepts. The second is an actual equation in game-theory.

Contrived Example

Suppose we wish to find solutions to this in the domain x: [0..1], y:(0..16], z:[0..32], t:[-4..4]. The resulting 2D contour plot is:

Conclusion

We can discern the solution to a system of equations or inequalities before solving for the solution. Although the technique works by displaying 2-dimensional contour plots, it works even with systems having an unlimited number of independent variables (dimensions). It even works with non-square systems that are possibly over- or under-determined.

The idea is to assign a visual marker (like a color) to solutions within the system’s large domain, and then reduce or flatten the domain while retaining the markers. If any solution marks appear anywhere in the result, the system is solvable.

Techniques like this one, that paint domains and track colors through to solutions, were successfully used in World War II to decrypt Nazi messages, and that was the inspiration for this entry.

Greg Frascadore, Serranos, August 2006. Updated Dec 2007.

Preimages: A Domain Coloring Intermezzo

Sat, 20 Oct 2007 11:53:45 -0600

Before proceeding with the domain coloring project, we need a way of painting a function’s range with an image in Mathematica. This will allow us to place a grid or other scale into the range and examine its appearance when viewed through the lens of the function.

Generating a grid and saving it to a file as an image turns out to be pretty easy. Basically we just draw some lines into a grid, generate a Graphics object, and then Export it to a PNG file called “grid.png”. I’m using PNG instead of GIF because the elements of PNG are RGB color values that are compatible with the RGB values of domain coloring.

gridGraphics[color_: LightGray] :=  Module[{i},  Graphics[{color, Thick,  Table[Line[{{i,0}, {i,9}}], {i,0,9}],  Table[Line[{{0,i}, {9,i}}], {i,0,9}]  }]]

gr = gridGraphics[LightGray];  Show[gr, ImageSize -> 100];  Export["grid.png", gr, "PNG"] gr = Import["grid.png", "PNG"];   gr1 = grColorFunc[gr, 0, 150]  Show@CodedDensity[{#^2 &}, {0, 15},
{gr1}, {},
{ImageSize -> 200, PlotPoints -> 250}]

There are two important concepts here. First, any Graphics object created by Mathematica can be painted onto the range of a function and then viewed through the lens of the function. Second, any image (well, at least any PNG) that can be imported can also be viewed through a function. Both of these concepts are demonstrated in the next two images. Here are views of the grid above, and my favorite 8thman, seen through the function w2 defined in “Domain Coloring II”.

gr = Import["grid.png", "PNG"];   gr1 = grColorFunc[gr, 0, 150] 
Show@CodedDensity[{w2[#] &}, {-1, 4},
{gr1}, {}, {ImageSize -> 200,   PlotPoints -> 250}] gr = Import["8thman.png", "PNG"];   gr1 = grColorFunc[gr, 0, 150] 
Show@CodedDensity[{w2[#] &}, {-1, 4},
{gr1}, {}, {ImageSize -> 200,   PlotPoints -> 250}]

Sylvester’s Determinant Identity

Sat, 20 Oct 2007 11:51:53 -0600

Sylvester was a 19th century mathematician and poet, a collaborator of Cayley, DeMorgan, and Chebyshev, he advanced the fields of matrix theory and algebraic equations, and founded the American Journal of Mathematics. In 1851 he published, in his words, “a remarkable theorem” showing the relation between determinants and submatrices. There are at least 7 published proofs of the theorem. However, Sylvester himself stated his identity without proof, and maybe because of that, the equation has historically been regarded as merely a notable curiosity of the Theory of Determinants. In 2005, I accidentally noticed a form of the identity using an elegant sub-matrix notation. On its face, this redux of Sylvester’s discovery bares a striking resemblance to the ε-δ identity studied in Tensors. In the belief that the similarity is not accidental, I set out to prove that Sylvester’s theorem could be developed (one more time) using the methods of Tensors.

Domain Coloring III

Sat, 20 Oct 2007 11:36:04 -0600

Lundmark used eight techniques to paint the range in his domain coloring paper. In this series of posts I’ll try to reproduce his results using Mathematica’s Cardano3 package.

In part 1, I described Lundmark’s steps for painting the range. In part II I was able to apply the first 5 techniques using Mathematica’s Cardano 3 package and generated some results that were similar, but still inferior to Lundmark’s results. In this final post on domain coloring, I’ll apply the last three techniques:

a. Shadowing
b. A grid or other reference background
c. * High resolution

Flagged * techniques were not explicitly stated by Lundmark.

To recap where things are at, compare the following two pair of images. I generated the left-side images using Mathematica’s Cardano3 package while applying techniques a through e. The right-sides are image captures from Lundmark’s paper. Obviously he is still doing things better.

(a) (b) (c) (d)

Technique F: Shadowing

Upon close inspection of images c and d you can make out an important difference. The color gradient of (d) depends on both angle and magnitude, while the gradient of (c) is varying only with the angle. You can discern this by drawing an imaginary straight line from the center of (d) towards 4’o-clock position and tracking the colors along the line; moving outwards from the center, the colors alternate yellow, red, yellow, red, etc, depending on the distance from the origin. In contrast, the same line in (c) is alternating yellow, grey, yellow, etc. The grey being the intensity of black appropriate for the angle.

Time for another refinement.
absColorMix[color1_, color2_, z_] :=
ColorMix[color1, color2][Max[qArg@z, Abs@FractionalPart@Log[2, 1 + Abs@z]]]

argColorMix[color1_, color2_, z_] :=
ColorMix[color1, color2][qArg@z]

zColorMix[color1_, color2_] :=
Function[argColorMix[color1, absColorMix[color1, color2, #], #]]

Show@GraphicsArray@(CodedDensity[{#}, {0, 3}, {blackRedYellow}, {}, \
{PlotPoints -> 400}] & /@ {w1, w2})
(e) (f)

Above, a new version of zColorMix uses absColorMix and argColorMix. Notice how the Arg angle plays a role in both, especially in absColorMix.

Now I am close. Images (e) and (f) are looking very much (b) and (d). Still missing is that background grid especially visible in (b). I’ll pick up there in Domain Coloring IV.

Domain Coloring II

Sat, 20 Oct 2007 11:32:23 -0600

Lundmark used eight techniques to paint the range in his domain coloring paper. In this entry I’ll try to accomplish them using Mathematica’s Cardano3 package.

In part 1, I described Lundmark’s steps for painting the range. For easy reference, here they are again ordered as I use them:

a. A angular color gradient
b. * Linear meld rate
c. Smooth color transition, with discontinuity at 2π
d. * Three colors: black, red, yellow
e. Logarithmic radius lines for scale
f. Shadowing
g. A grid or other reference background
h. * High resolution

Flagged * techniques were not explicitly stated by Lundmark.

As demonstration of the effectiveness of these techniques, compare the left and right sides of a plot of z and (z+2)²(z-w-2i)(z+i). I generated the left images with Cardano3 using Lundmark’s colors, but without his technique. The right sides are screen captures from Lundmark’s paper. In the remainder of this essay, you can distinguish Cardano3 images by their distinct and distracting center cross-hairs, which I wasn’t motivated to fix.

Techniques A through C

The first three techniques are easy to accomplish with Cardano3. In fact, I already used them in the left sides of the above images. You simply define a color function using Mathematica’s ColorMix and Arg functions. ColorMix uses a linear-meld rate already. A point I mention because I’ll adjust it later. The xArg simply rescale’s Mathematica’s Arg to yield results in the range [0..2π].

w1[z_]:=z
w2[z_]:= ((z + 2)^2*(z - 1 - 2*I)*(z + I))
xArg[z_]:= Arg[ -z]+\[Pi]

redYellow[z_]:=
ColorMix[ Red,Yellow][ xArg@z/ ( 2π+$MachineEpsilon)]

Show@GraphicsArray@(
CodedDensity[{#},{0,3},
{redYellow},{},{PlotPoints->300}]&/@ {w1,w2})

Technique D: Three Colors

Technique d takes a little more effort. ColorMix will only scale between two colors, so you need to define a more generalized color mixing function to replace ColorMix. qArg simply maps [0..2π] into [0..1]. zArgRescale works like Mathematica’s Rescale upon a complex number’s angle, leaving the magnitude intact.

qArg[z_]:= xArg[z]/(2π+$MachineEpsilon)

zColorMix[ color1_,color2_]:=
Function[ z, ColorMix[ color1,color2]@ qArg@z]

zArgRescale[ z_, { argLo_,argHi_}]:=
Abs@z E^(((xArg[z] - argLo)/(argHi - argLo))*2*π*I)

zRainbow[cs__]:=
zMixColors[ Length[ {cs}]-1, Sequence@@ Partition[ {cs},2,1]]

zMixColors[ 1,pair1_List]:=
Function[ z, ( zColorMix@@pair1)[z]]

zMixColors[ n_Integer, pair1_,pn__]:=
Function[ z, Which[
xArg@z< 2π/n, (zColorMix@@pair1)[ zArgRescale[ z, { 0, 2 \[Pi]/n}]],
xArg@z>= 2π/n, zMixColors[ n-1,pn][ zArgRescale[ z, { 2π/n, 2\[Pi]}]] ]]

blackRedYellow[z_]:= zRainbow[ Black,Red,Yellow][z]

Show@ GraphicsArray@
( CodedDensity[ {#}, { 0,3},
{blackRedYellow}, {}, { PlotPoints->300}]& /@ { w1,w2})

Technique E: Logarithmic Scale

Now for the logarithmic scale. Lundmark generates the scale as grey levels ranging from black to white as the fractional part of Log₂|w| varies from 0 to 1. There are two difficulties. First, image masks aren’t used in Cardano3; the scale must be integrated into the color function. This is done below to generate the left image, but as you can see it still isn’t quite right. The result seems to be a negative of the right image towards the center, while the periphery is correct. There is a black halo and the shading on the left radiates from white-to-black inside the halo, and black-to-white outside.Notice the black halo and how the shading radiates white-to-black inside the halo, and black-to-white outside.

logBlackWhite[z_] :=
ColorMix[Black, White][
Abs@FractionalPart@Log[2, Abs@z]]

Show@GraphicsArray@(
CodedDensity[{#}, {0, 2},
{logBlackWhite}, {}, {PlotPoints -> 400}] & /@ {w1})

The problem is that Log₂|w| undergoes a sign change at |w| = 1. The solution is to prescale w so its values are >= 1. This is done below by adding 1 in the term Log[2, 1+Abs@z] below.

logBlackWhite[z_] :=
ColorMix[Black, White][
Abs@FractionalPart@Log[2, 1+Abs@z]]

Show@GraphicsArray@(
CodedDensity[{#}, {0,512},
{logBlackWhite}, {}, {PlotPoints -> 400}] & /@ {w1})

Now for the results. Here are the pre-images of w1 and w2 over the domain (±2 ± 2ℹ).

absMask[blackColor_, whiteColor_, z_] :=
ColorMix[blackColor, whiteColor][Abs@FractionalPart@Log[2, 1 + Abs@z]]

argMask[blackColor_, whiteColor_, z_] :=
ColorMix[blackColor, whiteColor][qArg@z]

logBlackWhite[z_] :=
absMask[argMask[Black, White, z], White, z]

Show@GraphicsArray@(CodedDensity[{#}, {0, 2}, {logBlackWhite}, {}, \
{PlotPoints -> 400}] & /@ {w1, w2})

Finally, combining techniques A through E (angular gradient, linear meld rate, smooth transition, three colors, and logarithmic scale) results in:
logBlackRedYel[z_] :=
absMask[argMask[Black, #1, z], #1, z]&@blackRedYellow[z]

Show@GraphicsArray@(CodedDensity[{#}, {0, 2},
{logBlackRedYel}, {}, {PlotPoints -> 400}] & /@ {w1, w2})

This is looking much better, but obviously short of Lundmark’s results. Things will improve in Domain Coloring III.

Greg Frascadore @ Pike’s Perk, Colorado Springs CO, Jun 2006. Updated Mar 2007.

Domain Coloring

Fri, 19 Oct 2007 22:01:19 -0600

Domain coloring helps you visualize how a function behaves. With a little tuning, Mathematica’s Cardano3 package can paint images nearly as beautiful as those in Lundmark’s 2005 paper.

The process of domain coloring was named by Frank Farris and applied by Lundmark2005 to complex functions. There is a Mathematica package, Cardano3, that creates domain-colored images. Unfortunately, the images rendered by Cardano3 don’t come close to the beauty of Lundmark’s when applied to the same functions.

Here is a function colored by Cardano3 side-by-side with a rendering of the same function in Lundmark’s paper.

Pathetic. Obviously Lundmark gets much better results. Herein I’ll describe how to tune Cardano3 to use Lundmark’s technique.

Background

Cardano3 is a Mathematica package for creating graphical representations of complex functions. For domain coloring, you are only concerned with the function CodeDensity: a density plot using a color function to encode information. There is one supplied color function and a generic template from which other color schemes can be created. Here are some colorings using the distributed version of CodeDensity:

Well those look nice. Cardano3 seems to have the potential to create rich images.

Lundmark didn’t invent domain coloring, but he describes the process as follows:

1. “Paint” the range plane, either by copying a picture of something onto it, or by using some formula to color each point.
2. Color every point z in the domain of f with the color of the corresponding point f(z).

Lundmark then tuned the process for complex functions by refining the ways to paint the range. In particular, he describes these techniques:

a. A angular color gradient
b. Smooth color transition, but discontinuous at 2π
c. Logarithmic radius lines for scale
d. A grid or other reference background

Contrast the default Cardano3 range with Lundmark’s results on coloring (z)

Lundmark is getting much prettier results. There are several other things he is doing that he did not emphasize:

e. Shadowing effects
f. High resolution
g. non-linear meld rate

I’ve run out of time. I’ll pick things up in my next blog entry.

Greg Frascadore, Serranos Coffee, Monument CO, Jun 2006

Code Breakout

Mon, 1 Oct 2007 22:48:36 -0600

The Mathematica programming language pre-dates language-based security. Mathematica has no controls that protect intellectual property the way distributing compiled (binary-only) code does for conventional programming languages. Of course, that doesn't stop folk from trying.

Here is a protection technique from mathematica-users.org and an demonstration of its weakness.

The Approach

“The basic idea is to include commands at the end of your package which set the attributes of your "secret" functions to be ReadProtected, and then Locked. The ReadProtected means no one can see the function definitions, and the Locked means no one can undo the ReadProtected attribute...encode the package file with the Encode routine. This encrypts the package file, such that it is no longer human readable, but because it is an ASCII text file it is more portable. ... The Needs or Get commands can read in the Encoded package file (possibly requiring a password, if you set one) and decrypt it, and once the package is in memory, the Locked and ReadProtect attributes now protect the secrets in your code.”

- http://www.mathematica-users.org/webMathematica/wiki/wiki.jsp?pageName=FAQ_Writing_Packages

The Weakness

The protection afforded by this technique will stop only a casual attack. The weakness is that the package is being loaded into a malicious host - a huge interpreted programming environment (Mathematica) with few security features on which the encoded package can depend. A dedicated attack can craft that environment to pull the ReadProtected assumptions right out from under the loading package.

As an example, here is a code fragment that cuts right through the above scheme. Execute this before loading a protected package.

Unprotect[SetAttributes]
SetAttributes[sym_, atts_List] :=
SetAttributes[sym,
DeleteCases[atts, (Locked |ReadProtected)]] /;
MemberQ[atts, (Locked | ReadProtected)]
Protect[SetAttributes]
(* Then load package here *)

This redefines SetAttributes so the package locks its functions in vain. Against the mathematica-users.org example, this allows the attacker to then recover the source code by

??demo`*

All too easy.

Enhancements

The previous code describes the main idea. One enhancement we should make is to intercept Set as well as SetAttributes:

(* copied and extended here from Defeat Readonly below *)
Unprotect[SetAttributes, Set, Attributes]

SetAttributes[sym_, att_Symbol] /; MemberQ[{Locked, ReadProtected}, att] := \
Null

SetAttributes[sym_,
atts_List] /; MemberQ[atts, (Locked |
ReadProtected)] := SetAttributes[sym, DeleteCases[atts, (Locked |
ReadProtected)]]

Attributes /: Set[Attributes[sym_], att_Symbol] /; MemberQ[{Locked,
ReadProtected}, att] := Null

Attributes /: Set[Attributes[sym_],
atts_List] /; MemberQ[
atts, (Locked | ReadProtected)] := SetAttributes[sym, DeleteCases[
atts, (Locked | ReadProtected)]]

Protect[SetAttributes, Set, Attributes]

Countermeasures

I don’t know of any way to protect Mathematica packages from prying eyes. The Malicious Host Problem has no good solution. At best, one only slow the intrusion. For this SetAttributes-attack, you might try detecting whether SetAttributes has been overloaded:

Through[{System`UpValues, System`DownValues}[System`SetAttributes]]

If this returns other than {{},{}}, then something is suspicious and you can take an action like aborting the remaining ‘secret’ definitions. Of course, this assumes that UpValues and DownValues are intact.

Greg Frascadore, Pikes Perk, Jun 2006