SonarSource Rules
  • Products

    In-IDE

    Code Quality and Security in your IDE with SonarQube Ide

    IDE extension that lets you fix coding issues before they exist!

    Discover SonarQube for IDE

    SaaS

    Code Quality and Security in the cloud with SonarQube Cloud

    Setup is effortless and analysis is automatic for most languages

    Discover SonarQube Cloud

    Self-Hosted

    Code Quality and Security Self-Hosted with SonarQube Server

    Fast, accurate analysis; enterprise scalability

    Discover SonarQube Server
  • SecretsSecrets
  • ABAPABAP
  • AnsibleAnsible
  • ApexApex
  • AzureResourceManagerAzureResourceManager
  • CC
  • C#C#
  • C++C++
  • CloudFormationCloudFormation
  • COBOLCOBOL
  • CSSCSS
  • DartDart
  • DockerDocker
  • FlexFlex
  • GitHub ActionsGitHub Actions
  • GoGo
  • HTMLHTML
  • JavaJava
  • JavaScriptJavaScript
  • JSONJSON
  • JCLJCL
  • KotlinKotlin
  • KubernetesKubernetes
  • Objective CObjective C
  • PHPPHP
  • PL/IPL/I
  • PL/SQLPL/SQL
  • PythonPython
  • RPGRPG
  • RubyRuby
  • RustRust
  • ScalaScala
  • SwiftSwift
  • TerraformTerraform
  • TextText
  • TypeScriptTypeScript
  • T-SQLT-SQL
  • VB.NETVB.NET
  • VB6VB6
  • XMLXML
  • YAMLYAML
Go

Go static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your GO code

  • All rules 70
  • Vulnerability20
  • Bug7
  • Security Hotspot14
  • Code Smell29
 
Tags
    Impact
      Clean code attribute
        1. Credentials should not be hard-coded

           Vulnerability
        2. Extracting archives should not lead to zip slip vulnerabilities

           Vulnerability
        3. JWT should be signed and verified with strong cipher algorithms

           Vulnerability
        4. Cipher algorithms should be robust

           Vulnerability
        5. Encryption algorithms should be used with secure mode and padding scheme

           Vulnerability
        6. Server hostnames should be verified during SSL/TLS connections

           Vulnerability
        7. Insecure temporary file creation methods should not be used

           Vulnerability
        8. Passwords should not be stored in plaintext or with a fast hashing algorithm

           Vulnerability
        9. HTTP request redirections should not be open to forging attacks

           Vulnerability
        10. Logging should not be vulnerable to injection attacks

           Vulnerability
        11. Server-side requests should not be vulnerable to forging attacks

           Vulnerability
        12. Server certificates should be verified during SSL/TLS connections

           Vulnerability
        13. Cryptographic keys should be robust

           Vulnerability
        14. Weak SSL/TLS protocols should not be used

           Vulnerability
        15. Database queries should not be vulnerable to injection attacks

           Vulnerability
        16. Cipher Block Chaining IVs should be unpredictable

           Vulnerability
        17. XPath expressions should not be vulnerable to injection attacks

           Vulnerability
        18. I/O function calls should not be vulnerable to path injection attacks

           Vulnerability
        19. OS commands should not be vulnerable to command injection attacks

           Vulnerability
        20. Password hashing functions should use an unpredictable salt

           Vulnerability

        Insecure temporary file creation methods should not be used

        intentionality - complete
        security
        Vulnerability
        • cwe

        Temporary files are considered insecurely created when the file existence check is performed separately from the actual file creation. Such a situation can occur when creating temporary files using normal file handling functions or when using dedicated temporary file handling functions that are not atomic.

        Why is this an issue?

        How can I fix it?

        More Info

        Creating temporary files in a non-atomic way introduces race condition issues in the application’s behavior. Indeed, a third party can create a given file between when the application chooses its name and when it creates it.

        In such a situation, the application might use a temporary file that it does not entirely control. In particular, this file’s permissions might be different than expected. This can lead to trust boundary issues.

        What is the potential impact?

        Attackers with control over a temporary file used by a vulnerable application will be able to modify it in a way that will affect the application’s logic. By changing this file’s Access Control List or other operating system-level properties, they could prevent the file from being deleted or emptied. They may also alter the file’s content before or while the application uses it.

        Depending on why and how the affected temporary files are used, the exploitation of a race condition in an application can have various consequences. They can range from sensitive information disclosure to more serious application or hosting infrastructure compromise.

        Information disclosure

        Because attackers can control the permissions set on temporary files and prevent their removal, they can read what the application stores in them. This might be especially critical if this information is sensitive.

        For example, an application might use temporary files to store users' session-related information. In such a case, attackers controlling those files can access session-stored information. This might allow them to take over authenticated users' identities and entitlements.

        Attack surface extension

        An application might use temporary files to store technical data for further reuse or as a communication channel between multiple components. In that case, it might consider those files part of the trust boundaries and use their content without additional security validation or sanitation. In such a case, an attacker controlling the file content might use it as an attack vector for further compromise.

        For example, an application might store serialized data in temporary files for later use. In such a case, attackers controlling those files' content can change it in a way that will lead to an insecure deserialization exploitation. It might allow them to execute arbitrary code on the application hosting server and take it over.

          Available In:
        • SonarQube IdeCatch issues on the fly,
          in your IDE
        • SonarQube CloudDetect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories
        • SonarQube ServerAnalyze code in your
          on-premise CI

        © 2008-2025 SonarSource SA. All rights reserved.

        Privacy Policy | Cookie Policy | Terms of Use