7039862713

Committed 29 Nov 2023 11:34PM UTC coverage: 88.586% (-0.2%) from 88.765%

Build # 7039862713

Build Type

Pull #187

github

Committed by

AdamKorcz

Commit Message

Add length check to github signature

Signed-off-by: AdamKorcz <adam@adalogics.com>

Pull Request Pull Request #187: Add length check to github signature

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

2 existing lines in 1 file now uncovered.

877 of 990 relevant lines covered (88.59%)

8.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.07

/github/github.go

package github

import (
        "crypto/hmac"
        "crypto/sha256"
        "encoding/hex"
        "encoding/json"
        "errors"
        "fmt"
        "io"
        "net/http"
        "strings"
)

// parse errors
var (
        ErrEventNotSpecifiedToParse  = errors.New("no Event specified to parse")
        ErrInvalidHTTPMethod         = errors.New("invalid HTTP Method")
        ErrMissingGithubEventHeader  = errors.New("missing X-GitHub-Event Header")
        ErrMissingHubSignatureHeader = errors.New("missing X-Hub-Signature-256 Header")
        ErrEventNotFound             = errors.New("event not defined to be parsed")
        ErrParsingPayload            = errors.New("error parsing payload")
        ErrHMACVerificationFailed    = errors.New("HMAC verification failed")
        ErrWrongHubSignatureHeader   = errors.New("Invalid Github signature")
)

// Event defines a GitHub hook event type
type Event string

// GitHub hook types
const (
        CheckRunEvent                            Event = "check_run"
        CheckSuiteEvent                          Event = "check_suite"
        CommitCommentEvent                       Event = "commit_comment"
        CreateEvent                              Event = "create"
        DeleteEvent                              Event = "delete"
        DependabotAlertEvent                     Event = "dependabot_alert"
        DeployKeyEvent                           Event = "deploy_key"
        DeploymentEvent                          Event = "deployment"
        DeploymentStatusEvent                    Event = "deployment_status"
        ForkEvent                                Event = "fork"
        GollumEvent                              Event = "gollum"
        InstallationEvent                        Event = "installation"
        InstallationRepositoriesEvent            Event = "installation_repositories"
        IntegrationInstallationEvent             Event = "integration_installation"
        IntegrationInstallationRepositoriesEvent Event = "integration_installation_repositories"
        IssueCommentEvent                        Event = "issue_comment"
        IssuesEvent                              Event = "issues"
        LabelEvent                               Event = "label"
        MemberEvent                              Event = "member"
        MembershipEvent                          Event = "membership"
        MilestoneEvent                           Event = "milestone"
        MetaEvent                                Event = "meta"
        OrganizationEvent                        Event = "organization"
        OrgBlockEvent                            Event = "org_block"
        PageBuildEvent                           Event = "page_build"
        PingEvent                                Event = "ping"
        ProjectCardEvent                         Event = "project_card"
        ProjectColumnEvent                       Event = "project_column"
        ProjectEvent                             Event = "project"
        PublicEvent                              Event = "public"
        PullRequestEvent                         Event = "pull_request"
        PullRequestReviewEvent                   Event = "pull_request_review"
        PullRequestReviewCommentEvent            Event = "pull_request_review_comment"
        PushEvent                                Event = "push"
        ReleaseEvent                             Event = "release"
        RepositoryEvent                          Event = "repository"
        RepositoryVulnerabilityAlertEvent        Event = "repository_vulnerability_alert"
        SecurityAdvisoryEvent                    Event = "security_advisory"
        StatusEvent                              Event = "status"
        TeamEvent                                Event = "team"
        TeamAddEvent                             Event = "team_add"
        WatchEvent                               Event = "watch"
        WorkflowDispatchEvent                    Event = "workflow_dispatch"
        WorkflowJobEvent                         Event = "workflow_job"
        WorkflowRunEvent                         Event = "workflow_run"
        GitHubAppAuthorizationEvent              Event = "github_app_authorization"
)

// EventSubtype defines a GitHub Hook Event subtype
type EventSubtype string

// GitHub hook event subtypes
const (
        NoSubtype     EventSubtype = ""
        BranchSubtype EventSubtype = "branch"
        TagSubtype    EventSubtype = "tag"
        PullSubtype   EventSubtype = "pull"
        IssueSubtype  EventSubtype = "issues"
)

