func main() {
var err error
var challenge []byte
var response []byte
var group *bbssig.Group = new(bbssig.Group)
var gfile *os.File
gfile, err = os.Open(os.Args[3])
if err != nil {
log.Fatal(err)
}
var ghandle = bufio.NewReader(gfile)
{
var gb = basepack.Unpack(ghandle)
var success bool
_, success = group.Unmarshal(gb)
if !success {
log.Fatal("Unable to unmarshal public key")
}
}
challenge, err = base64.StdEncoding.DecodeString(os.Args[1])
if err != nil {
log.Fatal("Invalid challenge")
}
response, err = base64.StdEncoding.DecodeString(os.Args[2])
if err != nil {
log.Fatal("Invalid response")
}
if group.Verify(challenge, sha256.New(), response) {
fmt.Printf("yes\n")
os.Exit(0)
} else {
fmt.Printf("no\n")
os.Exit(1)
}
}
func main() {
var err error
var ofhandle *os.File
ofhandle, err = os.Create(os.Args[1])
if err != nil {
log.Fatal(err)
}
var privhandle *os.File
privhandle, err = os.Open(os.Args[2])
if err != nil {
log.Fatal(err)
}
var privreader *bufio.Reader
privreader = bufio.NewReader(privhandle)
var group *bbssig.Group = new(bbssig.Group)
var privkey *bbssig.PrivateKey = new(bbssig.PrivateKey)
var part *bbssig.MemberKey = new(bbssig.MemberKey)
var randreader *os.File
randreader, err = os.Open("/dev/random")
if err != nil {
log.Fatal(err)
}
var gb []byte
{
gb = basepack.Unpack(privreader)
var success bool
_, success = group.Unmarshal(gb)
if !success {
log.Fatal("Unable to unpack group data")
}
var pb = basepack.Unpack(privreader)
_, success = privkey.Unmarshal(group, pb)
if !success {
log.Fatal("Unable to unpack private key")
}
}
part, err = privkey.NewMember(randreader)
if err != nil {
log.Fatal(err)
}
{
var partbyte = part.Marshal()
objpack.PackGroup(ofhandle, part.Group)
basepack.Packout(ofhandle, partbyte)
fmt.Printf("Tag for part is ")
basepack.Packout(os.Stdout, part.Tag())
}
ofhandle.Close()
privhandle.Close()
randreader.Close()
}
func UnPackPart(partreader *bufio.Reader, group *bbssig.Group,
part *bbssig.MemberKey) {
var gb = basepack.Unpack(partreader)
var success bool
_, success = group.Unmarshal(gb)
if !success {
log.Fatal("Unable to unpack group")
}
var mb = basepack.Unpack(partreader)
_, success = part.Unmarshal(group, mb)
if !success {
log.Fatal("Unable to unpack part")
}
}
func main() {
var err error
var group = new(bbssig.Group)
var sk = new(bbssig.PrivateKey)
var part = new(bbssig.MemberKey)
var rev *bbssig.Revocation
var revbyte []byte
var partfile *os.File
partfile, err = os.Open(os.Args[1])
if err != nil {
log.Fatal(err)
}
var privfile *os.File
privfile, err = os.Open(os.Args[2])
if err != nil {
log.Fatal(err)
}
var partreader = bufio.NewReader(partfile)
var privreader = bufio.NewReader(privfile)
/* Now we have a detail, namely need to skip some stuff from
the part file before we can use it. But first load the
private key*/
{
var gb = basepack.Unpack(privreader)
var success bool
_, success = group.Unmarshal(gb)
if !success {
log.Fatal("Could not load key")
}
var sb = basepack.Unpack(privreader)
_, success = sk.Unmarshal(group, sb)
if !success {
log.Fatal("Could not load private key")
}
}
{
var success bool
basepack.Unpack(partreader) /*Skip first entry*/
var memb = basepack.Unpack(partreader)
_, success = part.Unmarshal(group, memb)
if !success {
log.Fatal("Part could not be upacked")
}
}
rev = sk.GenerateRevocation(part)
revbyte = rev.Marshal()
fmt.Printf("The revokation string is %s\n",
base64.StdEncoding.EncodeToString(revbyte))
}
func main() {
var err error
var group = new(bbssig.Group)
var priv = new(bbssig.PrivateKey)
var privhandle *os.File
privhandle, err = os.Open(os.Args[2])
if err != nil {
log.Fatal(err)
}
var privreader *bufio.Reader
privreader = bufio.NewReader(privhandle)
{
var gp []byte
var success bool
gp = basepack.Unpack(privreader)
_, success = group.Unmarshal(gp)
if !success {
log.Fatal("Unable to read group data")
}
var pb []byte
pb = basepack.Unpack(privreader)
_, success = priv.Unmarshal(group, pb)
if !success {
log.Fatal("Unable to read private key")
}
}
var sig []byte
sig, err = base64.StdEncoding.DecodeString(os.Args[1])
if err != nil {
log.Fatal("Signature is invalid")
}
var tag []byte
var success bool
tag, success = priv.Open(sig)
if !success {
log.Fatal("Signature unknown")
} else {
fmt.Printf("The tag is %s\n", base64.StdEncoding.EncodeToString(tag))
}
}
func (s *Server) revocation(from *[32]byte, signedRevocation *pond.SignedRevocation) *pond.Reply {
account, ok := s.getAccount(from)
if !ok {
return &pond.Reply{Status: pond.Reply_NO_ACCOUNT.Enum()}
}
revocation, ok := new(bbssig.Revocation).Unmarshal(signedRevocation.Revocation.Revocation)
if !ok {
return &pond.Reply{Status: pond.Reply_CANNOT_PARSE_REVOCATION.Enum()}
}
// First check that the account doesn't have too many revocations
// stored.
revPath := account.RevocationPath()
os.MkdirAll(revPath, 0777)
revDir, err := os.Open(revPath)
if err != nil {
log.Printf("Failed to open %s: %s", revPath, err)
return &pond.Reply{Status: pond.Reply_INTERNAL_ERROR.Enum()}
}
defer revDir.Close()
ents, err := revDir.Readdir(0)
if err != nil {
log.Printf("Failed to read %s: %s", revDir, err)
return &pond.Reply{Status: pond.Reply_INTERNAL_ERROR.Enum()}
}
if len(ents) > maxRevocations {
// Delete the oldest revocation.
names := make([]string, 0, len(ents))
for _, ent := range ents {
names = append(names, ent.Name())
}
sort.Strings(names)
path := filepath.Join(revPath, names[0])
if err := os.Remove(path); err != nil {
log.Printf("Failed to remove %s: %s", path, err)
return &pond.Reply{Status: pond.Reply_INTERNAL_ERROR.Enum()}
}
}
path := filepath.Join(revPath, fmt.Sprintf("%08x", *signedRevocation.Revocation.Generation))
revBytes, err := proto.Marshal(signedRevocation)
if err != nil {
log.Printf("Failed to serialise revocation: %s", err)
return &pond.Reply{Status: pond.Reply_INTERNAL_ERROR.Enum()}
}
if err := ioutil.WriteFile(path, revBytes, 0666); err != nil {
log.Printf("Failed to write revocation file: %s", err)
return &pond.Reply{Status: pond.Reply_INTERNAL_ERROR.Enum()}
}
group := account.Group()
if group == nil {
return &pond.Reply{Status: pond.Reply_INTERNAL_ERROR.Enum()}
}
groupCopy, _ := new(bbssig.Group).Unmarshal(group.Marshal())
groupCopy.Update(revocation)
account.Lock()
defer account.Unlock()
account.group = groupCopy
groupPath := filepath.Join(account.Path(), "group")
if err := ioutil.WriteFile(groupPath, groupCopy.Marshal(), 0600); err != nil {
log.Printf("failed to write group file: %s", err)
}
return nil
}
func PackGroup(out io.Writer, g *bbssig.Group) {
var pub []byte
pub = g.Marshal()
basepack.Packout(out, pub)
}
