Small adjustments to the contents protocol

I'm still not 100% on the crypto here, it seems like maybe I should
start with something simpler for proof-of-concept and if it's really
needed I could always make a v2 record type or something.

api/atyo/atyoping.go

···
 // RECORDTYPE: Ping
 type Ping struct {
 	LexiconTypeID string `json:"$type,const=app.atyo.ping" cborgen:"$type,const=app.atyo.ping"`
-	// contents: A message encrypted for a specific recipient, possibly including an encrypted payload. After decryption, this will deserialize as `app.atyo.ping#contents`.
+	// contents: A message encrypted for specific recipient(s), possibly including an encrypted payload. After decryption, this will deserialize as `app.atyo.ping#contents`.
 	Contents util.LexBytes `json:"contents,omitempty" cborgen:"contents,omitempty"`
 	// createdAt: The time of record creation.
 	CreatedAt string `json:"createdAt" cborgen:"createdAt"`
···
 	Nonce util.LexBytes `json:"nonce,omitempty" cborgen:"nonce,omitempty"`
 	// publicKey: One-time key used to encrypt the message contents
 	PublicKey util.LexBytes `json:"publicKey,omitempty" cborgen:"publicKey,omitempty"`
-	// targets: The one-time private key to decrypt `contents`, which has been encrypted for its recipient(s).
-	Targets util.LexBytes `json:"targets,omitempty" cborgen:"targets,omitempty"`
 }
 
 // Ping_Contents is a "contents" in the app.atyo.ping schema.

api/atyo/cbor_gen.go

···
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 6
+	fieldCount := 5
 
 	if t.Contents == nil {
 		fieldCount--
···
 	}
 
 	if t.PublicKey == nil {
-		fieldCount--
-	}
-
-	if t.Targets == nil {
 		fieldCount--
 	}
 
···
 		}
 
 		if _, err := cw.Write(t.Nonce); err != nil {
-			return err
-		}
-
-	}
-
-	// t.Targets (util.LexBytes) (slice)
-	if t.Targets != nil {
-
-		if len("targets") > 1000000 {
-			return xerrors.Errorf("Value in field \"targets\" was too long")
-		}
-
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targets"))); err != nil {
-			return err
-		}
-		if _, err := cw.WriteString(string("targets")); err != nil {
-			return err
-		}
-
-		if len(t.Targets) > 2097152 {
-			return xerrors.Errorf("Byte array in field t.Targets was too long")
-		}
-
-		if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Targets))); err != nil {
-			return err
-		}
-
-		if _, err := cw.Write(t.Targets); err != nil {
 			return err
 		}
 
···
 			}
 
 			if _, err := io.ReadFull(cr, t.Nonce); err != nil {
-				return err
-			}
-
-			// t.Targets (util.LexBytes) (slice)
-		case "targets":
-
-			maj, extra, err = cr.ReadHeader()
-			if err != nil {
-				return err
-			}
-
-			if extra > 2097152 {
-				return fmt.Errorf("t.Targets: byte array too large (%d)", extra)
-			}
-			if maj != cbg.MajByteString {
-				return fmt.Errorf("expected byte array")
-			}
-
-			if extra > 0 {
-				t.Targets = make([]uint8, extra)
-			}
-
-			if _, err := io.ReadFull(cr, t.Targets); err != nil {
 				return err
 			}
 

appview/ping.go

···
 package appview
 
 import (
+	"bytes"
 	"crypto/rand"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"net/http"
···
 		return
 	}
 
-	fmt.Fprintln(os.Stderr, "would write ping to PDS: "+string(jsonPing))
+	cborBuf := bytes.NewBuffer([]byte{})
+	err = ping.MarshalCBOR(cborBuf)
+	if err == nil {
+		fmt.Fprintln(os.Stderr, "ping length as CBOR:", cborBuf.Len())
+	} else {
+		fmt.Fprintln(os.Stderr, "failed to marshal as CBOR", err)
+	}
+
+	fmt.Fprintf(os.Stderr, hex.EncodeToString(cborBuf.Bytes())+"\n")
+
+	fmt.Fprintln(
+		os.Stderr,
+		"would write ping to PDS: "+string(jsonPing),
+	)
 
 	// TODO write records to our PDS
 
