// NewRegistrationAuthorityServer constructs an RPC server func NewRegistrationAuthorityServer(rpc Server, impl core.RegistrationAuthority, log blog.Logger) error { rpc.Handle(MethodNewRegistration, func(ctx context.Context, req []byte) (response []byte, err error) { var rr registrationRequest if err = json.Unmarshal(req, &rr); err != nil { improperMessage(MethodNewRegistration, err, req) return } reg, err := impl.NewRegistration(ctx, rr.Reg) if err != nil { return } response, err = json.Marshal(reg) if err != nil { errorCondition(MethodNewRegistration, err, req) return } return }) rpc.Handle(MethodNewAuthorization, func(ctx context.Context, req []byte) (response []byte, err error) { var ar authorizationRequest if err = json.Unmarshal(req, &ar); err != nil { improperMessage(MethodNewAuthorization, err, req) return } authz, err := impl.NewAuthorization(ctx, ar.Authz, ar.RegID) if err != nil { return } response, err = json.Marshal(authz) if err != nil { errorCondition(MethodNewAuthorization, err, req) return } return }) rpc.Handle(MethodNewCertificate, func(ctx context.Context, req []byte) (response []byte, err error) { var cr certificateRequest if err = json.Unmarshal(req, &cr); err != nil { improperMessage(MethodNewCertificate, err, req) return } cert, err := impl.NewCertificate(ctx, cr.Req, cr.RegID) if err != nil { return } response, err = json.Marshal(cert) if err != nil { errorCondition(MethodNewCertificate, err, req) return } return }) rpc.Handle(MethodUpdateRegistration, func(ctx context.Context, req []byte) (response []byte, err error) { var urReq updateRegistrationRequest err = json.Unmarshal(req, &urReq) if err != nil { improperMessage(MethodUpdateRegistration, err, req) return } reg, err := impl.UpdateRegistration(ctx, urReq.Base, urReq.Update) if err != nil { return } response, err = json.Marshal(reg) if err != nil { errorCondition(MethodUpdateRegistration, err, req) return } return }) rpc.Handle(MethodUpdateAuthorization, func(ctx context.Context, req []byte) (response []byte, err error) { var uaReq updateAuthorizationRequest err = json.Unmarshal(req, &uaReq) if err != nil { improperMessage(MethodUpdateAuthorization, err, req) return } newAuthz, err := impl.UpdateAuthorization(ctx, uaReq.Authz, uaReq.Index, uaReq.Response) if err != nil { return } response, err = json.Marshal(newAuthz) if err != nil { errorCondition(MethodUpdateAuthorization, err, req) return } return }) rpc.Handle(MethodRevokeCertificateWithReg, func(ctx context.Context, req []byte) (response []byte, err error) { var revReq struct { Cert []byte Reason revocation.Reason RegID int64 } if err = json.Unmarshal(req, &revReq); err != nil { improperMessage(MethodRevokeCertificateWithReg, err, req) return } cert, err := x509.ParseCertificate(revReq.Cert) if err != nil { return } err = impl.RevokeCertificateWithReg(ctx, *cert, revReq.Reason, revReq.RegID) return }) rpc.Handle(MethodAdministrativelyRevokeCertificate, func(ctx context.Context, req []byte) (response []byte, err error) { var revReq struct { Cert []byte Reason revocation.Reason User string } if err = json.Unmarshal(req, &revReq); err != nil { improperMessage(MethodAdministrativelyRevokeCertificate, err, req) return } cert, err := x509.ParseCertificate(revReq.Cert) if err != nil { return } err = impl.AdministrativelyRevokeCertificate(ctx, *cert, revReq.Reason, revReq.User) return }) rpc.Handle(MethodDeactivateAuthorization, func(ctx context.Context, req []byte) (response []byte, err error) { var authz core.Authorization err = json.Unmarshal(req, &authz) if err != nil { errorCondition(MethodDeactivateAuthorization, err, req) return } err = impl.DeactivateAuthorization(ctx, authz) return }) rpc.Handle(MethodDeactivateRegistration, func(ctx context.Context, req []byte) (response []byte, err error) { var reg core.Registration err = json.Unmarshal(req, ®) if err != nil { errorCondition(MethodDeactivateRegistration, err, req) return } err = impl.DeactivateRegistration(ctx, reg) return }) return nil }