Device identity#

use pamoja_security::{DeviceIdentity, PublicIdentity};

// The seed is provisioned into the device once and never leaves it. A real one comes
// from the factory or a secure element; any 32 bytes stand in here.
let device = DeviceIdentity::from_seed(&[7u8; 32]);

// Only the 32-byte public key travels to the gateway. Its fingerprint is the short
// form an operator reads off a screen to tell one device from another.
let gateway = PublicIdentity::from_bytes(&device.public().to_bytes()).expect("a valid key");
println!("device     {}", gateway.fingerprint());

// Signing is deterministic, so the same reading always produces the same 64 bytes and
// there is no randomness to get wrong on a microcontroller.
let reading = b"meter-4 1182.750 kWh";
let signature = device.sign(reading);
match gateway.verify(reading, &signature) {
    Ok(()) => println!("accepted   {}", String::from_utf8_lossy(reading)),
    Err(error) => println!("rejected   {error}"),
}

// A digit changed in transit no longer matches what was signed.
let edited = b"meter-4 1082.750 kWh";
match gateway.verify(edited, &signature) {
    Ok(()) => println!("accepted   an edited reading, which should never happen"),
    Err(_) => println!("rejected   {}", String::from_utf8_lossy(edited)),
}

// Nor does the same reading offered under another device's key.
let impostor = DeviceIdentity::from_seed(&[90u8; 32]);
match impostor.public().verify(reading, &signature) {
    Ok(()) => println!("accepted   an impostor, which should never happen"),
    Err(_) => println!("rejected   a signature offered under another device's key"),
}

// On a link the signature and the reading usually travel as one message, signature
// first, and the gateway gets the reading back only once it has checked it.
let message = device.sign_message(reading);
let size = message.len();
println!("message    {size} bytes on the wire, the signature and the reading together");
match gateway.verify_message(&message) {
    Ok(carried) => {
        let carried = String::from_utf8_lossy(carried);
        println!("accepted   {carried}, read out of the message");
    }
    Err(error) => println!("rejected   {error}"),
}

// A message that lost its last byte on the way is refused whole.
match gateway.verify_message(&message[..size - 1]) {
    Ok(_) => println!("accepted   a message cut short, which should never happen"),
    Err(_) => println!("rejected   a message that lost its last byte on the way"),
}

import { DeviceIdentity, fingerprint, verify, verifyMessage } from '@pamoja/security'

// The seed is provisioned into the device once and never leaves it. A real one comes from
// the factory or a secure element; any 32 bytes stand in here.
const device = DeviceIdentity.fromSeed(Buffer.alloc(32, 7))

// Only the 32-byte public key travels to the gateway. Its fingerprint is the short form an
// operator reads off a screen to tell one device from another.
const gatewayKey = device.publicKey()
console.log(`device     ${fingerprint(gatewayKey)}`)

// Signing is deterministic, so the same reading always produces the same 64 bytes and there
// is no randomness to get wrong on a microcontroller.
const reading = 'meter-4 1182.750 kWh'
const signature = device.sign(reading)
if (verify(gatewayKey, reading, signature)) {
  console.log(`accepted   ${reading}`)
} else {
  console.log('rejected   a reading the device really did sign, which should never happen')
}

// A digit changed in transit no longer matches what was signed.
const edited = 'meter-4 1082.750 kWh'
if (verify(gatewayKey, edited, signature)) {
  console.log('accepted   an edited reading, which should never happen')
} else {
  console.log(`rejected   ${edited}`)
}

// Nor does the same reading offered under another device's key.
const impostor = DeviceIdentity.fromSeed(Buffer.alloc(32, 90))
if (verify(impostor.publicKey(), reading, signature)) {
  console.log('accepted   an impostor, which should never happen')
} else {
  console.log("rejected   a signature offered under another device's key")
}

// On a link the signature and the reading usually travel as one message, signature first,
// and the gateway gets the reading back only once it has checked it.
const message = device.signMessage(reading)
const size = message.length
console.log(`message    ${size} bytes on the wire, the signature and the reading together`)
const carried = verifyMessage(gatewayKey, message)
if (carried) {
  console.log(`accepted   ${carried.toString()}, read out of the message`)
} else {
  console.log('rejected   a message the device really did sign, which should never happen')
}

// A message that lost its last byte on the way is refused whole.
if (verifyMessage(gatewayKey, message.subarray(0, size - 1))) {
  console.log('accepted   a message cut short, which should never happen')
} else {
  console.log('rejected   a message that lost its last byte on the way')
}