// Option is a configuration option for the webhook
type Option func(*Webhook) error

// Options is a namespace var for configuration options
var Options = WebhookOptions{}

// WebhookOptions is a namespace for configuration option methods
type WebhookOptions struct{}

// Secret registers the GitHub secret
func (WebhookOptions) Secret(secret string) Option {
        return func(hook *Webhook) error {
                hook.secret = secret
                return nil
        }
}

// Webhook instance contains all methods needed to process events
type Webhook struct {
        secret string
}

// New creates and returns a WebHook instance denoted by the Provider type
func New(options ...Option) (*Webhook, error) {
        hook := new(Webhook)
        for _, opt := range options {
                if err := opt(hook); err != nil {
                        return nil, errors.New("Error applying Option")
                }
        }
        return hook, nil
}

// Parse verifies and parses the events specified and returns the payload object or an error
func (hook Webhook) Parse(r *http.Request, events ...Event) (interface{}, error) {
        defer func() {
                _, _ = io.Copy(io.Discard, r.Body)
                _ = r.Body.Close()
        }()

        if len(events) == 0 {
                return nil, ErrEventNotSpecifiedToParse
        }
        if r.Method != http.MethodPost {
                return nil, ErrInvalidHTTPMethod
        }

        event := r.Header.Get("X-GitHub-Event")
        if event == "" {
                return nil, ErrMissingGithubEventHeader
        }
        gitHubEvent := Event(event)

        var found bool
        for _, evt := range events {
                if evt == gitHubEvent {
                        found = true
                        break
                }
        }
        // event not defined to be parsed
        if !found {
                return nil, ErrEventNotFound
        }

        payload, err := io.ReadAll(r.Body)
        if err != nil || len(payload) == 0 {
                return nil, ErrParsingPayload
        }

        // If we have a Secret set, we should check the MAC
        if len(hook.secret) > 0 {
                signature := r.Header.Get("X-Hub-Signature-256")
                if len(signature) == 0 {
                        return nil, ErrMissingHubSignatureHeader
                }

                signature = strings.TrimPrefix(signature, "sha256=")
                if len(signature) < 6 {
                        return nil, ErrWrongHubSignatureHeader
                }
                mac := hmac.New(sha256.New, []byte(hook.secret))
                _, _ = mac.Write(payload)
                expectedMAC := hex.EncodeToString(mac.Sum(nil))

                if !hmac.Equal([]byte(signature), []byte(expectedMAC)) {
                        return nil, ErrHMACVerificationFailed
                }
        }

        switch gitHubEvent {
        case CheckRunEvent:
                var pl CheckRunPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case CheckSuiteEvent:
                var pl CheckSuitePayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case CommitCommentEvent:
                var pl CommitCommentPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case CreateEvent:
                var pl CreatePayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case DeployKeyEvent:
                var pl DeployKeyPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case DeleteEvent:
                var pl DeletePayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case DependabotAlertEvent:
                var pl DependabotAlertPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case DeploymentEvent:
                var pl DeploymentPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case DeploymentStatusEvent:
                var pl DeploymentStatusPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case ForkEvent:
                var pl ForkPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case GollumEvent:
                var pl GollumPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case InstallationEvent, IntegrationInstallationEvent:
                var pl InstallationPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case InstallationRepositoriesEvent, IntegrationInstallationRepositoriesEvent:
                var pl InstallationRepositoriesPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case IssueCommentEvent:
                var pl IssueCommentPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case IssuesEvent:
                var pl IssuesPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case LabelEvent:
                var pl LabelPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case MemberEvent:
                var pl MemberPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case MembershipEvent:
                var pl MembershipPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case MetaEvent:
                var pl MetaPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case MilestoneEvent:
                var pl MilestonePayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case OrganizationEvent:
                var pl OrganizationPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case OrgBlockEvent:
                var pl OrgBlockPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case PageBuildEvent:
                var pl PageBuildPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case PingEvent:
                var pl PingPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case ProjectCardEvent:
                var pl ProjectCardPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case ProjectColumnEvent:
                var pl ProjectColumnPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case ProjectEvent:
                var pl ProjectPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case PublicEvent:
                var pl PublicPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case PullRequestEvent:
                var pl PullRequestPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case PullRequestReviewEvent:
                var pl PullRequestReviewPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case PullRequestReviewCommentEvent:
                var pl PullRequestReviewCommentPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case PushEvent:
                var pl PushPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case ReleaseEvent:
                var pl ReleasePayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case RepositoryEvent:
                var pl RepositoryPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case RepositoryVulnerabilityAlertEvent:
                var pl RepositoryVulnerabilityAlertPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case SecurityAdvisoryEvent:
                var pl SecurityAdvisoryPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case StatusEvent:
                var pl StatusPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case TeamEvent:
                var pl TeamPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case TeamAddEvent:
                var pl TeamAddPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case WatchEvent:
                var pl WatchPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case WorkflowDispatchEvent:
                var pl WorkflowDispatchPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case WorkflowJobEvent:
                var pl WorkflowJobPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case WorkflowRunEvent:
                var pl WorkflowRunPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        case GitHubAppAuthorizationEvent:
                var pl GitHubAppAuthorizationPayload
                err = json.Unmarshal([]byte(payload), &pl)
                return pl, err
        default:
                return nil, fmt.Errorf("unknown event %s", gitHubEvent)
        }
}

