Well, that being said, it sounds like there needs to be a more rigorous way of detecting these new codes.

One way I can think of, is to record data on the CMYK pins on the inkjet head itself. IIRC, they activate between 17v and 22v, and pulse per high.

The goal here is to make the printer think its printing, while recording all the data of the pulse operations. We would get a lengthy file out.

Ideally, the pulse coding should be consistent if printing the same image. "Printing" the same thing over multiple times could show time/date codes embedded.

I should also be able to compare underlying system internals too, with multiple clones of VMs with small config details different. They should be the same data. If they aren't, we know its encoding system stuffs.

But yeah, there is a way to attack this, and that's by going lower in the stack and treating the printers as a black box. It's not the best way, but a way I've thought of that could at least detect this new technique.

Examining printer firmware might also reveal the details more readily.

Probably. But my experiences are that these chips are fabless fab chips with half a dozen things on it. Reverse engineering is of course doable. But you're getting into ARM territory, with custom ARM licenses and different opcodes. It gets "unfun", and quickly. And ARM has no concept of probing for hardware, your best chance at a memorymap is whatever you build yourself, and not fry.

But I would imagine that a simple 3d printed harness would work a lot better with allowing signals to be recorded and make the printer think its printing. Then the bypass harness could have an ARM on it and spool instructions to either a SD card, or via USB serial.

The goal here is as transparent as possible, just in case there are other security systems that try to detect this attack. But I'd guess they havent got to that point yet.

Why make the printer "think" it's printing. Why not just literally measure and record the pulses sent to the actual print heads?

The "yellow dot" method would be picked up pretty quickly by the yellow being triggered while printing entirely B&W documents.

Things like dithering, if they encode things like printer serial numbers might be catchable by printing an identical set of documents across two examples of the printer.

> Why make the printer "think" it's printing. Why not just literally measure and record the pulses sent to the actual print heads?

That's what my shim would do, is record the signals to the ink solenoids. The reason to make the printer think its printing, is primarily because of all the DRM lockout crap all manufacturers use. Ideally, I'd even let it print so that when the firmware sees ink levels going down, nothing on the firmware side would look amiss.

> The "yellow dot" method would be picked up pretty quickly by the yellow being triggered while printing entirely B&W documents.

Indeed. However, its old hat about the yellow dots. I know they've moved on to something much harder to detect, and also likely scan and reprint resilient. What is this new type? No bloody clue. I'd assume a bad actor using heavy stego on chip. And if I were designing it, I'd watch for things like test images coming through and not mark them.

My first attempt would be with a high res 100$ bill scan. I betcha that'd trigger something interesting.

> Things like dithering, if they encode things like printer serial numbers might be catchable by printing an identical set of documents across two examples of the printer.

Yeah, I figure there's a serial number, time/date, hostname, IP, logged-in username.. All sorts of data. This is also corporate espionage area as well as national security, so I'd figure they would put out all the stops to catch, if they can't prevent the print itself.

Just chalk it up to me, and my paranoid mind. Still doesnt mean they arent out to get you!

Would filling all the color tanks with black ink before printing make initial detection easier?

I doubt it. There's tons of tricks and things that can be done to steganographically hide data in images. And given the algo is hidden, and the data is hidden in plain sight, we have to go to a level that can't be hidden from us.

Printing in different inks also wouldn't show us a way to diff 2 printed images. Whereas, saving the pulses from the CMYK pins would do that.

When you have a datalog of lots of pulses that represent a picture, you can back-calculate it into an image. You can also diff it without relying on losing data from scanning (or paying attention to the wrong thing). And with enough samples, we can recalculate the algorithm. With the knowledge of what they're doing, we can then start scanning other images for this... But only once we know what they're doing.

What about printing two images, each with only 1 black pixel in a different place?

What is annoying is that the user pays for this. How much more yellow toner do I need to buy because my print outs are covered in yellow dots?

I wonder how many million extra gallons of yellow toner and ink are wasted every year printing these tracker dots?

On some printers, this is the reason why the printer will refuse to print a BW-only printout while the only empty cartridge is the color one.

That needs a citation or a sarcasm tag.

Does an anecdote count? My Samsung refuses to print b&w when a color cartridge is empty.

Most likely it tries to print rich black, which uses color to make the b&w printout look better ( and use up all that costly color). You can disable that in your printer settings with most printers.

I heard that before, I think it's a tactic to bully people into buying more ink they don't need. Ensuring tracking dots is maybe just an unfortunate side effect.

I've always assumed that is just lazy design (some resources that _might_ be needed are unavailable, report and refuse to print withut checking if they are actually needed for the current job) rather than due to a security (or even ink selling) measure. I've seen the behaviour as far back as the first colour photocopier I ever used.

