A Raspberry Pi dashcam with two cameras and a GPS (opens in new tab)

For the pretty limited usecase of a "record only" dashcam, you might consider recording in chunks.

Create an ephemeral key for a symmetric encryption in advance, encrypt this ephemeral key with the public-key method of your choice and store somewhere. Then encrypt one minute of recording using this ephemeral key. I don't know if gnupg is performing good enough on all architectures, but in principle it can handle everything in one go, and it works exactly as described just above.

      ~ dd if=/dev/zero bs=1M count=50 | gpg -e -r 0x6AC3E4EC >encrypted.dat
    50+0 records in
    50+0 records out
    52428800 bytes (52 MB, 50 MiB) copied, 0.486881 s, 108 MB/s

    (Intel(R) Core(TM) i5 CPU M 450  @ 2.40GHz)

If you use mpeg transport streams, you can even cut at arbitrary positions (to make, say, each file exactly 50 MiB large). When you play back, decoders will catch up as soon as they find the proper markers. So your encryption pipeline doesn't even have to know much about video...

No need to do it at the filesystem level, just do it at the file level. You can encrypt using the public key in the dashcam, when you want to recover the video you bring the removable media to a system where you can use the private key to unlock it. Since there is often hardware support for AES you can use the public key to encrypt an AES key for the current segment, then when you get it home use the private key to recover the AES key and then use that to recover the video. The existence of the files is pretty obvious but they won't generally be decryptable.

It'd be hard to imagine how that should work on filesystem level (if I can't read contents of any directory, how do I figure out which directory do I add a newly created file to?).

OTOH, on the file contents level this seems very much doable. Sadly, I am unaware of any general purpose implementation of such a thing (encfs doesn't do anything of this kind).

I found this http://www.arthy.org/wocfs/ I have no idea if it really works. If you give it a try would you mind letting me know?

You could always just pipe it through gpg or the like. Just encrypt using the public key, and you can't decrypt unless you have the private.

Not quite the same thing, but forward secure sealing is relevant: https://lwn.net/Articles/512895/

You can always also use a smartcard type device to sign your files. Then a reboot (power cycle) will revoke signing capability until unlocked again.

I read your requirements.

So, there's an analog loophole: in order to "write", the filesystem has to receive the data to be written - otherwise, it's untestable (if it doesn't get the data to be written it could write whatever it wants and pass all tests) which is a roundabout way of saying that if it doesn't get the data it can't possibly work. So it has to get the data. At that point it could be saved if the filesystem is modified (patched) to exfiltrate it. So we have to assume that you kind-of trust the filesystem not to be patched.

But if the filesystem is not modified, though, that means you're fine with the path that that data takes all the way until your filesystem writes it -- however, in this case your requirements are 100% met by encrypting to the public key and writing that out.

    #jakobdabo's requirements
    
    #include <pgp stuff>
    #include <filesystem stuff>
    
    public key = arg0
    private key = arg1
    
    read_file(filename){
      if (have_private_key)
          try decrypt(private_key, read(filenename))
            return result 
            except  "didn't work"
       else
           "I wasn't called with a private key."
      }
    
    write_file(filename, data)
        towrite = encrypt(filename, data) //encrypted metada inside
        try write towrite
             except "didn't work"

so this should meet all of your requirements. If you wanted the filesystem to do stuff like hide whether a file is even modified, hide timestamps, etc etc, those are almost impossible. Consider:

I want to determine whether anyone is accessing a server at the moment.

Server is idling, with sockets listening to answer web queries.

Suddenly 5,000 Reddit users show up and look through the site, generating lots of logs which nginx dutifully saves - only you're saving it in your encrypted filesystem.

Now.

How would you make it so that the fact that all of this traffic is being saved is hidden? The updates to the drive image would have to happen like clockwork regardless of what was happening. But this isn't a reasonable requirement, as the amount of entropy entering the drive is bigger while Reddit is hugging it than normal. You couldn't make it so that you are saving as much information as at top load. so what do you do? Reduce the top average to some level that you can continuously fabricate?

It doesn't make sense.

So you wouldn't hide whether any data was being saved by the dash-cam at all. but it's easy to save an encrypted version. the dash cam doesn't even need the private key.

but you do have to trust the software running on it. (for example to correctly do the encryption and not also write the underlying data somehow.)

> why you have been driving like a jackass

Or just don't drive like a jackass. It's a serious business, take it seriously.

Some people keep records because they honestly believe they are doing things properly and want to be able to prove it.

Conversely, if you're a responsible driver then it prove that you are in the right.

How long does it take for them to subpoena you? That is if I were in an accident, and they don't physically confiscate the memory drive, could you extract any video that supports your case and delete the rest before they request it?

I figure this happens with police dashcams and bodycams all the time.

"What dashcam, Officer? Oh, that? It hasn't worked for weeks."

Is there well documented cases of this?

> I haven't been pulled over since.

How many times did you get pulled over before the cameras and over what time period? And how long have the cameras been installed?

So you intentionally mount these things front/rear and plainly visible to police? Interesting. Also, what model camera did you buy?

By verifying the contents of the hard drive once in a while?

If it's got wifi, you could check from your phone, or have it upload automatically from the garage (wifi range depending).

A dashed lane marking means that both sides may temporarily use the other lane to pass -- provided that they can see it will be safe. A solid center line means you cannot do that. A double line with one side solid and one side dashed means that the dashed side may attempt to pass, not the solid side.

All of these things become more clear once you realize they are primarily about sight-lines.

Yes, you can change lanes across a dotted line as you like. You do have to signal first though.

What does a dotted line mean in your country?

I'm a solid Debian user but I still keep the Arch wiki around since so much of the information is completely transferable.

>I switched though, because the only questions I'd get was of people using my commands on Raspbian and getting confused.

Not to attack your blog but was everything that Arch specific?

He wrote about handling shutdowns in another post on his blog.[1]

> For the automatic shutdown I have used a 12V programmable timer in combination with an optocoupler.

> When the car is powered the the timer gets triggered and is starting the power supply for the Raspberry pi, Dashcam pi will get started and will do its job. When the car is turned off the optocoupler triggers the GPIO pin of the raspberry and starts a shutdown. After 15 seconds the timer is shutting down and the raspberry pi is powerless.

1: http://pidashcam.blogspot.com/2016/03/cheap-solution-for-aut...

Actually, I think if you have all the parts already (i.e. RPi, webcams), this makes a lot of sense. Creating a Frankenstein system out of existing components would be interesting, and cost would be zero.

That's not a problem. It isn't that hard to design (or buy) a circuit to provide clean power from an automotive power source. The "carPC" community has been doing this for ages.