1	package github
2
3	import (
4	"crypto/hmac"
5	"crypto/sha256"
6	"encoding/hex"
7	"encoding/json"
8	"errors"
9	"fmt"
10	"io"
11	"net/http"
12	"strings"
13	)
14
15	// parse errors
16	var (
17	ErrEventNotSpecifiedToParse = errors.New("no Event specified to parse")
18	ErrInvalidHTTPMethod = errors.New("invalid HTTP Method")
19	ErrMissingGithubEventHeader = errors.New("missing X-GitHub-Event Header")
20	ErrMissingHubSignatureHeader = errors.New("missing X-Hub-Signature-256 Header")
21	ErrEventNotFound = errors.New("event not defined to be parsed")
22	ErrParsingPayload = errors.New("error parsing payload")
23	ErrHMACVerificationFailed = errors.New("HMAC verification failed")
24	ErrWrongHubSignatureHeader = errors.New("Invalid Github signature")
25	)
26
27	// Event defines a GitHub hook event type
28	type Event string
29
30	// GitHub hook types
31	const (
32	CheckRunEvent Event = "check_run"
33	CheckSuiteEvent Event = "check_suite"
34	CommitCommentEvent Event = "commit_comment"
35	CreateEvent Event = "create"
36	DeleteEvent Event = "delete"
37	DependabotAlertEvent Event = "dependabot_alert"
38	DeployKeyEvent Event = "deploy_key"
39	DeploymentEvent Event = "deployment"
40	DeploymentStatusEvent Event = "deployment_status"
41	ForkEvent Event = "fork"
42	GollumEvent Event = "gollum"
43	InstallationEvent Event = "installation"
44	InstallationRepositoriesEvent Event = "installation_repositories"
45	IntegrationInstallationEvent Event = "integration_installation"
46	IntegrationInstallationRepositoriesEvent Event = "integration_installation_repositories"
47	IssueCommentEvent Event = "issue_comment"
48	IssuesEvent Event = "issues"
49	LabelEvent Event = "label"
50	MemberEvent Event = "member"
51	MembershipEvent Event = "membership"
52	MilestoneEvent Event = "milestone"
53	MetaEvent Event = "meta"
54	OrganizationEvent Event = "organization"
55	OrgBlockEvent Event = "org_block"
56	PageBuildEvent Event = "page_build"
57	PingEvent Event = "ping"
58	ProjectCardEvent Event = "project_card"
59	ProjectColumnEvent Event = "project_column"
60	ProjectEvent Event = "project"
61	PublicEvent Event = "public"
62	PullRequestEvent Event = "pull_request"
63	PullRequestReviewEvent Event = "pull_request_review"
64	PullRequestReviewCommentEvent Event = "pull_request_review_comment"
65	PushEvent Event = "push"
66	ReleaseEvent Event = "release"
67	RepositoryEvent Event = "repository"
68	RepositoryVulnerabilityAlertEvent Event = "repository_vulnerability_alert"
69	SecurityAdvisoryEvent Event = "security_advisory"
70	StatusEvent Event = "status"
71	TeamEvent Event = "team"
72	TeamAddEvent Event = "team_add"
73	WatchEvent Event = "watch"
74	WorkflowDispatchEvent Event = "workflow_dispatch"
75	WorkflowJobEvent Event = "workflow_job"
76	WorkflowRunEvent Event = "workflow_run"
77	GitHubAppAuthorizationEvent Event = "github_app_authorization"
78	)
79
80	// EventSubtype defines a GitHub Hook Event subtype
81	type EventSubtype string
82
83	// GitHub hook event subtypes
84	const (
85	NoSubtype EventSubtype = ""
86	BranchSubtype EventSubtype = "branch"
87	TagSubtype EventSubtype = "tag"
88	PullSubtype EventSubtype = "pull"
89	IssueSubtype EventSubtype = "issues"
90	)
91
92	// Option is a configuration option for the webhook
93	type Option func(*Webhook) error
94
95	// Options is a namespace var for configuration options
96	var Options = WebhookOptions{}
97
98	// WebhookOptions is a namespace for configuration option methods
99	type WebhookOptions struct{}
100
101	// Secret registers the GitHub secret
102	func (WebhookOptions) Secret(secret string) Option {	1✔
103	return func(hook *Webhook) error {	2✔
104	hook.secret = secret	1✔
105	return nil	1✔
106	}	1✔
107	}
108
109	// Webhook instance contains all methods needed to process events
110	type Webhook struct {
111	secret string
112	}
113
114	// New creates and returns a WebHook instance denoted by the Provider type
115	func New(options ...Option) (*Webhook, error) {	1✔
116	hook := new(Webhook)	1✔
117	for _, opt := range options {	2✔
118	if err := opt(hook); err != nil {	1✔
119	return nil, errors.New("Error applying Option")	×
120	}	×
121	}
122	return hook, nil	1✔
123	}
124
125	// Parse verifies and parses the events specified and returns the payload object or an error
126	func (hook Webhook) Parse(r *http.Request, events ...Event) (interface{}, error) {	53✔
127	defer func() {	106✔
128	_, _ = io.Copy(io.Discard, r.Body)	53✔
129	_ = r.Body.Close()	53✔
130	}()	53✔
131
132	if len(events) == 0 {	53✔
133	return nil, ErrEventNotSpecifiedToParse	×
134	}	×
135	if r.Method != http.MethodPost {	53✔
136	return nil, ErrInvalidHTTPMethod	×
137	}	×
138
139	event := r.Header.Get("X-GitHub-Event")	53✔
140	if event == "" {	54✔
141	return nil, ErrMissingGithubEventHeader	1✔
142	}	1✔
143	gitHubEvent := Event(event)	52✔
144		52✔
145	var found bool	52✔
146	for _, evt := range events {	104✔
147	if evt == gitHubEvent {	103✔
148	found = true	51✔
149	break	51✔
150	}
151	}
152	// event not defined to be parsed
153	if !found {	53✔
154	return nil, ErrEventNotFound	1✔
155	}	1✔
156
157	payload, err := io.ReadAll(r.Body)	51✔
158	if err != nil \|\| len(payload) == 0 {	52✔
159	return nil, ErrParsingPayload	1✔
160	}	1✔
161
162	// If we have a Secret set, we should check the MAC
163	if len(hook.secret) > 0 {	100✔
164	signature := r.Header.Get("X-Hub-Signature-256")	50✔
165	if len(signature) == 0 {	52✔
166	return nil, ErrMissingHubSignatureHeader	2✔
167	}	2✔
168
169	signature = strings.TrimPrefix(signature, "sha256=")	48✔
170	if len(signature) < 6 {	49✔
171	return nil, ErrWrongHubSignatureHeader	1✔
172	}	1✔
173	mac := hmac.New(sha256.New, []byte(hook.secret))	47✔
174	_, _ = mac.Write(payload)	47✔
175	expectedMAC := hex.EncodeToString(mac.Sum(nil))	47✔
176		47✔
177	if !hmac.Equal([]byte(signature), []byte(expectedMAC)) {	47✔
UNCOV 178	return nil, ErrHMACVerificationFailed	×
UNCOV 179	}	×
180	}
181
182	switch gitHubEvent {	47✔
183	case CheckRunEvent:	1✔
184	var pl CheckRunPayload	1✔
185	err = json.Unmarshal([]byte(payload), &pl)	1✔
186	return pl, err	1✔
187	case CheckSuiteEvent:	1✔
188	var pl CheckSuitePayload	1✔
189	err = json.Unmarshal([]byte(payload), &pl)	1✔
190	return pl, err	1✔
191	case CommitCommentEvent:	1✔
192	var pl CommitCommentPayload	1✔
193	err = json.Unmarshal([]byte(payload), &pl)	1✔
194	return pl, err	1✔
195	case CreateEvent:	1✔
196	var pl CreatePayload	1✔
197	err = json.Unmarshal([]byte(payload), &pl)	1✔
198	return pl, err	1✔
199	case DeployKeyEvent:	1✔
200	var pl DeployKeyPayload	1✔
201	err = json.Unmarshal([]byte(payload), &pl)	1✔
202	return pl, err	1✔
203	case DeleteEvent:	1✔
204	var pl DeletePayload	1✔
205	err = json.Unmarshal([]byte(payload), &pl)	1✔
206	return pl, err	1✔
207	case DependabotAlertEvent:	1✔
208	var pl DependabotAlertPayload	1✔
209	err = json.Unmarshal([]byte(payload), &pl)	1✔
210	return pl, err	1✔
211	case DeploymentEvent:	1✔
212	var pl DeploymentPayload	1✔
213	err = json.Unmarshal([]byte(payload), &pl)	1✔
214	return pl, err	1✔
215	case DeploymentStatusEvent:	1✔
216	var pl DeploymentStatusPayload	1✔
217	err = json.Unmarshal([]byte(payload), &pl)	1✔
218	return pl, err	1✔
219	case ForkEvent:	1✔
220	var pl ForkPayload	1✔
221	err = json.Unmarshal([]byte(payload), &pl)	1✔
222	return pl, err	1✔
223	case GollumEvent:	1✔
224	var pl GollumPayload	1✔
225	err = json.Unmarshal([]byte(payload), &pl)	1✔
226	return pl, err	1✔
227	case InstallationEvent, IntegrationInstallationEvent:	2✔
228	var pl InstallationPayload	2✔
229	err = json.Unmarshal([]byte(payload), &pl)	2✔
230	return pl, err	2✔
231	case InstallationRepositoriesEvent, IntegrationInstallationRepositoriesEvent:	2✔
232	var pl InstallationRepositoriesPayload	2✔
233	err = json.Unmarshal([]byte(payload), &pl)	2✔
234	return pl, err	2✔
235	case IssueCommentEvent:	2✔
236	var pl IssueCommentPayload	2✔
237	err = json.Unmarshal([]byte(payload), &pl)	2✔
238	return pl, err	2✔
239	case IssuesEvent:	1✔
240	var pl IssuesPayload	1✔
241	err = json.Unmarshal([]byte(payload), &pl)	1✔
242	return pl, err	1✔
243	case LabelEvent:	1✔
244	var pl LabelPayload	1✔
245	err = json.Unmarshal([]byte(payload), &pl)	1✔
246	return pl, err	1✔
247	case MemberEvent:	1✔
248	var pl MemberPayload	1✔
249	err = json.Unmarshal([]byte(payload), &pl)	1✔
250	return pl, err	1✔
251	case MembershipEvent:	1✔
252	var pl MembershipPayload	1✔
253	err = json.Unmarshal([]byte(payload), &pl)	1✔
254	return pl, err	1✔
255	case MetaEvent:	×
256	var pl MetaPayload	×
257	err = json.Unmarshal([]byte(payload), &pl)	×
258	return pl, err	×
259	case MilestoneEvent:	1✔
260	var pl MilestonePayload	1✔
261	err = json.Unmarshal([]byte(payload), &pl)	1✔
262	return pl, err	1✔
263	case OrganizationEvent:	1✔
264	var pl OrganizationPayload	1✔
265	err = json.Unmarshal([]byte(payload), &pl)	1✔
266	return pl, err	1✔
267	case OrgBlockEvent:	1✔
268	var pl OrgBlockPayload	1✔
269	err = json.Unmarshal([]byte(payload), &pl)	1✔
270	return pl, err	1✔
271	case PageBuildEvent:	1✔
272	var pl PageBuildPayload	1✔
273	err = json.Unmarshal([]byte(payload), &pl)	1✔
274	return pl, err	1✔
275	case PingEvent:	1✔
276	var pl PingPayload	1✔
277	err = json.Unmarshal([]byte(payload), &pl)	1✔
278	return pl, err	1✔
279	case ProjectCardEvent:	1✔
280	var pl ProjectCardPayload	1✔
281	err = json.Unmarshal([]byte(payload), &pl)	1✔
282	return pl, err	1✔
283	case ProjectColumnEvent:	1✔
284	var pl ProjectColumnPayload	1✔
285	err = json.Unmarshal([]byte(payload), &pl)	1✔
286	return pl, err	1✔
287	case ProjectEvent:	1✔
288	var pl ProjectPayload	1✔
289	err = json.Unmarshal([]byte(payload), &pl)	1✔
290	return pl, err	1✔
291	case PublicEvent:	1✔
292	var pl PublicPayload	1✔
293	err = json.Unmarshal([]byte(payload), &pl)	1✔
294	return pl, err	1✔
295	case PullRequestEvent:	1✔
296	var pl PullRequestPayload	1✔
297	err = json.Unmarshal([]byte(payload), &pl)	1✔
298	return pl, err	1✔
299	case PullRequestReviewEvent:	1✔
300	var pl PullRequestReviewPayload	1✔
301	err = json.Unmarshal([]byte(payload), &pl)	1✔
302	return pl, err	1✔
303	case PullRequestReviewCommentEvent:	1✔
304	var pl PullRequestReviewCommentPayload	1✔
305	err = json.Unmarshal([]byte(payload), &pl)	1✔
306	return pl, err	1✔
307	case PushEvent:	1✔
308	var pl PushPayload	1✔
309	err = json.Unmarshal([]byte(payload), &pl)	1✔
310	return pl, err	1✔
311	case ReleaseEvent:	1✔
312	var pl ReleasePayload	1✔
313	err = json.Unmarshal([]byte(payload), &pl)	1✔
314	return pl, err	1✔
315	case RepositoryEvent:	2✔
316	var pl RepositoryPayload	2✔
317	err = json.Unmarshal([]byte(payload), &pl)	2✔
318	return pl, err	2✔
319	case RepositoryVulnerabilityAlertEvent:	1✔
320	var pl RepositoryVulnerabilityAlertPayload	1✔
321	err = json.Unmarshal([]byte(payload), &pl)	1✔
322	return pl, err	1✔
323	case SecurityAdvisoryEvent:	1✔
324	var pl SecurityAdvisoryPayload	1✔
325	err = json.Unmarshal([]byte(payload), &pl)	1✔
326	return pl, err	1✔
327	case StatusEvent:	1✔
328	var pl StatusPayload	1✔
329	err = json.Unmarshal([]byte(payload), &pl)	1✔
330	return pl, err	1✔
331	case TeamEvent:	1✔
332	var pl TeamPayload	1✔
333	err = json.Unmarshal([]byte(payload), &pl)	1✔
334	return pl, err	1✔
335	case TeamAddEvent:	1✔
336	var pl TeamAddPayload	1✔
337	err = json.Unmarshal([]byte(payload), &pl)	1✔
338	return pl, err	1✔
339	case WatchEvent:	1✔
340	var pl WatchPayload	1✔
341	err = json.Unmarshal([]byte(payload), &pl)	1✔
342	return pl, err	1✔
343	case WorkflowDispatchEvent:	1✔
344	var pl WorkflowDispatchPayload	1✔
345	err = json.Unmarshal([]byte(payload), &pl)	1✔
346	return pl, err	1✔
347	case WorkflowJobEvent:	1✔
348	var pl WorkflowJobPayload	1✔
349	err = json.Unmarshal([]byte(payload), &pl)	1✔
350	return pl, err	1✔
351	case WorkflowRunEvent:	1✔
352	var pl WorkflowRunPayload	1✔
353	err = json.Unmarshal([]byte(payload), &pl)	1✔
354	return pl, err	1✔
355	case GitHubAppAuthorizationEvent:	1✔
356	var pl GitHubAppAuthorizationPayload	1✔
357	err = json.Unmarshal([]byte(payload), &pl)	1✔
358	return pl, err	1✔
359	default:	×
360	return nil, fmt.Errorf("unknown event %s", gitHubEvent)	×
361	}
362	}

go-playground / webhooks / 7039862713

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous