repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
cloudflare/cfssl | initca/initca.go | New | func New(req *csr.CertificateRequest) (cert, csrPEM, key []byte, err error) {
policy := CAPolicy()
if req.CA != nil {
if req.CA.Expiry != "" {
policy.Default.ExpiryString = req.CA.Expiry
policy.Default.Expiry, err = time.ParseDuration(req.CA.Expiry)
if err != nil {
return
}
}
if req.CA.Backdate != "" {
policy.Default.Backdate, err = time.ParseDuration(req.CA.Backdate)
if err != nil {
return
}
}
policy.Default.CAConstraint.MaxPathLen = req.CA.PathLength
if req.CA.PathLength != 0 && req.CA.PathLenZero {
log.Infof("ignore invalid 'pathlenzero' value")
} else {
policy.Default.CAConstraint.MaxPathLenZero = req.CA.PathLenZero
}
}
g := &csr.Generator{Validator: validator}
csrPEM, key, err = g.ProcessRequest(req)
if err != nil {
log.Errorf("failed to process request: %v", err)
key = nil
return
}
priv, err := helpers.ParsePrivateKeyPEM(key)
if err != nil {
log.Errorf("failed to parse private key: %v", err)
return
}
s, err := local.NewSigner(priv, nil, signer.DefaultSigAlgo(priv), policy)
if err != nil {
log.Errorf("failed to create signer: %v", err)
return
}
signReq := signer.SignRequest{Hosts: req.Hosts, Request: string(csrPEM)}
cert, err = s.Sign(signReq)
return
} | go | func New(req *csr.CertificateRequest) (cert, csrPEM, key []byte, err error) {
policy := CAPolicy()
if req.CA != nil {
if req.CA.Expiry != "" {
policy.Default.ExpiryString = req.CA.Expiry
policy.Default.Expiry, err = time.ParseDuration(req.CA.Expiry)
if err != nil {
return
}
}
if req.CA.Backdate != "" {
policy.Default.Backdate, err = time.ParseDuration(req.CA.Backdate)
if err != nil {
return
}
}
policy.Default.CAConstraint.MaxPathLen = req.CA.PathLength
if req.CA.PathLength != 0 && req.CA.PathLenZero {
log.Infof("ignore invalid 'pathlenzero' value")
} else {
policy.Default.CAConstraint.MaxPathLenZero = req.CA.PathLenZero
}
}
g := &csr.Generator{Validator: validator}
csrPEM, key, err = g.ProcessRequest(req)
if err != nil {
log.Errorf("failed to process request: %v", err)
key = nil
return
}
priv, err := helpers.ParsePrivateKeyPEM(key)
if err != nil {
log.Errorf("failed to parse private key: %v", err)
return
}
s, err := local.NewSigner(priv, nil, signer.DefaultSigAlgo(priv), policy)
if err != nil {
log.Errorf("failed to create signer: %v", err)
return
}
signReq := signer.SignRequest{Hosts: req.Hosts, Request: string(csrPEM)}
cert, err = s.Sign(signReq)
return
} | [
"func",
"New",
"(",
"req",
"*",
"csr",
".",
"CertificateRequest",
")",
"(",
"cert",
",",
"csrPEM",
",",
"key",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"policy",
":=",
"CAPolicy",
"(",
")",
"\n",
"if",
"req",
".",
"CA",
"!=",
"nil",
"{",
"if",
"req",
".",
"CA",
".",
"Expiry",
"!=",
"\"",
"\"",
"{",
"policy",
".",
"Default",
".",
"ExpiryString",
"=",
"req",
".",
"CA",
".",
"Expiry",
"\n",
"policy",
".",
"Default",
".",
"Expiry",
",",
"err",
"=",
"time",
".",
"ParseDuration",
"(",
"req",
".",
"CA",
".",
"Expiry",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"req",
".",
"CA",
".",
"Backdate",
"!=",
"\"",
"\"",
"{",
"policy",
".",
"Default",
".",
"Backdate",
",",
"err",
"=",
"time",
".",
"ParseDuration",
"(",
"req",
".",
"CA",
".",
"Backdate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"policy",
".",
"Default",
".",
"CAConstraint",
".",
"MaxPathLen",
"=",
"req",
".",
"CA",
".",
"PathLength",
"\n",
"if",
"req",
".",
"CA",
".",
"PathLength",
"!=",
"0",
"&&",
"req",
".",
"CA",
".",
"PathLenZero",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"policy",
".",
"Default",
".",
"CAConstraint",
".",
"MaxPathLenZero",
"=",
"req",
".",
"CA",
".",
"PathLenZero",
"\n",
"}",
"\n",
"}",
"\n\n",
"g",
":=",
"&",
"csr",
".",
"Generator",
"{",
"Validator",
":",
"validator",
"}",
"\n",
"csrPEM",
",",
"key",
",",
"err",
"=",
"g",
".",
"ProcessRequest",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"key",
"=",
"nil",
"\n",
"return",
"\n",
"}",
"\n\n",
"priv",
",",
"err",
":=",
"helpers",
".",
"ParsePrivateKeyPEM",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"s",
",",
"err",
":=",
"local",
".",
"NewSigner",
"(",
"priv",
",",
"nil",
",",
"signer",
".",
"DefaultSigAlgo",
"(",
"priv",
")",
",",
"policy",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"signReq",
":=",
"signer",
".",
"SignRequest",
"{",
"Hosts",
":",
"req",
".",
"Hosts",
",",
"Request",
":",
"string",
"(",
"csrPEM",
")",
"}",
"\n",
"cert",
",",
"err",
"=",
"s",
".",
"Sign",
"(",
"signReq",
")",
"\n\n",
"return",
"\n\n",
"}"
] | // New creates a new root certificate from the certificate request. | [
"New",
"creates",
"a",
"new",
"root",
"certificate",
"from",
"the",
"certificate",
"request",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/initca/initca.go#L46-L97 | train |
cloudflare/cfssl | initca/initca.go | NewFromPEM | func NewFromPEM(req *csr.CertificateRequest, keyFile string) (cert, csrPEM []byte, err error) {
privData, err := helpers.ReadBytes(keyFile)
if err != nil {
return nil, nil, err
}
priv, err := helpers.ParsePrivateKeyPEM(privData)
if err != nil {
return nil, nil, err
}
return NewFromSigner(req, priv)
} | go | func NewFromPEM(req *csr.CertificateRequest, keyFile string) (cert, csrPEM []byte, err error) {
privData, err := helpers.ReadBytes(keyFile)
if err != nil {
return nil, nil, err
}
priv, err := helpers.ParsePrivateKeyPEM(privData)
if err != nil {
return nil, nil, err
}
return NewFromSigner(req, priv)
} | [
"func",
"NewFromPEM",
"(",
"req",
"*",
"csr",
".",
"CertificateRequest",
",",
"keyFile",
"string",
")",
"(",
"cert",
",",
"csrPEM",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"privData",
",",
"err",
":=",
"helpers",
".",
"ReadBytes",
"(",
"keyFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"priv",
",",
"err",
":=",
"helpers",
".",
"ParsePrivateKeyPEM",
"(",
"privData",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewFromSigner",
"(",
"req",
",",
"priv",
")",
"\n",
"}"
] | // NewFromPEM creates a new root certificate from the key file passed in. | [
"NewFromPEM",
"creates",
"a",
"new",
"root",
"certificate",
"from",
"the",
"key",
"file",
"passed",
"in",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/initca/initca.go#L100-L112 | train |
cloudflare/cfssl | initca/initca.go | RenewFromPEM | func RenewFromPEM(caFile, keyFile string) ([]byte, error) {
caBytes, err := helpers.ReadBytes(caFile)
if err != nil {
return nil, err
}
ca, err := helpers.ParseCertificatePEM(caBytes)
if err != nil {
return nil, err
}
keyBytes, err := helpers.ReadBytes(keyFile)
if err != nil {
return nil, err
}
key, err := helpers.ParsePrivateKeyPEM(keyBytes)
if err != nil {
return nil, err
}
return RenewFromSigner(ca, key)
} | go | func RenewFromPEM(caFile, keyFile string) ([]byte, error) {
caBytes, err := helpers.ReadBytes(caFile)
if err != nil {
return nil, err
}
ca, err := helpers.ParseCertificatePEM(caBytes)
if err != nil {
return nil, err
}
keyBytes, err := helpers.ReadBytes(keyFile)
if err != nil {
return nil, err
}
key, err := helpers.ParsePrivateKeyPEM(keyBytes)
if err != nil {
return nil, err
}
return RenewFromSigner(ca, key)
} | [
"func",
"RenewFromPEM",
"(",
"caFile",
",",
"keyFile",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"caBytes",
",",
"err",
":=",
"helpers",
".",
"ReadBytes",
"(",
"caFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"ca",
",",
"err",
":=",
"helpers",
".",
"ParseCertificatePEM",
"(",
"caBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"keyBytes",
",",
"err",
":=",
"helpers",
".",
"ReadBytes",
"(",
"keyFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"key",
",",
"err",
":=",
"helpers",
".",
"ParsePrivateKeyPEM",
"(",
"keyBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"RenewFromSigner",
"(",
"ca",
",",
"key",
")",
"\n",
"}"
] | // RenewFromPEM re-creates a root certificate from the CA cert and key
// files. The resulting root certificate will have the input CA certificate
// as the template and have the same expiry length. E.g. the existing CA
// is valid for a year from Jan 01 2015 to Jan 01 2016, the renewed certificate
// will be valid from now and expire in one year as well. | [
"RenewFromPEM",
"re",
"-",
"creates",
"a",
"root",
"certificate",
"from",
"the",
"CA",
"cert",
"and",
"key",
"files",
".",
"The",
"resulting",
"root",
"certificate",
"will",
"have",
"the",
"input",
"CA",
"certificate",
"as",
"the",
"template",
"and",
"have",
"the",
"same",
"expiry",
"length",
".",
"E",
".",
"g",
".",
"the",
"existing",
"CA",
"is",
"valid",
"for",
"a",
"year",
"from",
"Jan",
"01",
"2015",
"to",
"Jan",
"01",
"2016",
"the",
"renewed",
"certificate",
"will",
"be",
"valid",
"from",
"now",
"and",
"expire",
"in",
"one",
"year",
"as",
"well",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/initca/initca.go#L119-L141 | train |
cloudflare/cfssl | initca/initca.go | NewFromSigner | func NewFromSigner(req *csr.CertificateRequest, priv crypto.Signer) (cert, csrPEM []byte, err error) {
policy := CAPolicy()
if req.CA != nil {
if req.CA.Expiry != "" {
policy.Default.ExpiryString = req.CA.Expiry
policy.Default.Expiry, err = time.ParseDuration(req.CA.Expiry)
if err != nil {
return nil, nil, err
}
}
policy.Default.CAConstraint.MaxPathLen = req.CA.PathLength
if req.CA.PathLength != 0 && req.CA.PathLenZero == true {
log.Infof("ignore invalid 'pathlenzero' value")
} else {
policy.Default.CAConstraint.MaxPathLenZero = req.CA.PathLenZero
}
}
csrPEM, err = csr.Generate(priv, req)
if err != nil {
return nil, nil, err
}
s, err := local.NewSigner(priv, nil, signer.DefaultSigAlgo(priv), policy)
if err != nil {
log.Errorf("failed to create signer: %v", err)
return
}
signReq := signer.SignRequest{Request: string(csrPEM)}
cert, err = s.Sign(signReq)
return
} | go | func NewFromSigner(req *csr.CertificateRequest, priv crypto.Signer) (cert, csrPEM []byte, err error) {
policy := CAPolicy()
if req.CA != nil {
if req.CA.Expiry != "" {
policy.Default.ExpiryString = req.CA.Expiry
policy.Default.Expiry, err = time.ParseDuration(req.CA.Expiry)
if err != nil {
return nil, nil, err
}
}
policy.Default.CAConstraint.MaxPathLen = req.CA.PathLength
if req.CA.PathLength != 0 && req.CA.PathLenZero == true {
log.Infof("ignore invalid 'pathlenzero' value")
} else {
policy.Default.CAConstraint.MaxPathLenZero = req.CA.PathLenZero
}
}
csrPEM, err = csr.Generate(priv, req)
if err != nil {
return nil, nil, err
}
s, err := local.NewSigner(priv, nil, signer.DefaultSigAlgo(priv), policy)
if err != nil {
log.Errorf("failed to create signer: %v", err)
return
}
signReq := signer.SignRequest{Request: string(csrPEM)}
cert, err = s.Sign(signReq)
return
} | [
"func",
"NewFromSigner",
"(",
"req",
"*",
"csr",
".",
"CertificateRequest",
",",
"priv",
"crypto",
".",
"Signer",
")",
"(",
"cert",
",",
"csrPEM",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"policy",
":=",
"CAPolicy",
"(",
")",
"\n",
"if",
"req",
".",
"CA",
"!=",
"nil",
"{",
"if",
"req",
".",
"CA",
".",
"Expiry",
"!=",
"\"",
"\"",
"{",
"policy",
".",
"Default",
".",
"ExpiryString",
"=",
"req",
".",
"CA",
".",
"Expiry",
"\n",
"policy",
".",
"Default",
".",
"Expiry",
",",
"err",
"=",
"time",
".",
"ParseDuration",
"(",
"req",
".",
"CA",
".",
"Expiry",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"policy",
".",
"Default",
".",
"CAConstraint",
".",
"MaxPathLen",
"=",
"req",
".",
"CA",
".",
"PathLength",
"\n",
"if",
"req",
".",
"CA",
".",
"PathLength",
"!=",
"0",
"&&",
"req",
".",
"CA",
".",
"PathLenZero",
"==",
"true",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"policy",
".",
"Default",
".",
"CAConstraint",
".",
"MaxPathLenZero",
"=",
"req",
".",
"CA",
".",
"PathLenZero",
"\n",
"}",
"\n",
"}",
"\n\n",
"csrPEM",
",",
"err",
"=",
"csr",
".",
"Generate",
"(",
"priv",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"s",
",",
"err",
":=",
"local",
".",
"NewSigner",
"(",
"priv",
",",
"nil",
",",
"signer",
".",
"DefaultSigAlgo",
"(",
"priv",
")",
",",
"policy",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"signReq",
":=",
"signer",
".",
"SignRequest",
"{",
"Request",
":",
"string",
"(",
"csrPEM",
")",
"}",
"\n",
"cert",
",",
"err",
"=",
"s",
".",
"Sign",
"(",
"signReq",
")",
"\n",
"return",
"\n",
"}"
] | // NewFromSigner creates a new root certificate from a crypto.Signer. | [
"NewFromSigner",
"creates",
"a",
"new",
"root",
"certificate",
"from",
"a",
"crypto",
".",
"Signer",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/initca/initca.go#L144-L177 | train |
cloudflare/cfssl | initca/initca.go | RenewFromSigner | func RenewFromSigner(ca *x509.Certificate, priv crypto.Signer) ([]byte, error) {
if !ca.IsCA {
return nil, errors.New("input certificate is not a CA cert")
}
// matching certificate public key vs private key
switch {
case ca.PublicKeyAlgorithm == x509.RSA:
var rsaPublicKey *rsa.PublicKey
var ok bool
if rsaPublicKey, ok = priv.Public().(*rsa.PublicKey); !ok {
return nil, cferr.New(cferr.PrivateKeyError, cferr.KeyMismatch)
}
if ca.PublicKey.(*rsa.PublicKey).N.Cmp(rsaPublicKey.N) != 0 {
return nil, cferr.New(cferr.PrivateKeyError, cferr.KeyMismatch)
}
case ca.PublicKeyAlgorithm == x509.ECDSA:
var ecdsaPublicKey *ecdsa.PublicKey
var ok bool
if ecdsaPublicKey, ok = priv.Public().(*ecdsa.PublicKey); !ok {
return nil, cferr.New(cferr.PrivateKeyError, cferr.KeyMismatch)
}
if ca.PublicKey.(*ecdsa.PublicKey).X.Cmp(ecdsaPublicKey.X) != 0 {
return nil, cferr.New(cferr.PrivateKeyError, cferr.KeyMismatch)
}
default:
return nil, cferr.New(cferr.PrivateKeyError, cferr.NotRSAOrECC)
}
req := csr.ExtractCertificateRequest(ca)
cert, _, err := NewFromSigner(req, priv)
return cert, err
} | go | func RenewFromSigner(ca *x509.Certificate, priv crypto.Signer) ([]byte, error) {
if !ca.IsCA {
return nil, errors.New("input certificate is not a CA cert")
}
// matching certificate public key vs private key
switch {
case ca.PublicKeyAlgorithm == x509.RSA:
var rsaPublicKey *rsa.PublicKey
var ok bool
if rsaPublicKey, ok = priv.Public().(*rsa.PublicKey); !ok {
return nil, cferr.New(cferr.PrivateKeyError, cferr.KeyMismatch)
}
if ca.PublicKey.(*rsa.PublicKey).N.Cmp(rsaPublicKey.N) != 0 {
return nil, cferr.New(cferr.PrivateKeyError, cferr.KeyMismatch)
}
case ca.PublicKeyAlgorithm == x509.ECDSA:
var ecdsaPublicKey *ecdsa.PublicKey
var ok bool
if ecdsaPublicKey, ok = priv.Public().(*ecdsa.PublicKey); !ok {
return nil, cferr.New(cferr.PrivateKeyError, cferr.KeyMismatch)
}
if ca.PublicKey.(*ecdsa.PublicKey).X.Cmp(ecdsaPublicKey.X) != 0 {
return nil, cferr.New(cferr.PrivateKeyError, cferr.KeyMismatch)
}
default:
return nil, cferr.New(cferr.PrivateKeyError, cferr.NotRSAOrECC)
}
req := csr.ExtractCertificateRequest(ca)
cert, _, err := NewFromSigner(req, priv)
return cert, err
} | [
"func",
"RenewFromSigner",
"(",
"ca",
"*",
"x509",
".",
"Certificate",
",",
"priv",
"crypto",
".",
"Signer",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"!",
"ca",
".",
"IsCA",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// matching certificate public key vs private key",
"switch",
"{",
"case",
"ca",
".",
"PublicKeyAlgorithm",
"==",
"x509",
".",
"RSA",
":",
"var",
"rsaPublicKey",
"*",
"rsa",
".",
"PublicKey",
"\n",
"var",
"ok",
"bool",
"\n",
"if",
"rsaPublicKey",
",",
"ok",
"=",
"priv",
".",
"Public",
"(",
")",
".",
"(",
"*",
"rsa",
".",
"PublicKey",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"cferr",
".",
"New",
"(",
"cferr",
".",
"PrivateKeyError",
",",
"cferr",
".",
"KeyMismatch",
")",
"\n",
"}",
"\n",
"if",
"ca",
".",
"PublicKey",
".",
"(",
"*",
"rsa",
".",
"PublicKey",
")",
".",
"N",
".",
"Cmp",
"(",
"rsaPublicKey",
".",
"N",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"cferr",
".",
"New",
"(",
"cferr",
".",
"PrivateKeyError",
",",
"cferr",
".",
"KeyMismatch",
")",
"\n",
"}",
"\n",
"case",
"ca",
".",
"PublicKeyAlgorithm",
"==",
"x509",
".",
"ECDSA",
":",
"var",
"ecdsaPublicKey",
"*",
"ecdsa",
".",
"PublicKey",
"\n",
"var",
"ok",
"bool",
"\n",
"if",
"ecdsaPublicKey",
",",
"ok",
"=",
"priv",
".",
"Public",
"(",
")",
".",
"(",
"*",
"ecdsa",
".",
"PublicKey",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"cferr",
".",
"New",
"(",
"cferr",
".",
"PrivateKeyError",
",",
"cferr",
".",
"KeyMismatch",
")",
"\n",
"}",
"\n",
"if",
"ca",
".",
"PublicKey",
".",
"(",
"*",
"ecdsa",
".",
"PublicKey",
")",
".",
"X",
".",
"Cmp",
"(",
"ecdsaPublicKey",
".",
"X",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"cferr",
".",
"New",
"(",
"cferr",
".",
"PrivateKeyError",
",",
"cferr",
".",
"KeyMismatch",
")",
"\n",
"}",
"\n",
"default",
":",
"return",
"nil",
",",
"cferr",
".",
"New",
"(",
"cferr",
".",
"PrivateKeyError",
",",
"cferr",
".",
"NotRSAOrECC",
")",
"\n",
"}",
"\n\n",
"req",
":=",
"csr",
".",
"ExtractCertificateRequest",
"(",
"ca",
")",
"\n",
"cert",
",",
"_",
",",
"err",
":=",
"NewFromSigner",
"(",
"req",
",",
"priv",
")",
"\n",
"return",
"cert",
",",
"err",
"\n\n",
"}"
] | // RenewFromSigner re-creates a root certificate from the CA cert and crypto.Signer.
// The resulting root certificate will have ca certificate
// as the template and have the same expiry length. E.g. the existing CA
// is valid for a year from Jan 01 2015 to Jan 01 2016, the renewed certificate
// will be valid from now and expire in one year as well. | [
"RenewFromSigner",
"re",
"-",
"creates",
"a",
"root",
"certificate",
"from",
"the",
"CA",
"cert",
"and",
"crypto",
".",
"Signer",
".",
"The",
"resulting",
"root",
"certificate",
"will",
"have",
"ca",
"certificate",
"as",
"the",
"template",
"and",
"have",
"the",
"same",
"expiry",
"length",
".",
"E",
".",
"g",
".",
"the",
"existing",
"CA",
"is",
"valid",
"for",
"a",
"year",
"from",
"Jan",
"01",
"2015",
"to",
"Jan",
"01",
"2016",
"the",
"renewed",
"certificate",
"will",
"be",
"valid",
"from",
"now",
"and",
"expire",
"in",
"one",
"year",
"as",
"well",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/initca/initca.go#L184-L217 | train |
cloudflare/cfssl | initca/initca.go | Update | func Update(ca *x509.Certificate, priv crypto.Signer) (cert []byte, err error) {
copy, err := x509.ParseCertificate(ca.Raw)
if err != nil {
return
}
validity := ca.NotAfter.Sub(ca.NotBefore)
copy.NotBefore = time.Now().Round(time.Minute).Add(-5 * time.Minute)
copy.NotAfter = copy.NotBefore.Add(validity)
cert, err = x509.CreateCertificate(rand.Reader, copy, copy, priv.Public(), priv)
if err != nil {
return
}
cert = pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: cert})
return
} | go | func Update(ca *x509.Certificate, priv crypto.Signer) (cert []byte, err error) {
copy, err := x509.ParseCertificate(ca.Raw)
if err != nil {
return
}
validity := ca.NotAfter.Sub(ca.NotBefore)
copy.NotBefore = time.Now().Round(time.Minute).Add(-5 * time.Minute)
copy.NotAfter = copy.NotBefore.Add(validity)
cert, err = x509.CreateCertificate(rand.Reader, copy, copy, priv.Public(), priv)
if err != nil {
return
}
cert = pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: cert})
return
} | [
"func",
"Update",
"(",
"ca",
"*",
"x509",
".",
"Certificate",
",",
"priv",
"crypto",
".",
"Signer",
")",
"(",
"cert",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"copy",
",",
"err",
":=",
"x509",
".",
"ParseCertificate",
"(",
"ca",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"validity",
":=",
"ca",
".",
"NotAfter",
".",
"Sub",
"(",
"ca",
".",
"NotBefore",
")",
"\n",
"copy",
".",
"NotBefore",
"=",
"time",
".",
"Now",
"(",
")",
".",
"Round",
"(",
"time",
".",
"Minute",
")",
".",
"Add",
"(",
"-",
"5",
"*",
"time",
".",
"Minute",
")",
"\n",
"copy",
".",
"NotAfter",
"=",
"copy",
".",
"NotBefore",
".",
"Add",
"(",
"validity",
")",
"\n",
"cert",
",",
"err",
"=",
"x509",
".",
"CreateCertificate",
"(",
"rand",
".",
"Reader",
",",
"copy",
",",
"copy",
",",
"priv",
".",
"Public",
"(",
")",
",",
"priv",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"cert",
"=",
"pem",
".",
"EncodeToMemory",
"(",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"\"",
"\"",
",",
"Bytes",
":",
"cert",
"}",
")",
"\n",
"return",
"\n",
"}"
] | // Update copies the CA certificate, updates the NotBefore and
// NotAfter fields, and then re-signs the certificate. | [
"Update",
"copies",
"the",
"CA",
"certificate",
"updates",
"the",
"NotBefore",
"and",
"NotAfter",
"fields",
"and",
"then",
"re",
"-",
"signs",
"the",
"certificate",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/initca/initca.go#L233-L249 | train |
cloudflare/cfssl | cli/config.go | RootFromConfig | func RootFromConfig(c *Config) universal.Root {
return universal.Root{
Config: map[string]string{
"cert-file": c.CAFile,
"key-file": c.CAKeyFile,
},
ForceRemote: c.Remote != "",
}
} | go | func RootFromConfig(c *Config) universal.Root {
return universal.Root{
Config: map[string]string{
"cert-file": c.CAFile,
"key-file": c.CAKeyFile,
},
ForceRemote: c.Remote != "",
}
} | [
"func",
"RootFromConfig",
"(",
"c",
"*",
"Config",
")",
"universal",
".",
"Root",
"{",
"return",
"universal",
".",
"Root",
"{",
"Config",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"c",
".",
"CAFile",
",",
"\"",
"\"",
":",
"c",
".",
"CAKeyFile",
",",
"}",
",",
"ForceRemote",
":",
"c",
".",
"Remote",
"!=",
"\"",
"\"",
",",
"}",
"\n",
"}"
] | // RootFromConfig returns a universal signer Root structure that can
// be used to produce a signer. | [
"RootFromConfig",
"returns",
"a",
"universal",
"signer",
"Root",
"structure",
"that",
"can",
"be",
"used",
"to",
"produce",
"a",
"signer",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/cli/config.go#L139-L147 | train |
cloudflare/cfssl | scan/broad.go | intermediateCAScan | func intermediateCAScan(addr, hostname string) (grade Grade, output Output, err error) {
cidr, port, _ := net.SplitHostPort(addr)
_, ipnet, err := net.ParseCIDR(cidr)
if err != nil {
return Skipped, nil, nil
}
b, err := bundler.NewBundler(caBundleFile, intBundleFile)
if err != nil {
return
}
var wg sync.WaitGroup
wg.Add(numWorkers)
dialer := &net.Dialer{Timeout: timeout}
config := &tls.Config{InsecureSkipVerify: true}
addrs := make(chan string)
chains := make(chan []*x509.Certificate, numWorkers)
go func() {
for chain := range chains {
b.Bundle(chain, nil, bundler.Force)
}
}()
for i := 0; i < numWorkers; i++ {
go func() {
for addr := range addrs {
conn, err := tls.DialWithDialer(dialer, Network, addr, config)
if err != nil {
continue
}
conn.Close()
if conn.ConnectionState().HandshakeComplete {
chains <- conn.ConnectionState().PeerCertificates
}
}
wg.Done()
}()
}
for ip := ipnet.IP.To16(); ipnet.Contains(ip); incrementBytes(ip) {
addrs <- net.JoinHostPort(ip.String(), port)
}
close(addrs)
wg.Wait()
close(chains)
grade = Good
return
} | go | func intermediateCAScan(addr, hostname string) (grade Grade, output Output, err error) {
cidr, port, _ := net.SplitHostPort(addr)
_, ipnet, err := net.ParseCIDR(cidr)
if err != nil {
return Skipped, nil, nil
}
b, err := bundler.NewBundler(caBundleFile, intBundleFile)
if err != nil {
return
}
var wg sync.WaitGroup
wg.Add(numWorkers)
dialer := &net.Dialer{Timeout: timeout}
config := &tls.Config{InsecureSkipVerify: true}
addrs := make(chan string)
chains := make(chan []*x509.Certificate, numWorkers)
go func() {
for chain := range chains {
b.Bundle(chain, nil, bundler.Force)
}
}()
for i := 0; i < numWorkers; i++ {
go func() {
for addr := range addrs {
conn, err := tls.DialWithDialer(dialer, Network, addr, config)
if err != nil {
continue
}
conn.Close()
if conn.ConnectionState().HandshakeComplete {
chains <- conn.ConnectionState().PeerCertificates
}
}
wg.Done()
}()
}
for ip := ipnet.IP.To16(); ipnet.Contains(ip); incrementBytes(ip) {
addrs <- net.JoinHostPort(ip.String(), port)
}
close(addrs)
wg.Wait()
close(chains)
grade = Good
return
} | [
"func",
"intermediateCAScan",
"(",
"addr",
",",
"hostname",
"string",
")",
"(",
"grade",
"Grade",
",",
"output",
"Output",
",",
"err",
"error",
")",
"{",
"cidr",
",",
"port",
",",
"_",
":=",
"net",
".",
"SplitHostPort",
"(",
"addr",
")",
"\n",
"_",
",",
"ipnet",
",",
"err",
":=",
"net",
".",
"ParseCIDR",
"(",
"cidr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Skipped",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"b",
",",
"err",
":=",
"bundler",
".",
"NewBundler",
"(",
"caBundleFile",
",",
"intBundleFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"wg",
".",
"Add",
"(",
"numWorkers",
")",
"\n",
"dialer",
":=",
"&",
"net",
".",
"Dialer",
"{",
"Timeout",
":",
"timeout",
"}",
"\n",
"config",
":=",
"&",
"tls",
".",
"Config",
"{",
"InsecureSkipVerify",
":",
"true",
"}",
"\n",
"addrs",
":=",
"make",
"(",
"chan",
"string",
")",
"\n",
"chains",
":=",
"make",
"(",
"chan",
"[",
"]",
"*",
"x509",
".",
"Certificate",
",",
"numWorkers",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"chain",
":=",
"range",
"chains",
"{",
"b",
".",
"Bundle",
"(",
"chain",
",",
"nil",
",",
"bundler",
".",
"Force",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"numWorkers",
";",
"i",
"++",
"{",
"go",
"func",
"(",
")",
"{",
"for",
"addr",
":=",
"range",
"addrs",
"{",
"conn",
",",
"err",
":=",
"tls",
".",
"DialWithDialer",
"(",
"dialer",
",",
"Network",
",",
"addr",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"conn",
".",
"Close",
"(",
")",
"\n",
"if",
"conn",
".",
"ConnectionState",
"(",
")",
".",
"HandshakeComplete",
"{",
"chains",
"<-",
"conn",
".",
"ConnectionState",
"(",
")",
".",
"PeerCertificates",
"\n",
"}",
"\n",
"}",
"\n",
"wg",
".",
"Done",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"for",
"ip",
":=",
"ipnet",
".",
"IP",
".",
"To16",
"(",
")",
";",
"ipnet",
".",
"Contains",
"(",
"ip",
")",
";",
"incrementBytes",
"(",
"ip",
")",
"{",
"addrs",
"<-",
"net",
".",
"JoinHostPort",
"(",
"ip",
".",
"String",
"(",
")",
",",
"port",
")",
"\n",
"}",
"\n",
"close",
"(",
"addrs",
")",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n",
"close",
"(",
"chains",
")",
"\n",
"grade",
"=",
"Good",
"\n",
"return",
"\n",
"}"
] | // intermediateCAScan scans for new intermediate CAs not in the trust store. | [
"intermediateCAScan",
"scans",
"for",
"new",
"intermediate",
"CAs",
"not",
"in",
"the",
"trust",
"store",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/broad.go#L40-L84 | train |
cloudflare/cfssl | scan/crypto/rsa/pkcs1v15.go | decryptPKCS1v15 | func decryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (valid int, em []byte, index int, err error) {
k := (priv.N.BitLen() + 7) / 8
if k < 11 {
err = ErrDecryption
return
}
c := new(big.Int).SetBytes(ciphertext)
m, err := decrypt(rand, priv, c)
if err != nil {
return
}
em = leftPad(m.Bytes(), k)
firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0)
secondByteIsTwo := subtle.ConstantTimeByteEq(em[1], 2)
// The remainder of the plaintext must be a string of non-zero random
// octets, followed by a 0, followed by the message.
// lookingForIndex: 1 iff we are still looking for the zero.
// index: the offset of the first zero byte.
lookingForIndex := 1
for i := 2; i < len(em); i++ {
equals0 := subtle.ConstantTimeByteEq(em[i], 0)
index = subtle.ConstantTimeSelect(lookingForIndex&equals0, i, index)
lookingForIndex = subtle.ConstantTimeSelect(equals0, 0, lookingForIndex)
}
// The PS padding must be at least 8 bytes long, and it starts two
// bytes into em.
validPS := subtle.ConstantTimeLessOrEq(2+8, index)
valid = firstByteIsZero & secondByteIsTwo & (^lookingForIndex & 1) & validPS
index = subtle.ConstantTimeSelect(valid, index+1, 0)
return valid, em, index, nil
} | go | func decryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (valid int, em []byte, index int, err error) {
k := (priv.N.BitLen() + 7) / 8
if k < 11 {
err = ErrDecryption
return
}
c := new(big.Int).SetBytes(ciphertext)
m, err := decrypt(rand, priv, c)
if err != nil {
return
}
em = leftPad(m.Bytes(), k)
firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0)
secondByteIsTwo := subtle.ConstantTimeByteEq(em[1], 2)
// The remainder of the plaintext must be a string of non-zero random
// octets, followed by a 0, followed by the message.
// lookingForIndex: 1 iff we are still looking for the zero.
// index: the offset of the first zero byte.
lookingForIndex := 1
for i := 2; i < len(em); i++ {
equals0 := subtle.ConstantTimeByteEq(em[i], 0)
index = subtle.ConstantTimeSelect(lookingForIndex&equals0, i, index)
lookingForIndex = subtle.ConstantTimeSelect(equals0, 0, lookingForIndex)
}
// The PS padding must be at least 8 bytes long, and it starts two
// bytes into em.
validPS := subtle.ConstantTimeLessOrEq(2+8, index)
valid = firstByteIsZero & secondByteIsTwo & (^lookingForIndex & 1) & validPS
index = subtle.ConstantTimeSelect(valid, index+1, 0)
return valid, em, index, nil
} | [
"func",
"decryptPKCS1v15",
"(",
"rand",
"io",
".",
"Reader",
",",
"priv",
"*",
"PrivateKey",
",",
"ciphertext",
"[",
"]",
"byte",
")",
"(",
"valid",
"int",
",",
"em",
"[",
"]",
"byte",
",",
"index",
"int",
",",
"err",
"error",
")",
"{",
"k",
":=",
"(",
"priv",
".",
"N",
".",
"BitLen",
"(",
")",
"+",
"7",
")",
"/",
"8",
"\n",
"if",
"k",
"<",
"11",
"{",
"err",
"=",
"ErrDecryption",
"\n",
"return",
"\n",
"}",
"\n\n",
"c",
":=",
"new",
"(",
"big",
".",
"Int",
")",
".",
"SetBytes",
"(",
"ciphertext",
")",
"\n",
"m",
",",
"err",
":=",
"decrypt",
"(",
"rand",
",",
"priv",
",",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"em",
"=",
"leftPad",
"(",
"m",
".",
"Bytes",
"(",
")",
",",
"k",
")",
"\n",
"firstByteIsZero",
":=",
"subtle",
".",
"ConstantTimeByteEq",
"(",
"em",
"[",
"0",
"]",
",",
"0",
")",
"\n",
"secondByteIsTwo",
":=",
"subtle",
".",
"ConstantTimeByteEq",
"(",
"em",
"[",
"1",
"]",
",",
"2",
")",
"\n\n",
"// The remainder of the plaintext must be a string of non-zero random",
"// octets, followed by a 0, followed by the message.",
"// lookingForIndex: 1 iff we are still looking for the zero.",
"// index: the offset of the first zero byte.",
"lookingForIndex",
":=",
"1",
"\n\n",
"for",
"i",
":=",
"2",
";",
"i",
"<",
"len",
"(",
"em",
")",
";",
"i",
"++",
"{",
"equals0",
":=",
"subtle",
".",
"ConstantTimeByteEq",
"(",
"em",
"[",
"i",
"]",
",",
"0",
")",
"\n",
"index",
"=",
"subtle",
".",
"ConstantTimeSelect",
"(",
"lookingForIndex",
"&",
"equals0",
",",
"i",
",",
"index",
")",
"\n",
"lookingForIndex",
"=",
"subtle",
".",
"ConstantTimeSelect",
"(",
"equals0",
",",
"0",
",",
"lookingForIndex",
")",
"\n",
"}",
"\n\n",
"// The PS padding must be at least 8 bytes long, and it starts two",
"// bytes into em.",
"validPS",
":=",
"subtle",
".",
"ConstantTimeLessOrEq",
"(",
"2",
"+",
"8",
",",
"index",
")",
"\n\n",
"valid",
"=",
"firstByteIsZero",
"&",
"secondByteIsTwo",
"&",
"(",
"^",
"lookingForIndex",
"&",
"1",
")",
"&",
"validPS",
"\n",
"index",
"=",
"subtle",
".",
"ConstantTimeSelect",
"(",
"valid",
",",
"index",
"+",
"1",
",",
"0",
")",
"\n",
"return",
"valid",
",",
"em",
",",
"index",
",",
"nil",
"\n",
"}"
] | // decryptPKCS1v15 decrypts ciphertext using priv and blinds the operation if
// rand is not nil. It returns one or zero in valid that indicates whether the
// plaintext was correctly structured. In either case, the plaintext is
// returned in em so that it may be read independently of whether it was valid
// in order to maintain constant memory access patterns. If the plaintext was
// valid then index contains the index of the original message in em. | [
"decryptPKCS1v15",
"decrypts",
"ciphertext",
"using",
"priv",
"and",
"blinds",
"the",
"operation",
"if",
"rand",
"is",
"not",
"nil",
".",
"It",
"returns",
"one",
"or",
"zero",
"in",
"valid",
"that",
"indicates",
"whether",
"the",
"plaintext",
"was",
"correctly",
"structured",
".",
"In",
"either",
"case",
"the",
"plaintext",
"is",
"returned",
"in",
"em",
"so",
"that",
"it",
"may",
"be",
"read",
"independently",
"of",
"whether",
"it",
"was",
"valid",
"in",
"order",
"to",
"maintain",
"constant",
"memory",
"access",
"patterns",
".",
"If",
"the",
"plaintext",
"was",
"valid",
"then",
"index",
"contains",
"the",
"index",
"of",
"the",
"original",
"message",
"in",
"em",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/rsa/pkcs1v15.go#L137-L173 | train |
cloudflare/cfssl | scan/crypto/rsa/pkcs1v15.go | copyWithLeftPad | func copyWithLeftPad(dest, src []byte) {
numPaddingBytes := len(dest) - len(src)
for i := 0; i < numPaddingBytes; i++ {
dest[i] = 0
}
copy(dest[numPaddingBytes:], src)
} | go | func copyWithLeftPad(dest, src []byte) {
numPaddingBytes := len(dest) - len(src)
for i := 0; i < numPaddingBytes; i++ {
dest[i] = 0
}
copy(dest[numPaddingBytes:], src)
} | [
"func",
"copyWithLeftPad",
"(",
"dest",
",",
"src",
"[",
"]",
"byte",
")",
"{",
"numPaddingBytes",
":=",
"len",
"(",
"dest",
")",
"-",
"len",
"(",
"src",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"numPaddingBytes",
";",
"i",
"++",
"{",
"dest",
"[",
"i",
"]",
"=",
"0",
"\n",
"}",
"\n",
"copy",
"(",
"dest",
"[",
"numPaddingBytes",
":",
"]",
",",
"src",
")",
"\n",
"}"
] | // copyWithLeftPad copies src to the end of dest, padding with zero bytes as
// needed. | [
"copyWithLeftPad",
"copies",
"src",
"to",
"the",
"end",
"of",
"dest",
"padding",
"with",
"zero",
"bytes",
"as",
"needed",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/rsa/pkcs1v15.go#L319-L325 | train |
cloudflare/cfssl | api/signhandler/signhandler.go | NewHandlerFromSigner | func NewHandlerFromSigner(signer signer.Signer) (h *api.HTTPHandler, err error) {
policy := signer.Policy()
if policy == nil {
err = errors.New(errors.PolicyError, errors.InvalidPolicy)
return
}
// Sign will only respond for profiles that have no auth provider.
// So if all of the profiles require authentication, we return an error.
haveUnauth := (policy.Default.Provider == nil)
for _, profile := range policy.Profiles {
haveUnauth = haveUnauth || (profile.Provider == nil)
}
if !haveUnauth {
err = errors.New(errors.PolicyError, errors.InvalidPolicy)
return
}
return &api.HTTPHandler{
Handler: &Handler{
signer: signer,
},
Methods: []string{"POST"},
}, nil
} | go | func NewHandlerFromSigner(signer signer.Signer) (h *api.HTTPHandler, err error) {
policy := signer.Policy()
if policy == nil {
err = errors.New(errors.PolicyError, errors.InvalidPolicy)
return
}
// Sign will only respond for profiles that have no auth provider.
// So if all of the profiles require authentication, we return an error.
haveUnauth := (policy.Default.Provider == nil)
for _, profile := range policy.Profiles {
haveUnauth = haveUnauth || (profile.Provider == nil)
}
if !haveUnauth {
err = errors.New(errors.PolicyError, errors.InvalidPolicy)
return
}
return &api.HTTPHandler{
Handler: &Handler{
signer: signer,
},
Methods: []string{"POST"},
}, nil
} | [
"func",
"NewHandlerFromSigner",
"(",
"signer",
"signer",
".",
"Signer",
")",
"(",
"h",
"*",
"api",
".",
"HTTPHandler",
",",
"err",
"error",
")",
"{",
"policy",
":=",
"signer",
".",
"Policy",
"(",
")",
"\n",
"if",
"policy",
"==",
"nil",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"errors",
".",
"PolicyError",
",",
"errors",
".",
"InvalidPolicy",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Sign will only respond for profiles that have no auth provider.",
"// So if all of the profiles require authentication, we return an error.",
"haveUnauth",
":=",
"(",
"policy",
".",
"Default",
".",
"Provider",
"==",
"nil",
")",
"\n",
"for",
"_",
",",
"profile",
":=",
"range",
"policy",
".",
"Profiles",
"{",
"haveUnauth",
"=",
"haveUnauth",
"||",
"(",
"profile",
".",
"Provider",
"==",
"nil",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"haveUnauth",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"errors",
".",
"PolicyError",
",",
"errors",
".",
"InvalidPolicy",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"HTTPHandler",
"{",
"Handler",
":",
"&",
"Handler",
"{",
"signer",
":",
"signer",
",",
"}",
",",
"Methods",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewHandlerFromSigner generates a new Handler directly from
// an existing signer. | [
"NewHandlerFromSigner",
"generates",
"a",
"new",
"Handler",
"directly",
"from",
"an",
"existing",
"signer",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/api/signhandler/signhandler.go#L32-L57 | train |
cloudflare/cfssl | api/signhandler/signhandler.go | Handle | func (h *Handler) Handle(w http.ResponseWriter, r *http.Request) error {
log.Info("signature request received")
body, err := ioutil.ReadAll(r.Body)
if err != nil {
return err
}
r.Body.Close()
var req jsonSignRequest
err = json.Unmarshal(body, &req)
if err != nil {
return errors.NewBadRequestString("Unable to parse sign request")
}
signReq := jsonReqToTrue(req)
if req.Request == "" {
return errors.NewBadRequestString("missing parameter 'certificate_request'")
}
var cert []byte
profile, err := signer.Profile(h.signer, req.Profile)
if err != nil {
return err
}
if profile.Provider != nil {
log.Error("profile requires authentication")
return errors.NewBadRequestString("authentication required")
}
cert, err = h.signer.Sign(signReq)
if err != nil {
log.Warningf("failed to sign request: %v", err)
return err
}
result := map[string]interface{}{"certificate": string(cert)}
if req.Bundle {
if h.bundler == nil {
return api.SendResponseWithMessage(w, result, NoBundlerMessage,
errors.New(errors.PolicyError, errors.InvalidRequest).ErrorCode)
}
bundle, err := h.bundler.BundleFromPEMorDER(cert, nil, bundler.Optimal, "")
if err != nil {
return err
}
result["bundle"] = bundle
}
log.Info("wrote response")
return api.SendResponse(w, result)
} | go | func (h *Handler) Handle(w http.ResponseWriter, r *http.Request) error {
log.Info("signature request received")
body, err := ioutil.ReadAll(r.Body)
if err != nil {
return err
}
r.Body.Close()
var req jsonSignRequest
err = json.Unmarshal(body, &req)
if err != nil {
return errors.NewBadRequestString("Unable to parse sign request")
}
signReq := jsonReqToTrue(req)
if req.Request == "" {
return errors.NewBadRequestString("missing parameter 'certificate_request'")
}
var cert []byte
profile, err := signer.Profile(h.signer, req.Profile)
if err != nil {
return err
}
if profile.Provider != nil {
log.Error("profile requires authentication")
return errors.NewBadRequestString("authentication required")
}
cert, err = h.signer.Sign(signReq)
if err != nil {
log.Warningf("failed to sign request: %v", err)
return err
}
result := map[string]interface{}{"certificate": string(cert)}
if req.Bundle {
if h.bundler == nil {
return api.SendResponseWithMessage(w, result, NoBundlerMessage,
errors.New(errors.PolicyError, errors.InvalidRequest).ErrorCode)
}
bundle, err := h.bundler.BundleFromPEMorDER(cert, nil, bundler.Optimal, "")
if err != nil {
return err
}
result["bundle"] = bundle
}
log.Info("wrote response")
return api.SendResponse(w, result)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"Handle",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"body",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"r",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"var",
"req",
"jsonSignRequest",
"\n\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"NewBadRequestString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"signReq",
":=",
"jsonReqToTrue",
"(",
"req",
")",
"\n\n",
"if",
"req",
".",
"Request",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"NewBadRequestString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"cert",
"[",
"]",
"byte",
"\n",
"profile",
",",
"err",
":=",
"signer",
".",
"Profile",
"(",
"h",
".",
"signer",
",",
"req",
".",
"Profile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"profile",
".",
"Provider",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"return",
"errors",
".",
"NewBadRequestString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cert",
",",
"err",
"=",
"h",
".",
"signer",
".",
"Sign",
"(",
"signReq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"result",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"string",
"(",
"cert",
")",
"}",
"\n",
"if",
"req",
".",
"Bundle",
"{",
"if",
"h",
".",
"bundler",
"==",
"nil",
"{",
"return",
"api",
".",
"SendResponseWithMessage",
"(",
"w",
",",
"result",
",",
"NoBundlerMessage",
",",
"errors",
".",
"New",
"(",
"errors",
".",
"PolicyError",
",",
"errors",
".",
"InvalidRequest",
")",
".",
"ErrorCode",
")",
"\n",
"}",
"\n\n",
"bundle",
",",
"err",
":=",
"h",
".",
"bundler",
".",
"BundleFromPEMorDER",
"(",
"cert",
",",
"nil",
",",
"bundler",
".",
"Optimal",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"result",
"[",
"\"",
"\"",
"]",
"=",
"bundle",
"\n",
"}",
"\n",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"return",
"api",
".",
"SendResponse",
"(",
"w",
",",
"result",
")",
"\n",
"}"
] | // Handle responds to requests for the CA to sign the certificate request
// present in the "certificate_request" parameter for the host named
// in the "hostname" parameter. The certificate should be PEM-encoded. If
// provided, subject information from the "subject" parameter will be used
// in place of the subject information from the CSR. | [
"Handle",
"responds",
"to",
"requests",
"for",
"the",
"CA",
"to",
"sign",
"the",
"certificate",
"request",
"present",
"in",
"the",
"certificate_request",
"parameter",
"for",
"the",
"host",
"named",
"in",
"the",
"hostname",
"parameter",
".",
"The",
"certificate",
"should",
"be",
"PEM",
"-",
"encoded",
".",
"If",
"provided",
"subject",
"information",
"from",
"the",
"subject",
"parameter",
"will",
"be",
"used",
"in",
"place",
"of",
"the",
"subject",
"information",
"from",
"the",
"CSR",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/api/signhandler/signhandler.go#L114-L169 | train |
cloudflare/cfssl | api/signhandler/signhandler.go | NewAuthHandlerFromSigner | func NewAuthHandlerFromSigner(signer signer.Signer) (http.Handler, error) {
policy := signer.Policy()
if policy == nil {
return nil, errors.New(errors.PolicyError, errors.InvalidPolicy)
}
if policy.Default == nil && policy.Profiles == nil {
return nil, errors.New(errors.PolicyError, errors.InvalidPolicy)
}
// AuthSign will not respond for profiles that have no auth provider.
// So if there are no profiles with auth providers in this policy,
// we return an error.
haveAuth := (policy.Default.Provider != nil)
for _, profile := range policy.Profiles {
if haveAuth {
break
}
haveAuth = (profile.Provider != nil)
}
if !haveAuth {
return nil, errors.New(errors.PolicyError, errors.InvalidPolicy)
}
return &api.HTTPHandler{
Handler: &AuthHandler{
signer: signer,
},
Methods: []string{"POST"},
}, nil
} | go | func NewAuthHandlerFromSigner(signer signer.Signer) (http.Handler, error) {
policy := signer.Policy()
if policy == nil {
return nil, errors.New(errors.PolicyError, errors.InvalidPolicy)
}
if policy.Default == nil && policy.Profiles == nil {
return nil, errors.New(errors.PolicyError, errors.InvalidPolicy)
}
// AuthSign will not respond for profiles that have no auth provider.
// So if there are no profiles with auth providers in this policy,
// we return an error.
haveAuth := (policy.Default.Provider != nil)
for _, profile := range policy.Profiles {
if haveAuth {
break
}
haveAuth = (profile.Provider != nil)
}
if !haveAuth {
return nil, errors.New(errors.PolicyError, errors.InvalidPolicy)
}
return &api.HTTPHandler{
Handler: &AuthHandler{
signer: signer,
},
Methods: []string{"POST"},
}, nil
} | [
"func",
"NewAuthHandlerFromSigner",
"(",
"signer",
"signer",
".",
"Signer",
")",
"(",
"http",
".",
"Handler",
",",
"error",
")",
"{",
"policy",
":=",
"signer",
".",
"Policy",
"(",
")",
"\n",
"if",
"policy",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"errors",
".",
"PolicyError",
",",
"errors",
".",
"InvalidPolicy",
")",
"\n",
"}",
"\n\n",
"if",
"policy",
".",
"Default",
"==",
"nil",
"&&",
"policy",
".",
"Profiles",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"errors",
".",
"PolicyError",
",",
"errors",
".",
"InvalidPolicy",
")",
"\n",
"}",
"\n\n",
"// AuthSign will not respond for profiles that have no auth provider.",
"// So if there are no profiles with auth providers in this policy,",
"// we return an error.",
"haveAuth",
":=",
"(",
"policy",
".",
"Default",
".",
"Provider",
"!=",
"nil",
")",
"\n",
"for",
"_",
",",
"profile",
":=",
"range",
"policy",
".",
"Profiles",
"{",
"if",
"haveAuth",
"{",
"break",
"\n",
"}",
"\n",
"haveAuth",
"=",
"(",
"profile",
".",
"Provider",
"!=",
"nil",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"haveAuth",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"errors",
".",
"PolicyError",
",",
"errors",
".",
"InvalidPolicy",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"HTTPHandler",
"{",
"Handler",
":",
"&",
"AuthHandler",
"{",
"signer",
":",
"signer",
",",
"}",
",",
"Methods",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewAuthHandlerFromSigner creates a new AuthHandler from the signer
// that is passed in. | [
"NewAuthHandlerFromSigner",
"creates",
"a",
"new",
"AuthHandler",
"from",
"the",
"signer",
"that",
"is",
"passed",
"in",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/api/signhandler/signhandler.go#L179-L210 | train |
cloudflare/cfssl | api/signhandler/signhandler.go | SetBundler | func (h *AuthHandler) SetBundler(caBundleFile, intBundleFile string) (err error) {
h.bundler, err = bundler.NewBundler(caBundleFile, intBundleFile)
return err
} | go | func (h *AuthHandler) SetBundler(caBundleFile, intBundleFile string) (err error) {
h.bundler, err = bundler.NewBundler(caBundleFile, intBundleFile)
return err
} | [
"func",
"(",
"h",
"*",
"AuthHandler",
")",
"SetBundler",
"(",
"caBundleFile",
",",
"intBundleFile",
"string",
")",
"(",
"err",
"error",
")",
"{",
"h",
".",
"bundler",
",",
"err",
"=",
"bundler",
".",
"NewBundler",
"(",
"caBundleFile",
",",
"intBundleFile",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // SetBundler allows injecting an optional Bundler into the Handler. | [
"SetBundler",
"allows",
"injecting",
"an",
"optional",
"Bundler",
"into",
"the",
"Handler",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/api/signhandler/signhandler.go#L213-L216 | train |
cloudflare/cfssl | api/signhandler/signhandler.go | Handle | func (h *AuthHandler) Handle(w http.ResponseWriter, r *http.Request) error {
log.Info("signature request received")
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Errorf("failed to read response body: %v", err)
return err
}
r.Body.Close()
var aReq auth.AuthenticatedRequest
err = json.Unmarshal(body, &aReq)
if err != nil {
log.Errorf("failed to unmarshal authenticated request: %v", err)
return errors.NewBadRequest(err)
}
var req jsonSignRequest
err = json.Unmarshal(aReq.Request, &req)
if err != nil {
log.Errorf("failed to unmarshal request from authenticated request: %v", err)
return errors.NewBadRequestString("Unable to parse authenticated sign request")
}
// Sanity checks to ensure that we have a valid policy. This
// should have been checked in NewAuthHandler.
policy := h.signer.Policy()
if policy == nil {
log.Critical("signer was initialised without a signing policy")
return errors.NewBadRequestString("invalid policy")
}
profile, err := signer.Profile(h.signer, req.Profile)
if err != nil {
return err
}
if profile.Provider == nil {
log.Error("profile has no authentication provider")
return errors.NewBadRequestString("no authentication provider")
}
if !profile.Provider.Verify(&aReq) {
log.Warning("received authenticated request with invalid token")
return errors.NewBadRequestString("invalid token")
}
signReq := jsonReqToTrue(req)
if signReq.Request == "" {
return errors.NewBadRequestString("missing parameter 'certificate_request'")
}
cert, err := h.signer.Sign(signReq)
if err != nil {
log.Errorf("signature failed: %v", err)
return err
}
result := map[string]interface{}{"certificate": string(cert)}
if req.Bundle {
if h.bundler == nil {
return api.SendResponseWithMessage(w, result, NoBundlerMessage,
errors.New(errors.PolicyError, errors.InvalidRequest).ErrorCode)
}
bundle, err := h.bundler.BundleFromPEMorDER(cert, nil, bundler.Optimal, "")
if err != nil {
return err
}
result["bundle"] = bundle
}
log.Info("wrote response")
return api.SendResponse(w, result)
} | go | func (h *AuthHandler) Handle(w http.ResponseWriter, r *http.Request) error {
log.Info("signature request received")
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Errorf("failed to read response body: %v", err)
return err
}
r.Body.Close()
var aReq auth.AuthenticatedRequest
err = json.Unmarshal(body, &aReq)
if err != nil {
log.Errorf("failed to unmarshal authenticated request: %v", err)
return errors.NewBadRequest(err)
}
var req jsonSignRequest
err = json.Unmarshal(aReq.Request, &req)
if err != nil {
log.Errorf("failed to unmarshal request from authenticated request: %v", err)
return errors.NewBadRequestString("Unable to parse authenticated sign request")
}
// Sanity checks to ensure that we have a valid policy. This
// should have been checked in NewAuthHandler.
policy := h.signer.Policy()
if policy == nil {
log.Critical("signer was initialised without a signing policy")
return errors.NewBadRequestString("invalid policy")
}
profile, err := signer.Profile(h.signer, req.Profile)
if err != nil {
return err
}
if profile.Provider == nil {
log.Error("profile has no authentication provider")
return errors.NewBadRequestString("no authentication provider")
}
if !profile.Provider.Verify(&aReq) {
log.Warning("received authenticated request with invalid token")
return errors.NewBadRequestString("invalid token")
}
signReq := jsonReqToTrue(req)
if signReq.Request == "" {
return errors.NewBadRequestString("missing parameter 'certificate_request'")
}
cert, err := h.signer.Sign(signReq)
if err != nil {
log.Errorf("signature failed: %v", err)
return err
}
result := map[string]interface{}{"certificate": string(cert)}
if req.Bundle {
if h.bundler == nil {
return api.SendResponseWithMessage(w, result, NoBundlerMessage,
errors.New(errors.PolicyError, errors.InvalidRequest).ErrorCode)
}
bundle, err := h.bundler.BundleFromPEMorDER(cert, nil, bundler.Optimal, "")
if err != nil {
return err
}
result["bundle"] = bundle
}
log.Info("wrote response")
return api.SendResponse(w, result)
} | [
"func",
"(",
"h",
"*",
"AuthHandler",
")",
"Handle",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"body",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"r",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"var",
"aReq",
"auth",
".",
"AuthenticatedRequest",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"aReq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"errors",
".",
"NewBadRequest",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"req",
"jsonSignRequest",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"aReq",
".",
"Request",
",",
"&",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"errors",
".",
"NewBadRequestString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Sanity checks to ensure that we have a valid policy. This",
"// should have been checked in NewAuthHandler.",
"policy",
":=",
"h",
".",
"signer",
".",
"Policy",
"(",
")",
"\n",
"if",
"policy",
"==",
"nil",
"{",
"log",
".",
"Critical",
"(",
"\"",
"\"",
")",
"\n",
"return",
"errors",
".",
"NewBadRequestString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"profile",
",",
"err",
":=",
"signer",
".",
"Profile",
"(",
"h",
".",
"signer",
",",
"req",
".",
"Profile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"profile",
".",
"Provider",
"==",
"nil",
"{",
"log",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"return",
"errors",
".",
"NewBadRequestString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"profile",
".",
"Provider",
".",
"Verify",
"(",
"&",
"aReq",
")",
"{",
"log",
".",
"Warning",
"(",
"\"",
"\"",
")",
"\n",
"return",
"errors",
".",
"NewBadRequestString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"signReq",
":=",
"jsonReqToTrue",
"(",
"req",
")",
"\n\n",
"if",
"signReq",
".",
"Request",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"NewBadRequestString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cert",
",",
"err",
":=",
"h",
".",
"signer",
".",
"Sign",
"(",
"signReq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"result",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"string",
"(",
"cert",
")",
"}",
"\n",
"if",
"req",
".",
"Bundle",
"{",
"if",
"h",
".",
"bundler",
"==",
"nil",
"{",
"return",
"api",
".",
"SendResponseWithMessage",
"(",
"w",
",",
"result",
",",
"NoBundlerMessage",
",",
"errors",
".",
"New",
"(",
"errors",
".",
"PolicyError",
",",
"errors",
".",
"InvalidRequest",
")",
".",
"ErrorCode",
")",
"\n",
"}",
"\n\n",
"bundle",
",",
"err",
":=",
"h",
".",
"bundler",
".",
"BundleFromPEMorDER",
"(",
"cert",
",",
"nil",
",",
"bundler",
".",
"Optimal",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"result",
"[",
"\"",
"\"",
"]",
"=",
"bundle",
"\n",
"}",
"\n",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"return",
"api",
".",
"SendResponse",
"(",
"w",
",",
"result",
")",
"\n",
"}"
] | // Handle receives the incoming request, validates it, and processes it. | [
"Handle",
"receives",
"the",
"incoming",
"request",
"validates",
"it",
"and",
"processes",
"it",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/api/signhandler/signhandler.go#L219-L294 | train |
cloudflare/cfssl | crypto/pkcs7/pkcs7.go | ParsePKCS7 | func ParsePKCS7(raw []byte) (msg *PKCS7, err error) {
var pkcs7 initPKCS7
_, err = asn1.Unmarshal(raw, &pkcs7)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
msg = new(PKCS7)
msg.Raw = pkcs7.Raw
msg.ContentInfo = pkcs7.ContentType.String()
switch {
case msg.ContentInfo == ObjIDData:
msg.ContentInfo = "Data"
_, err = asn1.Unmarshal(pkcs7.Content.Bytes, &msg.Content.Data)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
case msg.ContentInfo == ObjIDSignedData:
msg.ContentInfo = "SignedData"
var signedData signedData
_, err = asn1.Unmarshal(pkcs7.Content.Bytes, &signedData)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
if len(signedData.Certificates.Bytes) != 0 {
msg.Content.SignedData.Certificates, err = x509.ParseCertificates(signedData.Certificates.Bytes)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
}
if len(signedData.Crls.Bytes) != 0 {
msg.Content.SignedData.Crl, err = x509.ParseDERCRL(signedData.Crls.Bytes)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
}
msg.Content.SignedData.Version = signedData.Version
msg.Content.SignedData.Raw = pkcs7.Content.Bytes
case msg.ContentInfo == ObjIDEncryptedData:
msg.ContentInfo = "EncryptedData"
var encryptedData EncryptedData
_, err = asn1.Unmarshal(pkcs7.Content.Bytes, &encryptedData)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
if encryptedData.Version != 0 {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, errors.New("Only support for PKCS #7 encryptedData version 0"))
}
msg.Content.EncryptedData = encryptedData
default:
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, errors.New("Attempt to parse PKCS# 7 Content not of type data, signed data or encrypted data"))
}
return msg, nil
} | go | func ParsePKCS7(raw []byte) (msg *PKCS7, err error) {
var pkcs7 initPKCS7
_, err = asn1.Unmarshal(raw, &pkcs7)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
msg = new(PKCS7)
msg.Raw = pkcs7.Raw
msg.ContentInfo = pkcs7.ContentType.String()
switch {
case msg.ContentInfo == ObjIDData:
msg.ContentInfo = "Data"
_, err = asn1.Unmarshal(pkcs7.Content.Bytes, &msg.Content.Data)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
case msg.ContentInfo == ObjIDSignedData:
msg.ContentInfo = "SignedData"
var signedData signedData
_, err = asn1.Unmarshal(pkcs7.Content.Bytes, &signedData)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
if len(signedData.Certificates.Bytes) != 0 {
msg.Content.SignedData.Certificates, err = x509.ParseCertificates(signedData.Certificates.Bytes)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
}
if len(signedData.Crls.Bytes) != 0 {
msg.Content.SignedData.Crl, err = x509.ParseDERCRL(signedData.Crls.Bytes)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
}
msg.Content.SignedData.Version = signedData.Version
msg.Content.SignedData.Raw = pkcs7.Content.Bytes
case msg.ContentInfo == ObjIDEncryptedData:
msg.ContentInfo = "EncryptedData"
var encryptedData EncryptedData
_, err = asn1.Unmarshal(pkcs7.Content.Bytes, &encryptedData)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, err)
}
if encryptedData.Version != 0 {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, errors.New("Only support for PKCS #7 encryptedData version 0"))
}
msg.Content.EncryptedData = encryptedData
default:
return nil, cferr.Wrap(cferr.CertificateError, cferr.ParseFailed, errors.New("Attempt to parse PKCS# 7 Content not of type data, signed data or encrypted data"))
}
return msg, nil
} | [
"func",
"ParsePKCS7",
"(",
"raw",
"[",
"]",
"byte",
")",
"(",
"msg",
"*",
"PKCS7",
",",
"err",
"error",
")",
"{",
"var",
"pkcs7",
"initPKCS7",
"\n",
"_",
",",
"err",
"=",
"asn1",
".",
"Unmarshal",
"(",
"raw",
",",
"&",
"pkcs7",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CertificateError",
",",
"cferr",
".",
"ParseFailed",
",",
"err",
")",
"\n",
"}",
"\n\n",
"msg",
"=",
"new",
"(",
"PKCS7",
")",
"\n",
"msg",
".",
"Raw",
"=",
"pkcs7",
".",
"Raw",
"\n",
"msg",
".",
"ContentInfo",
"=",
"pkcs7",
".",
"ContentType",
".",
"String",
"(",
")",
"\n",
"switch",
"{",
"case",
"msg",
".",
"ContentInfo",
"==",
"ObjIDData",
":",
"msg",
".",
"ContentInfo",
"=",
"\"",
"\"",
"\n",
"_",
",",
"err",
"=",
"asn1",
".",
"Unmarshal",
"(",
"pkcs7",
".",
"Content",
".",
"Bytes",
",",
"&",
"msg",
".",
"Content",
".",
"Data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CertificateError",
",",
"cferr",
".",
"ParseFailed",
",",
"err",
")",
"\n",
"}",
"\n",
"case",
"msg",
".",
"ContentInfo",
"==",
"ObjIDSignedData",
":",
"msg",
".",
"ContentInfo",
"=",
"\"",
"\"",
"\n",
"var",
"signedData",
"signedData",
"\n",
"_",
",",
"err",
"=",
"asn1",
".",
"Unmarshal",
"(",
"pkcs7",
".",
"Content",
".",
"Bytes",
",",
"&",
"signedData",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CertificateError",
",",
"cferr",
".",
"ParseFailed",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"signedData",
".",
"Certificates",
".",
"Bytes",
")",
"!=",
"0",
"{",
"msg",
".",
"Content",
".",
"SignedData",
".",
"Certificates",
",",
"err",
"=",
"x509",
".",
"ParseCertificates",
"(",
"signedData",
".",
"Certificates",
".",
"Bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CertificateError",
",",
"cferr",
".",
"ParseFailed",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"signedData",
".",
"Crls",
".",
"Bytes",
")",
"!=",
"0",
"{",
"msg",
".",
"Content",
".",
"SignedData",
".",
"Crl",
",",
"err",
"=",
"x509",
".",
"ParseDERCRL",
"(",
"signedData",
".",
"Crls",
".",
"Bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CertificateError",
",",
"cferr",
".",
"ParseFailed",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"msg",
".",
"Content",
".",
"SignedData",
".",
"Version",
"=",
"signedData",
".",
"Version",
"\n",
"msg",
".",
"Content",
".",
"SignedData",
".",
"Raw",
"=",
"pkcs7",
".",
"Content",
".",
"Bytes",
"\n",
"case",
"msg",
".",
"ContentInfo",
"==",
"ObjIDEncryptedData",
":",
"msg",
".",
"ContentInfo",
"=",
"\"",
"\"",
"\n",
"var",
"encryptedData",
"EncryptedData",
"\n",
"_",
",",
"err",
"=",
"asn1",
".",
"Unmarshal",
"(",
"pkcs7",
".",
"Content",
".",
"Bytes",
",",
"&",
"encryptedData",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CertificateError",
",",
"cferr",
".",
"ParseFailed",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"encryptedData",
".",
"Version",
"!=",
"0",
"{",
"return",
"nil",
",",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CertificateError",
",",
"cferr",
".",
"ParseFailed",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"msg",
".",
"Content",
".",
"EncryptedData",
"=",
"encryptedData",
"\n\n",
"default",
":",
"return",
"nil",
",",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CertificateError",
",",
"cferr",
".",
"ParseFailed",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n\n",
"return",
"msg",
",",
"nil",
"\n\n",
"}"
] | // ParsePKCS7 attempts to parse the DER encoded bytes of a
// PKCS7 structure. | [
"ParsePKCS7",
"attempts",
"to",
"parse",
"the",
"DER",
"encoded",
"bytes",
"of",
"a",
"PKCS7",
"structure",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/crypto/pkcs7/pkcs7.go#L131-L188 | train |
cloudflare/cfssl | signer/local/local.go | NewSigner | func NewSigner(priv crypto.Signer, cert *x509.Certificate, sigAlgo x509.SignatureAlgorithm, policy *config.Signing) (*Signer, error) {
if policy == nil {
policy = &config.Signing{
Profiles: map[string]*config.SigningProfile{},
Default: config.DefaultConfig()}
}
if !policy.Valid() {
return nil, cferr.New(cferr.PolicyError, cferr.InvalidPolicy)
}
return &Signer{
ca: cert,
priv: priv,
sigAlgo: sigAlgo,
policy: policy,
}, nil
} | go | func NewSigner(priv crypto.Signer, cert *x509.Certificate, sigAlgo x509.SignatureAlgorithm, policy *config.Signing) (*Signer, error) {
if policy == nil {
policy = &config.Signing{
Profiles: map[string]*config.SigningProfile{},
Default: config.DefaultConfig()}
}
if !policy.Valid() {
return nil, cferr.New(cferr.PolicyError, cferr.InvalidPolicy)
}
return &Signer{
ca: cert,
priv: priv,
sigAlgo: sigAlgo,
policy: policy,
}, nil
} | [
"func",
"NewSigner",
"(",
"priv",
"crypto",
".",
"Signer",
",",
"cert",
"*",
"x509",
".",
"Certificate",
",",
"sigAlgo",
"x509",
".",
"SignatureAlgorithm",
",",
"policy",
"*",
"config",
".",
"Signing",
")",
"(",
"*",
"Signer",
",",
"error",
")",
"{",
"if",
"policy",
"==",
"nil",
"{",
"policy",
"=",
"&",
"config",
".",
"Signing",
"{",
"Profiles",
":",
"map",
"[",
"string",
"]",
"*",
"config",
".",
"SigningProfile",
"{",
"}",
",",
"Default",
":",
"config",
".",
"DefaultConfig",
"(",
")",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"policy",
".",
"Valid",
"(",
")",
"{",
"return",
"nil",
",",
"cferr",
".",
"New",
"(",
"cferr",
".",
"PolicyError",
",",
"cferr",
".",
"InvalidPolicy",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"Signer",
"{",
"ca",
":",
"cert",
",",
"priv",
":",
"priv",
",",
"sigAlgo",
":",
"sigAlgo",
",",
"policy",
":",
"policy",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewSigner creates a new Signer directly from a
// private key and certificate, with optional policy. | [
"NewSigner",
"creates",
"a",
"new",
"Signer",
"directly",
"from",
"a",
"private",
"key",
"and",
"certificate",
"with",
"optional",
"policy",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/signer/local/local.go#L47-L64 | train |
cloudflare/cfssl | signer/local/local.go | NewSignerFromFile | func NewSignerFromFile(caFile, caKeyFile string, policy *config.Signing) (*Signer, error) {
log.Debug("Loading CA: ", caFile)
ca, err := helpers.ReadBytes(caFile)
if err != nil {
return nil, err
}
log.Debug("Loading CA key: ", caKeyFile)
cakey, err := helpers.ReadBytes(caKeyFile)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ReadFailed, err)
}
parsedCa, err := helpers.ParseCertificatePEM(ca)
if err != nil {
return nil, err
}
strPassword := os.Getenv("CFSSL_CA_PK_PASSWORD")
password := []byte(strPassword)
if strPassword == "" {
password = nil
}
priv, err := helpers.ParsePrivateKeyPEMWithPassword(cakey, password)
if err != nil {
log.Debug("Malformed private key %v", err)
return nil, err
}
return NewSigner(priv, parsedCa, signer.DefaultSigAlgo(priv), policy)
} | go | func NewSignerFromFile(caFile, caKeyFile string, policy *config.Signing) (*Signer, error) {
log.Debug("Loading CA: ", caFile)
ca, err := helpers.ReadBytes(caFile)
if err != nil {
return nil, err
}
log.Debug("Loading CA key: ", caKeyFile)
cakey, err := helpers.ReadBytes(caKeyFile)
if err != nil {
return nil, cferr.Wrap(cferr.CertificateError, cferr.ReadFailed, err)
}
parsedCa, err := helpers.ParseCertificatePEM(ca)
if err != nil {
return nil, err
}
strPassword := os.Getenv("CFSSL_CA_PK_PASSWORD")
password := []byte(strPassword)
if strPassword == "" {
password = nil
}
priv, err := helpers.ParsePrivateKeyPEMWithPassword(cakey, password)
if err != nil {
log.Debug("Malformed private key %v", err)
return nil, err
}
return NewSigner(priv, parsedCa, signer.DefaultSigAlgo(priv), policy)
} | [
"func",
"NewSignerFromFile",
"(",
"caFile",
",",
"caKeyFile",
"string",
",",
"policy",
"*",
"config",
".",
"Signing",
")",
"(",
"*",
"Signer",
",",
"error",
")",
"{",
"log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"caFile",
")",
"\n",
"ca",
",",
"err",
":=",
"helpers",
".",
"ReadBytes",
"(",
"caFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"caKeyFile",
")",
"\n",
"cakey",
",",
"err",
":=",
"helpers",
".",
"ReadBytes",
"(",
"caKeyFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CertificateError",
",",
"cferr",
".",
"ReadFailed",
",",
"err",
")",
"\n",
"}",
"\n\n",
"parsedCa",
",",
"err",
":=",
"helpers",
".",
"ParseCertificatePEM",
"(",
"ca",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"strPassword",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"password",
":=",
"[",
"]",
"byte",
"(",
"strPassword",
")",
"\n",
"if",
"strPassword",
"==",
"\"",
"\"",
"{",
"password",
"=",
"nil",
"\n",
"}",
"\n\n",
"priv",
",",
"err",
":=",
"helpers",
".",
"ParsePrivateKeyPEMWithPassword",
"(",
"cakey",
",",
"password",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewSigner",
"(",
"priv",
",",
"parsedCa",
",",
"signer",
".",
"DefaultSigAlgo",
"(",
"priv",
")",
",",
"policy",
")",
"\n",
"}"
] | // NewSignerFromFile generates a new local signer from a caFile
// and a caKey file, both PEM encoded. | [
"NewSignerFromFile",
"generates",
"a",
"new",
"local",
"signer",
"from",
"a",
"caFile",
"and",
"a",
"caKey",
"file",
"both",
"PEM",
"encoded",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/signer/local/local.go#L68-L98 | train |
cloudflare/cfssl | signer/local/local.go | PopulateSubjectFromCSR | func PopulateSubjectFromCSR(s *signer.Subject, req pkix.Name) pkix.Name {
// if no subject, use req
if s == nil {
return req
}
name := s.Name()
if name.CommonName == "" {
name.CommonName = req.CommonName
}
replaceSliceIfEmpty(&name.Country, &req.Country)
replaceSliceIfEmpty(&name.Province, &req.Province)
replaceSliceIfEmpty(&name.Locality, &req.Locality)
replaceSliceIfEmpty(&name.Organization, &req.Organization)
replaceSliceIfEmpty(&name.OrganizationalUnit, &req.OrganizationalUnit)
if name.SerialNumber == "" {
name.SerialNumber = req.SerialNumber
}
return name
} | go | func PopulateSubjectFromCSR(s *signer.Subject, req pkix.Name) pkix.Name {
// if no subject, use req
if s == nil {
return req
}
name := s.Name()
if name.CommonName == "" {
name.CommonName = req.CommonName
}
replaceSliceIfEmpty(&name.Country, &req.Country)
replaceSliceIfEmpty(&name.Province, &req.Province)
replaceSliceIfEmpty(&name.Locality, &req.Locality)
replaceSliceIfEmpty(&name.Organization, &req.Organization)
replaceSliceIfEmpty(&name.OrganizationalUnit, &req.OrganizationalUnit)
if name.SerialNumber == "" {
name.SerialNumber = req.SerialNumber
}
return name
} | [
"func",
"PopulateSubjectFromCSR",
"(",
"s",
"*",
"signer",
".",
"Subject",
",",
"req",
"pkix",
".",
"Name",
")",
"pkix",
".",
"Name",
"{",
"// if no subject, use req",
"if",
"s",
"==",
"nil",
"{",
"return",
"req",
"\n",
"}",
"\n\n",
"name",
":=",
"s",
".",
"Name",
"(",
")",
"\n\n",
"if",
"name",
".",
"CommonName",
"==",
"\"",
"\"",
"{",
"name",
".",
"CommonName",
"=",
"req",
".",
"CommonName",
"\n",
"}",
"\n\n",
"replaceSliceIfEmpty",
"(",
"&",
"name",
".",
"Country",
",",
"&",
"req",
".",
"Country",
")",
"\n",
"replaceSliceIfEmpty",
"(",
"&",
"name",
".",
"Province",
",",
"&",
"req",
".",
"Province",
")",
"\n",
"replaceSliceIfEmpty",
"(",
"&",
"name",
".",
"Locality",
",",
"&",
"req",
".",
"Locality",
")",
"\n",
"replaceSliceIfEmpty",
"(",
"&",
"name",
".",
"Organization",
",",
"&",
"req",
".",
"Organization",
")",
"\n",
"replaceSliceIfEmpty",
"(",
"&",
"name",
".",
"OrganizationalUnit",
",",
"&",
"req",
".",
"OrganizationalUnit",
")",
"\n",
"if",
"name",
".",
"SerialNumber",
"==",
"\"",
"\"",
"{",
"name",
".",
"SerialNumber",
"=",
"req",
".",
"SerialNumber",
"\n",
"}",
"\n",
"return",
"name",
"\n",
"}"
] | // PopulateSubjectFromCSR has functionality similar to Name, except
// it fills the fields of the resulting pkix.Name with req's if the
// subject's corresponding fields are empty | [
"PopulateSubjectFromCSR",
"has",
"functionality",
"similar",
"to",
"Name",
"except",
"it",
"fills",
"the",
"fields",
"of",
"the",
"resulting",
"pkix",
".",
"Name",
"with",
"req",
"s",
"if",
"the",
"subject",
"s",
"corresponding",
"fields",
"are",
"empty"
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/signer/local/local.go#L141-L162 | train |
cloudflare/cfssl | signer/local/local.go | OverrideHosts | func OverrideHosts(template *x509.Certificate, hosts []string) {
if hosts != nil {
template.IPAddresses = []net.IP{}
template.EmailAddresses = []string{}
template.DNSNames = []string{}
template.URIs = []*url.URL{}
}
for i := range hosts {
if ip := net.ParseIP(hosts[i]); ip != nil {
template.IPAddresses = append(template.IPAddresses, ip)
} else if email, err := mail.ParseAddress(hosts[i]); err == nil && email != nil {
template.EmailAddresses = append(template.EmailAddresses, email.Address)
} else if uri, err := url.ParseRequestURI(hosts[i]); err == nil && uri != nil {
template.URIs = append(template.URIs, uri)
} else {
template.DNSNames = append(template.DNSNames, hosts[i])
}
}
} | go | func OverrideHosts(template *x509.Certificate, hosts []string) {
if hosts != nil {
template.IPAddresses = []net.IP{}
template.EmailAddresses = []string{}
template.DNSNames = []string{}
template.URIs = []*url.URL{}
}
for i := range hosts {
if ip := net.ParseIP(hosts[i]); ip != nil {
template.IPAddresses = append(template.IPAddresses, ip)
} else if email, err := mail.ParseAddress(hosts[i]); err == nil && email != nil {
template.EmailAddresses = append(template.EmailAddresses, email.Address)
} else if uri, err := url.ParseRequestURI(hosts[i]); err == nil && uri != nil {
template.URIs = append(template.URIs, uri)
} else {
template.DNSNames = append(template.DNSNames, hosts[i])
}
}
} | [
"func",
"OverrideHosts",
"(",
"template",
"*",
"x509",
".",
"Certificate",
",",
"hosts",
"[",
"]",
"string",
")",
"{",
"if",
"hosts",
"!=",
"nil",
"{",
"template",
".",
"IPAddresses",
"=",
"[",
"]",
"net",
".",
"IP",
"{",
"}",
"\n",
"template",
".",
"EmailAddresses",
"=",
"[",
"]",
"string",
"{",
"}",
"\n",
"template",
".",
"DNSNames",
"=",
"[",
"]",
"string",
"{",
"}",
"\n",
"template",
".",
"URIs",
"=",
"[",
"]",
"*",
"url",
".",
"URL",
"{",
"}",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"range",
"hosts",
"{",
"if",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"hosts",
"[",
"i",
"]",
")",
";",
"ip",
"!=",
"nil",
"{",
"template",
".",
"IPAddresses",
"=",
"append",
"(",
"template",
".",
"IPAddresses",
",",
"ip",
")",
"\n",
"}",
"else",
"if",
"email",
",",
"err",
":=",
"mail",
".",
"ParseAddress",
"(",
"hosts",
"[",
"i",
"]",
")",
";",
"err",
"==",
"nil",
"&&",
"email",
"!=",
"nil",
"{",
"template",
".",
"EmailAddresses",
"=",
"append",
"(",
"template",
".",
"EmailAddresses",
",",
"email",
".",
"Address",
")",
"\n",
"}",
"else",
"if",
"uri",
",",
"err",
":=",
"url",
".",
"ParseRequestURI",
"(",
"hosts",
"[",
"i",
"]",
")",
";",
"err",
"==",
"nil",
"&&",
"uri",
"!=",
"nil",
"{",
"template",
".",
"URIs",
"=",
"append",
"(",
"template",
".",
"URIs",
",",
"uri",
")",
"\n",
"}",
"else",
"{",
"template",
".",
"DNSNames",
"=",
"append",
"(",
"template",
".",
"DNSNames",
",",
"hosts",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"}"
] | // OverrideHosts fills template's IPAddresses, EmailAddresses, DNSNames, and URIs with the
// content of hosts, if it is not nil. | [
"OverrideHosts",
"fills",
"template",
"s",
"IPAddresses",
"EmailAddresses",
"DNSNames",
"and",
"URIs",
"with",
"the",
"content",
"of",
"hosts",
"if",
"it",
"is",
"not",
"nil",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/signer/local/local.go#L166-L186 | train |
cloudflare/cfssl | signer/local/local.go | SignFromPrecert | func (s *Signer) SignFromPrecert(precert *x509.Certificate, scts []ct.SignedCertificateTimestamp) ([]byte, error) {
// Verify certificate was signed by s.ca
if err := precert.CheckSignatureFrom(s.ca); err != nil {
return nil, err
}
// Verify certificate is a precert
isPrecert := false
poisonIndex := 0
for i, ext := range precert.Extensions {
if ext.Id.Equal(signer.CTPoisonOID) {
if !ext.Critical {
return nil, cferr.New(cferr.CTError, cferr.PrecertInvalidPoison)
}
// Check extension contains ASN.1 NULL
if bytes.Compare(ext.Value, []byte{0x05, 0x00}) != 0 {
return nil, cferr.New(cferr.CTError, cferr.PrecertInvalidPoison)
}
isPrecert = true
poisonIndex = i
break
}
}
if !isPrecert {
return nil, cferr.New(cferr.CTError, cferr.PrecertMissingPoison)
}
// Serialize SCTs into list format and create extension
serializedList, err := helpers.SerializeSCTList(scts)
if err != nil {
return nil, err
}
// Serialize again as an octet string before embedding
serializedList, err = asn1.Marshal(serializedList)
if err != nil {
return nil, cferr.Wrap(cferr.CTError, cferr.Unknown, err)
}
sctExt := pkix.Extension{Id: signer.SCTListOID, Critical: false, Value: serializedList}
// Create the new tbsCert from precert. Do explicit copies of any slices so that we don't
// use memory that may be altered by us or the caller at a later stage.
tbsCert := x509.Certificate{
SignatureAlgorithm: precert.SignatureAlgorithm,
PublicKeyAlgorithm: precert.PublicKeyAlgorithm,
PublicKey: precert.PublicKey,
Version: precert.Version,
SerialNumber: precert.SerialNumber,
Issuer: precert.Issuer,
Subject: precert.Subject,
NotBefore: precert.NotBefore,
NotAfter: precert.NotAfter,
KeyUsage: precert.KeyUsage,
BasicConstraintsValid: precert.BasicConstraintsValid,
IsCA: precert.IsCA,
MaxPathLen: precert.MaxPathLen,
MaxPathLenZero: precert.MaxPathLenZero,
PermittedDNSDomainsCritical: precert.PermittedDNSDomainsCritical,
}
if len(precert.Extensions) > 0 {
tbsCert.ExtraExtensions = make([]pkix.Extension, len(precert.Extensions))
copy(tbsCert.ExtraExtensions, precert.Extensions)
}
// Remove the poison extension from ExtraExtensions
tbsCert.ExtraExtensions = append(tbsCert.ExtraExtensions[:poisonIndex], tbsCert.ExtraExtensions[poisonIndex+1:]...)
// Insert the SCT list extension
tbsCert.ExtraExtensions = append(tbsCert.ExtraExtensions, sctExt)
// Sign the tbsCert
return s.sign(&tbsCert)
} | go | func (s *Signer) SignFromPrecert(precert *x509.Certificate, scts []ct.SignedCertificateTimestamp) ([]byte, error) {
// Verify certificate was signed by s.ca
if err := precert.CheckSignatureFrom(s.ca); err != nil {
return nil, err
}
// Verify certificate is a precert
isPrecert := false
poisonIndex := 0
for i, ext := range precert.Extensions {
if ext.Id.Equal(signer.CTPoisonOID) {
if !ext.Critical {
return nil, cferr.New(cferr.CTError, cferr.PrecertInvalidPoison)
}
// Check extension contains ASN.1 NULL
if bytes.Compare(ext.Value, []byte{0x05, 0x00}) != 0 {
return nil, cferr.New(cferr.CTError, cferr.PrecertInvalidPoison)
}
isPrecert = true
poisonIndex = i
break
}
}
if !isPrecert {
return nil, cferr.New(cferr.CTError, cferr.PrecertMissingPoison)
}
// Serialize SCTs into list format and create extension
serializedList, err := helpers.SerializeSCTList(scts)
if err != nil {
return nil, err
}
// Serialize again as an octet string before embedding
serializedList, err = asn1.Marshal(serializedList)
if err != nil {
return nil, cferr.Wrap(cferr.CTError, cferr.Unknown, err)
}
sctExt := pkix.Extension{Id: signer.SCTListOID, Critical: false, Value: serializedList}
// Create the new tbsCert from precert. Do explicit copies of any slices so that we don't
// use memory that may be altered by us or the caller at a later stage.
tbsCert := x509.Certificate{
SignatureAlgorithm: precert.SignatureAlgorithm,
PublicKeyAlgorithm: precert.PublicKeyAlgorithm,
PublicKey: precert.PublicKey,
Version: precert.Version,
SerialNumber: precert.SerialNumber,
Issuer: precert.Issuer,
Subject: precert.Subject,
NotBefore: precert.NotBefore,
NotAfter: precert.NotAfter,
KeyUsage: precert.KeyUsage,
BasicConstraintsValid: precert.BasicConstraintsValid,
IsCA: precert.IsCA,
MaxPathLen: precert.MaxPathLen,
MaxPathLenZero: precert.MaxPathLenZero,
PermittedDNSDomainsCritical: precert.PermittedDNSDomainsCritical,
}
if len(precert.Extensions) > 0 {
tbsCert.ExtraExtensions = make([]pkix.Extension, len(precert.Extensions))
copy(tbsCert.ExtraExtensions, precert.Extensions)
}
// Remove the poison extension from ExtraExtensions
tbsCert.ExtraExtensions = append(tbsCert.ExtraExtensions[:poisonIndex], tbsCert.ExtraExtensions[poisonIndex+1:]...)
// Insert the SCT list extension
tbsCert.ExtraExtensions = append(tbsCert.ExtraExtensions, sctExt)
// Sign the tbsCert
return s.sign(&tbsCert)
} | [
"func",
"(",
"s",
"*",
"Signer",
")",
"SignFromPrecert",
"(",
"precert",
"*",
"x509",
".",
"Certificate",
",",
"scts",
"[",
"]",
"ct",
".",
"SignedCertificateTimestamp",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// Verify certificate was signed by s.ca",
"if",
"err",
":=",
"precert",
".",
"CheckSignatureFrom",
"(",
"s",
".",
"ca",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Verify certificate is a precert",
"isPrecert",
":=",
"false",
"\n",
"poisonIndex",
":=",
"0",
"\n",
"for",
"i",
",",
"ext",
":=",
"range",
"precert",
".",
"Extensions",
"{",
"if",
"ext",
".",
"Id",
".",
"Equal",
"(",
"signer",
".",
"CTPoisonOID",
")",
"{",
"if",
"!",
"ext",
".",
"Critical",
"{",
"return",
"nil",
",",
"cferr",
".",
"New",
"(",
"cferr",
".",
"CTError",
",",
"cferr",
".",
"PrecertInvalidPoison",
")",
"\n",
"}",
"\n",
"// Check extension contains ASN.1 NULL",
"if",
"bytes",
".",
"Compare",
"(",
"ext",
".",
"Value",
",",
"[",
"]",
"byte",
"{",
"0x05",
",",
"0x00",
"}",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"cferr",
".",
"New",
"(",
"cferr",
".",
"CTError",
",",
"cferr",
".",
"PrecertInvalidPoison",
")",
"\n",
"}",
"\n",
"isPrecert",
"=",
"true",
"\n",
"poisonIndex",
"=",
"i",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"isPrecert",
"{",
"return",
"nil",
",",
"cferr",
".",
"New",
"(",
"cferr",
".",
"CTError",
",",
"cferr",
".",
"PrecertMissingPoison",
")",
"\n",
"}",
"\n\n",
"// Serialize SCTs into list format and create extension",
"serializedList",
",",
"err",
":=",
"helpers",
".",
"SerializeSCTList",
"(",
"scts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"// Serialize again as an octet string before embedding",
"serializedList",
",",
"err",
"=",
"asn1",
".",
"Marshal",
"(",
"serializedList",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CTError",
",",
"cferr",
".",
"Unknown",
",",
"err",
")",
"\n",
"}",
"\n",
"sctExt",
":=",
"pkix",
".",
"Extension",
"{",
"Id",
":",
"signer",
".",
"SCTListOID",
",",
"Critical",
":",
"false",
",",
"Value",
":",
"serializedList",
"}",
"\n\n",
"// Create the new tbsCert from precert. Do explicit copies of any slices so that we don't",
"// use memory that may be altered by us or the caller at a later stage.",
"tbsCert",
":=",
"x509",
".",
"Certificate",
"{",
"SignatureAlgorithm",
":",
"precert",
".",
"SignatureAlgorithm",
",",
"PublicKeyAlgorithm",
":",
"precert",
".",
"PublicKeyAlgorithm",
",",
"PublicKey",
":",
"precert",
".",
"PublicKey",
",",
"Version",
":",
"precert",
".",
"Version",
",",
"SerialNumber",
":",
"precert",
".",
"SerialNumber",
",",
"Issuer",
":",
"precert",
".",
"Issuer",
",",
"Subject",
":",
"precert",
".",
"Subject",
",",
"NotBefore",
":",
"precert",
".",
"NotBefore",
",",
"NotAfter",
":",
"precert",
".",
"NotAfter",
",",
"KeyUsage",
":",
"precert",
".",
"KeyUsage",
",",
"BasicConstraintsValid",
":",
"precert",
".",
"BasicConstraintsValid",
",",
"IsCA",
":",
"precert",
".",
"IsCA",
",",
"MaxPathLen",
":",
"precert",
".",
"MaxPathLen",
",",
"MaxPathLenZero",
":",
"precert",
".",
"MaxPathLenZero",
",",
"PermittedDNSDomainsCritical",
":",
"precert",
".",
"PermittedDNSDomainsCritical",
",",
"}",
"\n",
"if",
"len",
"(",
"precert",
".",
"Extensions",
")",
">",
"0",
"{",
"tbsCert",
".",
"ExtraExtensions",
"=",
"make",
"(",
"[",
"]",
"pkix",
".",
"Extension",
",",
"len",
"(",
"precert",
".",
"Extensions",
")",
")",
"\n",
"copy",
"(",
"tbsCert",
".",
"ExtraExtensions",
",",
"precert",
".",
"Extensions",
")",
"\n",
"}",
"\n\n",
"// Remove the poison extension from ExtraExtensions",
"tbsCert",
".",
"ExtraExtensions",
"=",
"append",
"(",
"tbsCert",
".",
"ExtraExtensions",
"[",
":",
"poisonIndex",
"]",
",",
"tbsCert",
".",
"ExtraExtensions",
"[",
"poisonIndex",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"// Insert the SCT list extension",
"tbsCert",
".",
"ExtraExtensions",
"=",
"append",
"(",
"tbsCert",
".",
"ExtraExtensions",
",",
"sctExt",
")",
"\n\n",
"// Sign the tbsCert",
"return",
"s",
".",
"sign",
"(",
"&",
"tbsCert",
")",
"\n",
"}"
] | // SignFromPrecert creates and signs a certificate from an existing precertificate
// that was previously signed by Signer.ca and inserts the provided SCTs into the
// new certificate. The resulting certificate will be a exact copy of the precert
// except for the removal of the poison extension and the addition of the SCT list
// extension. SignFromPrecert does not verify that the contents of the certificate
// still match the signing profile of the signer, it only requires that the precert
// was previously signed by the Signers CA. | [
"SignFromPrecert",
"creates",
"and",
"signs",
"a",
"certificate",
"from",
"an",
"existing",
"precertificate",
"that",
"was",
"previously",
"signed",
"by",
"Signer",
".",
"ca",
"and",
"inserts",
"the",
"provided",
"SCTs",
"into",
"the",
"new",
"certificate",
".",
"The",
"resulting",
"certificate",
"will",
"be",
"a",
"exact",
"copy",
"of",
"the",
"precert",
"except",
"for",
"the",
"removal",
"of",
"the",
"poison",
"extension",
"and",
"the",
"addition",
"of",
"the",
"SCT",
"list",
"extension",
".",
"SignFromPrecert",
"does",
"not",
"verify",
"that",
"the",
"contents",
"of",
"the",
"certificate",
"still",
"match",
"the",
"signing",
"profile",
"of",
"the",
"signer",
"it",
"only",
"requires",
"that",
"the",
"precert",
"was",
"previously",
"signed",
"by",
"the",
"Signers",
"CA",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/signer/local/local.go#L441-L511 | train |
cloudflare/cfssl | signer/local/local.go | Info | func (s *Signer) Info(req info.Req) (resp *info.Resp, err error) {
cert, err := s.Certificate(req.Label, req.Profile)
if err != nil {
return
}
profile, err := signer.Profile(s, req.Profile)
if err != nil {
return
}
resp = new(info.Resp)
if cert.Raw != nil {
resp.Certificate = string(bytes.TrimSpace(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: cert.Raw})))
}
resp.Usage = profile.Usage
resp.ExpiryString = profile.ExpiryString
return
} | go | func (s *Signer) Info(req info.Req) (resp *info.Resp, err error) {
cert, err := s.Certificate(req.Label, req.Profile)
if err != nil {
return
}
profile, err := signer.Profile(s, req.Profile)
if err != nil {
return
}
resp = new(info.Resp)
if cert.Raw != nil {
resp.Certificate = string(bytes.TrimSpace(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: cert.Raw})))
}
resp.Usage = profile.Usage
resp.ExpiryString = profile.ExpiryString
return
} | [
"func",
"(",
"s",
"*",
"Signer",
")",
"Info",
"(",
"req",
"info",
".",
"Req",
")",
"(",
"resp",
"*",
"info",
".",
"Resp",
",",
"err",
"error",
")",
"{",
"cert",
",",
"err",
":=",
"s",
".",
"Certificate",
"(",
"req",
".",
"Label",
",",
"req",
".",
"Profile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"profile",
",",
"err",
":=",
"signer",
".",
"Profile",
"(",
"s",
",",
"req",
".",
"Profile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"resp",
"=",
"new",
"(",
"info",
".",
"Resp",
")",
"\n",
"if",
"cert",
".",
"Raw",
"!=",
"nil",
"{",
"resp",
".",
"Certificate",
"=",
"string",
"(",
"bytes",
".",
"TrimSpace",
"(",
"pem",
".",
"EncodeToMemory",
"(",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"\"",
"\"",
",",
"Bytes",
":",
"cert",
".",
"Raw",
"}",
")",
")",
")",
"\n",
"}",
"\n",
"resp",
".",
"Usage",
"=",
"profile",
".",
"Usage",
"\n",
"resp",
".",
"ExpiryString",
"=",
"profile",
".",
"ExpiryString",
"\n\n",
"return",
"\n",
"}"
] | // Info return a populated info.Resp struct or an error. | [
"Info",
"return",
"a",
"populated",
"info",
".",
"Resp",
"struct",
"or",
"an",
"error",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/signer/local/local.go#L514-L533 | train |
cloudflare/cfssl | signer/local/local.go | Certificate | func (s *Signer) Certificate(label, profile string) (*x509.Certificate, error) {
cert := *s.ca
return &cert, nil
} | go | func (s *Signer) Certificate(label, profile string) (*x509.Certificate, error) {
cert := *s.ca
return &cert, nil
} | [
"func",
"(",
"s",
"*",
"Signer",
")",
"Certificate",
"(",
"label",
",",
"profile",
"string",
")",
"(",
"*",
"x509",
".",
"Certificate",
",",
"error",
")",
"{",
"cert",
":=",
"*",
"s",
".",
"ca",
"\n",
"return",
"&",
"cert",
",",
"nil",
"\n",
"}"
] | // Certificate returns the signer's certificate. | [
"Certificate",
"returns",
"the",
"signer",
"s",
"certificate",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/signer/local/local.go#L541-L544 | train |
cloudflare/cfssl | api/initca/initca.go | initialCAHandler | func initialCAHandler(w http.ResponseWriter, r *http.Request) error {
log.Info("setting up initial CA handler")
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Warningf("failed to read request body: %v", err)
return errors.NewBadRequest(err)
}
r.Body.Close()
req := new(csr.CertificateRequest)
req.KeyRequest = csr.NewBasicKeyRequest()
err = json.Unmarshal(body, req)
if err != nil {
log.Warningf("failed to unmarshal request: %v", err)
return errors.NewBadRequest(err)
}
cert, _, key, err := initca.New(req)
if err != nil {
log.Warningf("failed to initialise new CA: %v", err)
return err
}
response := api.NewSuccessResponse(&NewCA{string(key), string(cert)})
enc := json.NewEncoder(w)
err = enc.Encode(response)
return err
} | go | func initialCAHandler(w http.ResponseWriter, r *http.Request) error {
log.Info("setting up initial CA handler")
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Warningf("failed to read request body: %v", err)
return errors.NewBadRequest(err)
}
r.Body.Close()
req := new(csr.CertificateRequest)
req.KeyRequest = csr.NewBasicKeyRequest()
err = json.Unmarshal(body, req)
if err != nil {
log.Warningf("failed to unmarshal request: %v", err)
return errors.NewBadRequest(err)
}
cert, _, key, err := initca.New(req)
if err != nil {
log.Warningf("failed to initialise new CA: %v", err)
return err
}
response := api.NewSuccessResponse(&NewCA{string(key), string(cert)})
enc := json.NewEncoder(w)
err = enc.Encode(response)
return err
} | [
"func",
"initialCAHandler",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"body",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"errors",
".",
"NewBadRequest",
"(",
"err",
")",
"\n",
"}",
"\n",
"r",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"req",
":=",
"new",
"(",
"csr",
".",
"CertificateRequest",
")",
"\n",
"req",
".",
"KeyRequest",
"=",
"csr",
".",
"NewBasicKeyRequest",
"(",
")",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"errors",
".",
"NewBadRequest",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"cert",
",",
"_",
",",
"key",
",",
"err",
":=",
"initca",
".",
"New",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"response",
":=",
"api",
".",
"NewSuccessResponse",
"(",
"&",
"NewCA",
"{",
"string",
"(",
"key",
")",
",",
"string",
"(",
"cert",
")",
"}",
")",
"\n\n",
"enc",
":=",
"json",
".",
"NewEncoder",
"(",
"w",
")",
"\n",
"err",
"=",
"enc",
".",
"Encode",
"(",
"response",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // initialCAHandler is an HTTP handler that accepts a JSON blob in the
// same format as the CSR endpoint; this blob should contain the
// identity information for the CA's root key. This endpoint is not
// suitable for creating intermediate certificates. | [
"initialCAHandler",
"is",
"an",
"HTTP",
"handler",
"that",
"accepts",
"a",
"JSON",
"blob",
"in",
"the",
"same",
"format",
"as",
"the",
"CSR",
"endpoint",
";",
"this",
"blob",
"should",
"contain",
"the",
"identity",
"information",
"for",
"the",
"CA",
"s",
"root",
"key",
".",
"This",
"endpoint",
"is",
"not",
"suitable",
"for",
"creating",
"intermediate",
"certificates",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/api/initca/initca.go#L27-L55 | train |
cloudflare/cfssl | transport/ca/cfssl_provider.go | newStandardProvider | func newStandardProvider(ak config.AuthKey, ad []byte) (auth.Provider, error) {
return auth.New(ak.Key, ad)
} | go | func newStandardProvider(ak config.AuthKey, ad []byte) (auth.Provider, error) {
return auth.New(ak.Key, ad)
} | [
"func",
"newStandardProvider",
"(",
"ak",
"config",
".",
"AuthKey",
",",
"ad",
"[",
"]",
"byte",
")",
"(",
"auth",
".",
"Provider",
",",
"error",
")",
"{",
"return",
"auth",
".",
"New",
"(",
"ak",
".",
"Key",
",",
"ad",
")",
"\n",
"}"
] | // Create a standard provider without providing any additional data. | [
"Create",
"a",
"standard",
"provider",
"without",
"providing",
"any",
"additional",
"data",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/cfssl_provider.go#L36-L38 | train |
cloudflare/cfssl | transport/ca/cfssl_provider.go | newProvider | func newProvider(ak config.AuthKey, ad []byte) (auth.Provider, error) {
// If no auth key was provided, use unauthenticated
// requests. This is useful when a local CFSSL is being used.
if ak.Type == "" && ak.Key == "" {
return nil, nil
}
f, ok := authTypes[ak.Type]
if !ok {
return nil, &authError{authType: ak.Type}
}
return f(ak, ad)
} | go | func newProvider(ak config.AuthKey, ad []byte) (auth.Provider, error) {
// If no auth key was provided, use unauthenticated
// requests. This is useful when a local CFSSL is being used.
if ak.Type == "" && ak.Key == "" {
return nil, nil
}
f, ok := authTypes[ak.Type]
if !ok {
return nil, &authError{authType: ak.Type}
}
return f(ak, ad)
} | [
"func",
"newProvider",
"(",
"ak",
"config",
".",
"AuthKey",
",",
"ad",
"[",
"]",
"byte",
")",
"(",
"auth",
".",
"Provider",
",",
"error",
")",
"{",
"// If no auth key was provided, use unauthenticated",
"// requests. This is useful when a local CFSSL is being used.",
"if",
"ak",
".",
"Type",
"==",
"\"",
"\"",
"&&",
"ak",
".",
"Key",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"f",
",",
"ok",
":=",
"authTypes",
"[",
"ak",
".",
"Type",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"&",
"authError",
"{",
"authType",
":",
"ak",
".",
"Type",
"}",
"\n",
"}",
"\n\n",
"return",
"f",
"(",
"ak",
",",
"ad",
")",
"\n",
"}"
] | // Create a new provider from an authentication key and possibly
// additional data. | [
"Create",
"a",
"new",
"provider",
"from",
"an",
"authentication",
"key",
"and",
"possibly",
"additional",
"data",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/cfssl_provider.go#L42-L55 | train |
cloudflare/cfssl | transport/ca/cfssl_provider.go | validateAuth | func (cap *CFSSL) validateAuth() error {
// The client is using some form of authentication, and the best way
// to figure out that the auth is invalid is when it's used. Therefore,
// we'll delay checking the credentials until that time.
if cap.provider != nil {
return nil
}
hosts := cap.remote.Hosts()
for i := range hosts {
ips, err := net.LookupIP(hosts[i])
if err != nil {
return err
}
for _, ip := range ips {
if !ipIsLocal(ip) {
return ErrNoAuth
}
}
}
return nil
} | go | func (cap *CFSSL) validateAuth() error {
// The client is using some form of authentication, and the best way
// to figure out that the auth is invalid is when it's used. Therefore,
// we'll delay checking the credentials until that time.
if cap.provider != nil {
return nil
}
hosts := cap.remote.Hosts()
for i := range hosts {
ips, err := net.LookupIP(hosts[i])
if err != nil {
return err
}
for _, ip := range ips {
if !ipIsLocal(ip) {
return ErrNoAuth
}
}
}
return nil
} | [
"func",
"(",
"cap",
"*",
"CFSSL",
")",
"validateAuth",
"(",
")",
"error",
"{",
"// The client is using some form of authentication, and the best way",
"// to figure out that the auth is invalid is when it's used. Therefore,",
"// we'll delay checking the credentials until that time.",
"if",
"cap",
".",
"provider",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"hosts",
":=",
"cap",
".",
"remote",
".",
"Hosts",
"(",
")",
"\n",
"for",
"i",
":=",
"range",
"hosts",
"{",
"ips",
",",
"err",
":=",
"net",
".",
"LookupIP",
"(",
"hosts",
"[",
"i",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ip",
":=",
"range",
"ips",
"{",
"if",
"!",
"ipIsLocal",
"(",
"ip",
")",
"{",
"return",
"ErrNoAuth",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // The only time a client should be doing unauthenticated requests is
// when a local CFSSL is being used. | [
"The",
"only",
"time",
"a",
"client",
"should",
"be",
"doing",
"unauthenticated",
"requests",
"is",
"when",
"a",
"local",
"CFSSL",
"is",
"being",
"used",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/cfssl_provider.go#L77-L100 | train |
cloudflare/cfssl | transport/ca/cfssl_provider.go | loadAuth | func (cap *CFSSL) loadAuth() error {
var err error
cap.provider, err = newProvider(cap.DefaultAuth, nil)
return err
} | go | func (cap *CFSSL) loadAuth() error {
var err error
cap.provider, err = newProvider(cap.DefaultAuth, nil)
return err
} | [
"func",
"(",
"cap",
"*",
"CFSSL",
")",
"loadAuth",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"cap",
".",
"provider",
",",
"err",
"=",
"newProvider",
"(",
"cap",
".",
"DefaultAuth",
",",
"nil",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // loadAuth loads an authentication provider from the client config's
// explicitly set auth key. | [
"loadAuth",
"loads",
"an",
"authentication",
"provider",
"from",
"the",
"client",
"config",
"s",
"explicitly",
"set",
"auth",
"key",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/cfssl_provider.go#L145-L149 | train |
cloudflare/cfssl | transport/ca/cfssl_provider.go | SignCSR | func (cap *CFSSL) SignCSR(csrPEM []byte) (cert []byte, err error) {
p, _ := pem.Decode(csrPEM)
if p == nil || p.Type != "CERTIFICATE REQUEST" {
return nil, errors.New("transport: invalid PEM-encoded certificate signing request")
}
csr, err := x509.ParseCertificateRequest(p.Bytes)
if err != nil {
return nil, err
}
hosts := make([]string, len(csr.DNSNames), len(csr.DNSNames)+len(csr.IPAddresses))
copy(hosts, csr.DNSNames)
for i := range csr.IPAddresses {
hosts = append(hosts, csr.IPAddresses[i].String())
}
sreq := &signer.SignRequest{
Hosts: hosts,
Request: string(csrPEM),
Profile: cap.Profile,
Label: cap.Label,
}
out, err := json.Marshal(sreq)
if err != nil {
return nil, err
}
if cap.provider != nil {
return cap.remote.AuthSign(out, nil, cap.provider)
}
return cap.remote.Sign(out)
} | go | func (cap *CFSSL) SignCSR(csrPEM []byte) (cert []byte, err error) {
p, _ := pem.Decode(csrPEM)
if p == nil || p.Type != "CERTIFICATE REQUEST" {
return nil, errors.New("transport: invalid PEM-encoded certificate signing request")
}
csr, err := x509.ParseCertificateRequest(p.Bytes)
if err != nil {
return nil, err
}
hosts := make([]string, len(csr.DNSNames), len(csr.DNSNames)+len(csr.IPAddresses))
copy(hosts, csr.DNSNames)
for i := range csr.IPAddresses {
hosts = append(hosts, csr.IPAddresses[i].String())
}
sreq := &signer.SignRequest{
Hosts: hosts,
Request: string(csrPEM),
Profile: cap.Profile,
Label: cap.Label,
}
out, err := json.Marshal(sreq)
if err != nil {
return nil, err
}
if cap.provider != nil {
return cap.remote.AuthSign(out, nil, cap.provider)
}
return cap.remote.Sign(out)
} | [
"func",
"(",
"cap",
"*",
"CFSSL",
")",
"SignCSR",
"(",
"csrPEM",
"[",
"]",
"byte",
")",
"(",
"cert",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"p",
",",
"_",
":=",
"pem",
".",
"Decode",
"(",
"csrPEM",
")",
"\n",
"if",
"p",
"==",
"nil",
"||",
"p",
".",
"Type",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"csr",
",",
"err",
":=",
"x509",
".",
"ParseCertificateRequest",
"(",
"p",
".",
"Bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"hosts",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"csr",
".",
"DNSNames",
")",
",",
"len",
"(",
"csr",
".",
"DNSNames",
")",
"+",
"len",
"(",
"csr",
".",
"IPAddresses",
")",
")",
"\n",
"copy",
"(",
"hosts",
",",
"csr",
".",
"DNSNames",
")",
"\n\n",
"for",
"i",
":=",
"range",
"csr",
".",
"IPAddresses",
"{",
"hosts",
"=",
"append",
"(",
"hosts",
",",
"csr",
".",
"IPAddresses",
"[",
"i",
"]",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"sreq",
":=",
"&",
"signer",
".",
"SignRequest",
"{",
"Hosts",
":",
"hosts",
",",
"Request",
":",
"string",
"(",
"csrPEM",
")",
",",
"Profile",
":",
"cap",
".",
"Profile",
",",
"Label",
":",
"cap",
".",
"Label",
",",
"}",
"\n\n",
"out",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"sreq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"cap",
".",
"provider",
"!=",
"nil",
"{",
"return",
"cap",
".",
"remote",
".",
"AuthSign",
"(",
"out",
",",
"nil",
",",
"cap",
".",
"provider",
")",
"\n",
"}",
"\n\n",
"return",
"cap",
".",
"remote",
".",
"Sign",
"(",
"out",
")",
"\n",
"}"
] | // SignCSR requests a certificate from a CFSSL signer. | [
"SignCSR",
"requests",
"a",
"certificate",
"from",
"a",
"CFSSL",
"signer",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/cfssl_provider.go#L198-L233 | train |
cloudflare/cfssl | transport/ca/cfssl_provider.go | CACertificate | func (cap *CFSSL) CACertificate() ([]byte, error) {
req := &info.Req{
Label: cap.Label,
Profile: cap.Profile,
}
out, err := json.Marshal(req)
if err != nil {
return nil, err
}
resp, err := cap.remote.Info(out)
if err != nil {
return nil, err
}
return []byte(resp.Certificate), nil
} | go | func (cap *CFSSL) CACertificate() ([]byte, error) {
req := &info.Req{
Label: cap.Label,
Profile: cap.Profile,
}
out, err := json.Marshal(req)
if err != nil {
return nil, err
}
resp, err := cap.remote.Info(out)
if err != nil {
return nil, err
}
return []byte(resp.Certificate), nil
} | [
"func",
"(",
"cap",
"*",
"CFSSL",
")",
"CACertificate",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"req",
":=",
"&",
"info",
".",
"Req",
"{",
"Label",
":",
"cap",
".",
"Label",
",",
"Profile",
":",
"cap",
".",
"Profile",
",",
"}",
"\n",
"out",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"cap",
".",
"remote",
".",
"Info",
"(",
"out",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"[",
"]",
"byte",
"(",
"resp",
".",
"Certificate",
")",
",",
"nil",
"\n",
"}"
] | // CACertificate returns the certificate for a CFSSL CA. | [
"CACertificate",
"returns",
"the",
"certificate",
"for",
"a",
"CFSSL",
"CA",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/cfssl_provider.go#L236-L252 | train |
cloudflare/cfssl | transport/example/exlib/exlib.go | Unpack | func Unpack(r io.Reader) ([]byte, error) {
var bl [2]byte
_, err := io.ReadFull(r, bl[:])
if err != nil {
return nil, err
}
n := binary.LittleEndian.Uint16(bl[:])
buf := make([]byte, int(n))
_, err = io.ReadFull(r, buf)
return buf, err
} | go | func Unpack(r io.Reader) ([]byte, error) {
var bl [2]byte
_, err := io.ReadFull(r, bl[:])
if err != nil {
return nil, err
}
n := binary.LittleEndian.Uint16(bl[:])
buf := make([]byte, int(n))
_, err = io.ReadFull(r, buf)
return buf, err
} | [
"func",
"Unpack",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"bl",
"[",
"2",
"]",
"byte",
"\n\n",
"_",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"r",
",",
"bl",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"n",
":=",
"binary",
".",
"LittleEndian",
".",
"Uint16",
"(",
"bl",
"[",
":",
"]",
")",
"\n",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"int",
"(",
"n",
")",
")",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"r",
",",
"buf",
")",
"\n",
"return",
"buf",
",",
"err",
"\n",
"}"
] | // Unpack reads a message from an io.Reader. | [
"Unpack",
"reads",
"a",
"message",
"from",
"an",
"io",
".",
"Reader",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/example/exlib/exlib.go#L50-L62 | train |
cloudflare/cfssl | transport/example/exlib/exlib.go | Pack | func Pack(w io.Writer, buf []byte) error {
if len(buf) > messageMax {
return errors.New("message is too large")
}
var bl [2]byte
binary.LittleEndian.PutUint16(bl[:], uint16(len(buf)))
_, err := w.Write(bl[:])
if err != nil {
return err
}
_, err = w.Write(buf)
return err
} | go | func Pack(w io.Writer, buf []byte) error {
if len(buf) > messageMax {
return errors.New("message is too large")
}
var bl [2]byte
binary.LittleEndian.PutUint16(bl[:], uint16(len(buf)))
_, err := w.Write(bl[:])
if err != nil {
return err
}
_, err = w.Write(buf)
return err
} | [
"func",
"Pack",
"(",
"w",
"io",
".",
"Writer",
",",
"buf",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"len",
"(",
"buf",
")",
">",
"messageMax",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"bl",
"[",
"2",
"]",
"byte",
"\n",
"binary",
".",
"LittleEndian",
".",
"PutUint16",
"(",
"bl",
"[",
":",
"]",
",",
"uint16",
"(",
"len",
"(",
"buf",
")",
")",
")",
"\n",
"_",
",",
"err",
":=",
"w",
".",
"Write",
"(",
"bl",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"w",
".",
"Write",
"(",
"buf",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Pack writes a message to an io.Writer. | [
"Pack",
"writes",
"a",
"message",
"to",
"an",
"io",
".",
"Writer",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/example/exlib/exlib.go#L67-L81 | train |
cloudflare/cfssl | ubiquity/ubiquity_crypto.go | hashUbiquity | func hashUbiquity(cert *x509.Certificate) HashUbiquity {
switch cert.SignatureAlgorithm {
case x509.ECDSAWithSHA1, x509.DSAWithSHA1, x509.SHA1WithRSA:
return SHA1Ubiquity
case x509.ECDSAWithSHA256, x509.ECDSAWithSHA384, x509.ECDSAWithSHA512,
x509.DSAWithSHA256, x509.SHA256WithRSA, x509.SHA384WithRSA,
x509.SHA512WithRSA:
return SHA2Ubiquity
case x509.MD5WithRSA, x509.MD2WithRSA:
return MD5Ubiquity
default:
return UnknownHashUbiquity
}
} | go | func hashUbiquity(cert *x509.Certificate) HashUbiquity {
switch cert.SignatureAlgorithm {
case x509.ECDSAWithSHA1, x509.DSAWithSHA1, x509.SHA1WithRSA:
return SHA1Ubiquity
case x509.ECDSAWithSHA256, x509.ECDSAWithSHA384, x509.ECDSAWithSHA512,
x509.DSAWithSHA256, x509.SHA256WithRSA, x509.SHA384WithRSA,
x509.SHA512WithRSA:
return SHA2Ubiquity
case x509.MD5WithRSA, x509.MD2WithRSA:
return MD5Ubiquity
default:
return UnknownHashUbiquity
}
} | [
"func",
"hashUbiquity",
"(",
"cert",
"*",
"x509",
".",
"Certificate",
")",
"HashUbiquity",
"{",
"switch",
"cert",
".",
"SignatureAlgorithm",
"{",
"case",
"x509",
".",
"ECDSAWithSHA1",
",",
"x509",
".",
"DSAWithSHA1",
",",
"x509",
".",
"SHA1WithRSA",
":",
"return",
"SHA1Ubiquity",
"\n",
"case",
"x509",
".",
"ECDSAWithSHA256",
",",
"x509",
".",
"ECDSAWithSHA384",
",",
"x509",
".",
"ECDSAWithSHA512",
",",
"x509",
".",
"DSAWithSHA256",
",",
"x509",
".",
"SHA256WithRSA",
",",
"x509",
".",
"SHA384WithRSA",
",",
"x509",
".",
"SHA512WithRSA",
":",
"return",
"SHA2Ubiquity",
"\n",
"case",
"x509",
".",
"MD5WithRSA",
",",
"x509",
".",
"MD2WithRSA",
":",
"return",
"MD5Ubiquity",
"\n",
"default",
":",
"return",
"UnknownHashUbiquity",
"\n",
"}",
"\n",
"}"
] | // hashUbiquity computes the ubiquity of the hash algorithm in the
// signature algorithm of a cert.
// SHA1 > SHA2 > MD > Others | [
"hashUbiquity",
"computes",
"the",
"ubiquity",
"of",
"the",
"hash",
"algorithm",
"in",
"the",
"signature",
"algorithm",
"of",
"a",
"cert",
".",
"SHA1",
">",
"SHA2",
">",
"MD",
">",
"Others"
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/ubiquity_crypto.go#L49-L62 | train |
cloudflare/cfssl | ubiquity/ubiquity_crypto.go | keyAlgoUbiquity | func keyAlgoUbiquity(cert *x509.Certificate) KeyAlgoUbiquity {
switch cert.PublicKeyAlgorithm {
case x509.ECDSA:
switch cert.PublicKey.(*ecdsa.PublicKey).Curve {
case elliptic.P256():
return ECDSA256Ubiquity
case elliptic.P384():
return ECDSA384Ubiquity
case elliptic.P521():
return ECDSA521Ubiquity
default:
return UnknownAlgoUbiquity
}
case x509.RSA:
if cert.PublicKey.(*rsa.PublicKey).N.BitLen() >= 1024 {
return RSAUbiquity
}
return UnknownAlgoUbiquity
case x509.DSA:
return DSAUbiquity
default:
return UnknownAlgoUbiquity
}
} | go | func keyAlgoUbiquity(cert *x509.Certificate) KeyAlgoUbiquity {
switch cert.PublicKeyAlgorithm {
case x509.ECDSA:
switch cert.PublicKey.(*ecdsa.PublicKey).Curve {
case elliptic.P256():
return ECDSA256Ubiquity
case elliptic.P384():
return ECDSA384Ubiquity
case elliptic.P521():
return ECDSA521Ubiquity
default:
return UnknownAlgoUbiquity
}
case x509.RSA:
if cert.PublicKey.(*rsa.PublicKey).N.BitLen() >= 1024 {
return RSAUbiquity
}
return UnknownAlgoUbiquity
case x509.DSA:
return DSAUbiquity
default:
return UnknownAlgoUbiquity
}
} | [
"func",
"keyAlgoUbiquity",
"(",
"cert",
"*",
"x509",
".",
"Certificate",
")",
"KeyAlgoUbiquity",
"{",
"switch",
"cert",
".",
"PublicKeyAlgorithm",
"{",
"case",
"x509",
".",
"ECDSA",
":",
"switch",
"cert",
".",
"PublicKey",
".",
"(",
"*",
"ecdsa",
".",
"PublicKey",
")",
".",
"Curve",
"{",
"case",
"elliptic",
".",
"P256",
"(",
")",
":",
"return",
"ECDSA256Ubiquity",
"\n",
"case",
"elliptic",
".",
"P384",
"(",
")",
":",
"return",
"ECDSA384Ubiquity",
"\n",
"case",
"elliptic",
".",
"P521",
"(",
")",
":",
"return",
"ECDSA521Ubiquity",
"\n",
"default",
":",
"return",
"UnknownAlgoUbiquity",
"\n",
"}",
"\n",
"case",
"x509",
".",
"RSA",
":",
"if",
"cert",
".",
"PublicKey",
".",
"(",
"*",
"rsa",
".",
"PublicKey",
")",
".",
"N",
".",
"BitLen",
"(",
")",
">=",
"1024",
"{",
"return",
"RSAUbiquity",
"\n",
"}",
"\n",
"return",
"UnknownAlgoUbiquity",
"\n",
"case",
"x509",
".",
"DSA",
":",
"return",
"DSAUbiquity",
"\n",
"default",
":",
"return",
"UnknownAlgoUbiquity",
"\n",
"}",
"\n",
"}"
] | // keyAlgoUbiquity compute the ubiquity of the cert's public key algorithm
// RSA, DSA>ECDSA>Unknown | [
"keyAlgoUbiquity",
"compute",
"the",
"ubiquity",
"of",
"the",
"cert",
"s",
"public",
"key",
"algorithm",
"RSA",
"DSA",
">",
"ECDSA",
">",
"Unknown"
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/ubiquity_crypto.go#L66-L89 | train |
cloudflare/cfssl | ubiquity/ubiquity_crypto.go | ChainHashUbiquity | func ChainHashUbiquity(chain []*x509.Certificate) HashUbiquity {
ret := math.MaxInt32
for _, cert := range chain {
uscore := int(hashUbiquity(cert))
if ret > uscore {
ret = uscore
}
}
return HashUbiquity(ret)
} | go | func ChainHashUbiquity(chain []*x509.Certificate) HashUbiquity {
ret := math.MaxInt32
for _, cert := range chain {
uscore := int(hashUbiquity(cert))
if ret > uscore {
ret = uscore
}
}
return HashUbiquity(ret)
} | [
"func",
"ChainHashUbiquity",
"(",
"chain",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"HashUbiquity",
"{",
"ret",
":=",
"math",
".",
"MaxInt32",
"\n",
"for",
"_",
",",
"cert",
":=",
"range",
"chain",
"{",
"uscore",
":=",
"int",
"(",
"hashUbiquity",
"(",
"cert",
")",
")",
"\n",
"if",
"ret",
">",
"uscore",
"{",
"ret",
"=",
"uscore",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"HashUbiquity",
"(",
"ret",
")",
"\n",
"}"
] | // ChainHashUbiquity scores a chain based on the hash algorithms used
// by the certificates in the chain. | [
"ChainHashUbiquity",
"scores",
"a",
"chain",
"based",
"on",
"the",
"hash",
"algorithms",
"used",
"by",
"the",
"certificates",
"in",
"the",
"chain",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/ubiquity_crypto.go#L93-L102 | train |
cloudflare/cfssl | ubiquity/ubiquity_crypto.go | ChainKeyAlgoUbiquity | func ChainKeyAlgoUbiquity(chain []*x509.Certificate) KeyAlgoUbiquity {
ret := math.MaxInt32
for _, cert := range chain {
uscore := int(keyAlgoUbiquity(cert))
if ret > uscore {
ret = uscore
}
}
return KeyAlgoUbiquity(ret)
} | go | func ChainKeyAlgoUbiquity(chain []*x509.Certificate) KeyAlgoUbiquity {
ret := math.MaxInt32
for _, cert := range chain {
uscore := int(keyAlgoUbiquity(cert))
if ret > uscore {
ret = uscore
}
}
return KeyAlgoUbiquity(ret)
} | [
"func",
"ChainKeyAlgoUbiquity",
"(",
"chain",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"KeyAlgoUbiquity",
"{",
"ret",
":=",
"math",
".",
"MaxInt32",
"\n",
"for",
"_",
",",
"cert",
":=",
"range",
"chain",
"{",
"uscore",
":=",
"int",
"(",
"keyAlgoUbiquity",
"(",
"cert",
")",
")",
"\n",
"if",
"ret",
">",
"uscore",
"{",
"ret",
"=",
"uscore",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"KeyAlgoUbiquity",
"(",
"ret",
")",
"\n",
"}"
] | // ChainKeyAlgoUbiquity scores a chain based on the public-key algorithms
// used by the certificates in the chain. | [
"ChainKeyAlgoUbiquity",
"scores",
"a",
"chain",
"based",
"on",
"the",
"public",
"-",
"key",
"algorithms",
"used",
"by",
"the",
"certificates",
"in",
"the",
"chain",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/ubiquity_crypto.go#L106-L115 | train |
cloudflare/cfssl | ubiquity/ubiquity_crypto.go | CompareChainHashUbiquity | func CompareChainHashUbiquity(chain1, chain2 []*x509.Certificate) int {
hu1 := ChainHashUbiquity(chain1)
hu2 := ChainHashUbiquity(chain2)
return int(hu1) - int(hu2)
} | go | func CompareChainHashUbiquity(chain1, chain2 []*x509.Certificate) int {
hu1 := ChainHashUbiquity(chain1)
hu2 := ChainHashUbiquity(chain2)
return int(hu1) - int(hu2)
} | [
"func",
"CompareChainHashUbiquity",
"(",
"chain1",
",",
"chain2",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"hu1",
":=",
"ChainHashUbiquity",
"(",
"chain1",
")",
"\n",
"hu2",
":=",
"ChainHashUbiquity",
"(",
"chain2",
")",
"\n",
"return",
"int",
"(",
"hu1",
")",
"-",
"int",
"(",
"hu2",
")",
"\n",
"}"
] | // CompareChainHashUbiquity returns a positive, zero, or negative value
// if the hash ubiquity of the first chain is greater, equal, or less
// than the second chain. | [
"CompareChainHashUbiquity",
"returns",
"a",
"positive",
"zero",
"or",
"negative",
"value",
"if",
"the",
"hash",
"ubiquity",
"of",
"the",
"first",
"chain",
"is",
"greater",
"equal",
"or",
"less",
"than",
"the",
"second",
"chain",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/ubiquity_crypto.go#L120-L124 | train |
cloudflare/cfssl | ubiquity/ubiquity_crypto.go | CompareChainKeyAlgoUbiquity | func CompareChainKeyAlgoUbiquity(chain1, chain2 []*x509.Certificate) int {
kau1 := ChainKeyAlgoUbiquity(chain1)
kau2 := ChainKeyAlgoUbiquity(chain2)
return int(kau1) - int(kau2)
} | go | func CompareChainKeyAlgoUbiquity(chain1, chain2 []*x509.Certificate) int {
kau1 := ChainKeyAlgoUbiquity(chain1)
kau2 := ChainKeyAlgoUbiquity(chain2)
return int(kau1) - int(kau2)
} | [
"func",
"CompareChainKeyAlgoUbiquity",
"(",
"chain1",
",",
"chain2",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"kau1",
":=",
"ChainKeyAlgoUbiquity",
"(",
"chain1",
")",
"\n",
"kau2",
":=",
"ChainKeyAlgoUbiquity",
"(",
"chain2",
")",
"\n",
"return",
"int",
"(",
"kau1",
")",
"-",
"int",
"(",
"kau2",
")",
"\n",
"}"
] | // CompareChainKeyAlgoUbiquity returns a positive, zero, or negative value
// if the public-key ubiquity of the first chain is greater, equal,
// or less than the second chain. | [
"CompareChainKeyAlgoUbiquity",
"returns",
"a",
"positive",
"zero",
"or",
"negative",
"value",
"if",
"the",
"public",
"-",
"key",
"ubiquity",
"of",
"the",
"first",
"chain",
"is",
"greater",
"equal",
"or",
"less",
"than",
"the",
"second",
"chain",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/ubiquity_crypto.go#L129-L133 | train |
cloudflare/cfssl | ubiquity/ubiquity_crypto.go | CompareExpiryUbiquity | func CompareExpiryUbiquity(chain1, chain2 []*x509.Certificate) int {
for i := 0; ; i++ {
if i >= len(chain1) || i >= len(chain2) {
break
}
c1 := chain1[len(chain1)-1-i]
c2 := chain2[len(chain2)-1-i]
t1 := c1.NotAfter
t2 := c2.NotAfter
// Check if expiry dates valid. Return if one or other is invalid.
// Otherwise rank by expiry date. Later is ranked higher.
c1Valid := helpers.ValidExpiry(c1)
c2Valid := helpers.ValidExpiry(c2)
if c1Valid && !c2Valid {
return 1
}
if !c1Valid && c2Valid {
return -1
}
r := compareTime(t1, t2)
// Return when we find rank difference.
if r != 0 {
return r
}
}
return 0
} | go | func CompareExpiryUbiquity(chain1, chain2 []*x509.Certificate) int {
for i := 0; ; i++ {
if i >= len(chain1) || i >= len(chain2) {
break
}
c1 := chain1[len(chain1)-1-i]
c2 := chain2[len(chain2)-1-i]
t1 := c1.NotAfter
t2 := c2.NotAfter
// Check if expiry dates valid. Return if one or other is invalid.
// Otherwise rank by expiry date. Later is ranked higher.
c1Valid := helpers.ValidExpiry(c1)
c2Valid := helpers.ValidExpiry(c2)
if c1Valid && !c2Valid {
return 1
}
if !c1Valid && c2Valid {
return -1
}
r := compareTime(t1, t2)
// Return when we find rank difference.
if r != 0 {
return r
}
}
return 0
} | [
"func",
"CompareExpiryUbiquity",
"(",
"chain1",
",",
"chain2",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"for",
"i",
":=",
"0",
";",
";",
"i",
"++",
"{",
"if",
"i",
">=",
"len",
"(",
"chain1",
")",
"||",
"i",
">=",
"len",
"(",
"chain2",
")",
"{",
"break",
"\n",
"}",
"\n",
"c1",
":=",
"chain1",
"[",
"len",
"(",
"chain1",
")",
"-",
"1",
"-",
"i",
"]",
"\n",
"c2",
":=",
"chain2",
"[",
"len",
"(",
"chain2",
")",
"-",
"1",
"-",
"i",
"]",
"\n",
"t1",
":=",
"c1",
".",
"NotAfter",
"\n",
"t2",
":=",
"c2",
".",
"NotAfter",
"\n\n",
"// Check if expiry dates valid. Return if one or other is invalid.",
"// Otherwise rank by expiry date. Later is ranked higher.",
"c1Valid",
":=",
"helpers",
".",
"ValidExpiry",
"(",
"c1",
")",
"\n",
"c2Valid",
":=",
"helpers",
".",
"ValidExpiry",
"(",
"c2",
")",
"\n",
"if",
"c1Valid",
"&&",
"!",
"c2Valid",
"{",
"return",
"1",
"\n",
"}",
"\n",
"if",
"!",
"c1Valid",
"&&",
"c2Valid",
"{",
"return",
"-",
"1",
"\n",
"}",
"\n\n",
"r",
":=",
"compareTime",
"(",
"t1",
",",
"t2",
")",
"\n",
"// Return when we find rank difference.",
"if",
"r",
"!=",
"0",
"{",
"return",
"r",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"0",
"\n",
"}"
] | // CompareExpiryUbiquity ranks two certificate chains based on the exiry dates of intermediates and roots.
// Certs expire later are ranked higher than ones expire earlier. The ranking between chains are determined by
// the first pair of intermediates, scanned from the root level, that ar ranked differently. | [
"CompareExpiryUbiquity",
"ranks",
"two",
"certificate",
"chains",
"based",
"on",
"the",
"exiry",
"dates",
"of",
"intermediates",
"and",
"roots",
".",
"Certs",
"expire",
"later",
"are",
"ranked",
"higher",
"than",
"ones",
"expire",
"earlier",
".",
"The",
"ranking",
"between",
"chains",
"are",
"determined",
"by",
"the",
"first",
"pair",
"of",
"intermediates",
"scanned",
"from",
"the",
"root",
"level",
"that",
"ar",
"ranked",
"differently",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/ubiquity_crypto.go#L138-L166 | train |
cloudflare/cfssl | whitelist/whitelist_net.go | Remove | func (wl *BasicNet) Remove(n *net.IPNet) {
if n == nil {
return
}
index := -1
wl.lock.Lock()
defer wl.lock.Unlock()
for i := range wl.whitelist {
if wl.whitelist[i].String() == n.String() {
index = i
break
}
}
if index == -1 {
return
}
wl.whitelist = append(wl.whitelist[:index], wl.whitelist[index+1:]...)
} | go | func (wl *BasicNet) Remove(n *net.IPNet) {
if n == nil {
return
}
index := -1
wl.lock.Lock()
defer wl.lock.Unlock()
for i := range wl.whitelist {
if wl.whitelist[i].String() == n.String() {
index = i
break
}
}
if index == -1 {
return
}
wl.whitelist = append(wl.whitelist[:index], wl.whitelist[index+1:]...)
} | [
"func",
"(",
"wl",
"*",
"BasicNet",
")",
"Remove",
"(",
"n",
"*",
"net",
".",
"IPNet",
")",
"{",
"if",
"n",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"index",
":=",
"-",
"1",
"\n",
"wl",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"wl",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"for",
"i",
":=",
"range",
"wl",
".",
"whitelist",
"{",
"if",
"wl",
".",
"whitelist",
"[",
"i",
"]",
".",
"String",
"(",
")",
"==",
"n",
".",
"String",
"(",
")",
"{",
"index",
"=",
"i",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"index",
"==",
"-",
"1",
"{",
"return",
"\n",
"}",
"\n\n",
"wl",
".",
"whitelist",
"=",
"append",
"(",
"wl",
".",
"whitelist",
"[",
":",
"index",
"]",
",",
"wl",
".",
"whitelist",
"[",
"index",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"}"
] | // Remove removes a network from the whitelist. | [
"Remove",
"removes",
"a",
"network",
"from",
"the",
"whitelist",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/whitelist/whitelist_net.go#L68-L88 | train |
cloudflare/cfssl | whitelist/whitelist_net.go | MarshalJSON | func (wl *BasicNet) MarshalJSON() ([]byte, error) {
var ss = make([]string, 0, len(wl.whitelist))
for i := range wl.whitelist {
ss = append(ss, wl.whitelist[i].String())
}
out := []byte(`"` + strings.Join(ss, ",") + `"`)
return out, nil
} | go | func (wl *BasicNet) MarshalJSON() ([]byte, error) {
var ss = make([]string, 0, len(wl.whitelist))
for i := range wl.whitelist {
ss = append(ss, wl.whitelist[i].String())
}
out := []byte(`"` + strings.Join(ss, ",") + `"`)
return out, nil
} | [
"func",
"(",
"wl",
"*",
"BasicNet",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"ss",
"=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"wl",
".",
"whitelist",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"wl",
".",
"whitelist",
"{",
"ss",
"=",
"append",
"(",
"ss",
",",
"wl",
".",
"whitelist",
"[",
"i",
"]",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"out",
":=",
"[",
"]",
"byte",
"(",
"`\"`",
"+",
"strings",
".",
"Join",
"(",
"ss",
",",
"\"",
"\"",
")",
"+",
"`\"`",
")",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // MarshalJSON serialises a network whitelist to a comma-separated
// list of networks. | [
"MarshalJSON",
"serialises",
"a",
"network",
"whitelist",
"to",
"a",
"comma",
"-",
"separated",
"list",
"of",
"networks",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/whitelist/whitelist_net.go#L99-L107 | train |
cloudflare/cfssl | whitelist/whitelist_net.go | UnmarshalJSON | func (wl *BasicNet) UnmarshalJSON(in []byte) error {
if in[0] != '"' || in[len(in)-1] != '"' {
return errors.New("whitelist: invalid whitelist")
}
if wl.lock == nil {
wl.lock = new(sync.Mutex)
}
wl.lock.Lock()
defer wl.lock.Unlock()
var err error
netString := strings.TrimSpace(string(in[1 : len(in)-1]))
nets := strings.Split(netString, ",")
wl.whitelist = make([]*net.IPNet, len(nets))
for i := range nets {
addr := strings.TrimSpace(nets[i])
if addr == "" {
continue
}
_, wl.whitelist[i], err = net.ParseCIDR(addr)
if err != nil {
wl.whitelist = nil
return err
}
}
return nil
} | go | func (wl *BasicNet) UnmarshalJSON(in []byte) error {
if in[0] != '"' || in[len(in)-1] != '"' {
return errors.New("whitelist: invalid whitelist")
}
if wl.lock == nil {
wl.lock = new(sync.Mutex)
}
wl.lock.Lock()
defer wl.lock.Unlock()
var err error
netString := strings.TrimSpace(string(in[1 : len(in)-1]))
nets := strings.Split(netString, ",")
wl.whitelist = make([]*net.IPNet, len(nets))
for i := range nets {
addr := strings.TrimSpace(nets[i])
if addr == "" {
continue
}
_, wl.whitelist[i], err = net.ParseCIDR(addr)
if err != nil {
wl.whitelist = nil
return err
}
}
return nil
} | [
"func",
"(",
"wl",
"*",
"BasicNet",
")",
"UnmarshalJSON",
"(",
"in",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"in",
"[",
"0",
"]",
"!=",
"'\"'",
"||",
"in",
"[",
"len",
"(",
"in",
")",
"-",
"1",
"]",
"!=",
"'\"'",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"wl",
".",
"lock",
"==",
"nil",
"{",
"wl",
".",
"lock",
"=",
"new",
"(",
"sync",
".",
"Mutex",
")",
"\n",
"}",
"\n\n",
"wl",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"wl",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"err",
"error",
"\n",
"netString",
":=",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"in",
"[",
"1",
":",
"len",
"(",
"in",
")",
"-",
"1",
"]",
")",
")",
"\n",
"nets",
":=",
"strings",
".",
"Split",
"(",
"netString",
",",
"\"",
"\"",
")",
"\n",
"wl",
".",
"whitelist",
"=",
"make",
"(",
"[",
"]",
"*",
"net",
".",
"IPNet",
",",
"len",
"(",
"nets",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"nets",
"{",
"addr",
":=",
"strings",
".",
"TrimSpace",
"(",
"nets",
"[",
"i",
"]",
")",
"\n",
"if",
"addr",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"_",
",",
"wl",
".",
"whitelist",
"[",
"i",
"]",
",",
"err",
"=",
"net",
".",
"ParseCIDR",
"(",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"wl",
".",
"whitelist",
"=",
"nil",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalJSON implements the json.Unmarshaler interface for network
// whitelists, taking a comma-separated string of networks. | [
"UnmarshalJSON",
"implements",
"the",
"json",
".",
"Unmarshaler",
"interface",
"for",
"network",
"whitelists",
"taking",
"a",
"comma",
"-",
"separated",
"string",
"of",
"networks",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/whitelist/whitelist_net.go#L111-L140 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | splitPreMasterSecret | func splitPreMasterSecret(secret []byte) (s1, s2 []byte) {
s1 = secret[0 : (len(secret)+1)/2]
s2 = secret[len(secret)/2:]
return
} | go | func splitPreMasterSecret(secret []byte) (s1, s2 []byte) {
s1 = secret[0 : (len(secret)+1)/2]
s2 = secret[len(secret)/2:]
return
} | [
"func",
"splitPreMasterSecret",
"(",
"secret",
"[",
"]",
"byte",
")",
"(",
"s1",
",",
"s2",
"[",
"]",
"byte",
")",
"{",
"s1",
"=",
"secret",
"[",
"0",
":",
"(",
"len",
"(",
"secret",
")",
"+",
"1",
")",
"/",
"2",
"]",
"\n",
"s2",
"=",
"secret",
"[",
"len",
"(",
"secret",
")",
"/",
"2",
":",
"]",
"\n",
"return",
"\n",
"}"
] | // Split a premaster secret in two as specified in RFC 4346, section 5. | [
"Split",
"a",
"premaster",
"secret",
"in",
"two",
"as",
"specified",
"in",
"RFC",
"4346",
"section",
"5",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L19-L23 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | pHash | func pHash(result, secret, seed []byte, hash func() hash.Hash) {
h := hmac.New(hash, secret)
h.Write(seed)
a := h.Sum(nil)
j := 0
for j < len(result) {
h.Reset()
h.Write(a)
h.Write(seed)
b := h.Sum(nil)
todo := len(b)
if j+todo > len(result) {
todo = len(result) - j
}
copy(result[j:j+todo], b)
j += todo
h.Reset()
h.Write(a)
a = h.Sum(nil)
}
} | go | func pHash(result, secret, seed []byte, hash func() hash.Hash) {
h := hmac.New(hash, secret)
h.Write(seed)
a := h.Sum(nil)
j := 0
for j < len(result) {
h.Reset()
h.Write(a)
h.Write(seed)
b := h.Sum(nil)
todo := len(b)
if j+todo > len(result) {
todo = len(result) - j
}
copy(result[j:j+todo], b)
j += todo
h.Reset()
h.Write(a)
a = h.Sum(nil)
}
} | [
"func",
"pHash",
"(",
"result",
",",
"secret",
",",
"seed",
"[",
"]",
"byte",
",",
"hash",
"func",
"(",
")",
"hash",
".",
"Hash",
")",
"{",
"h",
":=",
"hmac",
".",
"New",
"(",
"hash",
",",
"secret",
")",
"\n",
"h",
".",
"Write",
"(",
"seed",
")",
"\n",
"a",
":=",
"h",
".",
"Sum",
"(",
"nil",
")",
"\n\n",
"j",
":=",
"0",
"\n",
"for",
"j",
"<",
"len",
"(",
"result",
")",
"{",
"h",
".",
"Reset",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"a",
")",
"\n",
"h",
".",
"Write",
"(",
"seed",
")",
"\n",
"b",
":=",
"h",
".",
"Sum",
"(",
"nil",
")",
"\n",
"todo",
":=",
"len",
"(",
"b",
")",
"\n",
"if",
"j",
"+",
"todo",
">",
"len",
"(",
"result",
")",
"{",
"todo",
"=",
"len",
"(",
"result",
")",
"-",
"j",
"\n",
"}",
"\n",
"copy",
"(",
"result",
"[",
"j",
":",
"j",
"+",
"todo",
"]",
",",
"b",
")",
"\n",
"j",
"+=",
"todo",
"\n\n",
"h",
".",
"Reset",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"a",
")",
"\n",
"a",
"=",
"h",
".",
"Sum",
"(",
"nil",
")",
"\n",
"}",
"\n",
"}"
] | // pHash implements the P_hash function, as defined in RFC 4346, section 5. | [
"pHash",
"implements",
"the",
"P_hash",
"function",
"as",
"defined",
"in",
"RFC",
"4346",
"section",
"5",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L26-L48 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | prf10 | func prf10(result, secret, label, seed []byte) {
hashSHA1 := sha1.New
hashMD5 := md5.New
labelAndSeed := make([]byte, len(label)+len(seed))
copy(labelAndSeed, label)
copy(labelAndSeed[len(label):], seed)
s1, s2 := splitPreMasterSecret(secret)
pHash(result, s1, labelAndSeed, hashMD5)
result2 := make([]byte, len(result))
pHash(result2, s2, labelAndSeed, hashSHA1)
for i, b := range result2 {
result[i] ^= b
}
} | go | func prf10(result, secret, label, seed []byte) {
hashSHA1 := sha1.New
hashMD5 := md5.New
labelAndSeed := make([]byte, len(label)+len(seed))
copy(labelAndSeed, label)
copy(labelAndSeed[len(label):], seed)
s1, s2 := splitPreMasterSecret(secret)
pHash(result, s1, labelAndSeed, hashMD5)
result2 := make([]byte, len(result))
pHash(result2, s2, labelAndSeed, hashSHA1)
for i, b := range result2 {
result[i] ^= b
}
} | [
"func",
"prf10",
"(",
"result",
",",
"secret",
",",
"label",
",",
"seed",
"[",
"]",
"byte",
")",
"{",
"hashSHA1",
":=",
"sha1",
".",
"New",
"\n",
"hashMD5",
":=",
"md5",
".",
"New",
"\n\n",
"labelAndSeed",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"label",
")",
"+",
"len",
"(",
"seed",
")",
")",
"\n",
"copy",
"(",
"labelAndSeed",
",",
"label",
")",
"\n",
"copy",
"(",
"labelAndSeed",
"[",
"len",
"(",
"label",
")",
":",
"]",
",",
"seed",
")",
"\n\n",
"s1",
",",
"s2",
":=",
"splitPreMasterSecret",
"(",
"secret",
")",
"\n",
"pHash",
"(",
"result",
",",
"s1",
",",
"labelAndSeed",
",",
"hashMD5",
")",
"\n",
"result2",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"result",
")",
")",
"\n",
"pHash",
"(",
"result2",
",",
"s2",
",",
"labelAndSeed",
",",
"hashSHA1",
")",
"\n\n",
"for",
"i",
",",
"b",
":=",
"range",
"result2",
"{",
"result",
"[",
"i",
"]",
"^=",
"b",
"\n",
"}",
"\n",
"}"
] | // prf10 implements the TLS 1.0 pseudo-random function, as defined in RFC 2246, section 5. | [
"prf10",
"implements",
"the",
"TLS",
"1",
".",
"0",
"pseudo",
"-",
"random",
"function",
"as",
"defined",
"in",
"RFC",
"2246",
"section",
"5",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L51-L67 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | prf12 | func prf12(hashFunc func() hash.Hash) func(result, secret, label, seed []byte) {
return func(result, secret, label, seed []byte) {
labelAndSeed := make([]byte, len(label)+len(seed))
copy(labelAndSeed, label)
copy(labelAndSeed[len(label):], seed)
pHash(result, secret, labelAndSeed, hashFunc)
}
} | go | func prf12(hashFunc func() hash.Hash) func(result, secret, label, seed []byte) {
return func(result, secret, label, seed []byte) {
labelAndSeed := make([]byte, len(label)+len(seed))
copy(labelAndSeed, label)
copy(labelAndSeed[len(label):], seed)
pHash(result, secret, labelAndSeed, hashFunc)
}
} | [
"func",
"prf12",
"(",
"hashFunc",
"func",
"(",
")",
"hash",
".",
"Hash",
")",
"func",
"(",
"result",
",",
"secret",
",",
"label",
",",
"seed",
"[",
"]",
"byte",
")",
"{",
"return",
"func",
"(",
"result",
",",
"secret",
",",
"label",
",",
"seed",
"[",
"]",
"byte",
")",
"{",
"labelAndSeed",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"label",
")",
"+",
"len",
"(",
"seed",
")",
")",
"\n",
"copy",
"(",
"labelAndSeed",
",",
"label",
")",
"\n",
"copy",
"(",
"labelAndSeed",
"[",
"len",
"(",
"label",
")",
":",
"]",
",",
"seed",
")",
"\n\n",
"pHash",
"(",
"result",
",",
"secret",
",",
"labelAndSeed",
",",
"hashFunc",
")",
"\n",
"}",
"\n",
"}"
] | // prf12 implements the TLS 1.2 pseudo-random function, as defined in RFC 5246, section 5. | [
"prf12",
"implements",
"the",
"TLS",
"1",
".",
"2",
"pseudo",
"-",
"random",
"function",
"as",
"defined",
"in",
"RFC",
"5246",
"section",
"5",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L70-L78 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | keysFromMasterSecret | func keysFromMasterSecret(version uint16, suite *cipherSuite, masterSecret, clientRandom, serverRandom []byte, macLen, keyLen, ivLen int) (clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV []byte) {
seed := make([]byte, 0, len(serverRandom)+len(clientRandom))
seed = append(seed, serverRandom...)
seed = append(seed, clientRandom...)
n := 2*macLen + 2*keyLen + 2*ivLen
keyMaterial := make([]byte, n)
prfForVersion(version, suite)(keyMaterial, masterSecret, keyExpansionLabel, seed)
clientMAC = keyMaterial[:macLen]
keyMaterial = keyMaterial[macLen:]
serverMAC = keyMaterial[:macLen]
keyMaterial = keyMaterial[macLen:]
clientKey = keyMaterial[:keyLen]
keyMaterial = keyMaterial[keyLen:]
serverKey = keyMaterial[:keyLen]
keyMaterial = keyMaterial[keyLen:]
clientIV = keyMaterial[:ivLen]
keyMaterial = keyMaterial[ivLen:]
serverIV = keyMaterial[:ivLen]
return
} | go | func keysFromMasterSecret(version uint16, suite *cipherSuite, masterSecret, clientRandom, serverRandom []byte, macLen, keyLen, ivLen int) (clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV []byte) {
seed := make([]byte, 0, len(serverRandom)+len(clientRandom))
seed = append(seed, serverRandom...)
seed = append(seed, clientRandom...)
n := 2*macLen + 2*keyLen + 2*ivLen
keyMaterial := make([]byte, n)
prfForVersion(version, suite)(keyMaterial, masterSecret, keyExpansionLabel, seed)
clientMAC = keyMaterial[:macLen]
keyMaterial = keyMaterial[macLen:]
serverMAC = keyMaterial[:macLen]
keyMaterial = keyMaterial[macLen:]
clientKey = keyMaterial[:keyLen]
keyMaterial = keyMaterial[keyLen:]
serverKey = keyMaterial[:keyLen]
keyMaterial = keyMaterial[keyLen:]
clientIV = keyMaterial[:ivLen]
keyMaterial = keyMaterial[ivLen:]
serverIV = keyMaterial[:ivLen]
return
} | [
"func",
"keysFromMasterSecret",
"(",
"version",
"uint16",
",",
"suite",
"*",
"cipherSuite",
",",
"masterSecret",
",",
"clientRandom",
",",
"serverRandom",
"[",
"]",
"byte",
",",
"macLen",
",",
"keyLen",
",",
"ivLen",
"int",
")",
"(",
"clientMAC",
",",
"serverMAC",
",",
"clientKey",
",",
"serverKey",
",",
"clientIV",
",",
"serverIV",
"[",
"]",
"byte",
")",
"{",
"seed",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"len",
"(",
"serverRandom",
")",
"+",
"len",
"(",
"clientRandom",
")",
")",
"\n",
"seed",
"=",
"append",
"(",
"seed",
",",
"serverRandom",
"...",
")",
"\n",
"seed",
"=",
"append",
"(",
"seed",
",",
"clientRandom",
"...",
")",
"\n\n",
"n",
":=",
"2",
"*",
"macLen",
"+",
"2",
"*",
"keyLen",
"+",
"2",
"*",
"ivLen",
"\n",
"keyMaterial",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"n",
")",
"\n",
"prfForVersion",
"(",
"version",
",",
"suite",
")",
"(",
"keyMaterial",
",",
"masterSecret",
",",
"keyExpansionLabel",
",",
"seed",
")",
"\n",
"clientMAC",
"=",
"keyMaterial",
"[",
":",
"macLen",
"]",
"\n",
"keyMaterial",
"=",
"keyMaterial",
"[",
"macLen",
":",
"]",
"\n",
"serverMAC",
"=",
"keyMaterial",
"[",
":",
"macLen",
"]",
"\n",
"keyMaterial",
"=",
"keyMaterial",
"[",
"macLen",
":",
"]",
"\n",
"clientKey",
"=",
"keyMaterial",
"[",
":",
"keyLen",
"]",
"\n",
"keyMaterial",
"=",
"keyMaterial",
"[",
"keyLen",
":",
"]",
"\n",
"serverKey",
"=",
"keyMaterial",
"[",
":",
"keyLen",
"]",
"\n",
"keyMaterial",
"=",
"keyMaterial",
"[",
"keyLen",
":",
"]",
"\n",
"clientIV",
"=",
"keyMaterial",
"[",
":",
"ivLen",
"]",
"\n",
"keyMaterial",
"=",
"keyMaterial",
"[",
"ivLen",
":",
"]",
"\n",
"serverIV",
"=",
"keyMaterial",
"[",
":",
"ivLen",
"]",
"\n",
"return",
"\n",
"}"
] | // keysFromMasterSecret generates the connection keys from the master
// secret, given the lengths of the MAC key, cipher key and IV, as defined in
// RFC 2246, section 6.3. | [
"keysFromMasterSecret",
"generates",
"the",
"connection",
"keys",
"from",
"the",
"master",
"secret",
"given",
"the",
"lengths",
"of",
"the",
"MAC",
"key",
"cipher",
"key",
"and",
"IV",
"as",
"defined",
"in",
"RFC",
"2246",
"section",
"6",
".",
"3",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L160-L180 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | lookupTLSHash | func lookupTLSHash(hash uint8) (crypto.Hash, error) {
switch hash {
case hashSHA1:
return crypto.SHA1, nil
case hashSHA256:
return crypto.SHA256, nil
case hashSHA384:
return crypto.SHA384, nil
default:
return 0, errors.New("tls: unsupported hash algorithm")
}
} | go | func lookupTLSHash(hash uint8) (crypto.Hash, error) {
switch hash {
case hashSHA1:
return crypto.SHA1, nil
case hashSHA256:
return crypto.SHA256, nil
case hashSHA384:
return crypto.SHA384, nil
default:
return 0, errors.New("tls: unsupported hash algorithm")
}
} | [
"func",
"lookupTLSHash",
"(",
"hash",
"uint8",
")",
"(",
"crypto",
".",
"Hash",
",",
"error",
")",
"{",
"switch",
"hash",
"{",
"case",
"hashSHA1",
":",
"return",
"crypto",
".",
"SHA1",
",",
"nil",
"\n",
"case",
"hashSHA256",
":",
"return",
"crypto",
".",
"SHA256",
",",
"nil",
"\n",
"case",
"hashSHA384",
":",
"return",
"crypto",
".",
"SHA384",
",",
"nil",
"\n",
"default",
":",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // lookupTLSHash looks up the corresponding crypto.Hash for a given
// TLS hash identifier. | [
"lookupTLSHash",
"looks",
"up",
"the",
"corresponding",
"crypto",
".",
"Hash",
"for",
"a",
"given",
"TLS",
"hash",
"identifier",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L184-L195 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | finishedSum30 | func finishedSum30(md5, sha1 hash.Hash, masterSecret []byte, magic []byte) []byte {
md5.Write(magic)
md5.Write(masterSecret)
md5.Write(ssl30Pad1[:])
md5Digest := md5.Sum(nil)
md5.Reset()
md5.Write(masterSecret)
md5.Write(ssl30Pad2[:])
md5.Write(md5Digest)
md5Digest = md5.Sum(nil)
sha1.Write(magic)
sha1.Write(masterSecret)
sha1.Write(ssl30Pad1[:40])
sha1Digest := sha1.Sum(nil)
sha1.Reset()
sha1.Write(masterSecret)
sha1.Write(ssl30Pad2[:40])
sha1.Write(sha1Digest)
sha1Digest = sha1.Sum(nil)
ret := make([]byte, len(md5Digest)+len(sha1Digest))
copy(ret, md5Digest)
copy(ret[len(md5Digest):], sha1Digest)
return ret
} | go | func finishedSum30(md5, sha1 hash.Hash, masterSecret []byte, magic []byte) []byte {
md5.Write(magic)
md5.Write(masterSecret)
md5.Write(ssl30Pad1[:])
md5Digest := md5.Sum(nil)
md5.Reset()
md5.Write(masterSecret)
md5.Write(ssl30Pad2[:])
md5.Write(md5Digest)
md5Digest = md5.Sum(nil)
sha1.Write(magic)
sha1.Write(masterSecret)
sha1.Write(ssl30Pad1[:40])
sha1Digest := sha1.Sum(nil)
sha1.Reset()
sha1.Write(masterSecret)
sha1.Write(ssl30Pad2[:40])
sha1.Write(sha1Digest)
sha1Digest = sha1.Sum(nil)
ret := make([]byte, len(md5Digest)+len(sha1Digest))
copy(ret, md5Digest)
copy(ret[len(md5Digest):], sha1Digest)
return ret
} | [
"func",
"finishedSum30",
"(",
"md5",
",",
"sha1",
"hash",
".",
"Hash",
",",
"masterSecret",
"[",
"]",
"byte",
",",
"magic",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"md5",
".",
"Write",
"(",
"magic",
")",
"\n",
"md5",
".",
"Write",
"(",
"masterSecret",
")",
"\n",
"md5",
".",
"Write",
"(",
"ssl30Pad1",
"[",
":",
"]",
")",
"\n",
"md5Digest",
":=",
"md5",
".",
"Sum",
"(",
"nil",
")",
"\n\n",
"md5",
".",
"Reset",
"(",
")",
"\n",
"md5",
".",
"Write",
"(",
"masterSecret",
")",
"\n",
"md5",
".",
"Write",
"(",
"ssl30Pad2",
"[",
":",
"]",
")",
"\n",
"md5",
".",
"Write",
"(",
"md5Digest",
")",
"\n",
"md5Digest",
"=",
"md5",
".",
"Sum",
"(",
"nil",
")",
"\n\n",
"sha1",
".",
"Write",
"(",
"magic",
")",
"\n",
"sha1",
".",
"Write",
"(",
"masterSecret",
")",
"\n",
"sha1",
".",
"Write",
"(",
"ssl30Pad1",
"[",
":",
"40",
"]",
")",
"\n",
"sha1Digest",
":=",
"sha1",
".",
"Sum",
"(",
"nil",
")",
"\n\n",
"sha1",
".",
"Reset",
"(",
")",
"\n",
"sha1",
".",
"Write",
"(",
"masterSecret",
")",
"\n",
"sha1",
".",
"Write",
"(",
"ssl30Pad2",
"[",
":",
"40",
"]",
")",
"\n",
"sha1",
".",
"Write",
"(",
"sha1Digest",
")",
"\n",
"sha1Digest",
"=",
"sha1",
".",
"Sum",
"(",
"nil",
")",
"\n\n",
"ret",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"md5Digest",
")",
"+",
"len",
"(",
"sha1Digest",
")",
")",
"\n",
"copy",
"(",
"ret",
",",
"md5Digest",
")",
"\n",
"copy",
"(",
"ret",
"[",
"len",
"(",
"md5Digest",
")",
":",
"]",
",",
"sha1Digest",
")",
"\n",
"return",
"ret",
"\n",
"}"
] | // finishedSum30 calculates the contents of the verify_data member of a SSLv3
// Finished message given the MD5 and SHA1 hashes of a set of handshake
// messages. | [
"finishedSum30",
"calculates",
"the",
"contents",
"of",
"the",
"verify_data",
"member",
"of",
"a",
"SSLv3",
"Finished",
"message",
"given",
"the",
"MD5",
"and",
"SHA1",
"hashes",
"of",
"a",
"set",
"of",
"handshake",
"messages",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L257-L284 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | clientSum | func (h finishedHash) clientSum(masterSecret []byte) []byte {
if h.version == VersionSSL30 {
return finishedSum30(h.clientMD5, h.client, masterSecret, ssl3ClientFinishedMagic[:])
}
out := make([]byte, finishedVerifyLength)
h.prf(out, masterSecret, clientFinishedLabel, h.Sum())
return out
} | go | func (h finishedHash) clientSum(masterSecret []byte) []byte {
if h.version == VersionSSL30 {
return finishedSum30(h.clientMD5, h.client, masterSecret, ssl3ClientFinishedMagic[:])
}
out := make([]byte, finishedVerifyLength)
h.prf(out, masterSecret, clientFinishedLabel, h.Sum())
return out
} | [
"func",
"(",
"h",
"finishedHash",
")",
"clientSum",
"(",
"masterSecret",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"h",
".",
"version",
"==",
"VersionSSL30",
"{",
"return",
"finishedSum30",
"(",
"h",
".",
"clientMD5",
",",
"h",
".",
"client",
",",
"masterSecret",
",",
"ssl3ClientFinishedMagic",
"[",
":",
"]",
")",
"\n",
"}",
"\n\n",
"out",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"finishedVerifyLength",
")",
"\n",
"h",
".",
"prf",
"(",
"out",
",",
"masterSecret",
",",
"clientFinishedLabel",
",",
"h",
".",
"Sum",
"(",
")",
")",
"\n",
"return",
"out",
"\n",
"}"
] | // clientSum returns the contents of the verify_data member of a client's
// Finished message. | [
"clientSum",
"returns",
"the",
"contents",
"of",
"the",
"verify_data",
"member",
"of",
"a",
"client",
"s",
"Finished",
"message",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L291-L299 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | serverSum | func (h finishedHash) serverSum(masterSecret []byte) []byte {
if h.version == VersionSSL30 {
return finishedSum30(h.serverMD5, h.server, masterSecret, ssl3ServerFinishedMagic[:])
}
out := make([]byte, finishedVerifyLength)
h.prf(out, masterSecret, serverFinishedLabel, h.Sum())
return out
} | go | func (h finishedHash) serverSum(masterSecret []byte) []byte {
if h.version == VersionSSL30 {
return finishedSum30(h.serverMD5, h.server, masterSecret, ssl3ServerFinishedMagic[:])
}
out := make([]byte, finishedVerifyLength)
h.prf(out, masterSecret, serverFinishedLabel, h.Sum())
return out
} | [
"func",
"(",
"h",
"finishedHash",
")",
"serverSum",
"(",
"masterSecret",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"h",
".",
"version",
"==",
"VersionSSL30",
"{",
"return",
"finishedSum30",
"(",
"h",
".",
"serverMD5",
",",
"h",
".",
"server",
",",
"masterSecret",
",",
"ssl3ServerFinishedMagic",
"[",
":",
"]",
")",
"\n",
"}",
"\n\n",
"out",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"finishedVerifyLength",
")",
"\n",
"h",
".",
"prf",
"(",
"out",
",",
"masterSecret",
",",
"serverFinishedLabel",
",",
"h",
".",
"Sum",
"(",
")",
")",
"\n",
"return",
"out",
"\n",
"}"
] | // serverSum returns the contents of the verify_data member of a server's
// Finished message. | [
"serverSum",
"returns",
"the",
"contents",
"of",
"the",
"verify_data",
"member",
"of",
"a",
"server",
"s",
"Finished",
"message",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L303-L311 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | selectClientCertSignatureAlgorithm | func (h finishedHash) selectClientCertSignatureAlgorithm(serverList []signatureAndHash, sigType uint8) (signatureAndHash, error) {
if h.version < VersionTLS12 {
// Nothing to negotiate before TLS 1.2.
return signatureAndHash{signature: sigType}, nil
}
for _, v := range serverList {
if v.signature == sigType && isSupportedSignatureAndHash(v, supportedSignatureAlgorithms) {
return v, nil
}
}
return signatureAndHash{}, errors.New("tls: no supported signature algorithm found for signing client certificate")
} | go | func (h finishedHash) selectClientCertSignatureAlgorithm(serverList []signatureAndHash, sigType uint8) (signatureAndHash, error) {
if h.version < VersionTLS12 {
// Nothing to negotiate before TLS 1.2.
return signatureAndHash{signature: sigType}, nil
}
for _, v := range serverList {
if v.signature == sigType && isSupportedSignatureAndHash(v, supportedSignatureAlgorithms) {
return v, nil
}
}
return signatureAndHash{}, errors.New("tls: no supported signature algorithm found for signing client certificate")
} | [
"func",
"(",
"h",
"finishedHash",
")",
"selectClientCertSignatureAlgorithm",
"(",
"serverList",
"[",
"]",
"signatureAndHash",
",",
"sigType",
"uint8",
")",
"(",
"signatureAndHash",
",",
"error",
")",
"{",
"if",
"h",
".",
"version",
"<",
"VersionTLS12",
"{",
"// Nothing to negotiate before TLS 1.2.",
"return",
"signatureAndHash",
"{",
"signature",
":",
"sigType",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"v",
":=",
"range",
"serverList",
"{",
"if",
"v",
".",
"signature",
"==",
"sigType",
"&&",
"isSupportedSignatureAndHash",
"(",
"v",
",",
"supportedSignatureAlgorithms",
")",
"{",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"signatureAndHash",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // selectClientCertSignatureAlgorithm returns a signatureAndHash to sign a
// client's CertificateVerify with, or an error if none can be found. | [
"selectClientCertSignatureAlgorithm",
"returns",
"a",
"signatureAndHash",
"to",
"sign",
"a",
"client",
"s",
"CertificateVerify",
"with",
"or",
"an",
"error",
"if",
"none",
"can",
"be",
"found",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L315-L327 | train |
cloudflare/cfssl | scan/crypto/tls/prf.go | hashForClientCertificate | func (h finishedHash) hashForClientCertificate(signatureAndHash signatureAndHash, masterSecret []byte) ([]byte, crypto.Hash, error) {
if (h.version == VersionSSL30 || h.version >= VersionTLS12) && h.buffer == nil {
panic("a handshake hash for a client-certificate was requested after discarding the handshake buffer")
}
if h.version == VersionSSL30 {
if signatureAndHash.signature != signatureRSA {
return nil, 0, errors.New("tls: unsupported signature type for client certificate")
}
md5Hash := md5.New()
md5Hash.Write(h.buffer)
sha1Hash := sha1.New()
sha1Hash.Write(h.buffer)
return finishedSum30(md5Hash, sha1Hash, masterSecret, nil), crypto.MD5SHA1, nil
}
if h.version >= VersionTLS12 {
hashAlg, err := lookupTLSHash(signatureAndHash.hash)
if err != nil {
return nil, 0, err
}
hash := hashAlg.New()
hash.Write(h.buffer)
return hash.Sum(nil), hashAlg, nil
}
if signatureAndHash.signature == signatureECDSA {
return h.server.Sum(nil), crypto.SHA1, nil
}
return h.Sum(), crypto.MD5SHA1, nil
} | go | func (h finishedHash) hashForClientCertificate(signatureAndHash signatureAndHash, masterSecret []byte) ([]byte, crypto.Hash, error) {
if (h.version == VersionSSL30 || h.version >= VersionTLS12) && h.buffer == nil {
panic("a handshake hash for a client-certificate was requested after discarding the handshake buffer")
}
if h.version == VersionSSL30 {
if signatureAndHash.signature != signatureRSA {
return nil, 0, errors.New("tls: unsupported signature type for client certificate")
}
md5Hash := md5.New()
md5Hash.Write(h.buffer)
sha1Hash := sha1.New()
sha1Hash.Write(h.buffer)
return finishedSum30(md5Hash, sha1Hash, masterSecret, nil), crypto.MD5SHA1, nil
}
if h.version >= VersionTLS12 {
hashAlg, err := lookupTLSHash(signatureAndHash.hash)
if err != nil {
return nil, 0, err
}
hash := hashAlg.New()
hash.Write(h.buffer)
return hash.Sum(nil), hashAlg, nil
}
if signatureAndHash.signature == signatureECDSA {
return h.server.Sum(nil), crypto.SHA1, nil
}
return h.Sum(), crypto.MD5SHA1, nil
} | [
"func",
"(",
"h",
"finishedHash",
")",
"hashForClientCertificate",
"(",
"signatureAndHash",
"signatureAndHash",
",",
"masterSecret",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"crypto",
".",
"Hash",
",",
"error",
")",
"{",
"if",
"(",
"h",
".",
"version",
"==",
"VersionSSL30",
"||",
"h",
".",
"version",
">=",
"VersionTLS12",
")",
"&&",
"h",
".",
"buffer",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"h",
".",
"version",
"==",
"VersionSSL30",
"{",
"if",
"signatureAndHash",
".",
"signature",
"!=",
"signatureRSA",
"{",
"return",
"nil",
",",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"md5Hash",
":=",
"md5",
".",
"New",
"(",
")",
"\n",
"md5Hash",
".",
"Write",
"(",
"h",
".",
"buffer",
")",
"\n",
"sha1Hash",
":=",
"sha1",
".",
"New",
"(",
")",
"\n",
"sha1Hash",
".",
"Write",
"(",
"h",
".",
"buffer",
")",
"\n",
"return",
"finishedSum30",
"(",
"md5Hash",
",",
"sha1Hash",
",",
"masterSecret",
",",
"nil",
")",
",",
"crypto",
".",
"MD5SHA1",
",",
"nil",
"\n",
"}",
"\n",
"if",
"h",
".",
"version",
">=",
"VersionTLS12",
"{",
"hashAlg",
",",
"err",
":=",
"lookupTLSHash",
"(",
"signatureAndHash",
".",
"hash",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n",
"hash",
":=",
"hashAlg",
".",
"New",
"(",
")",
"\n",
"hash",
".",
"Write",
"(",
"h",
".",
"buffer",
")",
"\n",
"return",
"hash",
".",
"Sum",
"(",
"nil",
")",
",",
"hashAlg",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"signatureAndHash",
".",
"signature",
"==",
"signatureECDSA",
"{",
"return",
"h",
".",
"server",
".",
"Sum",
"(",
"nil",
")",
",",
"crypto",
".",
"SHA1",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"h",
".",
"Sum",
"(",
")",
",",
"crypto",
".",
"MD5SHA1",
",",
"nil",
"\n",
"}"
] | // hashForClientCertificate returns a digest, hash function, and TLS 1.2 hash
// id suitable for signing by a TLS client certificate. | [
"hashForClientCertificate",
"returns",
"a",
"digest",
"hash",
"function",
"and",
"TLS",
"1",
".",
"2",
"hash",
"id",
"suitable",
"for",
"signing",
"by",
"a",
"TLS",
"client",
"certificate",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/tls/prf.go#L331-L362 | train |
cloudflare/cfssl | transport/ca/localca/signer.go | CACertificate | func (lca *CA) CACertificate() ([]byte, error) {
if lca.s == nil {
return nil, errNotSetup
}
cert, err := lca.s.Certificate(lca.Label, lca.Profile)
if err != nil {
return nil, err
}
p := &pem.Block{
Type: "CERTIFICATE",
Bytes: cert.Raw,
}
return pem.EncodeToMemory(p), nil
} | go | func (lca *CA) CACertificate() ([]byte, error) {
if lca.s == nil {
return nil, errNotSetup
}
cert, err := lca.s.Certificate(lca.Label, lca.Profile)
if err != nil {
return nil, err
}
p := &pem.Block{
Type: "CERTIFICATE",
Bytes: cert.Raw,
}
return pem.EncodeToMemory(p), nil
} | [
"func",
"(",
"lca",
"*",
"CA",
")",
"CACertificate",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"lca",
".",
"s",
"==",
"nil",
"{",
"return",
"nil",
",",
"errNotSetup",
"\n",
"}",
"\n\n",
"cert",
",",
"err",
":=",
"lca",
".",
"s",
".",
"Certificate",
"(",
"lca",
".",
"Label",
",",
"lca",
".",
"Profile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"p",
":=",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"\"",
"\"",
",",
"Bytes",
":",
"cert",
".",
"Raw",
",",
"}",
"\n",
"return",
"pem",
".",
"EncodeToMemory",
"(",
"p",
")",
",",
"nil",
"\n",
"}"
] | // CACertificate returns the certificate authority's certificate. | [
"CACertificate",
"returns",
"the",
"certificate",
"authority",
"s",
"certificate",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/localca/signer.go#L48-L63 | train |
cloudflare/cfssl | transport/ca/localca/signer.go | ExampleRequest | func ExampleRequest() *csr.CertificateRequest {
return &csr.CertificateRequest{
Hosts: []string{"localhost"},
KeyRequest: &csr.BasicKeyRequest{
A: "ecdsa",
S: 256,
},
CN: "Transport Failover Test Local CA",
CA: &csr.CAConfig{
PathLength: 1,
Expiry: "30m",
},
}
} | go | func ExampleRequest() *csr.CertificateRequest {
return &csr.CertificateRequest{
Hosts: []string{"localhost"},
KeyRequest: &csr.BasicKeyRequest{
A: "ecdsa",
S: 256,
},
CN: "Transport Failover Test Local CA",
CA: &csr.CAConfig{
PathLength: 1,
Expiry: "30m",
},
}
} | [
"func",
"ExampleRequest",
"(",
")",
"*",
"csr",
".",
"CertificateRequest",
"{",
"return",
"&",
"csr",
".",
"CertificateRequest",
"{",
"Hosts",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"KeyRequest",
":",
"&",
"csr",
".",
"BasicKeyRequest",
"{",
"A",
":",
"\"",
"\"",
",",
"S",
":",
"256",
",",
"}",
",",
"CN",
":",
"\"",
"\"",
",",
"CA",
":",
"&",
"csr",
".",
"CAConfig",
"{",
"PathLength",
":",
"1",
",",
"Expiry",
":",
"\"",
"\"",
",",
"}",
",",
"}",
"\n",
"}"
] | // ExampleRequest can be used as a sample request, or the returned
// request can be modified. | [
"ExampleRequest",
"can",
"be",
"used",
"as",
"a",
"sample",
"request",
"or",
"the",
"returned",
"request",
"can",
"be",
"modified",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/localca/signer.go#L107-L120 | train |
cloudflare/cfssl | transport/ca/localca/signer.go | ExampleSigningConfig | func ExampleSigningConfig() *config.Signing {
return &config.Signing{
Default: &config.SigningProfile{
Expiry: 15 * time.Minute,
Usage: []string{
"server auth", "client auth",
"signing", "key encipherment",
},
},
}
} | go | func ExampleSigningConfig() *config.Signing {
return &config.Signing{
Default: &config.SigningProfile{
Expiry: 15 * time.Minute,
Usage: []string{
"server auth", "client auth",
"signing", "key encipherment",
},
},
}
} | [
"func",
"ExampleSigningConfig",
"(",
")",
"*",
"config",
".",
"Signing",
"{",
"return",
"&",
"config",
".",
"Signing",
"{",
"Default",
":",
"&",
"config",
".",
"SigningProfile",
"{",
"Expiry",
":",
"15",
"*",
"time",
".",
"Minute",
",",
"Usage",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] | // ExampleSigningConfig returns a sample config.Signing with only a
// default profile. | [
"ExampleSigningConfig",
"returns",
"a",
"sample",
"config",
".",
"Signing",
"with",
"only",
"a",
"default",
"profile",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/localca/signer.go#L124-L134 | train |
cloudflare/cfssl | transport/ca/localca/signer.go | New | func New(req *csr.CertificateRequest, profiles *config.Signing) (*CA, error) {
certPEM, _, keyPEM, err := initca.New(req)
if err != nil {
return nil, err
}
// If initca returns successfully, the following (which are
// all CFSSL internal functions) should not return an
// error. If they do, we should abort --- something about
// CFSSL has become inconsistent, and it can't be trusted.
priv, err := helpers.ParsePrivateKeyPEM(keyPEM)
assert.NoError(err, "CFSSL-generated private key can't be parsed")
cert, err := helpers.ParseCertificatePEM(certPEM)
assert.NoError(err, "CFSSL-generated certificate can't be parsed")
s, err := local.NewSigner(priv, cert, helpers.SignerAlgo(priv), profiles)
assert.NoError(err, "a signer could not be constructed")
return NewFromSigner(s), nil
} | go | func New(req *csr.CertificateRequest, profiles *config.Signing) (*CA, error) {
certPEM, _, keyPEM, err := initca.New(req)
if err != nil {
return nil, err
}
// If initca returns successfully, the following (which are
// all CFSSL internal functions) should not return an
// error. If they do, we should abort --- something about
// CFSSL has become inconsistent, and it can't be trusted.
priv, err := helpers.ParsePrivateKeyPEM(keyPEM)
assert.NoError(err, "CFSSL-generated private key can't be parsed")
cert, err := helpers.ParseCertificatePEM(certPEM)
assert.NoError(err, "CFSSL-generated certificate can't be parsed")
s, err := local.NewSigner(priv, cert, helpers.SignerAlgo(priv), profiles)
assert.NoError(err, "a signer could not be constructed")
return NewFromSigner(s), nil
} | [
"func",
"New",
"(",
"req",
"*",
"csr",
".",
"CertificateRequest",
",",
"profiles",
"*",
"config",
".",
"Signing",
")",
"(",
"*",
"CA",
",",
"error",
")",
"{",
"certPEM",
",",
"_",
",",
"keyPEM",
",",
"err",
":=",
"initca",
".",
"New",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// If initca returns successfully, the following (which are",
"// all CFSSL internal functions) should not return an",
"// error. If they do, we should abort --- something about",
"// CFSSL has become inconsistent, and it can't be trusted.",
"priv",
",",
"err",
":=",
"helpers",
".",
"ParsePrivateKeyPEM",
"(",
"keyPEM",
")",
"\n",
"assert",
".",
"NoError",
"(",
"err",
",",
"\"",
"\"",
")",
"\n\n",
"cert",
",",
"err",
":=",
"helpers",
".",
"ParseCertificatePEM",
"(",
"certPEM",
")",
"\n",
"assert",
".",
"NoError",
"(",
"err",
",",
"\"",
"\"",
")",
"\n\n",
"s",
",",
"err",
":=",
"local",
".",
"NewSigner",
"(",
"priv",
",",
"cert",
",",
"helpers",
".",
"SignerAlgo",
"(",
"priv",
")",
",",
"profiles",
")",
"\n",
"assert",
".",
"NoError",
"(",
"err",
",",
"\"",
"\"",
")",
"\n\n",
"return",
"NewFromSigner",
"(",
"s",
")",
",",
"nil",
"\n",
"}"
] | // New generates a new CA from a certificate request and signing profile. | [
"New",
"generates",
"a",
"new",
"CA",
"from",
"a",
"certificate",
"request",
"and",
"signing",
"profile",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/localca/signer.go#L137-L158 | train |
cloudflare/cfssl | transport/ca/localca/signer.go | Load | func Load(lca *CA, profiles *config.Signing) (err error) {
lca.s, err = local.NewSignerFromFile(lca.CertFile, lca.KeyFile, profiles)
return err
} | go | func Load(lca *CA, profiles *config.Signing) (err error) {
lca.s, err = local.NewSignerFromFile(lca.CertFile, lca.KeyFile, profiles)
return err
} | [
"func",
"Load",
"(",
"lca",
"*",
"CA",
",",
"profiles",
"*",
"config",
".",
"Signing",
")",
"(",
"err",
"error",
")",
"{",
"lca",
".",
"s",
",",
"err",
"=",
"local",
".",
"NewSignerFromFile",
"(",
"lca",
".",
"CertFile",
",",
"lca",
".",
"KeyFile",
",",
"profiles",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Load reads the key and certificate from the files specified in the
// CA. | [
"Load",
"reads",
"the",
"key",
"and",
"certificate",
"from",
"the",
"files",
"specified",
"in",
"the",
"CA",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/ca/localca/signer.go#L167-L170 | train |
cloudflare/cfssl | ubiquity/performance.go | hashPriority | func hashPriority(cert *x509.Certificate) int {
switch cert.SignatureAlgorithm {
case x509.ECDSAWithSHA1, x509.DSAWithSHA1, x509.SHA1WithRSA:
return 10
case x509.ECDSAWithSHA256, x509.ECDSAWithSHA384, x509.ECDSAWithSHA512,
x509.DSAWithSHA256, x509.SHA256WithRSA, x509.SHA384WithRSA,
x509.SHA512WithRSA:
return 100
default:
return 0
}
} | go | func hashPriority(cert *x509.Certificate) int {
switch cert.SignatureAlgorithm {
case x509.ECDSAWithSHA1, x509.DSAWithSHA1, x509.SHA1WithRSA:
return 10
case x509.ECDSAWithSHA256, x509.ECDSAWithSHA384, x509.ECDSAWithSHA512,
x509.DSAWithSHA256, x509.SHA256WithRSA, x509.SHA384WithRSA,
x509.SHA512WithRSA:
return 100
default:
return 0
}
} | [
"func",
"hashPriority",
"(",
"cert",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"switch",
"cert",
".",
"SignatureAlgorithm",
"{",
"case",
"x509",
".",
"ECDSAWithSHA1",
",",
"x509",
".",
"DSAWithSHA1",
",",
"x509",
".",
"SHA1WithRSA",
":",
"return",
"10",
"\n",
"case",
"x509",
".",
"ECDSAWithSHA256",
",",
"x509",
".",
"ECDSAWithSHA384",
",",
"x509",
".",
"ECDSAWithSHA512",
",",
"x509",
".",
"DSAWithSHA256",
",",
"x509",
".",
"SHA256WithRSA",
",",
"x509",
".",
"SHA384WithRSA",
",",
"x509",
".",
"SHA512WithRSA",
":",
"return",
"100",
"\n",
"default",
":",
"return",
"0",
"\n",
"}",
"\n",
"}"
] | // Compute the priority of different hash algorithm based on security
// SHA2 > SHA1 >> MD = Others = Unknown | [
"Compute",
"the",
"priority",
"of",
"different",
"hash",
"algorithm",
"based",
"on",
"security",
"SHA2",
">",
"SHA1",
">>",
"MD",
"=",
"Others",
"=",
"Unknown"
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/performance.go#L16-L27 | train |
cloudflare/cfssl | ubiquity/performance.go | keyAlgoPriority | func keyAlgoPriority(cert *x509.Certificate) int {
switch cert.PublicKeyAlgorithm {
case x509.ECDSA:
switch cert.PublicKey.(*ecdsa.PublicKey).Curve {
case elliptic.P256():
return 100
case elliptic.P384():
return 120
case elliptic.P521():
return 140
default:
return 100
}
case x509.RSA:
switch cert.PublicKey.(*rsa.PublicKey).N.BitLen() {
case 4096:
return 70
case 3072:
return 50
case 2048:
return 30
// key size <= 1024 are discouraged.
default:
return 0
}
// we do not want to bundle a DSA cert.
case x509.DSA:
return 0
default:
return 0
}
} | go | func keyAlgoPriority(cert *x509.Certificate) int {
switch cert.PublicKeyAlgorithm {
case x509.ECDSA:
switch cert.PublicKey.(*ecdsa.PublicKey).Curve {
case elliptic.P256():
return 100
case elliptic.P384():
return 120
case elliptic.P521():
return 140
default:
return 100
}
case x509.RSA:
switch cert.PublicKey.(*rsa.PublicKey).N.BitLen() {
case 4096:
return 70
case 3072:
return 50
case 2048:
return 30
// key size <= 1024 are discouraged.
default:
return 0
}
// we do not want to bundle a DSA cert.
case x509.DSA:
return 0
default:
return 0
}
} | [
"func",
"keyAlgoPriority",
"(",
"cert",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"switch",
"cert",
".",
"PublicKeyAlgorithm",
"{",
"case",
"x509",
".",
"ECDSA",
":",
"switch",
"cert",
".",
"PublicKey",
".",
"(",
"*",
"ecdsa",
".",
"PublicKey",
")",
".",
"Curve",
"{",
"case",
"elliptic",
".",
"P256",
"(",
")",
":",
"return",
"100",
"\n",
"case",
"elliptic",
".",
"P384",
"(",
")",
":",
"return",
"120",
"\n",
"case",
"elliptic",
".",
"P521",
"(",
")",
":",
"return",
"140",
"\n",
"default",
":",
"return",
"100",
"\n",
"}",
"\n",
"case",
"x509",
".",
"RSA",
":",
"switch",
"cert",
".",
"PublicKey",
".",
"(",
"*",
"rsa",
".",
"PublicKey",
")",
".",
"N",
".",
"BitLen",
"(",
")",
"{",
"case",
"4096",
":",
"return",
"70",
"\n",
"case",
"3072",
":",
"return",
"50",
"\n",
"case",
"2048",
":",
"return",
"30",
"\n",
"// key size <= 1024 are discouraged.",
"default",
":",
"return",
"0",
"\n",
"}",
"\n",
"// we do not want to bundle a DSA cert.",
"case",
"x509",
".",
"DSA",
":",
"return",
"0",
"\n",
"default",
":",
"return",
"0",
"\n",
"}",
"\n",
"}"
] | // Compute the priority of different key algorithm based performance and security
// ECDSA>RSA>DSA>Unknown | [
"Compute",
"the",
"priority",
"of",
"different",
"key",
"algorithm",
"based",
"performance",
"and",
"security",
"ECDSA",
">",
"RSA",
">",
"DSA",
">",
"Unknown"
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/performance.go#L31-L62 | train |
cloudflare/cfssl | ubiquity/performance.go | HashPriority | func HashPriority(certs []*x509.Certificate) int {
ret := 0.0
for i, cert := range certs {
f1 := 1.0 / (float64(i) + 1.0)
f2 := 1.0 - f1
ret = ret*f2 + float64(hashPriority(cert))*f1
}
return int(ret)
} | go | func HashPriority(certs []*x509.Certificate) int {
ret := 0.0
for i, cert := range certs {
f1 := 1.0 / (float64(i) + 1.0)
f2 := 1.0 - f1
ret = ret*f2 + float64(hashPriority(cert))*f1
}
return int(ret)
} | [
"func",
"HashPriority",
"(",
"certs",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"ret",
":=",
"0.0",
"\n",
"for",
"i",
",",
"cert",
":=",
"range",
"certs",
"{",
"f1",
":=",
"1.0",
"/",
"(",
"float64",
"(",
"i",
")",
"+",
"1.0",
")",
"\n",
"f2",
":=",
"1.0",
"-",
"f1",
"\n",
"ret",
"=",
"ret",
"*",
"f2",
"+",
"float64",
"(",
"hashPriority",
"(",
"cert",
")",
")",
"*",
"f1",
"\n",
"}",
"\n",
"return",
"int",
"(",
"ret",
")",
"\n",
"}"
] | // HashPriority returns the hash priority of the chain as the average of hash priority of certs in it. | [
"HashPriority",
"returns",
"the",
"hash",
"priority",
"of",
"the",
"chain",
"as",
"the",
"average",
"of",
"hash",
"priority",
"of",
"certs",
"in",
"it",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/performance.go#L65-L73 | train |
cloudflare/cfssl | ubiquity/performance.go | KeyAlgoPriority | func KeyAlgoPriority(certs []*x509.Certificate) int {
ret := 0.0
for i, cert := range certs {
f1 := 1.0 / (float64(i) + 1.0)
f2 := 1.0 - f1
ret = float64(keyAlgoPriority(cert))*f1 + ret*f2
}
return int(ret)
} | go | func KeyAlgoPriority(certs []*x509.Certificate) int {
ret := 0.0
for i, cert := range certs {
f1 := 1.0 / (float64(i) + 1.0)
f2 := 1.0 - f1
ret = float64(keyAlgoPriority(cert))*f1 + ret*f2
}
return int(ret)
} | [
"func",
"KeyAlgoPriority",
"(",
"certs",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"ret",
":=",
"0.0",
"\n",
"for",
"i",
",",
"cert",
":=",
"range",
"certs",
"{",
"f1",
":=",
"1.0",
"/",
"(",
"float64",
"(",
"i",
")",
"+",
"1.0",
")",
"\n",
"f2",
":=",
"1.0",
"-",
"f1",
"\n",
"ret",
"=",
"float64",
"(",
"keyAlgoPriority",
"(",
"cert",
")",
")",
"*",
"f1",
"+",
"ret",
"*",
"f2",
"\n",
"}",
"\n",
"return",
"int",
"(",
"ret",
")",
"\n",
"}"
] | // KeyAlgoPriority returns the key algorithm priority of the chain as the average of key algorithm priority of certs in it. | [
"KeyAlgoPriority",
"returns",
"the",
"key",
"algorithm",
"priority",
"of",
"the",
"chain",
"as",
"the",
"average",
"of",
"key",
"algorithm",
"priority",
"of",
"certs",
"in",
"it",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/performance.go#L76-L84 | train |
cloudflare/cfssl | ubiquity/performance.go | CompareChainHashPriority | func CompareChainHashPriority(chain1, chain2 []*x509.Certificate) int {
hp1 := HashPriority(chain1)
hp2 := HashPriority(chain2)
return hp1 - hp2
} | go | func CompareChainHashPriority(chain1, chain2 []*x509.Certificate) int {
hp1 := HashPriority(chain1)
hp2 := HashPriority(chain2)
return hp1 - hp2
} | [
"func",
"CompareChainHashPriority",
"(",
"chain1",
",",
"chain2",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"hp1",
":=",
"HashPriority",
"(",
"chain1",
")",
"\n",
"hp2",
":=",
"HashPriority",
"(",
"chain2",
")",
"\n",
"return",
"hp1",
"-",
"hp2",
"\n",
"}"
] | // CompareChainHashPriority ranks chains with more current hash functions higher. | [
"CompareChainHashPriority",
"ranks",
"chains",
"with",
"more",
"current",
"hash",
"functions",
"higher",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/performance.go#L87-L91 | train |
cloudflare/cfssl | ubiquity/performance.go | CompareChainKeyAlgoPriority | func CompareChainKeyAlgoPriority(chain1, chain2 []*x509.Certificate) int {
kap1 := KeyAlgoPriority(chain1)
kap2 := KeyAlgoPriority(chain2)
return kap1 - kap2
} | go | func CompareChainKeyAlgoPriority(chain1, chain2 []*x509.Certificate) int {
kap1 := KeyAlgoPriority(chain1)
kap2 := KeyAlgoPriority(chain2)
return kap1 - kap2
} | [
"func",
"CompareChainKeyAlgoPriority",
"(",
"chain1",
",",
"chain2",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"kap1",
":=",
"KeyAlgoPriority",
"(",
"chain1",
")",
"\n",
"kap2",
":=",
"KeyAlgoPriority",
"(",
"chain2",
")",
"\n",
"return",
"kap1",
"-",
"kap2",
"\n",
"}"
] | // CompareChainKeyAlgoPriority ranks chains with more current key algorithm higher. | [
"CompareChainKeyAlgoPriority",
"ranks",
"chains",
"with",
"more",
"current",
"key",
"algorithm",
"higher",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/performance.go#L94-L98 | train |
cloudflare/cfssl | ubiquity/performance.go | CompareChainCryptoSuite | func CompareChainCryptoSuite(chain1, chain2 []*x509.Certificate) int {
cs1 := HashPriority(chain1) + KeyAlgoPriority(chain1)
cs2 := HashPriority(chain2) + KeyAlgoPriority(chain2)
return cs1 - cs2
} | go | func CompareChainCryptoSuite(chain1, chain2 []*x509.Certificate) int {
cs1 := HashPriority(chain1) + KeyAlgoPriority(chain1)
cs2 := HashPriority(chain2) + KeyAlgoPriority(chain2)
return cs1 - cs2
} | [
"func",
"CompareChainCryptoSuite",
"(",
"chain1",
",",
"chain2",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"cs1",
":=",
"HashPriority",
"(",
"chain1",
")",
"+",
"KeyAlgoPriority",
"(",
"chain1",
")",
"\n",
"cs2",
":=",
"HashPriority",
"(",
"chain2",
")",
"+",
"KeyAlgoPriority",
"(",
"chain2",
")",
"\n",
"return",
"cs1",
"-",
"cs2",
"\n",
"}"
] | // CompareChainCryptoSuite ranks chains with more current crypto suite higher. | [
"CompareChainCryptoSuite",
"ranks",
"chains",
"with",
"more",
"current",
"crypto",
"suite",
"higher",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/performance.go#L101-L105 | train |
cloudflare/cfssl | ubiquity/performance.go | CompareChainLength | func CompareChainLength(chain1, chain2 []*x509.Certificate) int {
return len(chain2) - len(chain1)
} | go | func CompareChainLength(chain1, chain2 []*x509.Certificate) int {
return len(chain2) - len(chain1)
} | [
"func",
"CompareChainLength",
"(",
"chain1",
",",
"chain2",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"return",
"len",
"(",
"chain2",
")",
"-",
"len",
"(",
"chain1",
")",
"\n",
"}"
] | // CompareChainLength ranks shorter chain higher. | [
"CompareChainLength",
"ranks",
"shorter",
"chain",
"higher",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/performance.go#L108-L110 | train |
cloudflare/cfssl | ubiquity/performance.go | CompareChainExpiry | func CompareChainExpiry(chain1, chain2 []*x509.Certificate) int {
t1 := helpers.ExpiryTime(chain1)
t2 := helpers.ExpiryTime(chain2)
return compareTime(t1, t2)
} | go | func CompareChainExpiry(chain1, chain2 []*x509.Certificate) int {
t1 := helpers.ExpiryTime(chain1)
t2 := helpers.ExpiryTime(chain2)
return compareTime(t1, t2)
} | [
"func",
"CompareChainExpiry",
"(",
"chain1",
",",
"chain2",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"int",
"{",
"t1",
":=",
"helpers",
".",
"ExpiryTime",
"(",
"chain1",
")",
"\n",
"t2",
":=",
"helpers",
".",
"ExpiryTime",
"(",
"chain2",
")",
"\n",
"return",
"compareTime",
"(",
"t1",
",",
"t2",
")",
"\n",
"}"
] | // CompareChainExpiry ranks chain that lasts longer higher. | [
"CompareChainExpiry",
"ranks",
"chain",
"that",
"lasts",
"longer",
"higher",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/performance.go#L122-L126 | train |
cloudflare/cfssl | cli/version/version.go | versionMain | func versionMain(args []string, c cli.Config) (err error) {
fmt.Printf("%s", FormatVersion())
return nil
} | go | func versionMain(args []string, c cli.Config) (err error) {
fmt.Printf("%s", FormatVersion())
return nil
} | [
"func",
"versionMain",
"(",
"args",
"[",
"]",
"string",
",",
"c",
"cli",
".",
"Config",
")",
"(",
"err",
"error",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\"",
",",
"FormatVersion",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // The main functionality of 'cfssl version' is to print out the version info. | [
"The",
"main",
"functionality",
"of",
"cfssl",
"version",
"is",
"to",
"print",
"out",
"the",
"version",
"info",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/cli/version/version.go#L36-L39 | train |
cloudflare/cfssl | transport/roots/system/root.go | New | func New(metadata map[string]string) ([]*x509.Certificate, error) {
roots := initSystemRoots()
if len(roots) == 0 {
return nil, errors.New("transport: unable to find system roots")
}
return roots, nil
} | go | func New(metadata map[string]string) ([]*x509.Certificate, error) {
roots := initSystemRoots()
if len(roots) == 0 {
return nil, errors.New("transport: unable to find system roots")
}
return roots, nil
} | [
"func",
"New",
"(",
"metadata",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"x509",
".",
"Certificate",
",",
"error",
")",
"{",
"roots",
":=",
"initSystemRoots",
"(",
")",
"\n",
"if",
"len",
"(",
"roots",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"roots",
",",
"nil",
"\n",
"}"
] | // New returns a new certificate pool loaded with the system
// roots. The provided argument is not used; it is included for
// compatibility with other functions. | [
"New",
"returns",
"a",
"new",
"certificate",
"pool",
"loaded",
"with",
"the",
"system",
"roots",
".",
"The",
"provided",
"argument",
"is",
"not",
"used",
";",
"it",
"is",
"included",
"for",
"compatibility",
"with",
"other",
"functions",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/roots/system/root.go#L41-L47 | train |
cloudflare/cfssl | cli/ocsprefresh/ocsprefresh.go | ocsprefreshMain | func ocsprefreshMain(args []string, c cli.Config) error {
if c.DBConfigFile == "" {
return errors.New("need DB config file (provide with -db-config)")
}
if c.ResponderFile == "" {
return errors.New("need responder certificate (provide with -responder)")
}
if c.ResponderKeyFile == "" {
return errors.New("need responder key (provide with -responder-key)")
}
if c.CAFile == "" {
return errors.New("need CA certificate (provide with -ca)")
}
s, err := SignerFromConfig(c)
if err != nil {
log.Critical("Unable to create OCSP signer: ", err)
return err
}
db, err := dbconf.DBFromConfig(c.DBConfigFile)
if err != nil {
return err
}
dbAccessor := sql.NewAccessor(db)
certs, err := dbAccessor.GetUnexpiredCertificates()
if err != nil {
return err
}
// Set an expiry timestamp for all certificates refreshed in this batch
ocspExpiry := time.Now().Add(c.Interval)
for _, certRecord := range certs {
cert, err := helpers.ParseCertificatePEM([]byte(certRecord.PEM))
if err != nil {
log.Critical("Unable to parse certificate: ", err)
return err
}
req := ocsp.SignRequest{
Certificate: cert,
Status: certRecord.Status,
}
if certRecord.Status == "revoked" {
req.Reason = int(certRecord.Reason)
req.RevokedAt = certRecord.RevokedAt
}
resp, err := s.Sign(req)
if err != nil {
log.Critical("Unable to sign OCSP response: ", err)
return err
}
err = dbAccessor.UpsertOCSP(cert.SerialNumber.String(), hex.EncodeToString(cert.AuthorityKeyId), string(resp), ocspExpiry)
if err != nil {
log.Critical("Unable to save OCSP response: ", err)
return err
}
}
return nil
} | go | func ocsprefreshMain(args []string, c cli.Config) error {
if c.DBConfigFile == "" {
return errors.New("need DB config file (provide with -db-config)")
}
if c.ResponderFile == "" {
return errors.New("need responder certificate (provide with -responder)")
}
if c.ResponderKeyFile == "" {
return errors.New("need responder key (provide with -responder-key)")
}
if c.CAFile == "" {
return errors.New("need CA certificate (provide with -ca)")
}
s, err := SignerFromConfig(c)
if err != nil {
log.Critical("Unable to create OCSP signer: ", err)
return err
}
db, err := dbconf.DBFromConfig(c.DBConfigFile)
if err != nil {
return err
}
dbAccessor := sql.NewAccessor(db)
certs, err := dbAccessor.GetUnexpiredCertificates()
if err != nil {
return err
}
// Set an expiry timestamp for all certificates refreshed in this batch
ocspExpiry := time.Now().Add(c.Interval)
for _, certRecord := range certs {
cert, err := helpers.ParseCertificatePEM([]byte(certRecord.PEM))
if err != nil {
log.Critical("Unable to parse certificate: ", err)
return err
}
req := ocsp.SignRequest{
Certificate: cert,
Status: certRecord.Status,
}
if certRecord.Status == "revoked" {
req.Reason = int(certRecord.Reason)
req.RevokedAt = certRecord.RevokedAt
}
resp, err := s.Sign(req)
if err != nil {
log.Critical("Unable to sign OCSP response: ", err)
return err
}
err = dbAccessor.UpsertOCSP(cert.SerialNumber.String(), hex.EncodeToString(cert.AuthorityKeyId), string(resp), ocspExpiry)
if err != nil {
log.Critical("Unable to save OCSP response: ", err)
return err
}
}
return nil
} | [
"func",
"ocsprefreshMain",
"(",
"args",
"[",
"]",
"string",
",",
"c",
"cli",
".",
"Config",
")",
"error",
"{",
"if",
"c",
".",
"DBConfigFile",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"ResponderFile",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"ResponderKeyFile",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"CAFile",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"s",
",",
"err",
":=",
"SignerFromConfig",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Critical",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"db",
",",
"err",
":=",
"dbconf",
".",
"DBFromConfig",
"(",
"c",
".",
"DBConfigFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"dbAccessor",
":=",
"sql",
".",
"NewAccessor",
"(",
"db",
")",
"\n",
"certs",
",",
"err",
":=",
"dbAccessor",
".",
"GetUnexpiredCertificates",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Set an expiry timestamp for all certificates refreshed in this batch",
"ocspExpiry",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"c",
".",
"Interval",
")",
"\n",
"for",
"_",
",",
"certRecord",
":=",
"range",
"certs",
"{",
"cert",
",",
"err",
":=",
"helpers",
".",
"ParseCertificatePEM",
"(",
"[",
"]",
"byte",
"(",
"certRecord",
".",
"PEM",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Critical",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"req",
":=",
"ocsp",
".",
"SignRequest",
"{",
"Certificate",
":",
"cert",
",",
"Status",
":",
"certRecord",
".",
"Status",
",",
"}",
"\n\n",
"if",
"certRecord",
".",
"Status",
"==",
"\"",
"\"",
"{",
"req",
".",
"Reason",
"=",
"int",
"(",
"certRecord",
".",
"Reason",
")",
"\n",
"req",
".",
"RevokedAt",
"=",
"certRecord",
".",
"RevokedAt",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"s",
".",
"Sign",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Critical",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"dbAccessor",
".",
"UpsertOCSP",
"(",
"cert",
".",
"SerialNumber",
".",
"String",
"(",
")",
",",
"hex",
".",
"EncodeToString",
"(",
"cert",
".",
"AuthorityKeyId",
")",
",",
"string",
"(",
"resp",
")",
",",
"ocspExpiry",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Critical",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // ocsprefreshMain is the main CLI of OCSP refresh functionality. | [
"ocsprefreshMain",
"is",
"the",
"main",
"CLI",
"of",
"OCSP",
"refresh",
"functionality",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/cli/ocsprefresh/ocsprefresh.go#L31-L98 | train |
cloudflare/cfssl | ubiquity/filter.go | Filter | func Filter(chains [][]*x509.Certificate, f RankingFunc) [][]*x509.Certificate {
// If there are no chain or only 1 chain, we are done.
if len(chains) <= 1 {
return chains
}
bestChain := chains[0]
var candidateChains [][]*x509.Certificate
for _, chain := range chains {
r := f(bestChain, chain)
if r < 0 {
bestChain = chain
candidateChains = [][]*x509.Certificate{chain}
} else if r == 0 {
candidateChains = append(candidateChains, chain)
}
}
return candidateChains
} | go | func Filter(chains [][]*x509.Certificate, f RankingFunc) [][]*x509.Certificate {
// If there are no chain or only 1 chain, we are done.
if len(chains) <= 1 {
return chains
}
bestChain := chains[0]
var candidateChains [][]*x509.Certificate
for _, chain := range chains {
r := f(bestChain, chain)
if r < 0 {
bestChain = chain
candidateChains = [][]*x509.Certificate{chain}
} else if r == 0 {
candidateChains = append(candidateChains, chain)
}
}
return candidateChains
} | [
"func",
"Filter",
"(",
"chains",
"[",
"]",
"[",
"]",
"*",
"x509",
".",
"Certificate",
",",
"f",
"RankingFunc",
")",
"[",
"]",
"[",
"]",
"*",
"x509",
".",
"Certificate",
"{",
"// If there are no chain or only 1 chain, we are done.",
"if",
"len",
"(",
"chains",
")",
"<=",
"1",
"{",
"return",
"chains",
"\n",
"}",
"\n\n",
"bestChain",
":=",
"chains",
"[",
"0",
"]",
"\n",
"var",
"candidateChains",
"[",
"]",
"[",
"]",
"*",
"x509",
".",
"Certificate",
"\n",
"for",
"_",
",",
"chain",
":=",
"range",
"chains",
"{",
"r",
":=",
"f",
"(",
"bestChain",
",",
"chain",
")",
"\n",
"if",
"r",
"<",
"0",
"{",
"bestChain",
"=",
"chain",
"\n",
"candidateChains",
"=",
"[",
"]",
"[",
"]",
"*",
"x509",
".",
"Certificate",
"{",
"chain",
"}",
"\n",
"}",
"else",
"if",
"r",
"==",
"0",
"{",
"candidateChains",
"=",
"append",
"(",
"candidateChains",
",",
"chain",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"candidateChains",
"\n",
"}"
] | // Filter filters out the chains with highest rank according to the ranking function f. | [
"Filter",
"filters",
"out",
"the",
"chains",
"with",
"highest",
"rank",
"according",
"to",
"the",
"ranking",
"function",
"f",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/filter.go#L18-L36 | train |
cloudflare/cfssl | scan/crypto/crypto.go | Size | func (h Hash) Size() int {
if h > 0 && h < maxHash {
return int(digestSizes[h])
}
panic("crypto: Size of unknown hash function")
} | go | func (h Hash) Size() int {
if h > 0 && h < maxHash {
return int(digestSizes[h])
}
panic("crypto: Size of unknown hash function")
} | [
"func",
"(",
"h",
"Hash",
")",
"Size",
"(",
")",
"int",
"{",
"if",
"h",
">",
"0",
"&&",
"h",
"<",
"maxHash",
"{",
"return",
"int",
"(",
"digestSizes",
"[",
"h",
"]",
")",
"\n",
"}",
"\n",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // Size returns the length, in bytes, of a digest resulting from the given hash
// function. It doesn't require that the hash function in question be linked
// into the program. | [
"Size",
"returns",
"the",
"length",
"in",
"bytes",
"of",
"a",
"digest",
"resulting",
"from",
"the",
"given",
"hash",
"function",
".",
"It",
"doesn",
"t",
"require",
"that",
"the",
"hash",
"function",
"in",
"question",
"be",
"linked",
"into",
"the",
"program",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/crypto.go#L63-L68 | train |
cloudflare/cfssl | selfsign/selfsign.go | parseCertificateRequest | func parseCertificateRequest(priv crypto.Signer, csrBytes []byte) (template *x509.Certificate, err error) {
csr, err := x509.ParseCertificateRequest(csrBytes)
if err != nil {
err = cferr.Wrap(cferr.CSRError, cferr.ParseFailed, err)
return
}
csr.CheckSignature()
if err != nil {
err = cferr.Wrap(cferr.CSRError, cferr.KeyMismatch, err)
return
}
template = &x509.Certificate{
Subject: csr.Subject,
PublicKeyAlgorithm: csr.PublicKeyAlgorithm,
PublicKey: csr.PublicKey,
SignatureAlgorithm: signer.DefaultSigAlgo(priv),
}
return
} | go | func parseCertificateRequest(priv crypto.Signer, csrBytes []byte) (template *x509.Certificate, err error) {
csr, err := x509.ParseCertificateRequest(csrBytes)
if err != nil {
err = cferr.Wrap(cferr.CSRError, cferr.ParseFailed, err)
return
}
csr.CheckSignature()
if err != nil {
err = cferr.Wrap(cferr.CSRError, cferr.KeyMismatch, err)
return
}
template = &x509.Certificate{
Subject: csr.Subject,
PublicKeyAlgorithm: csr.PublicKeyAlgorithm,
PublicKey: csr.PublicKey,
SignatureAlgorithm: signer.DefaultSigAlgo(priv),
}
return
} | [
"func",
"parseCertificateRequest",
"(",
"priv",
"crypto",
".",
"Signer",
",",
"csrBytes",
"[",
"]",
"byte",
")",
"(",
"template",
"*",
"x509",
".",
"Certificate",
",",
"err",
"error",
")",
"{",
"csr",
",",
"err",
":=",
"x509",
".",
"ParseCertificateRequest",
"(",
"csrBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CSRError",
",",
"cferr",
".",
"ParseFailed",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"csr",
".",
"CheckSignature",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"cferr",
".",
"Wrap",
"(",
"cferr",
".",
"CSRError",
",",
"cferr",
".",
"KeyMismatch",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"template",
"=",
"&",
"x509",
".",
"Certificate",
"{",
"Subject",
":",
"csr",
".",
"Subject",
",",
"PublicKeyAlgorithm",
":",
"csr",
".",
"PublicKeyAlgorithm",
",",
"PublicKey",
":",
"csr",
".",
"PublicKey",
",",
"SignatureAlgorithm",
":",
"signer",
".",
"DefaultSigAlgo",
"(",
"priv",
")",
",",
"}",
"\n\n",
"return",
"\n",
"}"
] | // parseCertificateRequest takes an incoming certificate request and
// builds a certificate template from it. | [
"parseCertificateRequest",
"takes",
"an",
"incoming",
"certificate",
"request",
"and",
"builds",
"a",
"certificate",
"template",
"from",
"it",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/selfsign/selfsign.go#L27-L49 | train |
cloudflare/cfssl | cli/serve/serve.go | Open | func (hb *httpBox) Open(name string) (http.File, error) {
if strings.HasPrefix(name, V1APIPrefix) {
return nil, os.ErrNotExist
}
if location, ok := hb.redirects[name]; ok {
return hb.Box.Open(location)
}
return hb.Box.Open(name)
} | go | func (hb *httpBox) Open(name string) (http.File, error) {
if strings.HasPrefix(name, V1APIPrefix) {
return nil, os.ErrNotExist
}
if location, ok := hb.redirects[name]; ok {
return hb.Box.Open(location)
}
return hb.Box.Open(name)
} | [
"func",
"(",
"hb",
"*",
"httpBox",
")",
"Open",
"(",
"name",
"string",
")",
"(",
"http",
".",
"File",
",",
"error",
")",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"name",
",",
"V1APIPrefix",
")",
"{",
"return",
"nil",
",",
"os",
".",
"ErrNotExist",
"\n",
"}",
"\n\n",
"if",
"location",
",",
"ok",
":=",
"hb",
".",
"redirects",
"[",
"name",
"]",
";",
"ok",
"{",
"return",
"hb",
".",
"Box",
".",
"Open",
"(",
"location",
")",
"\n",
"}",
"\n\n",
"return",
"hb",
".",
"Box",
".",
"Open",
"(",
"name",
")",
"\n",
"}"
] | // Open returns a File for non-API enpoints using the http.File interface. | [
"Open",
"returns",
"a",
"File",
"for",
"non",
"-",
"API",
"enpoints",
"using",
"the",
"http",
".",
"File",
"interface",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/cli/serve/serve.go#L96-L106 | train |
cloudflare/cfssl | cli/serve/serve.go | registerHandlers | func registerHandlers() {
disabled := make(map[string]bool)
if conf.Disable != "" {
for _, endpoint := range strings.Split(conf.Disable, ",") {
disabled[endpoint] = true
}
}
for path, getHandler := range endpoints {
log.Debugf("getHandler for %s", path)
if _, ok := disabled[path]; ok {
log.Infof("endpoint '%s' is explicitly disabled", path)
} else if handler, err := getHandler(); err != nil {
log.Warningf("endpoint '%s' is disabled: %v", path, err)
} else {
if path, handler, err = wrapHandler(path, handler, err); err != nil {
log.Warningf("endpoint '%s' is disabled by wrapper: %v", path, err)
} else {
log.Infof("endpoint '%s' is enabled", path)
http.Handle(path, handler)
}
}
}
log.Info("Handler set up complete.")
} | go | func registerHandlers() {
disabled := make(map[string]bool)
if conf.Disable != "" {
for _, endpoint := range strings.Split(conf.Disable, ",") {
disabled[endpoint] = true
}
}
for path, getHandler := range endpoints {
log.Debugf("getHandler for %s", path)
if _, ok := disabled[path]; ok {
log.Infof("endpoint '%s' is explicitly disabled", path)
} else if handler, err := getHandler(); err != nil {
log.Warningf("endpoint '%s' is disabled: %v", path, err)
} else {
if path, handler, err = wrapHandler(path, handler, err); err != nil {
log.Warningf("endpoint '%s' is disabled by wrapper: %v", path, err)
} else {
log.Infof("endpoint '%s' is enabled", path)
http.Handle(path, handler)
}
}
}
log.Info("Handler set up complete.")
} | [
"func",
"registerHandlers",
"(",
")",
"{",
"disabled",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"if",
"conf",
".",
"Disable",
"!=",
"\"",
"\"",
"{",
"for",
"_",
",",
"endpoint",
":=",
"range",
"strings",
".",
"Split",
"(",
"conf",
".",
"Disable",
",",
"\"",
"\"",
")",
"{",
"disabled",
"[",
"endpoint",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"path",
",",
"getHandler",
":=",
"range",
"endpoints",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"path",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"disabled",
"[",
"path",
"]",
";",
"ok",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"}",
"else",
"if",
"handler",
",",
"err",
":=",
"getHandler",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"path",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"if",
"path",
",",
"handler",
",",
"err",
"=",
"wrapHandler",
"(",
"path",
",",
"handler",
",",
"err",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"path",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"http",
".",
"Handle",
"(",
"path",
",",
"handler",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // registerHandlers instantiates various handlers and associate them to corresponding endpoints. | [
"registerHandlers",
"instantiates",
"various",
"handlers",
"and",
"associate",
"them",
"to",
"corresponding",
"endpoints",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/cli/serve/serve.go#L256-L281 | train |
cloudflare/cfssl | cli/serve/serve.go | defaultWrapHandler | func defaultWrapHandler(path string, handler http.Handler, err error) (string, http.Handler, error) {
return v1APIPath(path), handler, err
} | go | func defaultWrapHandler(path string, handler http.Handler, err error) (string, http.Handler, error) {
return v1APIPath(path), handler, err
} | [
"func",
"defaultWrapHandler",
"(",
"path",
"string",
",",
"handler",
"http",
".",
"Handler",
",",
"err",
"error",
")",
"(",
"string",
",",
"http",
".",
"Handler",
",",
"error",
")",
"{",
"return",
"v1APIPath",
"(",
"path",
")",
",",
"handler",
",",
"err",
"\n",
"}"
] | // The default wrapper simply returns the normal handler and prefixes the path appropriately | [
"The",
"default",
"wrapper",
"simply",
"returns",
"the",
"normal",
"handler",
"and",
"prefixes",
"the",
"path",
"appropriately"
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/cli/serve/serve.go#L379-L381 | train |
cloudflare/cfssl | cli/serve/serve.go | SetWrapHandler | func SetWrapHandler(wh func(path string, handler http.Handler, err error) (string, http.Handler, error)) {
wrapHandler = wh
} | go | func SetWrapHandler(wh func(path string, handler http.Handler, err error) (string, http.Handler, error)) {
wrapHandler = wh
} | [
"func",
"SetWrapHandler",
"(",
"wh",
"func",
"(",
"path",
"string",
",",
"handler",
"http",
".",
"Handler",
",",
"err",
"error",
")",
"(",
"string",
",",
"http",
".",
"Handler",
",",
"error",
")",
")",
"{",
"wrapHandler",
"=",
"wh",
"\n",
"}"
] | // SetWrapHandler sets the wrap handler which is called for all endpoints
// A custom wrap handler may be provided in order to add arbitrary server-side pre or post processing
// of server-side HTTP handling of requests. | [
"SetWrapHandler",
"sets",
"the",
"wrap",
"handler",
"which",
"is",
"called",
"for",
"all",
"endpoints",
"A",
"custom",
"wrap",
"handler",
"may",
"be",
"provided",
"in",
"order",
"to",
"add",
"arbitrary",
"server",
"-",
"side",
"pre",
"or",
"post",
"processing",
"of",
"server",
"-",
"side",
"HTTP",
"handling",
"of",
"requests",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/cli/serve/serve.go#L386-L388 | train |
cloudflare/cfssl | transport/example/maserver/server.go | main | func main() {
var addr, conf string
flag.StringVar(&addr, "a", "127.0.0.1:9876", "`address` of server")
flag.StringVar(&conf, "f", "server.json", "config `file` to use")
flag.Parse()
var id = new(core.Identity)
data, err := ioutil.ReadFile(conf)
if err != nil {
exlib.Err(1, err, "reading config file")
}
err = json.Unmarshal(data, id)
if err != nil {
exlib.Err(1, err, "parsing config file")
}
tr, err := transport.New(exlib.Before, id)
if err != nil {
exlib.Err(1, err, "creating transport")
}
l, err := transport.Listen(addr, tr)
if err != nil {
exlib.Err(1, err, "setting up listener")
}
var errChan = make(chan error, 0)
go func(ec <-chan error) {
for {
err, ok := <-ec
if !ok {
log.Warning("error channel closed, future errors will not be reported")
break
}
log.Errorf("auto update error: %v", err)
}
}(errChan)
log.Info("setting up auto-update")
go l.AutoUpdate(nil, errChan)
log.Info("listening on ", addr)
exlib.Warn(serve(l), "serving listener")
} | go | func main() {
var addr, conf string
flag.StringVar(&addr, "a", "127.0.0.1:9876", "`address` of server")
flag.StringVar(&conf, "f", "server.json", "config `file` to use")
flag.Parse()
var id = new(core.Identity)
data, err := ioutil.ReadFile(conf)
if err != nil {
exlib.Err(1, err, "reading config file")
}
err = json.Unmarshal(data, id)
if err != nil {
exlib.Err(1, err, "parsing config file")
}
tr, err := transport.New(exlib.Before, id)
if err != nil {
exlib.Err(1, err, "creating transport")
}
l, err := transport.Listen(addr, tr)
if err != nil {
exlib.Err(1, err, "setting up listener")
}
var errChan = make(chan error, 0)
go func(ec <-chan error) {
for {
err, ok := <-ec
if !ok {
log.Warning("error channel closed, future errors will not be reported")
break
}
log.Errorf("auto update error: %v", err)
}
}(errChan)
log.Info("setting up auto-update")
go l.AutoUpdate(nil, errChan)
log.Info("listening on ", addr)
exlib.Warn(serve(l), "serving listener")
} | [
"func",
"main",
"(",
")",
"{",
"var",
"addr",
",",
"conf",
"string",
"\n",
"flag",
".",
"StringVar",
"(",
"&",
"addr",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"StringVar",
"(",
"&",
"conf",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"Parse",
"(",
")",
"\n\n",
"var",
"id",
"=",
"new",
"(",
"core",
".",
"Identity",
")",
"\n",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"conf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"exlib",
".",
"Err",
"(",
"1",
",",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"exlib",
".",
"Err",
"(",
"1",
",",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"tr",
",",
"err",
":=",
"transport",
".",
"New",
"(",
"exlib",
".",
"Before",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"exlib",
".",
"Err",
"(",
"1",
",",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"l",
",",
"err",
":=",
"transport",
".",
"Listen",
"(",
"addr",
",",
"tr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"exlib",
".",
"Err",
"(",
"1",
",",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"errChan",
"=",
"make",
"(",
"chan",
"error",
",",
"0",
")",
"\n",
"go",
"func",
"(",
"ec",
"<-",
"chan",
"error",
")",
"{",
"for",
"{",
"err",
",",
"ok",
":=",
"<-",
"ec",
"\n",
"if",
"!",
"ok",
"{",
"log",
".",
"Warning",
"(",
"\"",
"\"",
")",
"\n",
"break",
"\n",
"}",
"\n",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
"errChan",
")",
"\n\n",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"go",
"l",
".",
"AutoUpdate",
"(",
"nil",
",",
"errChan",
")",
"\n\n",
"log",
".",
"Info",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"exlib",
".",
"Warn",
"(",
"serve",
"(",
"l",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // maclient is a mutual-authentication server, meant to demonstrate
// using the client-side mutual authentication side of the transport
// package. | [
"maclient",
"is",
"a",
"mutual",
"-",
"authentication",
"server",
"meant",
"to",
"demonstrate",
"using",
"the",
"client",
"-",
"side",
"mutual",
"authentication",
"side",
"of",
"the",
"transport",
"package",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/transport/example/maserver/server.go#L19-L63 | train |
cloudflare/cfssl | scan/crypto/sha256/sha256.go | New224 | func New224() hash.Hash {
d := new(digest)
d.is224 = true
d.Reset()
return d
} | go | func New224() hash.Hash {
d := new(digest)
d.is224 = true
d.Reset()
return d
} | [
"func",
"New224",
"(",
")",
"hash",
".",
"Hash",
"{",
"d",
":=",
"new",
"(",
"digest",
")",
"\n",
"d",
".",
"is224",
"=",
"true",
"\n",
"d",
".",
"Reset",
"(",
")",
"\n",
"return",
"d",
"\n",
"}"
] | // New224 returns a new hash.Hash computing the SHA224 checksum. | [
"New224",
"returns",
"a",
"new",
"hash",
".",
"Hash",
"computing",
"the",
"SHA224",
"checksum",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/sha256/sha256.go#L89-L94 | train |
cloudflare/cfssl | scan/crypto/sha256/sha256.go | Sum224 | func Sum224(data []byte) (sum224 [Size224]byte) {
var d digest
d.is224 = true
d.Reset()
d.Write(data)
sum := d.checkSum()
copy(sum224[:], sum[:Size224])
return
} | go | func Sum224(data []byte) (sum224 [Size224]byte) {
var d digest
d.is224 = true
d.Reset()
d.Write(data)
sum := d.checkSum()
copy(sum224[:], sum[:Size224])
return
} | [
"func",
"Sum224",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"sum224",
"[",
"Size224",
"]",
"byte",
")",
"{",
"var",
"d",
"digest",
"\n",
"d",
".",
"is224",
"=",
"true",
"\n",
"d",
".",
"Reset",
"(",
")",
"\n",
"d",
".",
"Write",
"(",
"data",
")",
"\n",
"sum",
":=",
"d",
".",
"checkSum",
"(",
")",
"\n",
"copy",
"(",
"sum224",
"[",
":",
"]",
",",
"sum",
"[",
":",
"Size224",
"]",
")",
"\n",
"return",
"\n",
"}"
] | // Sum224 returns the SHA224 checksum of the data. | [
"Sum224",
"returns",
"the",
"SHA224",
"checksum",
"of",
"the",
"data",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/scan/crypto/sha256/sha256.go#L185-L193 | train |
cloudflare/cfssl | ubiquity/sha1.go | Flag | func (p SHA1DeprecationPolicy) Flag(chain []*x509.Certificate) bool {
leaf := chain[0]
if time.Now().After(p.EffectiveDate) {
// Reject newly issued leaf certificate with SHA-1 after the specified deadline.
if !p.NeverIssueAfter.IsZero() && leaf.NotBefore.After(p.NeverIssueAfter) {
// Check hash algorithm of non-root leaf cert.
if len(chain) > 1 && helpers.HashAlgoString(leaf.SignatureAlgorithm) == "SHA1" {
return true
}
}
// Reject certificate chain with SHA-1 that are still valid after expiry deadline.
if !p.ExpiryDeadline.IsZero() && leaf.NotAfter.After(p.ExpiryDeadline) {
// Check hash algorithm of non-root certs.
for i, cert := range chain {
if i < len(chain)-1 {
if helpers.HashAlgoString(cert.SignatureAlgorithm) == "SHA1" {
return true
}
}
}
}
}
return false
} | go | func (p SHA1DeprecationPolicy) Flag(chain []*x509.Certificate) bool {
leaf := chain[0]
if time.Now().After(p.EffectiveDate) {
// Reject newly issued leaf certificate with SHA-1 after the specified deadline.
if !p.NeverIssueAfter.IsZero() && leaf.NotBefore.After(p.NeverIssueAfter) {
// Check hash algorithm of non-root leaf cert.
if len(chain) > 1 && helpers.HashAlgoString(leaf.SignatureAlgorithm) == "SHA1" {
return true
}
}
// Reject certificate chain with SHA-1 that are still valid after expiry deadline.
if !p.ExpiryDeadline.IsZero() && leaf.NotAfter.After(p.ExpiryDeadline) {
// Check hash algorithm of non-root certs.
for i, cert := range chain {
if i < len(chain)-1 {
if helpers.HashAlgoString(cert.SignatureAlgorithm) == "SHA1" {
return true
}
}
}
}
}
return false
} | [
"func",
"(",
"p",
"SHA1DeprecationPolicy",
")",
"Flag",
"(",
"chain",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"bool",
"{",
"leaf",
":=",
"chain",
"[",
"0",
"]",
"\n",
"if",
"time",
".",
"Now",
"(",
")",
".",
"After",
"(",
"p",
".",
"EffectiveDate",
")",
"{",
"// Reject newly issued leaf certificate with SHA-1 after the specified deadline.",
"if",
"!",
"p",
".",
"NeverIssueAfter",
".",
"IsZero",
"(",
")",
"&&",
"leaf",
".",
"NotBefore",
".",
"After",
"(",
"p",
".",
"NeverIssueAfter",
")",
"{",
"// Check hash algorithm of non-root leaf cert.",
"if",
"len",
"(",
"chain",
")",
">",
"1",
"&&",
"helpers",
".",
"HashAlgoString",
"(",
"leaf",
".",
"SignatureAlgorithm",
")",
"==",
"\"",
"\"",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Reject certificate chain with SHA-1 that are still valid after expiry deadline.",
"if",
"!",
"p",
".",
"ExpiryDeadline",
".",
"IsZero",
"(",
")",
"&&",
"leaf",
".",
"NotAfter",
".",
"After",
"(",
"p",
".",
"ExpiryDeadline",
")",
"{",
"// Check hash algorithm of non-root certs.",
"for",
"i",
",",
"cert",
":=",
"range",
"chain",
"{",
"if",
"i",
"<",
"len",
"(",
"chain",
")",
"-",
"1",
"{",
"if",
"helpers",
".",
"HashAlgoString",
"(",
"cert",
".",
"SignatureAlgorithm",
")",
"==",
"\"",
"\"",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // Flag returns whether the policy flags the cert chain as deprecated for matching its deprecation criteria | [
"Flag",
"returns",
"whether",
"the",
"policy",
"flags",
"the",
"cert",
"chain",
"as",
"deprecated",
"for",
"matching",
"its",
"deprecation",
"criteria"
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/sha1.go#L104-L130 | train |
cloudflare/cfssl | ubiquity/sha1.go | SHA1DeprecationMessages | func SHA1DeprecationMessages(chain []*x509.Certificate) []string {
// record the most severe deprecation policy by each platform
selectedPolicies := map[string]SHA1DeprecationPolicy{}
for _, policy := range SHA1DeprecationPolicys {
if policy.Flag(chain) {
// only keep the policy with highest severity
if selectedPolicies[policy.Platform].Severity < policy.Severity {
selectedPolicies[policy.Platform] = policy
}
}
}
// build the message list
list := []string{}
for _, policy := range selectedPolicies {
if policy.Severity > None {
list = append(list, fmt.Sprintf("%s %s due to SHA-1 deprecation", policy.Platform, policy.Description))
}
}
return list
} | go | func SHA1DeprecationMessages(chain []*x509.Certificate) []string {
// record the most severe deprecation policy by each platform
selectedPolicies := map[string]SHA1DeprecationPolicy{}
for _, policy := range SHA1DeprecationPolicys {
if policy.Flag(chain) {
// only keep the policy with highest severity
if selectedPolicies[policy.Platform].Severity < policy.Severity {
selectedPolicies[policy.Platform] = policy
}
}
}
// build the message list
list := []string{}
for _, policy := range selectedPolicies {
if policy.Severity > None {
list = append(list, fmt.Sprintf("%s %s due to SHA-1 deprecation", policy.Platform, policy.Description))
}
}
return list
} | [
"func",
"SHA1DeprecationMessages",
"(",
"chain",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"[",
"]",
"string",
"{",
"// record the most severe deprecation policy by each platform",
"selectedPolicies",
":=",
"map",
"[",
"string",
"]",
"SHA1DeprecationPolicy",
"{",
"}",
"\n",
"for",
"_",
",",
"policy",
":=",
"range",
"SHA1DeprecationPolicys",
"{",
"if",
"policy",
".",
"Flag",
"(",
"chain",
")",
"{",
"// only keep the policy with highest severity",
"if",
"selectedPolicies",
"[",
"policy",
".",
"Platform",
"]",
".",
"Severity",
"<",
"policy",
".",
"Severity",
"{",
"selectedPolicies",
"[",
"policy",
".",
"Platform",
"]",
"=",
"policy",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"// build the message list",
"list",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"policy",
":=",
"range",
"selectedPolicies",
"{",
"if",
"policy",
".",
"Severity",
">",
"None",
"{",
"list",
"=",
"append",
"(",
"list",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"policy",
".",
"Platform",
",",
"policy",
".",
"Description",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"list",
"\n",
"}"
] | // SHA1DeprecationMessages returns a list of human-readable messages. Each message describes
// how one platform rejects the chain based on SHA1 deprecation policies. | [
"SHA1DeprecationMessages",
"returns",
"a",
"list",
"of",
"human",
"-",
"readable",
"messages",
".",
"Each",
"message",
"describes",
"how",
"one",
"platform",
"rejects",
"the",
"chain",
"based",
"on",
"SHA1",
"deprecation",
"policies",
"."
] | 768cd563887febaad559b511aaa5964823ccb4ab | https://github.com/cloudflare/cfssl/blob/768cd563887febaad559b511aaa5964823ccb4ab/ubiquity/sha1.go#L134-L153 | train |
moby/buildkit | examples/gobuild/main.go | copy | func copy(src llb.State, srcPath string, dest llb.State, destPath string) llb.State {
cpImage := llb.Image("docker.io/library/alpine@sha256:1072e499f3f655a032e88542330cf75b02e7bdf673278f701d7ba61629ee3ebe")
cp := cpImage.Run(llb.Shlexf("cp -a /src%s /dest%s", srcPath, destPath))
cp.AddMount("/src", src, llb.Readonly)
return cp.AddMount("/dest", dest)
} | go | func copy(src llb.State, srcPath string, dest llb.State, destPath string) llb.State {
cpImage := llb.Image("docker.io/library/alpine@sha256:1072e499f3f655a032e88542330cf75b02e7bdf673278f701d7ba61629ee3ebe")
cp := cpImage.Run(llb.Shlexf("cp -a /src%s /dest%s", srcPath, destPath))
cp.AddMount("/src", src, llb.Readonly)
return cp.AddMount("/dest", dest)
} | [
"func",
"copy",
"(",
"src",
"llb",
".",
"State",
",",
"srcPath",
"string",
",",
"dest",
"llb",
".",
"State",
",",
"destPath",
"string",
")",
"llb",
".",
"State",
"{",
"cpImage",
":=",
"llb",
".",
"Image",
"(",
"\"",
"\"",
")",
"\n",
"cp",
":=",
"cpImage",
".",
"Run",
"(",
"llb",
".",
"Shlexf",
"(",
"\"",
"\"",
",",
"srcPath",
",",
"destPath",
")",
")",
"\n",
"cp",
".",
"AddMount",
"(",
"\"",
"\"",
",",
"src",
",",
"llb",
".",
"Readonly",
")",
"\n",
"return",
"cp",
".",
"AddMount",
"(",
"\"",
"\"",
",",
"dest",
")",
"\n",
"}"
] | // copy copies files between 2 states using cp until there is no copyOp | [
"copy",
"copies",
"files",
"between",
"2",
"states",
"using",
"cp",
"until",
"there",
"is",
"no",
"copyOp"
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/examples/gobuild/main.go#L91-L96 | train |
moby/buildkit | frontend/dockerfile/instructions/bflag.go | NewBFlags | func NewBFlags() *BFlags {
return &BFlags{
flags: make(map[string]*Flag),
used: make(map[string]*Flag),
}
} | go | func NewBFlags() *BFlags {
return &BFlags{
flags: make(map[string]*Flag),
used: make(map[string]*Flag),
}
} | [
"func",
"NewBFlags",
"(",
")",
"*",
"BFlags",
"{",
"return",
"&",
"BFlags",
"{",
"flags",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Flag",
")",
",",
"used",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Flag",
")",
",",
"}",
"\n",
"}"
] | // NewBFlags returns the new BFlags struct | [
"NewBFlags",
"returns",
"the",
"new",
"BFlags",
"struct"
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/instructions/bflag.go#L35-L40 | train |
moby/buildkit | frontend/dockerfile/instructions/bflag.go | NewBFlagsWithArgs | func NewBFlagsWithArgs(args []string) *BFlags {
flags := NewBFlags()
flags.Args = args
return flags
} | go | func NewBFlagsWithArgs(args []string) *BFlags {
flags := NewBFlags()
flags.Args = args
return flags
} | [
"func",
"NewBFlagsWithArgs",
"(",
"args",
"[",
"]",
"string",
")",
"*",
"BFlags",
"{",
"flags",
":=",
"NewBFlags",
"(",
")",
"\n",
"flags",
".",
"Args",
"=",
"args",
"\n",
"return",
"flags",
"\n",
"}"
] | // NewBFlagsWithArgs returns the new BFlags struct with Args set to args | [
"NewBFlagsWithArgs",
"returns",
"the",
"new",
"BFlags",
"struct",
"with",
"Args",
"set",
"to",
"args"
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/instructions/bflag.go#L43-L47 | train |
moby/buildkit | frontend/dockerfile/instructions/bflag.go | AddStrings | func (bf *BFlags) AddStrings(name string) *Flag {
flag := bf.addFlag(name, stringsType)
if flag == nil {
return nil
}
return flag
} | go | func (bf *BFlags) AddStrings(name string) *Flag {
flag := bf.addFlag(name, stringsType)
if flag == nil {
return nil
}
return flag
} | [
"func",
"(",
"bf",
"*",
"BFlags",
")",
"AddStrings",
"(",
"name",
"string",
")",
"*",
"Flag",
"{",
"flag",
":=",
"bf",
".",
"addFlag",
"(",
"name",
",",
"stringsType",
")",
"\n",
"if",
"flag",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"flag",
"\n",
"}"
] | // AddStrings adds a string flag to BFlags that can match multiple values | [
"AddStrings",
"adds",
"a",
"string",
"flag",
"to",
"BFlags",
"that",
"can",
"match",
"multiple",
"values"
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/instructions/bflag.go#L76-L82 | train |
moby/buildkit | frontend/dockerfile/instructions/bflag.go | IsUsed | func (fl *Flag) IsUsed() bool {
if _, ok := fl.bf.used[fl.name]; ok {
return true
}
return false
} | go | func (fl *Flag) IsUsed() bool {
if _, ok := fl.bf.used[fl.name]; ok {
return true
}
return false
} | [
"func",
"(",
"fl",
"*",
"Flag",
")",
"IsUsed",
"(",
")",
"bool",
"{",
"if",
"_",
",",
"ok",
":=",
"fl",
".",
"bf",
".",
"used",
"[",
"fl",
".",
"name",
"]",
";",
"ok",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsUsed checks if the flag is used | [
"IsUsed",
"checks",
"if",
"the",
"flag",
"is",
"used"
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/instructions/bflag.go#L104-L109 | train |
moby/buildkit | frontend/dockerfile/instructions/bflag.go | IsTrue | func (fl *Flag) IsTrue() bool {
if fl.flagType != boolType {
// Should never get here
panic(fmt.Errorf("Trying to use IsTrue on a non-boolean: %s", fl.name))
}
return fl.Value == "true"
} | go | func (fl *Flag) IsTrue() bool {
if fl.flagType != boolType {
// Should never get here
panic(fmt.Errorf("Trying to use IsTrue on a non-boolean: %s", fl.name))
}
return fl.Value == "true"
} | [
"func",
"(",
"fl",
"*",
"Flag",
")",
"IsTrue",
"(",
")",
"bool",
"{",
"if",
"fl",
".",
"flagType",
"!=",
"boolType",
"{",
"// Should never get here",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"fl",
".",
"name",
")",
")",
"\n",
"}",
"\n",
"return",
"fl",
".",
"Value",
"==",
"\"",
"\"",
"\n",
"}"
] | // IsTrue checks if a bool flag is true | [
"IsTrue",
"checks",
"if",
"a",
"bool",
"flag",
"is",
"true"
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/instructions/bflag.go#L112-L118 | train |
moby/buildkit | session/content/caller.go | NewCallerStore | func NewCallerStore(c session.Caller, storeID string) content.Store {
client := api.NewContentClient(c.Conn())
return &callerContentStore{
store: proxy.NewContentStore(client),
storeID: storeID,
}
} | go | func NewCallerStore(c session.Caller, storeID string) content.Store {
client := api.NewContentClient(c.Conn())
return &callerContentStore{
store: proxy.NewContentStore(client),
storeID: storeID,
}
} | [
"func",
"NewCallerStore",
"(",
"c",
"session",
".",
"Caller",
",",
"storeID",
"string",
")",
"content",
".",
"Store",
"{",
"client",
":=",
"api",
".",
"NewContentClient",
"(",
"c",
".",
"Conn",
"(",
")",
")",
"\n",
"return",
"&",
"callerContentStore",
"{",
"store",
":",
"proxy",
".",
"NewContentStore",
"(",
"client",
")",
",",
"storeID",
":",
"storeID",
",",
"}",
"\n",
"}"
] | // NewCallerStore creates content.Store from session.Caller with specified storeID | [
"NewCallerStore",
"creates",
"content",
".",
"Store",
"from",
"session",
".",
"Caller",
"with",
"specified",
"storeID"
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/session/content/caller.go#L78-L84 | train |
moby/buildkit | util/contentutil/pusher.go | Writer | func (i *pushingIngester) Writer(ctx context.Context, opts ...content.WriterOpt) (content.Writer, error) {
var wOpts content.WriterOpts
for _, opt := range opts {
if err := opt(&wOpts); err != nil {
return nil, err
}
}
if wOpts.Ref == "" {
return nil, errors.Wrap(errdefs.ErrInvalidArgument, "ref must not be empty")
}
// pusher requires desc.MediaType to determine the PUT URL, especially for manifest blobs.
contentWriter, err := i.p.Push(ctx, wOpts.Desc)
if err != nil {
return nil, err
}
return &writer{
Writer: contentWriter,
contentWriterRef: wOpts.Ref,
}, nil
} | go | func (i *pushingIngester) Writer(ctx context.Context, opts ...content.WriterOpt) (content.Writer, error) {
var wOpts content.WriterOpts
for _, opt := range opts {
if err := opt(&wOpts); err != nil {
return nil, err
}
}
if wOpts.Ref == "" {
return nil, errors.Wrap(errdefs.ErrInvalidArgument, "ref must not be empty")
}
// pusher requires desc.MediaType to determine the PUT URL, especially for manifest blobs.
contentWriter, err := i.p.Push(ctx, wOpts.Desc)
if err != nil {
return nil, err
}
return &writer{
Writer: contentWriter,
contentWriterRef: wOpts.Ref,
}, nil
} | [
"func",
"(",
"i",
"*",
"pushingIngester",
")",
"Writer",
"(",
"ctx",
"context",
".",
"Context",
",",
"opts",
"...",
"content",
".",
"WriterOpt",
")",
"(",
"content",
".",
"Writer",
",",
"error",
")",
"{",
"var",
"wOpts",
"content",
".",
"WriterOpts",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"if",
"err",
":=",
"opt",
"(",
"&",
"wOpts",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"wOpts",
".",
"Ref",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"errdefs",
".",
"ErrInvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// pusher requires desc.MediaType to determine the PUT URL, especially for manifest blobs.",
"contentWriter",
",",
"err",
":=",
"i",
".",
"p",
".",
"Push",
"(",
"ctx",
",",
"wOpts",
".",
"Desc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"writer",
"{",
"Writer",
":",
"contentWriter",
",",
"contentWriterRef",
":",
"wOpts",
".",
"Ref",
",",
"}",
",",
"nil",
"\n",
"}"
] | // Writer implements content.Ingester. desc.MediaType must be set for manifest blobs. | [
"Writer",
"implements",
"content",
".",
"Ingester",
".",
"desc",
".",
"MediaType",
"must",
"be",
"set",
"for",
"manifest",
"blobs",
"."
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/util/contentutil/pusher.go#L23-L42 | train |
moby/buildkit | client/connhelper/kubepod/kubepod.go | Helper | func Helper(u *url.URL) (*connhelper.ConnectionHelper, error) {
sp, err := SpecFromURL(u)
if err != nil {
return nil, err
}
return &connhelper.ConnectionHelper{
ContextDialer: func(ctx context.Context, addr string) (net.Conn, error) {
return commandconn.New(ctx, "kubectl", "--context="+sp.Context, "--namespace="+sp.Namespace,
"exec", "--container="+sp.Container, "-i", sp.Pod, "--", "buildctl", "dial-stdio")
},
}, nil
} | go | func Helper(u *url.URL) (*connhelper.ConnectionHelper, error) {
sp, err := SpecFromURL(u)
if err != nil {
return nil, err
}
return &connhelper.ConnectionHelper{
ContextDialer: func(ctx context.Context, addr string) (net.Conn, error) {
return commandconn.New(ctx, "kubectl", "--context="+sp.Context, "--namespace="+sp.Namespace,
"exec", "--container="+sp.Container, "-i", sp.Pod, "--", "buildctl", "dial-stdio")
},
}, nil
} | [
"func",
"Helper",
"(",
"u",
"*",
"url",
".",
"URL",
")",
"(",
"*",
"connhelper",
".",
"ConnectionHelper",
",",
"error",
")",
"{",
"sp",
",",
"err",
":=",
"SpecFromURL",
"(",
"u",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"connhelper",
".",
"ConnectionHelper",
"{",
"ContextDialer",
":",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"addr",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"commandconn",
".",
"New",
"(",
"ctx",
",",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"sp",
".",
"Context",
",",
"\"",
"\"",
"+",
"sp",
".",
"Namespace",
",",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"sp",
".",
"Container",
",",
"\"",
"\"",
",",
"sp",
".",
"Pod",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
",",
"}",
",",
"nil",
"\n",
"}"
] | // Helper returns helper for connecting to a Kubernetes pod.
// Requires BuildKit v0.5.0 or later in the pod. | [
"Helper",
"returns",
"helper",
"for",
"connecting",
"to",
"a",
"Kubernetes",
"pod",
".",
"Requires",
"BuildKit",
"v0",
".",
"5",
".",
"0",
"or",
"later",
"in",
"the",
"pod",
"."
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/client/connhelper/kubepod/kubepod.go#L21-L32 | train |
moby/buildkit | frontend/dockerfile/parser/line_parsers.go | parseIgnore | func parseIgnore(rest string, d *Directive) (*Node, map[string]bool, error) {
return &Node{}, nil, nil
} | go | func parseIgnore(rest string, d *Directive) (*Node, map[string]bool, error) {
return &Node{}, nil, nil
} | [
"func",
"parseIgnore",
"(",
"rest",
"string",
",",
"d",
"*",
"Directive",
")",
"(",
"*",
"Node",
",",
"map",
"[",
"string",
"]",
"bool",
",",
"error",
")",
"{",
"return",
"&",
"Node",
"{",
"}",
",",
"nil",
",",
"nil",
"\n",
"}"
] | // ignore the current argument. This will still leave a command parsed, but
// will not incorporate the arguments into the ast. | [
"ignore",
"the",
"current",
"argument",
".",
"This",
"will",
"still",
"leave",
"a",
"command",
"parsed",
"but",
"will",
"not",
"incorporate",
"the",
"arguments",
"into",
"the",
"ast",
"."
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/parser/line_parsers.go#L28-L30 | train |
moby/buildkit | frontend/dockerfile/parser/line_parsers.go | parseStringsWhitespaceDelimited | func parseStringsWhitespaceDelimited(rest string, d *Directive) (*Node, map[string]bool, error) {
if rest == "" {
return nil, nil, nil
}
node := &Node{}
rootnode := node
prevnode := node
for _, str := range tokenWhitespace.Split(rest, -1) { // use regexp
prevnode = node
node.Value = str
node.Next = &Node{}
node = node.Next
}
// XXX to get around regexp.Split *always* providing an empty string at the
// end due to how our loop is constructed, nil out the last node in the
// chain.
prevnode.Next = nil
return rootnode, nil, nil
} | go | func parseStringsWhitespaceDelimited(rest string, d *Directive) (*Node, map[string]bool, error) {
if rest == "" {
return nil, nil, nil
}
node := &Node{}
rootnode := node
prevnode := node
for _, str := range tokenWhitespace.Split(rest, -1) { // use regexp
prevnode = node
node.Value = str
node.Next = &Node{}
node = node.Next
}
// XXX to get around regexp.Split *always* providing an empty string at the
// end due to how our loop is constructed, nil out the last node in the
// chain.
prevnode.Next = nil
return rootnode, nil, nil
} | [
"func",
"parseStringsWhitespaceDelimited",
"(",
"rest",
"string",
",",
"d",
"*",
"Directive",
")",
"(",
"*",
"Node",
",",
"map",
"[",
"string",
"]",
"bool",
",",
"error",
")",
"{",
"if",
"rest",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"node",
":=",
"&",
"Node",
"{",
"}",
"\n",
"rootnode",
":=",
"node",
"\n",
"prevnode",
":=",
"node",
"\n",
"for",
"_",
",",
"str",
":=",
"range",
"tokenWhitespace",
".",
"Split",
"(",
"rest",
",",
"-",
"1",
")",
"{",
"// use regexp",
"prevnode",
"=",
"node",
"\n",
"node",
".",
"Value",
"=",
"str",
"\n",
"node",
".",
"Next",
"=",
"&",
"Node",
"{",
"}",
"\n",
"node",
"=",
"node",
".",
"Next",
"\n",
"}",
"\n\n",
"// XXX to get around regexp.Split *always* providing an empty string at the",
"// end due to how our loop is constructed, nil out the last node in the",
"// chain.",
"prevnode",
".",
"Next",
"=",
"nil",
"\n\n",
"return",
"rootnode",
",",
"nil",
",",
"nil",
"\n",
"}"
] | // parses a whitespace-delimited set of arguments. The result is effectively a
// linked list of string arguments. | [
"parses",
"a",
"whitespace",
"-",
"delimited",
"set",
"of",
"arguments",
".",
"The",
"result",
"is",
"effectively",
"a",
"linked",
"list",
"of",
"string",
"arguments",
"."
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/parser/line_parsers.go#L239-L260 | train |
moby/buildkit | frontend/dockerfile/parser/line_parsers.go | parseString | func parseString(rest string, d *Directive) (*Node, map[string]bool, error) {
if rest == "" {
return nil, nil, nil
}
n := &Node{}
n.Value = rest
return n, nil, nil
} | go | func parseString(rest string, d *Directive) (*Node, map[string]bool, error) {
if rest == "" {
return nil, nil, nil
}
n := &Node{}
n.Value = rest
return n, nil, nil
} | [
"func",
"parseString",
"(",
"rest",
"string",
",",
"d",
"*",
"Directive",
")",
"(",
"*",
"Node",
",",
"map",
"[",
"string",
"]",
"bool",
",",
"error",
")",
"{",
"if",
"rest",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"n",
":=",
"&",
"Node",
"{",
"}",
"\n",
"n",
".",
"Value",
"=",
"rest",
"\n",
"return",
"n",
",",
"nil",
",",
"nil",
"\n",
"}"
] | // parseString just wraps the string in quotes and returns a working node. | [
"parseString",
"just",
"wraps",
"the",
"string",
"in",
"quotes",
"and",
"returns",
"a",
"working",
"node",
"."
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/parser/line_parsers.go#L263-L270 | train |
moby/buildkit | frontend/dockerfile/parser/line_parsers.go | parseJSON | func parseJSON(rest string, d *Directive) (*Node, map[string]bool, error) {
rest = strings.TrimLeftFunc(rest, unicode.IsSpace)
if !strings.HasPrefix(rest, "[") {
return nil, nil, fmt.Errorf(`Error parsing "%s" as a JSON array`, rest)
}
var myJSON []interface{}
if err := json.NewDecoder(strings.NewReader(rest)).Decode(&myJSON); err != nil {
return nil, nil, err
}
var top, prev *Node
for _, str := range myJSON {
s, ok := str.(string)
if !ok {
return nil, nil, errDockerfileNotStringArray
}
node := &Node{Value: s}
if prev == nil {
top = node
} else {
prev.Next = node
}
prev = node
}
return top, map[string]bool{"json": true}, nil
} | go | func parseJSON(rest string, d *Directive) (*Node, map[string]bool, error) {
rest = strings.TrimLeftFunc(rest, unicode.IsSpace)
if !strings.HasPrefix(rest, "[") {
return nil, nil, fmt.Errorf(`Error parsing "%s" as a JSON array`, rest)
}
var myJSON []interface{}
if err := json.NewDecoder(strings.NewReader(rest)).Decode(&myJSON); err != nil {
return nil, nil, err
}
var top, prev *Node
for _, str := range myJSON {
s, ok := str.(string)
if !ok {
return nil, nil, errDockerfileNotStringArray
}
node := &Node{Value: s}
if prev == nil {
top = node
} else {
prev.Next = node
}
prev = node
}
return top, map[string]bool{"json": true}, nil
} | [
"func",
"parseJSON",
"(",
"rest",
"string",
",",
"d",
"*",
"Directive",
")",
"(",
"*",
"Node",
",",
"map",
"[",
"string",
"]",
"bool",
",",
"error",
")",
"{",
"rest",
"=",
"strings",
".",
"TrimLeftFunc",
"(",
"rest",
",",
"unicode",
".",
"IsSpace",
")",
"\n",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"rest",
",",
"\"",
"\"",
")",
"{",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"`Error parsing \"%s\" as a JSON array`",
",",
"rest",
")",
"\n",
"}",
"\n\n",
"var",
"myJSON",
"[",
"]",
"interface",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"strings",
".",
"NewReader",
"(",
"rest",
")",
")",
".",
"Decode",
"(",
"&",
"myJSON",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"top",
",",
"prev",
"*",
"Node",
"\n",
"for",
"_",
",",
"str",
":=",
"range",
"myJSON",
"{",
"s",
",",
"ok",
":=",
"str",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"nil",
",",
"errDockerfileNotStringArray",
"\n",
"}",
"\n\n",
"node",
":=",
"&",
"Node",
"{",
"Value",
":",
"s",
"}",
"\n",
"if",
"prev",
"==",
"nil",
"{",
"top",
"=",
"node",
"\n",
"}",
"else",
"{",
"prev",
".",
"Next",
"=",
"node",
"\n",
"}",
"\n",
"prev",
"=",
"node",
"\n",
"}",
"\n\n",
"return",
"top",
",",
"map",
"[",
"string",
"]",
"bool",
"{",
"\"",
"\"",
":",
"true",
"}",
",",
"nil",
"\n",
"}"
] | // parseJSON converts JSON arrays to an AST. | [
"parseJSON",
"converts",
"JSON",
"arrays",
"to",
"an",
"AST",
"."
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/parser/line_parsers.go#L273-L301 | train |
moby/buildkit | frontend/dockerfile/parser/line_parsers.go | parseMaybeJSON | func parseMaybeJSON(rest string, d *Directive) (*Node, map[string]bool, error) {
if rest == "" {
return nil, nil, nil
}
node, attrs, err := parseJSON(rest, d)
if err == nil {
return node, attrs, nil
}
if err == errDockerfileNotStringArray {
return nil, nil, err
}
node = &Node{}
node.Value = rest
return node, nil, nil
} | go | func parseMaybeJSON(rest string, d *Directive) (*Node, map[string]bool, error) {
if rest == "" {
return nil, nil, nil
}
node, attrs, err := parseJSON(rest, d)
if err == nil {
return node, attrs, nil
}
if err == errDockerfileNotStringArray {
return nil, nil, err
}
node = &Node{}
node.Value = rest
return node, nil, nil
} | [
"func",
"parseMaybeJSON",
"(",
"rest",
"string",
",",
"d",
"*",
"Directive",
")",
"(",
"*",
"Node",
",",
"map",
"[",
"string",
"]",
"bool",
",",
"error",
")",
"{",
"if",
"rest",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"node",
",",
"attrs",
",",
"err",
":=",
"parseJSON",
"(",
"rest",
",",
"d",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"node",
",",
"attrs",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"==",
"errDockerfileNotStringArray",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"node",
"=",
"&",
"Node",
"{",
"}",
"\n",
"node",
".",
"Value",
"=",
"rest",
"\n",
"return",
"node",
",",
"nil",
",",
"nil",
"\n",
"}"
] | // parseMaybeJSON determines if the argument appears to be a JSON array. If
// so, passes to parseJSON; if not, quotes the result and returns a single
// node. | [
"parseMaybeJSON",
"determines",
"if",
"the",
"argument",
"appears",
"to",
"be",
"a",
"JSON",
"array",
".",
"If",
"so",
"passes",
"to",
"parseJSON",
";",
"if",
"not",
"quotes",
"the",
"result",
"and",
"returns",
"a",
"single",
"node",
"."
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/parser/line_parsers.go#L306-L323 | train |
moby/buildkit | frontend/dockerfile/parser/line_parsers.go | parseMaybeJSONToList | func parseMaybeJSONToList(rest string, d *Directive) (*Node, map[string]bool, error) {
node, attrs, err := parseJSON(rest, d)
if err == nil {
return node, attrs, nil
}
if err == errDockerfileNotStringArray {
return nil, nil, err
}
return parseStringsWhitespaceDelimited(rest, d)
} | go | func parseMaybeJSONToList(rest string, d *Directive) (*Node, map[string]bool, error) {
node, attrs, err := parseJSON(rest, d)
if err == nil {
return node, attrs, nil
}
if err == errDockerfileNotStringArray {
return nil, nil, err
}
return parseStringsWhitespaceDelimited(rest, d)
} | [
"func",
"parseMaybeJSONToList",
"(",
"rest",
"string",
",",
"d",
"*",
"Directive",
")",
"(",
"*",
"Node",
",",
"map",
"[",
"string",
"]",
"bool",
",",
"error",
")",
"{",
"node",
",",
"attrs",
",",
"err",
":=",
"parseJSON",
"(",
"rest",
",",
"d",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"node",
",",
"attrs",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"==",
"errDockerfileNotStringArray",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"parseStringsWhitespaceDelimited",
"(",
"rest",
",",
"d",
")",
"\n",
"}"
] | // parseMaybeJSONToList determines if the argument appears to be a JSON array. If
// so, passes to parseJSON; if not, attempts to parse it as a whitespace
// delimited string. | [
"parseMaybeJSONToList",
"determines",
"if",
"the",
"argument",
"appears",
"to",
"be",
"a",
"JSON",
"array",
".",
"If",
"so",
"passes",
"to",
"parseJSON",
";",
"if",
"not",
"attempts",
"to",
"parse",
"it",
"as",
"a",
"whitespace",
"delimited",
"string",
"."
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/parser/line_parsers.go#L328-L339 | train |
moby/buildkit | frontend/dockerfile/parser/line_parsers.go | parseHealthConfig | func parseHealthConfig(rest string, d *Directive) (*Node, map[string]bool, error) {
// Find end of first argument
var sep int
for ; sep < len(rest); sep++ {
if unicode.IsSpace(rune(rest[sep])) {
break
}
}
next := sep
for ; next < len(rest); next++ {
if !unicode.IsSpace(rune(rest[next])) {
break
}
}
if sep == 0 {
return nil, nil, nil
}
typ := rest[:sep]
cmd, attrs, err := parseMaybeJSON(rest[next:], d)
if err != nil {
return nil, nil, err
}
return &Node{Value: typ, Next: cmd}, attrs, err
} | go | func parseHealthConfig(rest string, d *Directive) (*Node, map[string]bool, error) {
// Find end of first argument
var sep int
for ; sep < len(rest); sep++ {
if unicode.IsSpace(rune(rest[sep])) {
break
}
}
next := sep
for ; next < len(rest); next++ {
if !unicode.IsSpace(rune(rest[next])) {
break
}
}
if sep == 0 {
return nil, nil, nil
}
typ := rest[:sep]
cmd, attrs, err := parseMaybeJSON(rest[next:], d)
if err != nil {
return nil, nil, err
}
return &Node{Value: typ, Next: cmd}, attrs, err
} | [
"func",
"parseHealthConfig",
"(",
"rest",
"string",
",",
"d",
"*",
"Directive",
")",
"(",
"*",
"Node",
",",
"map",
"[",
"string",
"]",
"bool",
",",
"error",
")",
"{",
"// Find end of first argument",
"var",
"sep",
"int",
"\n",
"for",
";",
"sep",
"<",
"len",
"(",
"rest",
")",
";",
"sep",
"++",
"{",
"if",
"unicode",
".",
"IsSpace",
"(",
"rune",
"(",
"rest",
"[",
"sep",
"]",
")",
")",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"next",
":=",
"sep",
"\n",
"for",
";",
"next",
"<",
"len",
"(",
"rest",
")",
";",
"next",
"++",
"{",
"if",
"!",
"unicode",
".",
"IsSpace",
"(",
"rune",
"(",
"rest",
"[",
"next",
"]",
")",
")",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"sep",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"typ",
":=",
"rest",
"[",
":",
"sep",
"]",
"\n",
"cmd",
",",
"attrs",
",",
"err",
":=",
"parseMaybeJSON",
"(",
"rest",
"[",
"next",
":",
"]",
",",
"d",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"Node",
"{",
"Value",
":",
"typ",
",",
"Next",
":",
"cmd",
"}",
",",
"attrs",
",",
"err",
"\n",
"}"
] | // The HEALTHCHECK command is like parseMaybeJSON, but has an extra type argument. | [
"The",
"HEALTHCHECK",
"command",
"is",
"like",
"parseMaybeJSON",
"but",
"has",
"an",
"extra",
"type",
"argument",
"."
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/frontend/dockerfile/parser/line_parsers.go#L342-L368 | train |
moby/buildkit | session/manager.go | NewManager | func NewManager() (*Manager, error) {
sm := &Manager{
sessions: make(map[string]*client),
}
sm.updateCondition = sync.NewCond(&sm.mu)
return sm, nil
} | go | func NewManager() (*Manager, error) {
sm := &Manager{
sessions: make(map[string]*client),
}
sm.updateCondition = sync.NewCond(&sm.mu)
return sm, nil
} | [
"func",
"NewManager",
"(",
")",
"(",
"*",
"Manager",
",",
"error",
")",
"{",
"sm",
":=",
"&",
"Manager",
"{",
"sessions",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"client",
")",
",",
"}",
"\n",
"sm",
".",
"updateCondition",
"=",
"sync",
".",
"NewCond",
"(",
"&",
"sm",
".",
"mu",
")",
"\n",
"return",
"sm",
",",
"nil",
"\n",
"}"
] | // NewManager returns a new Manager | [
"NewManager",
"returns",
"a",
"new",
"Manager"
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/session/manager.go#L37-L43 | train |
moby/buildkit | session/manager.go | HandleHTTPRequest | func (sm *Manager) HandleHTTPRequest(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
hijacker, ok := w.(http.Hijacker)
if !ok {
return errors.New("handler does not support hijack")
}
id := r.Header.Get(headerSessionID)
proto := r.Header.Get("Upgrade")
sm.mu.Lock()
if _, ok := sm.sessions[id]; ok {
sm.mu.Unlock()
return errors.Errorf("session %s already exists", id)
}
if proto == "" {
sm.mu.Unlock()
return errors.New("no upgrade proto in request")
}
if proto != "h2c" {
sm.mu.Unlock()
return errors.Errorf("protocol %s not supported", proto)
}
conn, _, err := hijacker.Hijack()
if err != nil {
sm.mu.Unlock()
return errors.Wrap(err, "failed to hijack connection")
}
resp := &http.Response{
StatusCode: http.StatusSwitchingProtocols,
ProtoMajor: 1,
ProtoMinor: 1,
Header: http.Header{},
}
resp.Header.Set("Connection", "Upgrade")
resp.Header.Set("Upgrade", proto)
// set raw mode
conn.Write([]byte{})
resp.Write(conn)
return sm.handleConn(ctx, conn, r.Header)
} | go | func (sm *Manager) HandleHTTPRequest(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
hijacker, ok := w.(http.Hijacker)
if !ok {
return errors.New("handler does not support hijack")
}
id := r.Header.Get(headerSessionID)
proto := r.Header.Get("Upgrade")
sm.mu.Lock()
if _, ok := sm.sessions[id]; ok {
sm.mu.Unlock()
return errors.Errorf("session %s already exists", id)
}
if proto == "" {
sm.mu.Unlock()
return errors.New("no upgrade proto in request")
}
if proto != "h2c" {
sm.mu.Unlock()
return errors.Errorf("protocol %s not supported", proto)
}
conn, _, err := hijacker.Hijack()
if err != nil {
sm.mu.Unlock()
return errors.Wrap(err, "failed to hijack connection")
}
resp := &http.Response{
StatusCode: http.StatusSwitchingProtocols,
ProtoMajor: 1,
ProtoMinor: 1,
Header: http.Header{},
}
resp.Header.Set("Connection", "Upgrade")
resp.Header.Set("Upgrade", proto)
// set raw mode
conn.Write([]byte{})
resp.Write(conn)
return sm.handleConn(ctx, conn, r.Header)
} | [
"func",
"(",
"sm",
"*",
"Manager",
")",
"HandleHTTPRequest",
"(",
"ctx",
"context",
".",
"Context",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"hijacker",
",",
"ok",
":=",
"w",
".",
"(",
"http",
".",
"Hijacker",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"id",
":=",
"r",
".",
"Header",
".",
"Get",
"(",
"headerSessionID",
")",
"\n\n",
"proto",
":=",
"r",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n\n",
"sm",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"sm",
".",
"sessions",
"[",
"id",
"]",
";",
"ok",
"{",
"sm",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"id",
")",
"\n",
"}",
"\n\n",
"if",
"proto",
"==",
"\"",
"\"",
"{",
"sm",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"proto",
"!=",
"\"",
"\"",
"{",
"sm",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"proto",
")",
"\n",
"}",
"\n\n",
"conn",
",",
"_",
",",
"err",
":=",
"hijacker",
".",
"Hijack",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"sm",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"resp",
":=",
"&",
"http",
".",
"Response",
"{",
"StatusCode",
":",
"http",
".",
"StatusSwitchingProtocols",
",",
"ProtoMajor",
":",
"1",
",",
"ProtoMinor",
":",
"1",
",",
"Header",
":",
"http",
".",
"Header",
"{",
"}",
",",
"}",
"\n",
"resp",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"resp",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"proto",
")",
"\n\n",
"// set raw mode",
"conn",
".",
"Write",
"(",
"[",
"]",
"byte",
"{",
"}",
")",
"\n",
"resp",
".",
"Write",
"(",
"conn",
")",
"\n\n",
"return",
"sm",
".",
"handleConn",
"(",
"ctx",
",",
"conn",
",",
"r",
".",
"Header",
")",
"\n",
"}"
] | // HandleHTTPRequest handles an incoming HTTP request | [
"HandleHTTPRequest",
"handles",
"an",
"incoming",
"HTTP",
"request"
] | 89851c6c69bca875dd64b5e9d5d6ec60ff437d74 | https://github.com/moby/buildkit/blob/89851c6c69bca875dd64b5e9d5d6ec60ff437d74/session/manager.go#L46-L92 | train |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.