Skip to content

Commit 3a36867

Browse files
AlCutterAlCutter
committed
fmt
1 parent dbc1ec6 commit 3a36867

2 files changed

Lines changed: 77 additions & 70 deletions

File tree

‎note/note_cosigv1.go‎

Lines changed: 45 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -12,8 +12,8 @@ import (
1212
"encoding/binary"
1313
"errors"
1414
"fmt"
15-
"strings"
1615
"strconv"
16+
"strings"
1717
"time"
1818
"unicode"
1919
"unicode/utf8"
@@ -29,7 +29,7 @@ const (
2929
algECDSAWithSHA256 = 2
3030
algEd25519CosignatureV1 = 4
3131
algRFC6962STH = 5
32-
algMLDSA44 = 6
32+
algMLDSA44 = 6
3333
)
3434

3535
const (
@@ -50,11 +50,11 @@ func NewMLDSASigner(skey string) (*SubtreeSigner, error) {
5050
alg, key := key[0], key[1:]
5151
if alg != algMLDSA44 {
5252
return nil, errSignerID
53-
}
53+
}
5454
return newMLDSASigner(name, key)
5555
}
5656

57-
// newMLDSASigner returns a signer for MLDSA cosignature v1, with the provided
57+
// newMLDSASigner returns a signer for MLDSA cosignature v1, with the provided
5858
// name and key bytes in the format: algo || private key.
5959
func newMLDSASigner(name string, keyBytes []byte) (*SubtreeSigner, error) {
6060
s := &SubtreeSigner{name: name}
@@ -92,14 +92,16 @@ func newMLDSASigner(name string, keyBytes []byte) (*SubtreeSigner, error) {
9292
return sig, nil
9393
}
9494
s.verifier = &SubtreeVerifier{
95-
name: name,
96-
keyHash: s.hash,
95+
name: name,
96+
keyHash: s.hash,
9797
verifyNote: func(msg, sig []byte) bool { return verifyMLDSACosigV1(pubKey, name)(msg, sig) },
98-
verifySubtree: func(timestamp uint64, logOrigin string, start, end uint64, hash []byte, sig []byte) bool { return verifyMLDSACosigV1Subtree(pubKey, name)(logOrigin, start, end, hash, sig) },
98+
verifySubtree: func(timestamp uint64, logOrigin string, start, end uint64, hash []byte, sig []byte) bool {
99+
return verifyMLDSACosigV1Subtree(pubKey, name)(logOrigin, start, end, hash, sig)
100+
},
99101
}
100102

101103
return s, nil
102-
}
104+
}
103105

104106
// NewMLDSAVerifier constructs a verifier for MLDSA cosignature v1.
105107
func NewMLDSAVerifier(vkey string) (*SubtreeVerifier, error) {
@@ -112,10 +114,10 @@ func NewMLDSAVerifier(vkey string) (*SubtreeVerifier, error) {
112114
alg, pubKeyBytes := keyBytes[0], keyBytes[1:]
113115
if alg != algMLDSA44 {
114116
return nil, errVerifierID
115-
}
117+
}
116118

117119
v := &SubtreeVerifier{
118-
name: name,
120+
name: name,
119121
keyHash: keyHashMLDSA(name, keyBytes),
120122
}
121123

@@ -124,7 +126,9 @@ func NewMLDSAVerifier(vkey string) (*SubtreeVerifier, error) {
124126
return nil, err
125127
}
126128
v.verifyNote = func(msg, sig []byte) bool { return verifyMLDSACosigV1(pubKey, name)(msg, sig) }
127-
v.verifySubtree = func(timestamp uint64, logOrigin string, start, end uint64, hash []byte, sig []byte) bool { return verifyMLDSACosigV1Subtree(pubKey, name)(logOrigin, start, end, hash, sig) }
129+
v.verifySubtree = func(timestamp uint64, logOrigin string, start, end uint64, hash []byte, sig []byte) bool {
130+
return verifyMLDSACosigV1Subtree(pubKey, name)(logOrigin, start, end, hash, sig)
131+
}
128132
return v, nil
129133
}
130134