I've seen that as well a long time ago on a black+red photocopier, no yellow and probably no tracking patterns since red would have been quite visible.

No, the thing happening does not count as proof why it is happening. Printers refusing to print bw is widely known.

I would also be interested in a citation, but it does make sense; if tracking dots is well known (which they are), and it was easy to circumvent by just removing yellow toner, anyone somewhat technically adept would just remove their toner before printing their illegal documents.

This makes less sense than you might think because the original motivation from the government side was tracing counterfeit currency, not tracking all documents. Printing convincing counterfeit currency without yellow toner would be a challenge!

However, the governments did not succeed in limiting their technology to use in counterfeiting investigations, and may not even have attempted to do so.

If that's true that just makes me angrier because a far better solution would be to improve the currency, like Canada and many other countries did long ago.

I can feel my blood pressure rising...

Imagine the twist this put would on the whole Hanlon's razor thing if this were true.

No idea if this is the real reason, but it's still very annoying.

My previous printer did this, and my current Canon refuses to boot when any cartridge is missing or empty.

My Epson does this, and it's apparently because not having enough ink in the system leads to maintenance issues with heads drying out, etc. Which is understandable, but I wish there was like a 48-hour override so running out of a color didn't prevent me from printing the documents I urgently need RIGHT NOW. So instead, I have to purchase a couple hundred dollars worth of cartridges in advance.

I'm not so sure about that. Having had an inside view into one such program I can say confidently that at least in that particular major manufacturer's situation, that had absolutely nothing to do with it. It was entirely engineering-driven and about preserving the print head.

or so they said... Do you really know the ultimate reason why?

I do, yes. There were sound technical reasons for it.

That doesn't make much sense to me. B/W only (not greyscale) is currently understood to not output these dots at all, so why would the presence of yellow matter?

This is the first thing I thought of when I read about this. It made me quite angry and then a little satisfied finally knowing why this happens.

On the other hand, I didn't think of it until I read this. It made me a little satisfied, and then it made me quite angry.

I ought to be able to do better because I used to know more precisely how many dots per page are printed and how large they are.

But a back-of-the-envelope calculation suggested to me an upper limit of about 1000 kg to 10000 kg of extra toner per year in the United States. However, there are several factors that make me think that even the low figure is an overestimate.

I agree with your frustration about paying for this. Mako Hill used it as an example of an antifeature

https://wiki.mako.cc/Antifeatures

(It might be more accurate to define antifeatures in terms of buyers' willingness to pay to have the features removed, rather than sellers' insistence on being paid to remove them, since we can't, in fact, routinely pay for many of the antifeatures he mentions to be removed.)

Now that you mention it, yellow was the color that ran out first on my printer. By a very large margin.

I mostly print black & white.

But doesn't the comment above yours suggest that the 'yellow' dot thing may no longer be an issue and that now there's variation in the dithering parameters. Suggesting extra ink is not required.

More annoying are the privacy concessions that are the result of secret anti-counterfeiting measures (which is what I assume the measures are for).

I'm pretty sure any kind of such appeal can be refuted by connecting this tracking to hunting terrorists.

Almost none, considering that the dots are nearly invisible, and most of a printed page is visible ink

Is somebody working on identifying these modern watermarks? A start would be to print out test pages and compare high resolution scans. Maybe also multiple printouts from the same printer to see what the natural variation is, and if there is a timestamp component.

I would start, but I'm currently not around a printer...

I suppose the approach is to create a machine learning dataset that maps hi-res scans of sample documents to the printers that produced them. If the resulting classifier can accurately id the printer, you have probably found a watermark, but it might just be natural variations in the manufacturing.

The difficulty in this approach is that you have an extremely large number of classes. Each printer is its own class. Typically, as the number of classes goes up, accuracy goes done. That isn't to say it isn't possible, but it would require a lot of custom hacks to any learning algorithm.

Also to convince anyone that it works, you would need to test it out on an extremely large number of printers, including ones of the same model. In practice that could be expensive.

Nah, it's not feasible to know the printer model if you want to identify a laserprinted dollar.

A few variants at most.

still, if the result is a "fingerprint" of a printer, it'd be interesting to know, because it can be used by law enforcement too

Surely we can skip the paper stage and hookup the motors used for head positioning control to a rig - either reading through rotary measure or preferably reading the signal to the motors directly.

Print the same page, compare the signals sent to the motors? Won't that be a more easily/accurately measure proxy for what's actually being printed. One might need the timing data for the jets on an inkjet too, etc.

No printer controls their motors with >600 dpi resolution. Inkjet printers have print heads with many nozzles; the motors do the rough positioning / slide the head over the paper, the nozzles do the hard work. In laser printers a motor only moves the paper along (all rollers are either free-running or synchronized by gears).

So for an inkjet you'd have to look at the nozzle timing, which might be difficult depending on how integrated the drivers are (e.g. if they're a custom chip on a flexprint behind the heads... uhm...). For a laser printer you'd have to look at the laser modulation signal. That should be much easier, bugs have done that before.

