forked from zntrio/httpsig
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathsigner.go
More file actions
149 lines (126 loc) · 3.97 KB
/
Copy pathsigner.go
File metadata and controls
149 lines (126 loc) · 3.97 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
// Licensed to zntr.io under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. zntr.io licenses this file to you under
// the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package httpsig
import (
"context"
"crypto"
"crypto/ecdsa"
"crypto/ed25519"
"crypto/hmac"
"crypto/rand"
"crypto/rsa"
"crypto/sha512"
"errors"
"fmt"
"net/http"
)
// NewSigner returns a signer implementation instance for `hs2019` only.
func NewSigner(krf KeyResolverFunc) Signer {
return &signer{
keyResolverFunc: krf,
}
}
// -----------------------------------------------------------------------------
type signer struct {
keyResolverFunc KeyResolverFunc
}
// Sign the given request using signature-input spec.
//nolint:cyclop // Refactor
func (s *signer) Sign(ctx context.Context, sigMeta *SignatureInput, r *http.Request) ([]byte, error) {
// Check arguments
if sigMeta == nil {
return nil, errors.New("unable to sign the request with nil signature-input")
}
if r == nil {
return nil, errors.New("unable to sign nil request")
}
// Check expiration
if sigMeta.IsExpired() {
return nil, ErrExpiredSignature
}
// Only 'hs2019' algorithms are supported
if sigMeta.Algorithm != AlgorithmHS2019 {
return nil, ErrNotSupportedSignature
}
// Retrieve key from repository
key, err := s.keyResolverFunc(ctx, sigMeta.KeyID)
if err != nil && !errors.Is(err, ErrKeyNotFound) {
return nil, fmt.Errorf("unable to retrieve key '%s': %w", sigMeta.KeyID, err)
}
if key == nil || errors.Is(err, ErrKeyNotFound) {
return nil, ErrKeyNotFound
}
// Prepare protected body
msg, err := protected(sigMeta, r)
if err != nil {
return nil, fmt.Errorf("unable to generate message: %w", err)
}
// Use appropriate verification according to key type
switch k := key.(type) {
case *rsa.PrivateKey:
return s.signRSA(k, msg)
case *ecdsa.PrivateKey:
return s.signECDSA(k, msg)
case ed25519.PrivateKey:
return s.signEdDSA(k, msg)
case []byte:
return s.sealHMAC(k, msg)
default:
}
// Unsupported key
return nil, fmt.Errorf("unsupported private key type '%T'", key)
}
// -----------------------------------------------------------------------------
// signRSA uses RSASSA-PSS with SHA-512
func (s *signer) signRSA(priv *rsa.PrivateKey, protected []byte) ([]byte, error) {
// Compute SHA-512
h := sha512.Sum512(protected)
// Sign the request
sig, err := rsa.SignPSS(rand.Reader, priv, crypto.SHA512, h[:], nil)
if err != nil {
return nil, fmt.Errorf("unable to sign request: %w", err)
}
// Default to false
return sig, nil
}
// signECDSA uses private key curve with SHA-512
func (s *signer) signECDSA(priv *ecdsa.PrivateKey, protected []byte) ([]byte, error) {
// Compute SHA-512
h := sha512.Sum512(protected)
// Sign the request
sig, err := ecdsa.SignASN1(rand.Reader, priv, h[:])
if err != nil {
return nil, fmt.Errorf("unable to sign request: %w", err)
}
// Default to false
return sig, nil
}
// signEdDSA uses Ed25519 curve with SHA-512
func (s *signer) signEdDSA(priv ed25519.PrivateKey, protected []byte) ([]byte, error) {
sig := ed25519.Sign(priv, protected)
return sig, nil
}
// sealHMAC uses HMAC with SHA-512
func (s *signer) sealHMAC(secret, protected []byte) ([]byte, error) {
// Compute HMAC-SHA-512
hm := hmac.New(sha512.New, secret)
if _, err := hm.Write(protected); err != nil {
return nil, fmt.Errorf("unable to write payload for hmac: %w", err)
}
// Default to false
return hm.Sum(nil), nil
}