from pamoja.security import DeviceIdentity, fingerprint, verify, verify_message

# The seed is provisioned into the device once and never leaves it. A real one comes from
# the factory or a secure element; any 32 bytes stand in here.
device = DeviceIdentity.from_seed(bytes([7]) * 32)

# Only the 32-byte public key travels to the gateway. Its fingerprint is the short form an
# operator reads off a screen to tell one device from another.
gateway_key = device.public_key
print(f"device     {fingerprint(gateway_key)}")

# Signing is deterministic, so the same reading always produces the same 64 bytes and there
# is no randomness to get wrong on a microcontroller.
reading = "meter-4 1182.750 kWh"
signature = device.sign(reading)
if verify(gateway_key, reading, signature):
    print(f"accepted   {reading}")
else:
    print("rejected   a reading the device really did sign, which should never happen")

# A digit changed in transit no longer matches what was signed.
edited = "meter-4 1082.750 kWh"
if verify(gateway_key, edited, signature):
    print("accepted   an edited reading, which should never happen")
else:
    print(f"rejected   {edited}")

# Nor does the same reading offered under another device's key.
impostor = DeviceIdentity.from_seed(bytes([90]) * 32)
if verify(impostor.public_key, reading, signature):
    print("accepted   an impostor, which should never happen")
else:
    print("rejected   a signature offered under another device's key")

# On a link the signature and the reading usually travel as one message, signature first,
# and the gateway gets the reading back only once it has checked it.
message = device.sign_message(reading)
print(f"message    {len(message)} bytes on the wire, the signature and the reading together")
carried = verify_message(gateway_key, message)
if carried is not None:
    print(f"accepted   {carried.decode()}, read out of the message")
else:
    print("rejected   a message the device really did sign, which should never happen")

# A message that lost its last byte on the way is refused whole.
if verify_message(gateway_key, message[:-1]) is not None:
    print("accepted   a message cut short, which should never happen")
else:
    print("rejected   a message that lost its last byte on the way")

// The seed is provisioned into the device once and never leaves it. A real one
// comes from the factory or a secure element; any 32 bytes stand in here.
byte[] seed = new byte[DeviceIdentity.KeyLength];
Array.Fill(seed, (byte)7);
using var device = new DeviceIdentity(seed);

// Only the 32-byte public key travels to the gateway. Its fingerprint is the short
// form an operator reads off a screen to tell one device from another.
byte[] gatewayKey = device.PublicKey;
Console.WriteLine($"device     {DeviceIdentity.FingerprintOf(gatewayKey)}");

// Signing is deterministic, so the same reading always produces the same 64 bytes
// and there is no randomness to get wrong on a microcontroller.
const string reading = "meter-4 1182.750 kWh";
byte[] signature = device.Sign(reading);
Console.WriteLine(DeviceIdentity.Verify(gatewayKey, reading, signature)
    ? $"accepted   {reading}"
    : "rejected   a reading the device really did sign, which should never happen");

// A digit changed in transit no longer matches what was signed.
const string edited = "meter-4 1082.750 kWh";
Console.WriteLine(DeviceIdentity.Verify(gatewayKey, edited, signature)
    ? "accepted   an edited reading, which should never happen"
    : $"rejected   {edited}");

// Nor does the same reading offered under another device's key.
byte[] impostorSeed = new byte[DeviceIdentity.KeyLength];
Array.Fill(impostorSeed, (byte)90);
using var impostor = new DeviceIdentity(impostorSeed);
Console.WriteLine(DeviceIdentity.Verify(impostor.PublicKey, reading, signature)
    ? "accepted   an impostor, which should never happen"
    : "rejected   a signature offered under another device's key");

// On a link the signature and the reading usually travel as one message,
// signature first, and the gateway gets the reading back only once it has
// checked it.
byte[] message = device.SignMessage(reading);
int size = message.Length;
Console.WriteLine($"message    {size} bytes on the wire, the signature and the reading together");
byte[]? carried = DeviceIdentity.VerifyMessage(gatewayKey, message);
Console.WriteLine(carried is not null
    ? $"accepted   {Encoding.UTF8.GetString(carried)}, read out of the message"
    : "rejected   a message the device really did sign, which should never happen");

// A message that lost its last byte on the way is refused whole.
byte[]? cut = DeviceIdentity.VerifyMessage(gatewayKey, message.AsSpan(0, size - 1));
Console.WriteLine(cut is not null
    ? "accepted   a message cut short, which should never happen"
    : "rejected   a message that lost its last byte on the way");