johnandersen777.bsky.social/atlibs-identlink
ident.link agent-of walk with grants over CAR-verified sync.getRecord: Rust crate identlink, wasm, JS
0
0
use std::collections::HashMap;
use ipld_core::cid::{multihash::Multihash, Cid};
use ipld_core::ipld::Ipld;
use multibase::Base;
use serde::{de::DeserializeOwned, Deserialize};
use serde_json::Value;
use sha2::{Digest, Sha256};
use crate::{DidDoc, Error};
type Blocks = HashMap<Cid, Vec<u8>>;
pub fn verify_record(car: &[u8], doc: &DidDoc, did: &str, collection: &str, rkey: &str) -> Result<Option<Value>, Error> {
if doc.id != did {
return Err("the DID doc is for another DID".into());
}
let (root, blocks) = read_car(car)?;
let Ipld::Map(mut commit) = decode(&blocks, &root)? else {
return Err("the commit is not a map".into());
};
if commit.get("did") != Some(&Ipld::String(did.into())) {
return Err("the commit is for another repo".into());
}
let Some(Ipld::Bytes(sig)) = commit.remove("sig") else {
return Err("the commit has no sig".into());
};
let (_, key) = multibase::decode(doc.signing_key().ok_or("the DID doc has no #atproto key")?)?;
let Some(Ipld::Link(data)) = commit.get("data").cloned() else {
return Err("the commit has no data".into());
};
verify_sig(&key, &serde_ipld_dagcbor::to_vec(&Ipld::Map(commit))?, &sig)?;
match find(&blocks, data, format!("{collection}/{rkey}").as_bytes())? {
Some(cid) => Ok(Some(json(decode(&blocks, &cid)?)?)),
None => Ok(None),
}
}
fn verify_sig(key: &[u8], msg: &[u8], sig: &[u8]) -> Result<(), Error> {
let ok = match key.get(..2) {
Some([0xe7, 0x01]) => {
use k256::ecdsa::{signature::Verifier, Signature, VerifyingKey};
let sig = Signature::from_slice(sig).map_err(|_| "the commit sig is not 64 bytes")?;
let key = VerifyingKey::from_sec1_bytes(&key[2..]).map_err(|_| "the #atproto key is not a k256 point")?;
sig.normalize_s().is_none() && key.verify(msg, &sig).is_ok()
}
Some([0x80, 0x24]) => {
use p256::ecdsa::{signature::Verifier, Signature, VerifyingKey};
let sig = Signature::from_slice(sig).map_err(|_| "the commit sig is not 64 bytes")?;
let key = VerifyingKey::from_sec1_bytes(&key[2..]).map_err(|_| "the #atproto key is not a p256 point")?;
sig.normalize_s().is_none() && key.verify(msg, &sig).is_ok()
}
_ => return Err("the #atproto key is not k256 or p256".into()),
};
if !ok {
return Err("the commit signature does not verify (or is high-S)".into());
}
Ok(())
}
pub fn record_cid(value: &Value) -> Result<String, Error> {
let bytes = serde_ipld_dagcbor::to_vec(&ipld(value)?)?;
Ok(Cid::new_v1(0x71, Multihash::<64>::wrap(0x12, &Sha256::digest(&bytes))?).to_string())
}
fn ipld(v: &Value) -> Result<Ipld, Error> {
Ok(match v {
Value::Null => Ipld::Null,
Value::Bool(b) => Ipld::Bool(*b),
Value::Number(n) => Ipld::Integer(n.as_i64().map(i128::from).ok_or("not an atproto integer")?),
Value::String(s) => Ipld::String(s.clone()),
Value::Array(l) => Ipld::List(l.iter().map(ipld).collect::<Result<_, _>>()?),
Value::Object(m) => match (m.len(), m.get("$link"), m.get("$bytes")) {
(1, Some(Value::String(link)), _) => Ipld::Link(Cid::try_from(link.as_str())?),
(1, _, Some(Value::String(b))) => Ipld::Bytes(Base::Base64.decode(b)?),
_ => Ipld::Map(m.iter().map(|(k, v)| Ok((k.clone(), ipld(v)?))).collect::<Result<_, Error>>()?),
},
})
}
fn varint(buf: &mut &[u8]) -> Result<usize, Error> {
let mut n: u64 = 0;
for shift in (0..63).step_by(7) {
let (&b, rest) = buf.split_first().ok_or("truncated CAR")?;
*buf = rest;
n |= u64::from(b & 0x7f) << shift;
if b & 0x80 == 0 {
return Ok(usize::try_from(n)?);
}
}
Err("bad varint".into())
}
fn chunk<'a>(buf: &mut &'a [u8]) -> Result<&'a [u8], Error> {
let n = varint(buf)?;
let (head, rest) = buf.split_at_checked(n).ok_or("truncated CAR")?;
*buf = rest;
Ok(head)
}
fn read_car(mut car: &[u8]) -> Result<(Cid, Blocks), Error> {
#[derive(Deserialize)]
struct Header {
version: u64,
roots: Vec<Cid>,
}
let header: Header = serde_ipld_dagcbor::from_slice(chunk(&mut car)?)?;
let (1, [root]) = (header.version, header.roots.as_slice()) else {
return Err("not a one-root CAR v1".into());
};
let root = *root;
let mut blocks = Blocks::new();
while !car.is_empty() {
let block = chunk(&mut car)?;
let mut cursor = std::io::Cursor::new(block);
let cid = Cid::read_bytes(&mut cursor)?;
let data = &block[usize::try_from(cursor.position())?..];
if cid.hash().code() != 0x12 || cid.hash().digest() != &Sha256::digest(data)[..] {
return Err(format!("block {cid} does not match its hash").into());
}
blocks.insert(cid, data.to_vec());
}
Ok((root, blocks))
}
fn decode<T: DeserializeOwned>(blocks: &Blocks, cid: &Cid) -> Result<T, Error> {
Ok(serde_ipld_dagcbor::from_slice(blocks.get(cid).ok_or_else(|| format!("block {cid} is missing"))?)?)
}
#[derive(Deserialize)]
struct Node {
l: Option<Cid>,
e: Vec<Entry>,
}
#[derive(Deserialize)]
struct Entry {
p: usize,
#[serde(with = "serde_bytes")]
k: Vec<u8>,
v: Cid,
t: Option<Cid>,
}
fn find(blocks: &Blocks, mut node: Cid, key: &[u8]) -> Result<Option<Cid>, Error> {
loop {
let n: Node = decode(blocks, &node)?;
let mut prev: Vec<u8> = Vec::new();
let mut next = n.l;
for e in n.e {
let mut k = prev.get(..e.p).ok_or("bad MST key prefix")?.to_vec();
k.extend_from_slice(&e.k);
match k.as_slice().cmp(key) {
std::cmp::Ordering::Equal => return Ok(Some(e.v)),
std::cmp::Ordering::Less => next = e.t,
std::cmp::Ordering::Greater => break,
}
prev = k;
}
match next {
Some(c) => node = c,
None => return Ok(None),
}
}
}
fn json(v: Ipld) -> Result<Value, Error> {
Ok(match v {
Ipld::Null => Value::Null,
Ipld::Bool(b) => b.into(),
Ipld::Integer(i) => i64::try_from(i)?.into(),
Ipld::Float(f) => f.into(),
Ipld::String(s) => s.into(),
Ipld::Bytes(b) => serde_json::json!({ "$bytes": &multibase::encode(Base::Base64, b)[1..] }),
Ipld::List(l) => l.into_iter().map(json).collect::<Result<_, _>>()?,
Ipld::Map(m) => m.into_iter().map(|(k, v)| Ok((k, json(v)?))).collect::<Result<serde_json::Map<_, _>, Error>>()?.into(),
Ipld::Link(c) => serde_json::json!({ "$link": c.to_string() }),
})
}