@@ -175,7 +179,7 @@ func NewSignerForCosignatureV1(skey string) (*Signer, error) {
175179
return sig, nil
176180
}
177181
s.verify = verifyEd25519CosigV1(pubkey[1:])
178-
182+
179183
case algMLDSA44:
180184
stSigner, err := newMLDSASigner(name, key)
181185
if err != nil {
@@ -191,15 +195,15 @@ func NewSignerForCosignatureV1(skey string) (*Signer, error) {
191195

192196
// NewVerifierForCosignatureV1 constructs a new Verifier for timestamped
193197
// cosignature/v1 signatures from the provided vkey-formatted public key.
194-
//
198+
//
195199
// Supported vkey types are:
196200
// - a standard Ed25519 verifier key (type 0x01)
197201
// - an Ed25519 CosignatureV1 key (type 0x04)
198202
// - an ML-DSA-44 CosignatureV1 key (type 0x06)
199203
//
200-
// Note: If a standard Ed25519 verifier key (type 0x01) is provided, it will
201-
// be internally treated as an Ed25519 CosignatureV1 key (type 0x04), meaning
202-
// the returned Verifier has a different key hash from a non-timestamped Ed25519
204+
// Note: If a standard Ed25519 verifier key (type 0x01) is provided, it will
205+
// be internally treated as an Ed25519 CosignatureV1 key (type 0x04), meaning
206+
// the returned Verifier has a different key hash from a non-timestamped Ed25519
203207
// verifier key.
204208
func NewVerifierForCosignatureV1(vkey string) (note.Verifier, error) {
205209
name, vkey, _ := strings.Cut(vkey, "+")
@@ -370,10 +374,10 @@ func formatMLDSACosignatureV1(cosignerName string, timestamp uint64, logOrigin s
370374
// The signed message is a binary TLS presentation encoding of the
371375
// following structure:
372376
// struct {
373-
// uint8 label[12] = "subtree/v1\n\0";
377+
// uint8 label[12] = "subtree/v1\n\0";
374378
// opaque cosigner_name<1..2^8-1>;
375379
// uint64 timestamp;
376-
// opaque log_origin<1..2^8-1>;
380+
// opaque log_origin<1..2^8-1>;
377381
// uint64 start;
378382
// uint64 end;
379383
// uint8 hash[32];
@@ -396,12 +400,12 @@ func formatMLDSACosignatureV1(cosignerName string, timestamp uint64, logOrigin s
396400
}
397401

398402
var (
399-
errSignerID = errors.New("malformed signer id")
400-
errSignerAlg = errors.New("unknown signer algorithm")
401-
errVerifierID = errors.New("malformed verifier id")
402-
errVerifierAlg = errors.New("unknown verifier algorithm")
403-
errInvalidHash = errors.New("invalid key hash")
404-
errMalformedSig = errors.New("malformed signature")
403+
errSignerID = errors.New("malformed signer id")
404+
errSignerAlg = errors.New("unknown signer algorithm")
405+
errVerifierID = errors.New("malformed verifier id")
406+
errVerifierAlg = errors.New("unknown verifier algorithm")
407+
errInvalidHash = errors.New("invalid key hash")
408+
errMalformedSig = errors.New("malformed signature")
405409
errInvalidTimestamp = errors.New("invalid timestamp")
406410
)
407411

@@ -432,41 +436,44 @@ type Verifier struct {
432436
v func([]byte, []byte) bool
433437
}
434438

435-
func (v *Verifier) Name() string { return v.name }
436-
func (v *Verifier) KeyHash() uint32 { return v.keyHash }
439+
func (v *Verifier) Name() string { return v.name }
440+
func (v *Verifier) KeyHash() uint32 { return v.keyHash }
437441
func (v *Verifier) Verify(msg, sig []byte) bool { return v.v(msg, sig) }
438442

439-
440443
// SubtreeSigner is a signer that can produce both note and subtree signatures.
441444
type SubtreeSigner struct {
442-
name string
443-
hash uint32
444-
signNote func([]byte) ([]byte, error)
445+
name string
446+
hash uint32
447+
signNote func([]byte) ([]byte, error)
445448
signSubtree func(timestamp uint64, logOrigin string, start, end uint64, root []byte) ([]byte, error)
446-
verifier *SubtreeVerifier
449+
verifier *SubtreeVerifier
447450
}
448451

449452
func (s *SubtreeSigner) Name() string { return s.name }
450453
func (s *SubtreeSigner) KeyHash() uint32 { return s.hash }
451454
func (s *SubtreeSigner) Sign(msg []byte) ([]byte, error) { return s.signNote(msg) }
452-
func (s *SubtreeSigner) SignSubtree(timestamp uint64, logOrigin string, start, end uint64, root []byte) ([]byte, error) { return s.signSubtree(timestamp, logOrigin, start, end, root)}
455+
func (s *SubtreeSigner) SignSubtree(timestamp uint64, logOrigin string, start, end uint64, root []byte) ([]byte, error) {
456+
return s.signSubtree(timestamp, logOrigin, start, end, root)
457+
}
453458

454459
// SubtreeVerifier is a verifier that supports the verification of subtree signatures.
455460
//
456461
// This struct implements the note.Verifier interface to facilitate cosigning operations
457462
// against tree roots represented as checkpoints, but it can also be used to verify
458463
// arbitrary subtree roots using the VerifySubtree method.
459464
type SubtreeVerifier struct {
460-
name string
461-
keyHash uint32
462-
verifyNote func([]byte, []byte) bool
465+
name string
466+
keyHash uint32
467+
verifyNote func([]byte, []byte) bool
463468
verifySubtree func(timestamp uint64, logOrigin string, start, end uint64, hash []byte, sig []byte) bool
464469
}
465470

466-
func (v *SubtreeVerifier) Name() string { return v.name }
467-
func (v *SubtreeVerifier) KeyHash() uint32 { return v.keyHash }
471+
func (v *SubtreeVerifier) Name() string { return v.name }
472+
func (v *SubtreeVerifier) KeyHash() uint32 { return v.keyHash }
468473
func (v *SubtreeVerifier) Verify(msg, sig []byte) bool { return v.verifyNote(msg, sig) }
469-
func (v *SubtreeVerifier) VerifySubtree(timestamp uint64, logOrigin string, start, end uint64, hash []byte, sig []byte) bool { return v.verifySubtree(timestamp, logOrigin, start, end, hash, sig) }
474+
func (v *SubtreeVerifier) VerifySubtree(timestamp uint64, logOrigin string, start, end uint64, hash []byte, sig []byte) bool {
475+
return v.verifySubtree(timestamp, logOrigin, start, end, hash, sig)
476+
}
470477

471478
// isValidName reports whether name is valid.
472479
// It must be non-empty and not have any Unicode spaces or pluses.

‎note/note_cosigv1_test.go‎

Lines changed: 32 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -24,11 +24,11 @@ func TestSignerRoundtrip(t *testing.T) {
2424
skey string
2525
}{
2626
{
27-
name:"ed25519",
27+
name: "ed25519",
2828
skey: edSk,
2929
},
3030
{
31-
name: "mldsa",
31+
name: "mldsa",
3232
skey: mlSk,
3333
},
3434
} {
@@ -60,12 +60,12 @@ func TestMLDSASignerVerifierRoundtrip(t *testing.T) {
6060
vkey string
6161
}{
6262
{
63-
name:"ed25519",
63+
name: "ed25519",
6464
skey: edSk,
6565
vkey: edPk,
6666
},
6767
{
68-
name: "mldsa",
68+
name: "mldsa",
6969
skey: mlSk,
7070
vkey: mlPk,
7171
},
@@ -76,24 +76,24 @@ func TestMLDSASignerVerifierRoundtrip(t *testing.T) {
7676
t.Fatal(err)
7777
}
7878

79-
v, err := NewVerifierForCosignatureV1(test.vkey)
80-
if err != nil {
81-
t.Fatal(err)
82-
}
79+
v, err := NewVerifierForCosignatureV1(test.vkey)
80+
if err != nil {
81+
t.Fatal(err)
82+
}
8383

84-
msg := "test\n123\nf+7CoKgXKE/tNys9TTXcr/ad6U/K3xvznmzew9y6SP0=\n"
85-
n, err := note.Sign(&note.Note{Text: msg}, s)
86-
if err != nil {
87-
t.Fatal(err)
88-
}
84+
msg := "test\n123\nf+7CoKgXKE/tNys9TTXcr/ad6U/K3xvznmzew9y6SP0=\n"
85+
n, err := note.Sign(&note.Note{Text: msg}, s)
86+
if err != nil {
87+
t.Fatal(err)
88+
}
8989

90-
t.Logf("s.KeyHash(): %08x, v.KeyHash(): %08x", s.KeyHash(), v.KeyHash())
90+
t.Logf("s.KeyHash(): %08x, v.KeyHash(): %08x", s.KeyHash(), v.KeyHash())
9191

92-
if _, err := note.Open(n, note.VerifierList(v)); err != nil {
93-
t.Fatal(err)
92+
if _, err := note.Open(n, note.VerifierList(v)); err != nil {
93+
t.Fatal(err)
94+
}
95+
})
9496
}
95-
})
96-
}
9797
}
9898

