Sign upLogin

ecadlabs/signatory

View on GitHub
Star

Showing 102 of 102 total issues

Similar blocks of code found in 5 locations. Consider refactoring.
Open

func init() {
    vault.RegisterVault("cloudkms", func(ctx context.Context, node *yaml.Node) (vault.Vault, error) {
        var conf Config
        if node == nil || node.Kind == 0 {
            return nil, errors.New("(CloudKMS): config is missing")
Severity: Major
Found in pkg/vault/cloudkms/cloudkms.go and 4 other locations - About 1 hr to fix
pkg/vault/aws/awskms.go on lines 172..188
pkg/vault/hashicorp/vault.go on lines 60..76
pkg/vault/yubi/yubi.go on lines 421..437
pkg/vault/azure/azure.go on lines 466..482

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 182.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 5 locations. Consider refactoring.
Open

func init() {
    vault.RegisterVault("yubihsm", func(ctx context.Context, node *yaml.Node) (vault.Vault, error) {
        var conf Config
        if node == nil || node.Kind == 0 {
            return nil, errors.New("(YubiHSM): config is missing")
Severity: Major
Found in pkg/vault/yubi/yubi.go and 4 other locations - About 1 hr to fix
pkg/vault/aws/awskms.go on lines 172..188
pkg/vault/cloudkms/cloudkms.go on lines 399..415
pkg/vault/hashicorp/vault.go on lines 60..76
pkg/vault/azure/azure.go on lines 466..482

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 182.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Function Feature has 45 lines of code (exceeds 25 allowed). Consider refactoring.
Open

function Feature() {
    const { error, loading, status, subscribe, message } = useMailChimp({
        action: `https://ecadlabs.us20.list-manage.com/subscribe/post?u=8fdd00e1ab81d5f5550fadb32&id=de1bfb4af9`,
    });
Severity: Minor
Found in website/src/components/FooterForm/FooterForm.js - About 1 hr to fix

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    func NewListRequests(c *Context) *cobra.Command {
    cmd := &cobra.Command{
        Use:   "list-requests",
        Short: "Print possible request types",
        RunE: func(cmd *cobra.Command, args []string) error {
    Severity: Major
    Found in cmd/commands/list_ops.go and 1 other location - About 1 hr to fix
    cmd/commands/list_ops.go on lines 48..63

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 172.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    func NewListOps(c *Context) *cobra.Command {
    cmd := &cobra.Command{
        Use:   "list-ops",
        Short: "Print possible operation types inside the `generic` request",
        RunE: func(cmd *cobra.Command, args []string) error {
    Severity: Major
    Found in cmd/commands/list_ops.go and 1 other location - About 1 hr to fix
    cmd/commands/list_ops.go on lines 31..46

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 172.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Method Server.Handler has 65 lines of code (exceeds 50 allowed). Consider refactoring.
    Open

    func (s *Server) Handler() (http.Handler, error) {
    pub := s.PrivateKey.Public()
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var req signatory.PolicyHookRequest
        dec := json.NewDecoder(r.Body)
    Severity: Minor
    Found in cmd/approve-list-svc/server/server.go - About 1 hr to fix

      Function NewServeCommand has a Cognitive Complexity of 28 (exceeds 20 allowed). Consider refactoring.
      Open

      func NewServeCommand(c *Context) *cobra.Command {
    var noList bool

    serveCmd := cobra.Command{
        Use:   "serve",
      Severity: Minor
      Found in cmd/commands/serve.go - About 1 hr to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function ParseMap has 64 lines of code (exceeds 50 allowed). Consider refactoring.
      Open

      func ParseMap(s string, namevalSep, tuplesSep rune) (res map[string]string, err error) {
    res = make(map[string]string)
    p := []byte(s)
    for {
        p, err = eatSpace(p)
      Severity: Minor
      Found in pkg/utils/utils.go - About 1 hr to fix

        Method JWK.PrivateKey has a Cognitive Complexity of 27 (exceeds 20 allowed). Consider refactoring.
        Open

        func (j *JWK) PrivateKey() (crypto.PrivateKey, error) {
    switch j.KeyType {
    case "EC", "EC-HSM":
        if j.D == "" {
            return nil, ErrPublic
        Severity: Minor
        Found in pkg/vault/azure/jwk/jwk.go - About 1 hr to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Method Vault.Import has 14 return statements (exceeds 4 allowed).
        Open

        func (c *Vault) Import(ctx context.Context, pk crypt.PrivateKey, opt utils.Options) (vault.StoredKey, error) {
    keyName, ok, err := opt.GetString("name")
    if err != nil {
        return nil, fmt.Errorf("(CloudKMS/%s): %w", c.config.keyRingName(), err)
    }
        Severity: Major
        Found in pkg/vault/cloudkms/cloudkms.go - About 1 hr to fix

          Method JWK.PrivateKey has 14 return statements (exceeds 4 allowed).
          Open

          func (j *JWK) PrivateKey() (crypto.PrivateKey, error) {
    switch j.KeyType {
    case "EC", "EC-HSM":
        if j.D == "" {
            return nil, ErrPublic
          Severity: Major
          Found in pkg/vault/azure/jwk/jwk.go - About 1 hr to fix

            Consider simplifying this complex logical expression.
            Open

                        if c >= 32 && c <= 126 && !((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
            Severity: Critical
            Found in pkg/middlewares/jwt.go - About 1 hr to fix

              Function ParseMap has 13 return statements (exceeds 4 allowed).
              Open

              func ParseMap(s string, namevalSep, tuplesSep rune) (res map[string]string, err error) {
    res = make(map[string]string)
    p := []byte(s)
    for {
        p, err = eatSpace(p)
              Severity: Major
              Found in pkg/utils/utils.go - About 1 hr to fix

                Method JWT.CheckUpdateNewCred has 12 return statements (exceeds 4 allowed).
                Open

                func (j *JWT) CheckUpdateNewCred() error {
    for user, data := range j.Users {
        if data.NewData != nil {
            if data.NewData.Password == data.Password || data.NewData.Secret == data.Secret {
                return fmt.Errorf("JWT: new credentials are same as old for user %s", user)
                Severity: Major
                Found in pkg/middlewares/jwt.go - About 1 hr to fix

                  Function NewRootCommand has 12 return statements (exceeds 4 allowed).
                  Open

                  func NewRootCommand(c *Context, name string) *cobra.Command {
    var (
        level      string
        configFile string
        baseDir    string
                  Severity: Major
                  Found in cmd/commands/root.go - About 1 hr to fix

                    Identical blocks of code found in 2 locations. Consider refactoring.
                    Open

                    func main() {
    signalChan := make(chan os.Signal, 1)
    signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)

    ctx, cancel := context.WithCancel(context.Background())
                    Severity: Major
                    Found in cmd/signatory-cli/main.go and 1 other location - About 1 hr to fix
                    cmd/signatory/main.go on lines 38..53

                    Duplicated Code

                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                    Tuning

                    This issue has a mass of 140.

                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                    Refactorings

                    Further Reading

                    Identical blocks of code found in 2 locations. Consider refactoring.
                    Open

                    func main() {
    signalChan := make(chan os.Signal, 1)
    signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)

    ctx, cancel := context.WithCancel(context.Background())
                    Severity: Major
                    Found in cmd/signatory/main.go and 1 other location - About 1 hr to fix
                    cmd/signatory-cli/main.go on lines 44..59

                    Duplicated Code

                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                    Tuning

                    This issue has a mass of 140.

                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                    Refactorings

                    Further Reading

                    Method JWK.PrivateKey has 54 lines of code (exceeds 50 allowed). Consider refactoring.
                    Open

                    func (j *JWK) PrivateKey() (crypto.PrivateKey, error) {
    switch j.KeyType {
    case "EC", "EC-HSM":
        if j.D == "" {
            return nil, ErrPublic
                    Severity: Minor
                    Found in pkg/vault/azure/jwk/jwk.go - About 1 hr to fix

                      Method App.GetAppVersion has 11 return statements (exceeds 4 allowed).
                      Open

                      func (a *App) GetAppVersion() (*Version, error) {
    res, err := a.Exchange(&APDUCommand{
        Cla: claGlobal,
        Ins: insVersion,
    })
                      Severity: Major
                      Found in pkg/vault/ledger/ledger/ledger.go - About 1 hr to fix

                        Function Footer has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                        Open

                        function Footer() {
    const footerContainer = useRef(null);
    const [isActive, setIsActive] = useState(false);
    const { footer } = useThemeConfig();
    const { copyright, links = [], logo = {} } = footer || {};
                        Severity: Minor
                        Found in website/src/theme/Footer/index.js - About 1 hr to fix

                        Cognitive Complexity

                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                        A method's cognitive complexity is based on a few simple rules:

                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                        • Code is considered more complex for each "break in the linear flow of the code"
                        • Code is considered more complex when "flow breaking structures are nested"

                        Further reading

                        Severity
                        Category
                        Status
                        Source
                        Language