Add more example code

crandmck · crandmck · commit 9aa2deb03e7a · 2025-01-10T11:43:53.000-08:00
diff --git a/docs/tasks/read.mdx b/docs/tasks/read.mdx
@@ -18,20 +18,6 @@ Use [`c2pa.read`](../../docs/js-sdk/api/c2pa.c2pa#methods) to read manifest data
 - **validationStatus**: A list of any validation errors encountered. See [Validation](../../docs/js-sdk/guides/validation) for more information.
 
 ```js
-const version = '0.17.2';
-const sampleImage = '<IMAGE_URL>';
-
-import { createC2pa } from 'https://cdn.jsdelivr.net/npm/c2pa@${version}/+esm';
-
-(async () => {
-  // Initialize the c2pa-js SDK
-  const c2pa = await createC2pa({
-    wasmSrc:
-      'https://cdn.jsdelivr.net/npm/c2pa@${version}/dist/assets/wasm/toolkit_bg.wasm',
-    workerSrc:
-      'https://cdn.jsdelivr.net/npm/c2pa@${version}/dist/c2pa.worker.min.js',
-  });
-
   try {
     // Read in image and get a manifest store
     const { manifestStore } = await c2pa.read(sampleImage);
diff --git a/docs/tasks/setup.mdx b/docs/tasks/setup.mdx
@@ -9,9 +9,24 @@ import TabItem from '@theme/TabItem';
 
 <Tabs groupId="programming-lang">
 
-{' '}
 <TabItem value="js" label="JavaScript" default>
-  This is how to setup the JavaScript library.
+
+```js
+const version = '0.24.2';
+const sampleImage = '<IMAGE_URL>';
+
+import { createC2pa } from 'https://cdn.jsdelivr.net/npm/c2pa@${version}/+esm';
+
+(async () => {
+  // Initialize the c2pa-js SDK
+  const c2pa = await createC2pa({
+    wasmSrc:
+      'https://cdn.jsdelivr.net/npm/c2pa@${version}/dist/assets/wasm/toolkit_bg.wasm',
+    workerSrc:
+      'https://cdn.jsdelivr.net/npm/c2pa@${version}/dist/c2pa.worker.min.js',
+  });
+```
+
 </TabItem>
 
   <TabItem value="python" label="Python" default>
@@ -85,7 +100,14 @@ use std::{
 };
 
 use anyhow::Result;
-use c2pa::{settings::load_settings_from_str, Builder, CallbackSigner, SigningAlg};
+use c2pa::{settings::load_settings_from_str, Builder, CallbackSigner, Reader};
+
+use c2pa_crypto::raw_signature::SigningAlg;
+use serde_json::json;
+
+const TEST_IMAGE: &[u8] = include_bytes!("../tests/fixtures/CA.jpg");
+const CERTS: &[u8] = include_bytes!("../tests/fixtures/certs/ed25519.pub");
+const PRIVATE_KEY: &[u8] = include_bytes!("../tests/fixtures/certs/ed25519.pem");
 ```
 
   </TabItem>
diff --git a/docs/tasks/sign.mdx b/docs/tasks/sign.mdx
@@ -9,10 +9,262 @@ import TabItem from '@theme/TabItem';
 <Tabs groupId="programming-lang">
   <TabItem value="python" label="Python" default>
     This is how to sign a manifest using Python.
+
+```python
+request_data = ... # This is the asset being signed
+content_type = ... # MIME type of the asset
+
+manifest = json.dumps({
+    "title": "image.jpg",
+    "format": "image/jpeg",
+    "claim_generator_info": [
+        {
+            "name": "Documentation example",
+            "version": "0.0.1"
+        }
+    ],
+    "assertions": [
+        {
+            "label": "c2pa.actions",
+            "data": {
+                "actions": [
+                    {
+                        "action": "c2pa.edited",
+                        "softwareAgent": {
+                            "name": "C2PA Python Example",
+                            "version": "0.1.0"
+                        }
+                    }
+                ]
+            }
+        }
+    ]
+})
+
+try:
+  builder = Builder(manifest)
+
+  signer = create_signer(kms_sign, signing_alg,
+                        cert_chain, timestamp_url)
+
+  result = io.BytesIO(b"")
+  builder.sign(signer, content_type, io.BytesIO(request_data), result)
+
+  return result.getvalue()
+except Exception as e:
+    logging.error(e)
+    abort(500, description=e)
+```
+
   </TabItem>
 
 <TabItem value="node" label="Node.js">
   This is how to sign a manifest using Node.js.
+
+Use the `c2pa.sign()` method to sign an ingredient, either locally if you have a signing certificate and key available, or by using a remote signing API.
+
+## Signing buffers
+
+If you have an asset file's data loaded into memory, you can sign the the asset using the loaded buffer.
+
+**NOTE**: Signing using a buffer is currently supported only for `image/jpeg` and `image/png` data. For all other file types, use the [file-based approach](#signing-files) .
+
+```ts
+import { readFile } from 'node:fs/promises';
+import { createC2pa, createTestSigner } from 'c2pa-node';
+
+// read an asset into a buffer
+const buffer = await readFile('to-be-signed.jpg');
+const asset: Asset = { buffer, mimeType: 'image/jpeg' };
+
+// build a manifest to use for signing
+const manifest = new ManifestBuilder(
+  {
+    claim_generator: 'my-app/1.0.0',
+    format: 'image/jpeg',
+    title: 'buffer_signer.jpg',
+    assertions: [
+      {
+        label: 'c2pa.actions',
+        data: {
+          actions: [
+            {
+              action: 'c2pa.created',
+            },
+          ],
+        },
+      },
+      {
+        label: 'com.custom.my-assertion',
+        data: {
+          description: 'My custom test assertion',
+          version: '1.0.0',
+        },
+      },
+    ],
+  },
+  { vendor: 'cai' },
+);
+
+// create a signing function
+async function sign(asset, manifest) {
+  const signer = await createTestSigner();
+  const c2pa = createC2pa({
+    signer,
+  });
+
+  const { signedAsset, signedManifest } = await c2pa.sign({
+    asset,
+    manifest,
+  });
+}
+
+// sign
+await sign(asset, manifest);
+```
+
+## Signing files
+
+To avoid loading the entire asset into memory (or for file types other than JPEG and PNG that don't support in-memory signing), pass in the file path to the asset file to sign it; for example:
+
+```ts
+import { resolve } from 'node:path';
+import { createC2pa, createTestSigner } from 'c2pa-node';
+
+// get the asset full path
+const asset = {
+  path: resolve('to-be-signed.jpg'),
+};
+// define a location where to place the signed asset
+const outputPath = resolve('signed.jpg');
+
+// create a signing function
+async function sign(asset, manifest) {
+  const signer = await createTestSigner();
+  const c2pa = createC2pa({
+    signer,
+  });
+
+  const { signedAsset, signedManifest } = await c2pa.sign({
+    manifest,
+    asset,
+    options: {
+      outputPath,
+    },
+  });
+}
+
+// build a manifest to use for signing
+const manifest = new ManifestBuilder(
+  {
+    claim_generator: 'my-app/1.0.0',
+    format: 'image/jpeg',
+    title: 'buffer_signer.jpg',
+    assertions: [
+      {
+        label: 'c2pa.actions',
+        data: {
+          actions: [
+            {
+              action: 'c2pa.created',
+            },
+          ],
+        },
+      },
+      {
+        label: 'com.custom.my-assertion',
+        data: {
+          description: 'My custom test assertion',
+          version: '1.0.0',
+        },
+      },
+    ],
+  },
+  { vendor: 'cai' },
+);
+
+// sign
+await sign(asset, manifest);
+```
+
+## Remote signing
+
+If you have access to a web service that performs signing, you can use it to sign remotely; for example:
+
+```ts
+import { readFile } from 'node:fs/promises';
+import { fetch, Headers } from 'node-fetch';
+import { createC2pa, SigningAlgorithm } from 'c2pa-node';
+
+function createRemoteSigner() {
+  return {
+    type: 'remote',
+    async reserveSize() {
+      const url = `https://my.signing.service/box-size`;
+      const res = await fetch(url);
+      const data = (await res.json()) as { boxSize: number };
+      return data.boxSize;
+    },
+    async sign({ reserveSize, toBeSigned }) {
+      const url = `https://my.signing.service/sign?boxSize=${reserveSize}`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: new Headers({
+          'Content-Type': 'application/octet-stream',
+        }),
+        body: toBeSigned,
+      });
+      return res.buffer();
+    },
+  };
+}
+
+async function sign(asset, manifest) {
+  const signer = createRemoteSigner();
+  const c2pa = createC2pa({
+    signer,
+  });
+
+  const { signedAsset, signedManifest } = await c2pa.sign({
+    asset,
+    manifest,
+  });
+}
+
+const buffer = await readFile('to-be-signed.jpg');
+const asset: Asset = { buffer, mimeType: 'image/jpeg' };
+
+const manifest = new ManifestBuilder(
+  {
+    claim_generator: 'my-app/1.0.0',
+    format: 'image/jpeg',
+    title: 'buffer_signer.jpg',
+    assertions: [
+      {
+        label: 'c2pa.actions',
+        data: {
+          actions: [
+            {
+              action: 'c2pa.created',
+            },
+          ],
+        },
+      },
+      {
+        label: 'com.custom.my-assertion',
+        data: {
+          description: 'My custom test assertion',
+          version: '1.0.0',
+        },
+      },
+    ],
+  },
+  { vendor: 'cai' },
+);
+
+await sign(asset, manifest);
+```
+
 </TabItem>
 
 <TabItem value="cpp" label="C++">