9999
func TestSignerVerifierRoundtrip(t *testing.T) {
@@ -257,7 +257,7 @@ func TestVKeyToCosignatureV1(t *testing.T) {
257257
if err != nil {
258258
t.Fatalf("Failed to create cosignerv1: %v", err)
259259
}
260-
covkey, err := VKeyToCosignatureV1(vkey)
260+
covkey, err := VKeyToCosignatureV1(vkey)
261261
if err != nil {
262262
t.Fatalf("Failed to convert vkey to cosigv1 verifier: %v", err)
263263
}
@@ -286,7 +286,7 @@ func TestVKeyToCosignatureV1(t *testing.T) {
286286
}
287287
// Now check that the standard vkey cannot open a cosig signature.
288288
if _, err = note.Open(n, note.VerifierList(v)); err == nil {
289-
t.Errorf("Expected error trying to open cosigned note with standard vkey, but got success")
289+
t.Errorf("Expected error trying to open cosigned note with standard vkey, but got success")
290290
}
291291

292292
// Check that VKeyToCosignatureV1 fails for MLDSA keys.
@@ -298,17 +298,17 @@ func TestVKeyToCosignatureV1(t *testing.T) {
298298

299299
func TestSubtreeRoundtrip(t *testing.T) {
300300
skey, vkey := mustGenerateMLDSAKey(t, "mldsa")
301-
301+
302302
signer, err := NewMLDSASigner(skey)
303303
if err != nil {
304304
t.Fatal(err)
305305
}
306-
306+
307307
verifier, err := NewMLDSAVerifier(vkey)
308308
if err != nil {
309309
t.Fatal(err)
310310
}
311-
311+
312312
origin := "test-log"
313313
var start uint64 = 0
314314
var end uint64 = 10
@@ -317,23 +317,23 @@ func TestSubtreeRoundtrip(t *testing.T) {
317317
t.Fatal(err)
318318
}
319319
timestamp := uint64(time.Now().Unix())
320-
320+
321321
sig, err := signer.SignSubtree(timestamp, origin, start, end, root)
322322
if err != nil {
323323
t.Fatal(err)
324324
}
325-
325+
326326
if !verifier.VerifySubtree(timestamp, origin, start, end, root, sig) {
327327
t.Error("Failed to verify valid subtree signature")
328328
}
329-
329+
330330
// Test failure cases
331331
wrongRoot := make([]byte, 32)
332332
wrongRoot[0] = 1
333333
if verifier.VerifySubtree(timestamp, origin, start, end, wrongRoot, sig) {
334334
t.Error("VerifySubtree succeeded with wrong root")
335335
}
336-
336+
337337
if verifier.VerifySubtree(timestamp, "wrong origin", start, end, root, sig) {
338338
t.Error("VerifySubtree succeeded with wrong origin")
339339
}
@@ -345,13 +345,13 @@ func TestMLDSAInvalidTimestamp(t *testing.T) {
345345
if err != nil {
346346
t.Fatal(err)
347347
}
348-
348+
349349
origin := "test-log"
350350
var start uint64 = 10 // > 0
351351
var end uint64 = 20
352352
root := make([]byte, 32)
353353
timestamp := uint64(time.Now().Unix()) // > 0
354-
354+
355355
_, err = signer.SignSubtree(timestamp, origin, start, end, root)
356356
if err == nil {
357357
t.Error("Expected error for invalid timestamp (start > 0 && timestamp > 0), got nil")
@@ -375,11 +375,11 @@ func mustGenerateMLDSAKey(t *testing.T, name string) (string, string) {
375375
}
376376
privBytes := key.Bytes()
377377
pubBytes := key.PublicKey().Bytes()
378-
378+
379379
pubKeyWithAlg := append([]byte{algMLDSA44}, pubBytes...)
380380
hash := keyHashMLDSA(name, pubKeyWithAlg)
381-
381+
382382
skey := fmt.Sprintf("PRIVATE+KEY+%s+%08x+%s", name, hash, base64.StdEncoding.EncodeToString(append([]byte{algMLDSA44}, privBytes...)))
383383
vkey := fmt.Sprintf("%s+%08x+%s", name, hash, base64.StdEncoding.EncodeToString(pubKeyWithAlg))
384384
return skey, vkey
385-
}
385+
}

0 commit comments

Comments
 (0)