I think that what you want does not exist in chip form. Good crypto in embedded is hard, and takes hard work. If you don't want to get in it up to your eyeballs, maybe you should look for a 3rd party system (hardware, software, keying material,
instructions and policies etc.) with appropriate standards compliance?
I want no part in generating or maintaining any kind of key database.
Then you are doomed to failure. Key management is absolutely critical, and you can't rely on the end user to 'know what to do.' If you're lucky, you can get them to follow your explicit and carefully written instructions and procedures. Which means you
must take some part in key management.
The thing is declassified and you just have some kinda slot for the key to go into I guess, I never really looked at it, I know you can buy em though.
And how is this dongle loaded with keying information? How do you know it hasn't been tampered with? How do you know that all the dongles aren't just I2C EEPROM chips with the same key every time?
radioactive has kindly made a list of some standards. I suggest you have a look at them.
Off the top of my head, a quick set of considerations for the crypto:
- Accept that there will be a number of keys per device for various roles (e.g. communications vs pairing vs firmware update).
- Don't use DES. It's old and the keys are too small.
- Use AES128 or AES256.
- Use hardware for encryption and authentication. Software implementations leak information out (execution time, power supply ripples, RF radiation, ultrasonics, I'm sure people will find more). Hardware implementations are constant-time (and faster than SW!) and leak less information. Modern micros often have hardware built in, just add device drivers.
- Use cryptographic authentication to make sure someone hasn't tampered with the data in flight. Even if they can't read it, someone randomly flipping bits might cause a Very Bad Payload after decryption. CRC is not cryptographic authentication. You most likely need an AES HMAC or something from the SHA-2 family.
- AES keys must be unique per device. Otherwise someone can break one unit, and extract the One Key to Pwn Them All.
- Private RSA or ECC keys must use be unique device. See above
- Wherever random numbers are used, they need to be strong. They should come from a hardware (a.k.a. 'true') random number generator and should probably have some whitening.
- AES keys should be managed with a finite life (both in calendar time and number of blocks encrypted), after which they should be retired.
- All plaintext keying information must stay inside the micro unless it's encrypted. Be careful if using external RAM - special linker scripts may be required to manage the exact placement of key material.
- Unique serial number per device.
This is
by no means exhaustive.
I suggest you take a look at the MBED TLS software library. I believe the DTLS option can send data without TCP/IP, but still do the good stuff like public key exchange (I suggest TLS_ECDHE_ECDSA_AES_GCM_128). However, you need to either a) get yourself a preconfigured software library for your processor and review the #### out of it or b) hook the MBED TLS library into the hardware on your chip (coding required). Option c, which I don't recommend, does the AES, SHA etc. crypto primitives in software and be more vulnerable to side channel attacks.
Deployment of TLS like this will also require certificate management, which includes key handling. There's no way to avoid it.
In addition to all this, you must be able to update the product firmware in a secure manner. This means some kind of signature. Seeing as you don't want to prepare a separate update binary for every damn unit, you will need to deploy public key cryptography techniques (e.g. RSA or ECC). Typically you would load a manufacturer public key into every device (same for all devices is OK for
public keys) and sign the firmware binary with the manufacturer private key that you keep in a vault. Also, bonus points if you encrypt the payload so people can't read your binary.
EDIT: oops, I forgot
replay protection.