mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-08-23 21:17:58 +02:00
* Import github.com/git-lfs/lfs-test-server as lfs module base Imported commit is 3968aac269a77b73924649b9412ae03f7ccd3198 Removed: Dockerfile CONTRIBUTING.md mgmt* script/ vendor/ kvlogger.go .dockerignore .gitignore README.md * Remove config, add JWT support from github.com/mgit-at/lfs-test-server Imported commit f0cdcc5a01599c5a955dc1bbf683bb4acecdba83 * Add LFS settings * Add LFS meta object model * Add LFS routes and initialization * Import github.com/dgrijalva/jwt-go into vendor/ * Adapt LFS module: handlers, routing, meta store * Move LFS routes to /user/repo/info/lfs/* * Add request header checks to LFS BatchHandler / PostHandler * Implement LFS basic authentication * Rework JWT secret generation / load * Implement LFS SSH token authentication with JWT Specification: https://github.com/github/git-lfs/tree/master/docs/api * Integrate LFS settings into install process * Remove LFS objects when repository is deleted Only removes objects from content store when deleted repo is the only referencing repository * Make LFS module stateless Fixes bug where LFS would not work after installation without restarting Gitea * Change 500 'Internal Server Error' to 400 'Bad Request' * Change sql query to xorm call * Remove unneeded type from LFS module * Change internal imports to code.gitea.io/gitea/ * Add Gitea authors copyright * Change basic auth realm to "gitea-lfs" * Add unique indexes to LFS model * Use xorm count function in LFS check on repository delete * Return io.ReadCloser from content store and close after usage * Add LFS info to runWeb() * Export LFS content store base path * LFS file download from UI * Work around git-lfs client issue with unauthenticated requests Returning a dummy Authorization header for unauthenticated requests lets git-lfs client skip asking for auth credentials See: https://github.com/github/git-lfs/issues/1088 * Fix unauthenticated UI downloads from public repositories * Authentication check order, Finish LFS file view logic * Ignore LFS hooks if installed for current OS user Fixes Gitea UI actions for repositories tracking LFS files. Checks for minimum needed git version by parsing the semantic version string. * Hide LFS metafile diff from commit view, marking as binary * Show LFS notice if file in commit view is tracked * Add notbefore/nbf JWT claim * Correct lint suggestions - comments for structs and functions - Add comments to LFS model - Function comment for GetRandomBytesAsBase64 - LFS server function comments and lint variable suggestion * Move secret generation code out of conditional Ensures no LFS code may run with an empty secret * Do not hand out JWT tokens if LFS server support is disabled
147 lines
3.5 KiB
Go
147 lines
3.5 KiB
Go
package jwt
|
|
|
|
import (
|
|
"crypto"
|
|
"crypto/ecdsa"
|
|
"crypto/rand"
|
|
"errors"
|
|
"math/big"
|
|
)
|
|
|
|
var (
|
|
// Sadly this is missing from crypto/ecdsa compared to crypto/rsa
|
|
ErrECDSAVerification = errors.New("crypto/ecdsa: verification error")
|
|
)
|
|
|
|
// Implements the ECDSA family of signing methods signing methods
|
|
type SigningMethodECDSA struct {
|
|
Name string
|
|
Hash crypto.Hash
|
|
KeySize int
|
|
CurveBits int
|
|
}
|
|
|
|
// Specific instances for EC256 and company
|
|
var (
|
|
SigningMethodES256 *SigningMethodECDSA
|
|
SigningMethodES384 *SigningMethodECDSA
|
|
SigningMethodES512 *SigningMethodECDSA
|
|
)
|
|
|
|
func init() {
|
|
// ES256
|
|
SigningMethodES256 = &SigningMethodECDSA{"ES256", crypto.SHA256, 32, 256}
|
|
RegisterSigningMethod(SigningMethodES256.Alg(), func() SigningMethod {
|
|
return SigningMethodES256
|
|
})
|
|
|
|
// ES384
|
|
SigningMethodES384 = &SigningMethodECDSA{"ES384", crypto.SHA384, 48, 384}
|
|
RegisterSigningMethod(SigningMethodES384.Alg(), func() SigningMethod {
|
|
return SigningMethodES384
|
|
})
|
|
|
|
// ES512
|
|
SigningMethodES512 = &SigningMethodECDSA{"ES512", crypto.SHA512, 66, 521}
|
|
RegisterSigningMethod(SigningMethodES512.Alg(), func() SigningMethod {
|
|
return SigningMethodES512
|
|
})
|
|
}
|
|
|
|
func (m *SigningMethodECDSA) Alg() string {
|
|
return m.Name
|
|
}
|
|
|
|
// Implements the Verify method from SigningMethod
|
|
// For this verify method, key must be an ecdsa.PublicKey struct
|
|
func (m *SigningMethodECDSA) Verify(signingString, signature string, key interface{}) error {
|
|
var err error
|
|
|
|
// Decode the signature
|
|
var sig []byte
|
|
if sig, err = DecodeSegment(signature); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Get the key
|
|
var ecdsaKey *ecdsa.PublicKey
|
|
switch k := key.(type) {
|
|
case *ecdsa.PublicKey:
|
|
ecdsaKey = k
|
|
default:
|
|
return ErrInvalidKeyType
|
|
}
|
|
|
|
if len(sig) != 2*m.KeySize {
|
|
return ErrECDSAVerification
|
|
}
|
|
|
|
r := big.NewInt(0).SetBytes(sig[:m.KeySize])
|
|
s := big.NewInt(0).SetBytes(sig[m.KeySize:])
|
|
|
|
// Create hasher
|
|
if !m.Hash.Available() {
|
|
return ErrHashUnavailable
|
|
}
|
|
hasher := m.Hash.New()
|
|
hasher.Write([]byte(signingString))
|
|
|
|
// Verify the signature
|
|
if verifystatus := ecdsa.Verify(ecdsaKey, hasher.Sum(nil), r, s); verifystatus == true {
|
|
return nil
|
|
} else {
|
|
return ErrECDSAVerification
|
|
}
|
|
}
|
|
|
|
// Implements the Sign method from SigningMethod
|
|
// For this signing method, key must be an ecdsa.PrivateKey struct
|
|
func (m *SigningMethodECDSA) Sign(signingString string, key interface{}) (string, error) {
|
|
// Get the key
|
|
var ecdsaKey *ecdsa.PrivateKey
|
|
switch k := key.(type) {
|
|
case *ecdsa.PrivateKey:
|
|
ecdsaKey = k
|
|
default:
|
|
return "", ErrInvalidKeyType
|
|
}
|
|
|
|
// Create the hasher
|
|
if !m.Hash.Available() {
|
|
return "", ErrHashUnavailable
|
|
}
|
|
|
|
hasher := m.Hash.New()
|
|
hasher.Write([]byte(signingString))
|
|
|
|
// Sign the string and return r, s
|
|
if r, s, err := ecdsa.Sign(rand.Reader, ecdsaKey, hasher.Sum(nil)); err == nil {
|
|
curveBits := ecdsaKey.Curve.Params().BitSize
|
|
|
|
if m.CurveBits != curveBits {
|
|
return "", ErrInvalidKey
|
|
}
|
|
|
|
keyBytes := curveBits / 8
|
|
if curveBits%8 > 0 {
|
|
keyBytes += 1
|
|
}
|
|
|
|
// We serialize the outpus (r and s) into big-endian byte arrays and pad
|
|
// them with zeros on the left to make sure the sizes work out. Both arrays
|
|
// must be keyBytes long, and the output must be 2*keyBytes long.
|
|
rBytes := r.Bytes()
|
|
rBytesPadded := make([]byte, keyBytes)
|
|
copy(rBytesPadded[keyBytes-len(rBytes):], rBytes)
|
|
|
|
sBytes := s.Bytes()
|
|
sBytesPadded := make([]byte, keyBytes)
|
|
copy(sBytesPadded[keyBytes-len(sBytes):], sBytes)
|
|
|
|
out := append(rBytesPadded, sBytesPadded...)
|
|
|
|
return EncodeSegment(out), nil
|
|
} else {
|
|
return "", err
|
|
}
|
|
}
|