//export Java_io_v_v23_security_PublicKeyThirdPartyCaveatValidator_nativeValidate
func Java_io_v_v23_security_PublicKeyThirdPartyCaveatValidator_nativeValidate(jenv *C.JNIEnv, jThirdPartyValidatorClass C.jclass, jContext C.jobject, jCall C.jobject, jCaveatParam C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
param, err := jutil.GoVomCopyValue(env, jutil.Object(uintptr(unsafe.Pointer(jCaveatParam))))
if err != nil {
jutil.JThrowV(env, err)
return
}
ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
if err != nil {
jutil.JThrowV(env, err)
return
}
call, err := GoCall(env, jutil.Object(uintptr(unsafe.Pointer(jCall))))
if err != nil {
jutil.JThrowV(env, err)
return
}
caveat, err := security.NewCaveat(security.PublicKeyThirdPartyCaveat, param)
if err != nil {
jutil.JThrowV(env, err)
return
}
if err := caveat.Validate(ctx, call); err != nil {
jutil.JThrowV(env, err)
return
}
}
func (g *granter) Grant(ctx *context.T, call security.Call) (security.Blessings, error) {
// Verify that the remote end's blessings encapsulates the
// same user identity as g.user.
remoteBlessingNames, _ := security.RemoteBlessingNames(ctx, call)
authorized := false
for _, b := range remoteBlessingNames {
if vUser(b) == g.user {
authorized = true
}
}
if !authorized {
return security.Blessings{}, fmt.Errorf("remote end presented blessings %v, want a blessing for user %v", remoteBlessingNames, g.user)
}
peerPattern := security.BlessingPattern(g.lockName)
onlyThisLockCav, err := security.NewCaveat(security.PeerBlessingsCaveat, []security.BlessingPattern{peerPattern})
if err != nil {
return security.Blessings{}, fmt.Errorf("failed to create peer blessings caveat for key: %v", err)
}
caveats := []security.Caveat{onlyThisLockCav}
if g.expiry != 0 {
expiryCav, err := security.NewExpiryCaveat(time.Now().Add(g.expiry))
if err != nil {
return security.Blessings{}, fmt.Errorf("failed to create expiration caveat for key: %v", err)
}
caveats = append(caveats, expiryCav)
}
return call.LocalPrincipal().Bless(call.RemoteBlessings().PublicKey(), g.key, g.category, caveats[0], caveats[1:]...)
}
func (ul *unclaimedLock) makeKey(principal security.Principal, name string, remoteKey security.PublicKey) (security.Blessings, error) {
lockBlessing, err := principal.BlessSelf(name)
if err != nil {
return security.Blessings{}, err
}
if err := principal.BlessingStore().SetDefault(lockBlessing); err != nil {
return security.Blessings{}, err
}
if err := security.AddToRoots(principal, lockBlessing); err != nil {
return security.Blessings{}, err
}
// Add a caveat to the "key" blessing so that it can only be used to talking
// to this lock object.
// TODO(ataly): Add a client-only caveat as well so that someone who obtains
// this blessing or an extension of it cannot maliciously (or accidentally)
// start a server with this blessing (such a server could impersonate this
// lock object).
peerPattern := security.BlessingPattern(name)
onlyThisLockCav, err := security.NewCaveat(security.PeerBlessingsCaveat, []security.BlessingPattern{peerPattern})
if err != nil {
return security.Blessings{}, err
}
keyBlessing, err := principal.Bless(remoteKey, lockBlessing, keyBlessingExtension, onlyThisLockCav)
if err != nil {
return security.Blessings{}, err
}
return keyBlessing, nil
}
