func pbToAuthz(pb *corepb.Authorization) (core.Authorization, error) { challs := make([]core.Challenge, len(pb.Challenges)) for i, c := range pb.Challenges { chall, err := pbToChallenge(c) if err != nil { return core.Authorization{}, err } challs[i] = chall } var combos [][]int err := json.Unmarshal(pb.Combinations, &combos) if err != nil { return core.Authorization{}, err } expires := time.Unix(0, *pb.Expires) return core.Authorization{ ID: *pb.Id, Identifier: core.AcmeIdentifier{Type: core.IdentifierDNS, Value: *pb.Identifier}, RegistrationID: *pb.RegistrationID, Status: core.AcmeStatus(*pb.Status), Expires: &expires, Challenges: challs, Combinations: combos, }, nil }
func pbToRegistration(pb *corepb.Registration) (core.Registration, error) { var key jose.JsonWebKey err := key.UnmarshalJSON(pb.Key) if err != nil { return core.Registration{}, err } var initialIP net.IP err = initialIP.UnmarshalText(pb.InitialIP) if err != nil { return core.Registration{}, err } var contacts *[]string if *pb.ContactsPresent { if len(pb.Contact) != 0 { contacts = &pb.Contact } else { // When gRPC creates an empty slice it is actually a nil slice. Since // certain things boulder uses, like encoding/json, differentiate between // these we need to de-nil these slices. Without this we are unable to // properly do registration updates as contacts would always be removed // as we use the difference between a nil and empty slice in ra.mergeUpdate. empty := []string{} contacts = &empty } } return core.Registration{ ID: *pb.Id, Key: &key, Contact: contacts, Agreement: *pb.Agreement, InitialIP: initialIP, CreatedAt: time.Unix(0, *pb.CreatedAt), Status: core.AcmeStatus(*pb.Status), }, nil }
func pbToChallenge(in *corepb.Challenge) (challenge core.Challenge, err error) { if in == nil { return core.Challenge{}, ErrMissingParameters } if in.Id == nil || in.Type == nil || in.Status == nil || in.Token == nil || in.KeyAuthorization == nil { return core.Challenge{}, ErrMissingParameters } return core.Challenge{ ID: *in.Id, Type: *in.Type, Status: core.AcmeStatus(*in.Status), Token: *in.Token, ProvidedKeyAuthorization: *in.KeyAuthorization, }, nil }
func pbToVAChallenge(in *corepb.Challenge) (challenge core.Challenge, err error) { if in == nil { return core.Challenge{}, ErrMissingParameters } if in.AccountKey == nil || in.Id == nil || in.Type == nil || in.Status == nil || in.Token == nil || in.KeyAuthorization == nil { return core.Challenge{}, ErrMissingParameters } jwk := new(jose.JsonWebKey) err = jwk.UnmarshalJSON(in.AccountKey) if err != nil { return } return core.Challenge{ ID: *in.Id, Type: *in.Type, Status: core.AcmeStatus(*in.Status), Token: *in.Token, AccountKey: jwk, ProvidedKeyAuthorization: *in.KeyAuthorization, }, nil }
func modelToRegistration(ri interface{}) (core.Registration, error) { var rm *regModelv1 if features.Enabled(features.AllowAccountDeactivation) { r2 := ri.(*regModelv2) rm = &r2.regModelv1 } else { rm = ri.(*regModelv1) } k := &jose.JsonWebKey{} err := json.Unmarshal(rm.Key, k) if err != nil { err = fmt.Errorf("unable to unmarshal JsonWebKey in db: %s", err) return core.Registration{}, err } var contact *[]string // Contact can be nil when the DB contains the literal string "null". We // prefer to represent this in memory as a pointer to an empty slice rather // than a nil pointer. if rm.Contact == nil { contact = &[]string{} } else { contact = &rm.Contact } r := core.Registration{ ID: rm.ID, Key: k, Contact: contact, Agreement: rm.Agreement, InitialIP: net.IP(rm.InitialIP), CreatedAt: rm.CreatedAt, } if features.Enabled(features.AllowAccountDeactivation) { r2 := ri.(*regModelv2) r.Status = core.AcmeStatus(r2.Status) } return r, nil }
// FromDb converts a DB representation back into a Boulder object. func (tc BoulderTypeConverter) FromDb(target interface{}) (gorp.CustomScanner, bool) { switch target.(type) { case *core.AcmeIdentifier, *[]core.Challenge, *[]*core.AcmeURL, *[][]int: binder := func(holder, target interface{}) error { s, ok := holder.(*string) if !ok { return errors.New("FromDb: Unable to convert *string") } b := []byte(*s) return json.Unmarshal(b, target) } return gorp.CustomScanner{Holder: new(string), Target: target, Binder: binder}, true case *jose.JsonWebKey: binder := func(holder, target interface{}) error { s, ok := holder.(*string) if !ok { return fmt.Errorf("FromDb: Unable to convert %T to *string", holder) } if *s == "" { return errors.New("FromDb: Empty JWK field.") } b := []byte(*s) k, ok := target.(*jose.JsonWebKey) if !ok { return fmt.Errorf("FromDb: Unable to convert %T to *jose.JsonWebKey", target) } return k.UnmarshalJSON(b) } return gorp.CustomScanner{Holder: new(string), Target: target, Binder: binder}, true case *core.AcmeStatus: binder := func(holder, target interface{}) error { s, ok := holder.(*string) if !ok { return fmt.Errorf("FromDb: Unable to convert %T to *string", holder) } st, ok := target.(*core.AcmeStatus) if !ok { return fmt.Errorf("FromDb: Unable to convert %T to *core.AcmeStatus", target) } *st = core.AcmeStatus(*s) return nil } return gorp.CustomScanner{Holder: new(string), Target: target, Binder: binder}, true case *core.OCSPStatus: binder := func(holder, target interface{}) error { s, ok := holder.(*string) if !ok { return fmt.Errorf("FromDb: Unable to convert %T to *string", holder) } st, ok := target.(*core.OCSPStatus) if !ok { return fmt.Errorf("FromDb: Unable to convert %T to *core.OCSPStatus", target) } *st = core.OCSPStatus(*s) return nil } return gorp.CustomScanner{Holder: new(string), Target: target, Binder: binder}, true default: return gorp.CustomScanner{}, false } }