Merge "core: minor tweaks to description and api."
diff --git a/ibe/.api b/ibe/.api
index 7bbaf0c..d2dd141 100644
--- a/ibe/.api
+++ b/ibe/.api
@@ -1,14 +1,14 @@
+pkg ibe, const CiphertextSize ideal-int
+pkg ibe, const PlaintextSize ideal-int
pkg ibe, func MarshalParams(Params) ([]byte, error)
pkg ibe, func MarshalPrivateKey(PrivateKey) ([]byte, error)
pkg ibe, func SetupBB1() (Master, error)
pkg ibe, func UnmarshalParams([]byte) (Params, error)
pkg ibe, func UnmarshalPrivateKey(Params, []byte) (PrivateKey, error)
-pkg ibe, type Ciphertext [160]byte
pkg ibe, type Master interface { Extract, Params }
pkg ibe, type Master interface, Extract(string) (PrivateKey, error)
pkg ibe, type Master interface, Params() Params
pkg ibe, type Params interface { Encrypt }
-pkg ibe, type Params interface, Encrypt(string, *Plaintext, *Ciphertext) error
-pkg ibe, type Plaintext [32]byte
+pkg ibe, type Params interface, Encrypt(string, []byte, []byte) error
pkg ibe, type PrivateKey interface { Decrypt }
-pkg ibe, type PrivateKey interface, Decrypt(*Ciphertext, *Plaintext) error
+pkg ibe, type PrivateKey interface, Decrypt([]byte, []byte) error
diff --git a/ibe/bb1.go b/ibe/bb1.go
index 71e6937..2f1351a 100644
--- a/ibe/bb1.go
+++ b/ibe/bb1.go
@@ -110,7 +110,10 @@
v *bn256.GT
}
-func (e *bb1params) Encrypt(id string, m *Plaintext, C *Ciphertext) error {
+func (e *bb1params) Encrypt(id string, m, C []byte) error {
+ if err := checkSizes(m, C); err != nil {
+ return err
+ }
s, err := random()
if err != nil {
return err
@@ -149,7 +152,10 @@
d0, d1 bn256.G2
}
-func (k *bb1PrivateKey) Decrypt(C *Ciphertext, m *Plaintext) error {
+func (k *bb1PrivateKey) Decrypt(C, m []byte) error {
+ if err := checkSizes(m, C); err != nil {
+ return err
+ }
var (
A = C[0:len(m)]
B, C1 bn256.G1
@@ -206,3 +212,10 @@
copy(dst, src)
return nil
}
+
+func checkSizes(m, C []byte) error {
+ if msize, Csize := len(m), len(C); msize != PlaintextSize || Csize != CiphertextSize {
+ return fmt.Errorf("provided plaintext and ciphertext are of sizes (%d, %d), want (%d, %d)", msize, Csize, PlaintextSize, CiphertextSize)
+ }
+ return nil
+}
diff --git a/ibe/bb1_test.go b/ibe/bb1_test.go
index 8a8f4e8..b6218c0 100644
--- a/ibe/bb1_test.go
+++ b/ibe/bb1_test.go
@@ -37,35 +37,34 @@
}
// Encrypt
- var (
- m Plaintext
- C, C2 Ciphertext
- )
- if n := copy(m[:], []byte("AThirtyTwoBytePieceOfTextThisIs!")); n != len(m) {
- t.Fatalf("Test string must be %d bytes, not %d", len(m), n)
+ m := []byte("AThirtyTwoBytePieceOfTextThisIs!")
+ C := make([]byte, CiphertextSize)
+ C2 := make([]byte, CiphertextSize)
+ if msize := len(m); msize != PlaintextSize {
+ t.Fatalf("Test string must be %d bytes, not %d", PlaintextSize, msize)
}
- if err := master.Params().Encrypt(alice, &m, &C); err != nil {
+ if err := master.Params().Encrypt(alice, m, C); err != nil {
t.Fatal(err)
}
- if err := master.Params().Encrypt(alice, &m, &C2); err != nil {
+ if err := master.Params().Encrypt(alice, m, C2); err != nil {
t.Fatal(err)
}
- if bytes.Equal(C[:], C2[:]) {
+ if bytes.Equal(C, C2) {
t.Errorf("Repeated encryptions of the identical plaintext should not produce identical ciphertext")
}
// Decrypt
- decrypt := func(sk PrivateKey) (*Plaintext, error) {
- var ret Plaintext
- if err := sk.Decrypt(&C, &ret); err != nil {
+ decrypt := func(sk PrivateKey) ([]byte, error) {
+ ret := make([]byte, PlaintextSize)
+ if err := sk.Decrypt(C, ret); err != nil {
return nil, err
}
- return &ret, nil
+ return ret, nil
}
- if decrypted, err := decrypt(aliceSK); err != nil || !bytes.Equal(decrypted[:], m[:]) {
+ if decrypted, err := decrypt(aliceSK); err != nil || !bytes.Equal(decrypted, m) {
t.Errorf("Got (%v, %v), want (%v, nil)", decrypted, err, m[:])
}
- if decrypted, err := decrypt(aliceSK2); err != nil || !bytes.Equal(decrypted[:], m[:]) {
+ if decrypted, err := decrypt(aliceSK2); err != nil || !bytes.Equal(decrypted, m) {
t.Errorf("Got (%v, %v), want (%v, nil)", decrypted, err, m[:])
}
if decrypted, _ := decrypt(bobSK); bytes.Equal(decrypted[:], m[:]) {
@@ -74,10 +73,11 @@
}
var (
- bb1 Master
- bb1SK PrivateKey
- benchmarkm Plaintext
- bb1C Ciphertext
+ bb1 Master
+ bb1SK PrivateKey
+
+ benchmarkm = make([]byte, PlaintextSize)
+ bb1C = make([]byte, CiphertextSize)
)
func TestBB1Marshaling(t *testing.T) {
@@ -90,30 +90,31 @@
if err != nil {
t.Fatal(err)
}
- var m Plaintext
- if n := copy(m[:], []byte("01234567899876543210123456789012")); n != len(m) {
- t.Fatalf("%v vs. %v", n, len(m))
- }
- var C1, C2 Ciphertext
- var m1, m2 Plaintext
+ m := []byte("01234567899876543210123456789012")
+ var (
+ C1 = make([]byte, CiphertextSize)
+ C2 = make([]byte, CiphertextSize)
+ m1 = make([]byte, PlaintextSize)
+ m2 = make([]byte, PlaintextSize)
+ )
// Encrypt with the original params, decrypt with the unmarshaled key.
- if err := bb1P.Encrypt("alice", &m, &C1); err != nil {
+ if err := bb1P.Encrypt("alice", m, C1); err != nil {
t.Error(err)
} else if sk, err := UnmarshalPrivateKey(bb1P, skbytes); err != nil {
t.Error(err)
- } else if err := sk.Decrypt(&C1, &m2); err != nil {
+ } else if err := sk.Decrypt(C1, m2); err != nil {
t.Error(err)
- } else if !bytes.Equal(m[:], m2[:]) {
+ } else if !bytes.Equal(m, m2) {
t.Errorf("Got %q, want %q", m, m2)
}
// Encrypt with the unmarshaled params, decrypt with the original key.
if p, err := UnmarshalParams(pbytes); err != nil {
t.Error(err)
- } else if err := p.Encrypt("alice", &m, &C2); err != nil {
+ } else if err := p.Encrypt("alice", m, C2); err != nil {
t.Error(err)
- } else if err := bb1SK.Decrypt(&C2, &m1); err != nil {
+ } else if err := bb1SK.Decrypt(C2, m1); err != nil {
t.Error(err)
- } else if !bytes.Equal(m[:], m1[:]) {
+ } else if !bytes.Equal(m, m1) {
t.Errorf("Got %q, want %q", m, m1)
}
@@ -157,7 +158,7 @@
if _, err := rand.Read(benchmarkm[:]); err != nil {
panic(err)
}
- if err := bb1.Params().Encrypt("alice", &benchmarkm, &bb1C); err != nil {
+ if err := bb1.Params().Encrypt("alice", benchmarkm, bb1C); err != nil {
panic(err)
}
}
@@ -172,18 +173,18 @@
func BenchmarkEncryptBB(b *testing.B) {
p := bb1.Params()
- var C Ciphertext
+ C := make([]byte, CiphertextSize)
for i := 0; i < b.N; i++ {
- if err := p.Encrypt("alice", &benchmarkm, &C); err != nil {
+ if err := p.Encrypt("alice", benchmarkm, C); err != nil {
b.Fatal(err)
}
}
}
func BenchmarkDecryptBB(b *testing.B) {
- var m Plaintext
+ m := make([]byte, PlaintextSize)
for i := 0; i < b.N; i++ {
- if err := bb1SK.Decrypt(&bb1C, &m); err != nil {
+ if err := bb1SK.Decrypt(bb1C, m); err != nil {
b.Fatal(err)
}
}
diff --git a/ibe/ibe.go b/ibe/ibe.go
index 6045cb1..0d7c60e 100644
--- a/ibe/ibe.go
+++ b/ibe/ibe.go
@@ -32,14 +32,10 @@
// systems (at the time of this writing, only for the Boneh-Boyen scheme).
package ibe
-// Plaintext represents a plaintext message that can be encrypted.
-//
-// Typical use would be for plaintext to be a key used to encrypt arbitrary
-// messages.
-type Plaintext [32]byte
-
-// Ciphertext represents an encrypted plaintext.
-type Ciphertext [160]byte
+const (
+ PlaintextSize = 32
+ CiphertextSize = 160
+)
// Master is the interface used to extract private keys for arbitrary identities.
type Master interface {
@@ -51,10 +47,17 @@
// messages for a particular identity.
type Params interface {
// Encrypt encrypts m into C for the identity id.
- Encrypt(id string, m *Plaintext, C *Ciphertext) error
+ //
+ // The slices m and C must of PlaintextSize and CiphertextSize respectively,
+ // and must not overlap.
+ Encrypt(id string, m, C []byte) error
}
// PrivateKey is the interface used to decrypt encrypted messages.
type PrivateKey interface {
- Decrypt(C *Ciphertext, m *Plaintext) error
+ // Decrypt decrypts ciphertext C into m.
+ //
+ // The slices m and C must of PlaintextSize and CiphertextSize respectively,
+ // and must not overlap.
+ Decrypt(C, m []byte) error
}