Reverse engineering the firmware might be easier... on the other hand, the firmware is probably bolted shut rather well — the printer manufacturers cartridge DRM is in there somewhere.

I was assuming the nozzles has some sort of actuator that approximates to the term "motor" - I think you're either driving a tiny heater, or piezo, or a charge deflector plate in inkjet printing? That presumably is where the jitter would physically manifest; so you'd look at the input signal to those elements?

Reversing the firmware though, good call.

Maybe "just after the electronics, but before the print heads/motors" is the appropriate place to probe. It might be more work than anyone's prepared to put in (and of questionable utility), but you could emulate the motors and heads, and generate an image of what would have been printed.

Shouldn't we be able to control a printer on the pixel (dither) level in the first place?

This would be nice for other reasons too. There can be better halftoning algorithms to the typical pattern based halftoning of laser printers. It's hard to calibrate though, printers don't print "pixels". They print dots that typically overlap a lot, DPI for printers is the resolution for positioning the dots, not the size of the dots.

I think that ALL algorithms are better than the default halftone algorithms.

I think it's possible to send saturated pixels using PCL, and tell the printer to disable half-toning. It requires that a full page fits in memory, which isn't much (512MB) but typically more than the default.

For some reasons all printers use really vintage memory, so 512MB extra memory is crazy-expensive.

Even if we are able to, if the default is to divulge the printer ID via a dithering pattern either at the driver or machine level when given a blob of image data, I think this problem becomes similar to "Can't we all just encrypt our email?" i.e. largely academic.

We're currently in a situation where we don't even really fully know which are doing it or exactly how, so it would be many giant leaps in the right direction at least.

It would likely make identifying tracking marks and algorithms a lot easier.

Is there a notice/agreement tells customers there are tracking dots before buying? If there isn't, how is this not illegal?

Sometimes, for example

https://duckduckgo.com/?q=docucolor+"not+visible+under+norma...

We originally found that in German,

https://duckduckgo.com/?q=docucolor+"unter+normalen+bedingun...

However, I don't think that most printers currently disclose this, at least for sales in the U.S.

It's hard to imagine what law this would break.

By the same token, what is compelling them to do this? A sense of patriotic duty? The kindness of their hearts?

There's a lot of work that would go into designing, implementing, and testing this. Then you've got logistics in manufacturing. That's time and money.

> By the same token, what is compelling them to do this? A sense of patriotic duty?

The GSA Schedules: https://www.gsa.gov/portal/content/197989

The original motivation seems to have been a deal between a printer industry association and a central banks' association, perhaps as an alternative to threatened legislation, although we've never been able to get ahold of the details of that deal.

What law do you suppose this breaks? Illegal isn't defined as "something I dislike."

privacy / trade laws / 14th amendment equal protection / due process

It definitely does not feel right that some non government entity is deciding to encoding personally identifying information about you without public oversight.

FWIW: the link in "Other forensic marking techniques have been invented" is broken, now it points to: https://engineering.purdue.edu/~prints/

But it does not redirect anymore, I had to use archive.org

What about B&W printers?

There are methods of varying dithering/half-tone patterns in a way that is invisible to they eye but can carry enough bits of information that forensic analysis can identify an encoded printer serial number. Methods of making practically invisible changes to pure text are available too. Colour printers are starting to use these techniques instead of the (more easily noticed by the general public) extra yellow dots.

See the reply to SomeStupidPoint by schoen a few hours ago (and a couple of other posts on this thread) for more detail.

But that would be possible for a photo. But typically you would print some text. I wouldn't expect any dithering / half-tone in a text document.

"Methods of making practically invisible changes to pure text are available too" as mentioned in the post referred to. If using printer fonts rather than explicit vectors then it is possible to hide enough data in small "mistakes" invisible to the naked eye.

I'm not sure what would be possible for pure vector graphics.