···
 	}
 }
 
+// Build an app.atyo.ping record. Notes about the format of `contents`:
+//
+// Roughly based on the Scuttlebutt protocol for pivate messages:
+// https://ssbc.github.io/scuttlebutt-protocol-guide/#private-messages
 func (s *Server) buildPing(target *identity.Identity) (*atyo.Ping, *httpError) {
-	const nonceLen = 24
-	var nonce [nonceLen]byte
-	if len, err := rand.Read(nonce[:]); len != nonceLen || err != nil {
-		return nil, &httpError{
-			http.StatusInternalServerError,
-			"rand.Read returned unexpected result",
-		}
-	}
+	var nonce [24]byte
+	_, _ = rand.Read(nonce[:])
 
 	sharedPubKey, sharedSecretKey, err := box.GenerateKey(rand.Reader)
 	if err != nil {
···
 	}
 
 	// TODO: this is where e.g. geo contents would go
-	message := padMessage(nil)
+	// Maybe we should do padding after calculating shared key len
+	message := padMessage([]byte("Hello secret msg"))
 
 	targetPubkey, err := s.keys.fetchUserPubKey(target)
 	if err != nil {
···
 		}
 	}
 
-	encryptedMessage, err := box.SealAnonymous(nil, message, sharedPubKey, rand.Reader)
-	if err != nil {
-		return nil, &httpError{http.StatusInternalServerError,
-			"Failed to encrypt message payload",
-		}
+	// NOTE: sealing this way effectively makes sharedSecret a symmetric key, I think?
+	// Or maybe just makes the message unencrypted, tbh not completely sure.
+	encryptedMessage := box.Seal(nil, message, &nonce, sharedPubKey, sharedSecretKey)
 
-	}
+	encSharedKey := box.Seal(nil, sharedSecretKey[:], &nonce, &targetPubkey, sharedSecretKey)
 
-	encSharedKey, err := box.SealAnonymous(nil, sharedSecretKey[:], &targetPubkey, rand.Reader)
-	if err != nil {
-		return nil, &httpError{
-			http.StatusInternalServerError,
-			"Failed to encrypt shared secret for recipient",
-		}
-	}
+	contents := append(encSharedKey, encryptedMessage...)
+
+	fmt.Fprintln(os.Stderr, "contents total len: ", len(contents))
 
 	return &atyo.Ping{
-		Contents:  encryptedMessage,
+		Contents:  contents,
 		CreatedAt: syntax.DatetimeNow().String(),
 		Nonce:     nonce[:],
 		PublicKey: sharedPubKey[:],
-		Targets:   encSharedKey,
 	}, nil
 }
 

lexicons/ping.json

···
         "type": "object",
         "required": ["contents", "createdAt", "nonce", "publicKey"],
         "properties": {
-          "targets": {
-            "type": "bytes",
-            "description": "The one-time private key to decrypt `contents`, which has been encrypted for its recipient(s)."
-          },
           "contents": {
             "type": "bytes",
-            "description": "A message encrypted for a specific recipient, possibly including an encrypted payload. After decryption, this will deserialize as `app.atyo.ping#contents`."
+            "description": "A message encrypted for specific recipient(s), possibly including an encrypted payload. After decryption, this will deserialize as `app.atyo.ping#contents`."
           },
           "createdAt": {
             "type": "string",

public/index.html

···
       <h1>ATYo</h1>
         <form action="/login" id="login-form">
           <label for="user">Username:</label>
-          <input type="text" name="username" placeholder="@alice.example.com"><br>
+          <input type="text" name="usernane" placeholder="@alice.example.com"><br>
           <label for="password">
             App password (create <a href="https://bsky.app/settings/app-passwords">here</a>):
           </label>