~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/atlibs-identlink

ident.link agent-of walk with grants over CAR-verified sync.getRecord: Rust crate identlink, wasm, JS

1 collaborator
0
0
main
179 lines · 6.6 KB Raw History
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() }),
    })
}