For vector graphics, I suppose you could encode information in the least-significant bits (with redundancy, error correction and whatnot) if the printer can guarantee sufficiently high precision (not accuracy, mind you: https://www.tutelman.com/golf/measure/precision.php)

Could you elaborate/speculate on how dithering patterns would be used?

This isn't an answer, but I used to examine patents in this space. There are very advanced watermarking methods out there that are stable through transcoding, compression, obfuscation, etc. while being invisible to the naked eye. Really amazing stuff, wouldn't be surprised if there were lots of watermarks on media (audio, video, still image) that aren't readily apparent. One of the big use cases I remember was watermarking movies so that it would be possible to identify the time and place that a cam bootleg was recorded. That's a camcorder aimed at a movie screen and then heavily compressed and distributed over the internet, and the watermarks would still be detectable.

A simple, but reasonably robust solution to the cam problem is just to screw around with black frames, that is, the frames in the middle of a fade out. Give yourself 20 places where you can insert an extra frame and choose 10 to insert, and you already given yourself 40 bits to play with.

(It's trivial to deal with the audio sync issues.)

Cams may have a lot of spatial unreliability, but they have a lot of temporal resolution.

And that's just my stupid of-the-cuff answer, which is already off to a decent start. And there are in fact purely-spatial solutions that do work, to which the temporal solutions can be added. The upshot is don't expect to beat these anytime soon. There's just too many bits to hide in, and so few bits needed for the identification.

> The upshot is don't expect to beat these anytime soon. There's just too many bits to hide in, and so few bits needed for the identification.

I agree. Some of the off the top of my head ideas that I literally just came up with now:

- if printing an image, drop a few dots in some rows (or columns); data is hidden in the pattern of dropped dots

- if printing text (as in, actual text goes to be rendered on the driver or printer firmware level, and not by the OS / text editor), slightly alter the shape of some letters (by adding or dropping a dot) to hide a pattern

- if printing an image, try to hide some data in its FFT (e.g. by adjusting differences between low frequencies and hiding a pattern there)

- if recording a video, slightly alter some otherwise stable global characteristic (like avg brightness of a bunch of consecutive frames in an animated movie)

- if recording a video, screw with timing patterns, as you mentioned

There are just so many properties, that the difficulty is probably mostly in picking something that's stable through usual transformations a document will undergo (e.g. scanning, JPG compression).

No. It's not that simple.

For a real example that really works, see, for example, digimarc:

https://www.digimarc.com/support/product/digimarc-guardian-f...

Images can be cropped, rotated, recompressed, scaled, etc. and the digital watermark remains.

Also see: https://en.wikipedia.org/wiki/Digimarc

and read some of their patents, referenced in the Wikipedia article.

>Images can be cropped, rotated, recompressed, scaled, etc. and the digital watermark remains.

And none of those would impact the timing of black interim time lengths.

Also, this makes digimarc sound crappy (from their site):

>Facebook compresses images once they are posted, sometimes heavily, which can damage our invisible identifiers. Fortunately, there is a simple solution: if you pre-compress your images, then apply our identified, they should survive.

So they don't survive compression.

"And that's just my stupid of-the-cuff answer, which is already off to a decent start. And there are in fact purely-spatial solutions that do work, to which the temporal solutions can be added."

I have implemented one of those technologies at a previous company. Their claims and what the software was actually capable of were vastly different.

I would say about 20% of the files we sent over had enough recoverable watermark to be useful.

One of the things I wondered when I read this story is if it would be possible to develop software that would somehow circumvent this type of situation. For example, using autoencoding or something to lose watermarking details intentionally or something. But what you're discussing seems more advanced than the yellow dots idea.

I was surprised to see printers being involved--I thought something like this leak would all be digital. I was also surprised that the Intercept would not be more savvy about printer identification because it's been publicized so much over the years.

Speculation: Dithering algorithms traditionally include randomness. If you can determine a portion of this randomness by inspecting the output of the algorithm, then the dithering can be used to send a message, for example by using the message as a seed to a PRNG or as an input to a hash whose output serves as the randomness for the dithering operation. If the underlying message space is small enough, you could recover the message by brute force, examining each possible message and the results that it would have produced, and seeing which set of results matches the observed document.

The hand-waving part of this is "if you can determine a portion of this randomness by inspecting the output of the algorithm", because I don't really understand how easy this could be made without knowing the exact underlying signal that the dithering algorithm needs to quantize.

An alternative might be slightly changing some of the values in the matrices at

https://en.wikipedia.org/wiki/Ordered_dithering

in a way that barely reduces perceptual image quality (although I'm not certain how well that can be done). Perhaps there is an algorithm that uses statistics to deduce what matrix was used, and then the perturbations can be read out of the matrix.

This is related to research in digital watermarking that's been going on for decades, and I'm definitely not an expert in that or in digital image processing, so I'd love to hear from people who know more.

Nonetheless, looking up close at how printers produce different colors out of CMYK dots, I'm pretty confident that they have some degrees of freedom, and that some of them probably don't make a lot of different perceptually, and can probably be used to encode a message.

Isn't this mostly a driver issue, i.e. something that could change for any model at any time should the vendor decide to add tracking to a driver update?

I'm afraid it's probably built into the printer firmware, not drivers in OS.

Driver updates can usually modify the firmware in modern devices. I don't see a real dichotomy here...